diff --git a/.gitignore b/.gitignore
index 05192106d7..f5096afb3f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -63,3 +63,8 @@ vite.config.*.timestamp*
 vitest.config.*.timestamp*
 .cursor/rules/nx-rules.mdc
 .github/instructions/nx.instructions.md
+/packages/ui-mobile-base/windows/widgets-cpp/NativeSc.B6D1F2A0
+/packages/ui-mobile-base/windows/widgets-cpp/obj
+/packages/ui-mobile-base/windows/widgets-cpp/x64/Debug
+/packages/ui-mobile-base/windows/widgets-cpp/x64/Release
+/packages/ui-mobile-base/windows/widgets-cpp/ARM64
diff --git a/apps/toolbox/fonts/Twemoji.Mozilla.ttf b/apps/toolbox/fonts/Twemoji.Mozilla.ttf
new file mode 100644
index 0000000000..9f45178e9d
Binary files /dev/null and b/apps/toolbox/fonts/Twemoji.Mozilla.ttf differ
diff --git a/apps/toolbox/package.json b/apps/toolbox/package.json
index 331ac9ac73..1d8b85dcd3 100644
--- a/apps/toolbox/package.json
+++ b/apps/toolbox/package.json
@@ -17,6 +17,7 @@
     "@nativescript/visionos": "~9.0.0",
     "@nativescript/vite": "file:../../dist/packages/vite",
     "@nativescript/webpack": "file:../../dist/packages/webpack5",
+    "@nativescript/windows": "0.1.0-alpha.133",
     "typescript": "~5.8.0"
   }
 }
diff --git a/apps/toolbox/src/_app-platform.windows.css b/apps/toolbox/src/_app-platform.windows.css
new file mode 100644
index 0000000000..b713dcbfd2
--- /dev/null
+++ b/apps/toolbox/src/_app-platform.windows.css
@@ -0,0 +1,59 @@
+/* Import theme rules for Windows and include additional core rules so Windows gets the same
+	 look as other platforms without modifying the NativeScript runtime. */
+@import '../../../node_modules/nativescript-theme-core/css/core.light.windows.css';
+
+/* Only include the Windows-specific theme file here. Importing iOS/Android theme
+	files in the Windows platform CSS can introduce conflicting rules and
+	unexpected colors; platform-specific CSS should be kept separate. */
+
+/* Fallbacks / platform-specific tweaks for Windows host environments */
+
+/* Ensure pages default to white background like the theme */
+.page, Page {
+	background-color: #fff;
+}
+
+/* Visibility helper used across the theme */
+.invisible {
+	visibility: collapse;
+}
+
+/* h-full is referenced in markup but was never defined; map it to full height so a
+   ScrollView inside an auto-sized StackLayout gets a bounded viewport and can scroll. */
+.h-full {
+	height: 100%;
+}
+
+/* Simple shadow/gradient fallbacks — some Windows hosts may not fully support composition */
+.shadow {
+	box-shadow: 0 2 6 rgba(0,0,0,0.2);
+	border-radius: 4;
+}
+.gradient {
+	background: linear-gradient(to bottom, #f12711, #f5af19);
+}
+
+/* Make list items readable on Windows hosts */
+.list-group .list-group-item {
+	padding: 16;
+	color: #212121;
+}
+
+/* TabView / SegmentedBar defaults */
+.tab-view {
+	selected-color: #30bcff;
+	tabs-background-color: #fff;
+}
+.tab-view .tab-view-item {
+	background-color: #fff;
+}
+
+/* Ensure ScrollView / ListView backgrounds don't hide content */
+ScrollView, ListView, Repeater {
+	background-color: transparent;
+}
+
+/* Make sure controls have a sensible default enabled/disabled appearance */
+Button[isEnabled=false], TextField[isEnabled=false], TextView[isEnabled=false] {
+	opacity: 0.6;
+}
diff --git a/apps/toolbox/src/pages/a11y.ts b/apps/toolbox/src/pages/a11y.ts
index 6c82fb442f..f265c833b0 100644
--- a/apps/toolbox/src/pages/a11y.ts
+++ b/apps/toolbox/src/pages/a11y.ts
@@ -17,7 +17,7 @@ export class AccessibilityModel extends Observable {
 	accessibilityLiveRegions = AccessibilityLiveRegion;
 	accessibilityRole = AccessibilityRole;
 	accessibilityState = AccessibilityState;
-	largeImageSrc = 'https://i.picsum.photos/id/669/5000/5000.jpg?hmac=VlpchW0ODhflKm0SKOYQrc8qysLWbqKmDS1MGT9apAc';
+	largeImageSrc = 'https://picsum.photos/seed/VlpchW0ODhflKm0SKOYQrc8qysLWbqKmDS1MGT9apAc/5000/5000';
 
 	constructor() {
 		super();
@@ -30,8 +30,8 @@ export class AccessibilityModel extends Observable {
 
 		// prettier-ignore
 		this.notifyPropertyChange('largeImageSrc', checked ? 
-			'https://i.picsum.photos/id/669/5000/5000.jpg?hmac=VlpchW0ODhflKm0SKOYQrc8qysLWbqKmDS1MGT9apAc' : 
-			'https://i.picsum.photos/id/684/5000/5000.jpg?hmac=loiXO_OQ-y86XY_hc7p3qJdY39fSd9CuDM0iA_--P4Q');
+			'https://picsum.photos/seed/VlpchW0ODhflKm0SKOYQrc8qysLWbqKmDS1MGT9apAc/5000/5000' : 
+			'https://picsum.photos/seed/loiXO_OQ-y86XY_hc7p3qJdY39fSd9CuDM0iA_--P4Q/5000/5000');
 	}
 
 	openModal() {
diff --git a/apps/toolbox/src/pages/box-shadow.ts b/apps/toolbox/src/pages/box-shadow.ts
index f611b19f47..8beb59ffb6 100644
--- a/apps/toolbox/src/pages/box-shadow.ts
+++ b/apps/toolbox/src/pages/box-shadow.ts
@@ -178,4 +178,4 @@ export class BoxShadowModel extends Observable {
 				});
 		}
 	}
-}
+}
\ No newline at end of file
diff --git a/apps/toolbox/src/pages/box-shadow.xml b/apps/toolbox/src/pages/box-shadow.xml
index 46bc3ea52a..5a8d3597d1 100644
--- a/apps/toolbox/src/pages/box-shadow.xml
+++ b/apps/toolbox/src/pages/box-shadow.xml
@@ -1,9 +1,8 @@
-<Page xmlns="http://schemas.nativescript.org/tns.xsd" navigatingTo="navigatingTo" class="page">
+<Page xmlns="http://schemas.nativescript.org/tns.xsd" navigatingTo="navigatingTo" navigatedTo="navigatedTo" class="page">
     <Page.actionBar>
         <ActionBar title="Box Shadow" icon="" class="action-bar">
         </ActionBar>
     </Page.actionBar>
-
     <GridLayout rows="*, auto, *" class="box-shadow-demo">
         <StackLayout backgroundColor="#ededed" row="0" id="boxShadowDemo">
             <!-- layouts -->
diff --git a/apps/toolbox/src/pages/css-playground.ts b/apps/toolbox/src/pages/css-playground.ts
index c2d99fdf4b..a336474873 100644
--- a/apps/toolbox/src/pages/css-playground.ts
+++ b/apps/toolbox/src/pages/css-playground.ts
@@ -36,7 +36,7 @@ export class CssPlaygroundModel extends Observable {
 
 	applyCSS(args) {
 		this.resetCSS();
-		addTaggedAdditionalCSS(`#play { ${this.currentCSS}`, CSSTag);
+		addTaggedAdditionalCSS(`#play { ${this.currentCSS} }`, CSSTag);
 		playLabel._onCssStateChange();
 		playLabel.requestLayout();
 	}
diff --git a/apps/toolbox/src/pages/list-page-model-sticky.ts b/apps/toolbox/src/pages/list-page-model-sticky.ts
index cf8b3cb9c1..8cf67a3156 100644
--- a/apps/toolbox/src/pages/list-page-model-sticky.ts
+++ b/apps/toolbox/src/pages/list-page-model-sticky.ts
@@ -1430,4 +1430,4 @@ export class ListPageModelSticky extends Observable {
 				.filter((group) => group.items.length > 0)
 		);
 	}
-}
+}
\ No newline at end of file
diff --git a/apps/toolbox/src/pages/list-page-sticky.xml b/apps/toolbox/src/pages/list-page-sticky.xml
index d7b6f0abc2..187653535c 100644
--- a/apps/toolbox/src/pages/list-page-sticky.xml
+++ b/apps/toolbox/src/pages/list-page-sticky.xml
@@ -7,7 +7,7 @@
             <ListView.itemTemplates>
                 <template key="main">
                     <GridLayout columns="auto,auto,*" padding="14 12 14 12" margin="2 6 2 6" borderRadius="10" backgroundColor="#fff" boxShadow="0px 1px 2px rgba(0,0,0,0.2)">
-                        <Label color="black" text="{{ flag }}" marginLeft="4"></Label>
+                        <Label color="black" text="{{ flag }}" marginLeft="4" fontFamily="ms-appx:///app/fonts/Twemoji.Mozilla.ttf#Twemoji Mozilla"></Label>
                         <Label col="1" text="{{ name }}" marginLeft="6" color="black"></Label>
                         <Label col="2" text="{{ code }}" marginLeft="4" color="#999"></Label>
                     </GridLayout>
diff --git a/apps/toolbox/src/pages/list-page.xml b/apps/toolbox/src/pages/list-page.xml
index cce6c49c71..e5e61dc874 100644
--- a/apps/toolbox/src/pages/list-page.xml
+++ b/apps/toolbox/src/pages/list-page.xml
@@ -23,6 +23,9 @@
                                     <Label text="{{ iconText }}" class="icon-label"/>
                                 </StackLayout>
                             </android>
+                            <windows>
+                                <Label text="{{ iconText }}" class="icon-around icon-label"/>
+                            </windows>
                             <StackLayout class="va-middle">
                                 <Label text="{{ name }}" class="component-label"></Label>
                             </StackLayout>
@@ -47,6 +50,9 @@
                                     <Label text="{{ iconText }}" class="icon-label"/>
                                 </StackLayout>
                             </android>
+                            <windows>
+                                <Label text="{{ iconText }}" class="icon-around icon-label"/>
+                            </windows>
                             <StackLayout class="va-middle">
                                 <Label text="{{ name }}" class="component-label"></Label>
                             </StackLayout>
diff --git a/apps/toolbox/src/split-view/split-view-primary.ts b/apps/toolbox/src/split-view/split-view-primary.ts
index 3f5748cb28..6bf982c72e 100644
--- a/apps/toolbox/src/split-view/split-view-primary.ts
+++ b/apps/toolbox/src/split-view/split-view-primary.ts
@@ -4,7 +4,9 @@ let page: Page;
 
 export function navigatingTo(args: EventData) {
 	page = <Page>args.object;
-	page.bindingContext = new SplitViewPrimaryModel();
+	const model = new SplitViewPrimaryModel();
+	page.bindingContext = model;
+	try { console.log('[Primary] navigatingTo, items.length=', model.items?.length); } catch (_e) {}
 }
 
 export class SplitViewPrimaryModel extends Observable {
diff --git a/apps/toolbox/tsconfig.json b/apps/toolbox/tsconfig.json
index 0d0dc494b0..90dddd3baa 100644
--- a/apps/toolbox/tsconfig.json
+++ b/apps/toolbox/tsconfig.json
@@ -5,5 +5,6 @@
 		"paths": {
 			"~/*": ["src/*"]
 		}
-	}
+	},
+	"exclude": ["node_modules", "tmp", "platforms", "__tests__", "vite.config.ts"]
 }
diff --git a/apps/toolbox/webpack.config.js b/apps/toolbox/webpack.config.js
index c47db7c6f6..5ac42bc263 100644
--- a/apps/toolbox/webpack.config.js
+++ b/apps/toolbox/webpack.config.js
@@ -1,4 +1,5 @@
 const webpack = require("@nativescript/webpack");
+const path = require("path");
 
 module.exports = (env) => {
 	webpack.init(env);
@@ -11,6 +12,11 @@ module.exports = (env) => {
 
 			return args
 		  })
+
+		// Stub Windows-unsupported packages
+		if (env.windows) {
+			config.resolve.alias.set('@nativescript/imagepicker', path.resolve(__dirname, 'src/stubs/imagepicker.js'));
+		}
 	})
 
 	return webpack.resolveConfig();
diff --git a/apps/ui/package.json b/apps/ui/package.json
index 0168a45c97..f0e6e7305d 100644
--- a/apps/ui/package.json
+++ b/apps/ui/package.json
@@ -15,6 +15,7 @@
     "@nativescript/ios": "~9.0.0",
     "@nativescript/visionos": "~9.0.0",
     "@nativescript/webpack": "file:../../dist/packages/webpack5",
+    "@nativescript/windows": "0.1.0-alpha.133",
     "typescript": "~5.8.0"
   },
   "gitHead": "8ab7726d1ee9991706069c1359c552e67ee0d1a4",
diff --git a/apps/ui/src/animation/effect-summary-details-page.windows.ts b/apps/ui/src/animation/effect-summary-details-page.windows.ts
new file mode 100644
index 0000000000..ede719d395
--- /dev/null
+++ b/apps/ui/src/animation/effect-summary-details-page.windows.ts
@@ -0,0 +1,64 @@
+import { getViewById, View, Page, Animation, Screen, TextView } from '@nativescript/core';
+
+let toggle = false;
+
+export function pageLoaded(args) {
+	const page = args.object;
+	const screenHeight = Screen.mainScreen.heightDIPs;
+	const screenYCenter = screenHeight / 2;
+	page.bindingContext = {
+		screenHeight,
+		screenYCenter,
+		detailsHeight: 96,
+		summary: 'Space! 🌌',
+		ipsum: `Houston, Tranquillity Base here. The Eagle has landed.
+
+For those who have seen the Earth from space, and for the hundreds and perhaps thousands more who will, the experience most certainly changes your perspective. The things that we share in our world are far more valuable than those which divide us.
+
+As we got further and further away, it [the Earth] diminished in size. Finally it shrank to the size of a marble, the most beautiful you can imagine. That beautiful, warm, living object looked so fragile, so delicate, that if you touched it with a finger it would crumble and fall apart. Seeing this has to change a man.
+
+What was most significant about the lunar voyage was not that man set foot on the Moon but that they set eye on the earth.
+
+Spaceflights cannot be stopped. This is not the work of any one man or even a group of men. It is a historical process which mankind is carrying out in accordance with the natural laws of human development.
+
+NASA is not about the 'Adventure of Human Space Exploration'…We won't be doing it just to get out there in space – we'll be doing it because the things we learn out there will be making life better for a lot of people who won't be able to go.
+
+Science has not yet mastered prophecy. We predict too much for the next year and yet far too little for the next 10.
+
+Science cuts two ways, of course; its products can be used for both good and evil. But there's no turning back from science. The early warnings about technological dangers also come from science.
+
+Here men from the planet Earth first set foot upon the Moon. July 1969 AD. We came in peace for all mankind.
+
+When I orbited the Earth in a spaceship, I saw for the first time how beautiful our planet is. Mankind, let us preserve and increase this beauty, and not destroy it!
+
+http://spaceipsum.com`,
+	};
+}
+
+export function theFinalFrontier(args) {
+	const clicked = args.object as View;
+	const page: Page = clicked.page;
+	const details = getViewById(page, 'details') as TextView;
+	const ctx = page.bindingContext;
+	const detailHeaderHeight: number = ctx.detailsHeight;
+	const textViewHeight: number = ctx.screenHeight - detailHeaderHeight;
+	const transitions = [
+		{
+			target: clicked,
+			height: toggle ? '100%' : detailHeaderHeight,
+			duration: 200,
+			curve: 'ease',
+		},
+		{
+			target: details,
+			opacity: toggle ? 0 : 1,
+			height: textViewHeight,
+			translate: { x: 0, y: toggle ? 50 : 0 },
+			duration: 200,
+			curve: 'easeIn',
+		},
+	];
+	const animationSet = new Animation(transitions, false);
+	animationSet.play();
+	toggle = !toggle;
+}
diff --git a/packages/core/animation-frame/animation-native.windows.ts b/packages/core/animation-frame/animation-native.windows.ts
new file mode 100644
index 0000000000..4d13033a2b
--- /dev/null
+++ b/packages/core/animation-frame/animation-native.windows.ts
@@ -0,0 +1,3 @@
+export function getTimeInFrameBase(): number {
+	return Date.now();
+}
diff --git a/packages/core/application-settings/index.windows.ts b/packages/core/application-settings/index.windows.ts
new file mode 100644
index 0000000000..4cba40932a
--- /dev/null
+++ b/packages/core/application-settings/index.windows.ts
@@ -0,0 +1,108 @@
+import * as Common from './application-settings-common';
+
+export function hasKey(key: string): boolean | undefined {
+	if (!Common.checkKey(key)) {
+		return;
+	}
+
+	const localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
+	return localSettings.Values.HasKey(key);
+}
+
+export function getBoolean(key: string, defaultValue?: boolean): boolean | undefined {
+	if (!Common.checkKey(key)) {
+		return undefined;
+	}
+	if (hasKey(key)) {
+		const localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
+		return localSettings.Values[key] as never;
+	}
+
+	return defaultValue;
+}
+
+export function getString(key: string, defaultValue?: string): string | undefined {
+	if (!Common.checkKey(key)) {
+		return;
+	}
+	if (hasKey(key)) {
+		const localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
+		return localSettings.Values[key] as never;
+	}
+
+	return defaultValue;
+}
+
+export function getNumber(key: string, defaultValue?: number): number | undefined {
+	if (!Common.checkKey(key)) {
+		return;
+	}
+	if (hasKey(key)) {
+		const localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
+		return localSettings.Values[key] as never;
+	}
+
+	return defaultValue;
+}
+
+export function setBoolean(key: string, value: boolean): void {
+	if (!Common.checkKey(key)) {
+		return;
+	}
+	if (!Common.ensureValidValue(value, 'boolean')) {
+		return;
+	}
+	const localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
+	localSettings.Values[key] = value;
+}
+
+export function setString(key: string, value: string): void {
+	if (!Common.checkKey(key)) {
+		return;
+	}
+	if (!Common.ensureValidValue(value, 'string')) {
+		return;
+	}
+	const localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
+	localSettings.Values[key] = value;
+}
+
+export function setNumber(key: string, value: number): void {
+	if (!Common.checkKey(key)) {
+		return;
+	}
+	if (!Common.ensureValidValue(value, 'number')) {
+		return;
+	}
+	const localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
+	localSettings.Values[key] = value;
+}
+
+export function remove(key: string): void {
+	if (!Common.checkKey(key)) {
+		return;
+	}
+	const localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
+	localSettings.Values.Remove(key);
+}
+
+export function clear(): void {
+	Windows.Storage.ApplicationData.Current.LocalSettings.Values.Clear();
+}
+
+export function flush(): boolean {
+	// no-op since Windows.Storage.ApplicationData is automatically flushed by the system
+	return true;
+}
+
+export function getAllKeys(): Array<string> {
+	const Values = Windows.Storage.ApplicationData.Current.LocalSettings.Values;
+	const first = Values.First();
+	const ret: string[] = [];
+	while (first && first.HasCurrent) {
+		ret.push(first.Current.Key);
+		first.MoveNext();
+	}
+
+	return ret;
+}
diff --git a/packages/core/application/application-common.ts b/packages/core/application/application-common.ts
index 50b27b6f8d..123bef2c07 100644
--- a/packages/core/application/application-common.ts
+++ b/packages/core/application/application-common.ts
@@ -415,6 +415,7 @@ export class ApplicationCommon {
 			object: this,
 			ios: this.ios,
 			android: this.android,
+			windows: this.windows,
 			...additionalLanchEventData,
 		};
 		this.notify(launchArgs);
@@ -746,6 +747,10 @@ export class ApplicationCommon {
 		return undefined;
 	}
 
+	get windows() {
+		return undefined;
+	}
+
 	get AndroidApplication() {
 		return this.android;
 	}
diff --git a/packages/core/application/application.windows.ts b/packages/core/application/application.windows.ts
new file mode 100644
index 0000000000..60bae6fb68
--- /dev/null
+++ b/packages/core/application/application.windows.ts
@@ -0,0 +1,219 @@
+import { ApplicationCommon } from './application-common';
+import type { NavigationEntry } from '../ui/frame/frame-interfaces';
+import { setAppMainEntry, setToggleApplicationEventListenersCallback, setApplicationPropertiesCallback, setA11yUpdatePropertiesCallback } from './helpers-common';
+import type { View } from '../ui/core/view';
+import { setRootView } from './helpers-common';
+import { CoreTypes } from 'index';
+import { activateCurrentWindow, getCurrentWindowContent, setCurrentWindowContent, getCurrentWindowBounds, setCurrentWindowTitle } from './window-helper.windows';
+
+
+enum AppEventKind {
+	Activated = 1,
+	Deactivated = 2,
+	Shown = 3,
+	Hidden = 4,
+	UncaughtError = 5,
+	Exit = 6
+}
+
+export class WindowsApplication extends ApplicationCommon {
+
+	private _rootView: View;
+
+	getRootView(): View {
+		return this._rootView;
+	}
+
+	run(entry?: string | NavigationEntry): void {
+		if (this.started) {
+			throw new Error('Application is already started.');
+		}
+
+		this.setupLifecycleEvents();
+
+		this.started = true;
+		setAppMainEntry(typeof entry === 'string' ? { moduleName: entry } : entry);
+		this.setWindowContent();
+	}
+
+
+	private setWindowContent(view?: View): void {
+		if (this._rootView) {
+			this._rootView._onRootViewReset();
+		}
+		const rootView = this.createRootView(view, true);
+		if (!rootView) return;
+
+		this._rootView = rootView;
+		setRootView(rootView);
+
+		rootView._setupAsRootView({});
+
+		if (!setCurrentWindowContent(rootView.nativeViewProtected)) {
+			throw new Error('Unable to resolve the current Windows window.');
+		}
+		this.setupOrientationTracking(rootView.nativeViewProtected);
+		activateCurrentWindow();
+		this._applyWindowTitle();
+
+		this.initRootView(rootView);
+		rootView.callLoaded();
+	}
+
+	// Give the window a sensible title. A code-created WinUI3 Window starts with an empty Title and
+	// does NOT inherit the package DisplayName, so the caption otherwise shows the host exe name.
+	private _applyWindowTitle(): void {
+		try {
+			let title = '';
+			try {
+				title = Windows.ApplicationModel.Package.Current.DisplayName || '';
+			} catch (_e) { /* Package projection unavailable (e.g. unpackaged) — fall through */ }
+			if (title) {
+				setCurrentWindowTitle(title);
+			}
+		} catch (_e) { /* never let window titling break app startup */ }
+	}
+
+	getNativeApplication() {
+		return Microsoft.UI.Xaml.Application.Current;
+	}
+
+	protected getOrientation(): 'portrait' | 'landscape' | 'unknown' {
+		const bounds = getCurrentWindowBounds();
+		if (!bounds) {
+			return 'unknown';
+		}
+
+		const width = bounds.Width;
+		const height = bounds.Height;
+
+		if (width === height) {
+			return 'unknown';
+		}
+
+		return width >= height ? 'landscape' : 'portrait';
+	}
+
+	protected getSystemAppearance(): 'dark' | 'light' | null {
+		try {
+			const content: any = getCurrentWindowContent();
+
+			const actualTheme = content?.ActualTheme;
+			const ElementTheme = Microsoft.UI.Xaml.ElementTheme;
+			if (typeof actualTheme === 'number' && ElementTheme) {
+				if (actualTheme === ElementTheme.Dark) return 'dark';
+				if (actualTheme === ElementTheme.Light) return 'light';
+			}
+
+			const appTheme = Microsoft.UI.Xaml.Application.Current.RequestedTheme;
+			const ApplicationTheme = Microsoft.UI.Xaml.ApplicationTheme;
+			if (appTheme === ApplicationTheme.Dark) return 'dark';
+			if (appTheme === ApplicationTheme.Light) return 'light';
+
+			const UISettings = Windows.UI.ViewManagement.UISettings;
+			const ui = new UISettings();
+			const foreground = ui.GetColorValue(Windows.UI.ViewManagement.UIColorType.Foreground);
+			if (!foreground) {
+				return null;
+			}
+
+			// In dark mode Windows uses a light (near-white) foreground color
+			return foreground.R > 128 ? 'dark' : 'light';
+		} catch (e) { }
+
+		return null;
+	}
+
+	protected getLayoutDirection(): CoreTypes.LayoutDirectionType {
+		const content = getCurrentWindowContent<Microsoft.UI.Xaml.FrameworkElement>();
+		if (!content) {
+			return null as never;
+		}
+
+
+		const direction = content.FlowDirection;
+
+		if (direction === Microsoft.UI.Xaml.FlowDirection.RightToLeft) {
+			return 'rtl';
+		}
+		return 'ltr';
+	}
+
+	private setupLifecycleEvents(): void {
+		(globalThis as any).__nsOnAppEvent = (kind: number, message: string | undefined) => {
+
+			switch (kind) {
+				case AppEventKind.Shown:
+					this.setInBackground(false);
+					this.setSuspended(false);
+					break;
+				case AppEventKind.Deactivated:
+					this.setInBackground(true);
+					break;
+				case AppEventKind.Hidden:
+					this.setInBackground(true);
+					this.setSuspended(true);
+					break;
+				case AppEventKind.Exit:
+					this.notify({ eventName: this.exitEvent, object: this });
+					break;
+				case AppEventKind.UncaughtError:
+					this.notify({ eventName: this.uncaughtErrorEvent, object: this, error: new Error(message ?? 'Unhandled exception') } as any);
+					break;
+			}
+		};
+
+		try {
+			const ui = new Windows.UI.ViewManagement.UISettings();
+			if (ui && ui.ColorValuesChanged !== undefined) {
+				ui.ColorValuesChanged = () => {
+					const newSys = this.getSystemAppearance();
+					if (newSys !== null) {
+						this.setSystemAppearance(newSys);
+					}
+				};
+			}
+		} catch (_e) { }
+	}
+
+	// Orientation derives from window size, so re-evaluate when the root content resizes.
+	private _orientationDelegate: any = null; // held so the handler isn't GC'd
+	private setupOrientationTracking(content: Microsoft.UI.Xaml.UIElement): void {
+			const element = content as Microsoft.UI.Xaml.FrameworkElement;
+			if (element && element.SizeChanged !== undefined) {
+				// Wire via asDelegate (a raw-fn assignment does not reliably subscribe in this host) + hold it.
+				this._orientationDelegate = NSWinRT.asDelegate('Microsoft.UI.Xaml.SizeChangedEventHandler', () => this.setOrientation(this.getOrientation()));
+				(element as any).SizeChanged = this._orientationDelegate;
+			}
+	}
+}
+
+export const Application: WindowsApplication = new WindowsApplication();
+
+function updateAccessibilityProperties(view: any): void {
+	if (!view || !view.nativeViewProtected) {
+		return;
+	}
+
+}
+
+setA11yUpdatePropertiesCallback(updateAccessibilityProperties);
+
+const applicationEvents: string[] = [Application.orientationChangedEvent, Application.systemAppearanceChangedEvent];
+function toggleApplicationEventListeners(toAdd: boolean, callback: (args: any) => void) {
+	for (const eventName of applicationEvents) {
+		if (toAdd) {
+			Application.on(eventName, callback);
+		} else {
+			Application.off(eventName, callback);
+		}
+	}
+}
+setToggleApplicationEventListenersCallback(toggleApplicationEventListeners);
+
+setApplicationPropertiesCallback(() => {
+	return {
+		orientation: Application.orientation(),
+		systemAppearance: Application.systemAppearance(),
+	};
+});
diff --git a/packages/core/application/helpers.windows.ts b/packages/core/application/helpers.windows.ts
new file mode 100644
index 0000000000..db854a7c42
--- /dev/null
+++ b/packages/core/application/helpers.windows.ts
@@ -0,0 +1,14 @@
+// Stubs to avoid bundler warnings on Windows — mirrors helpers.ios.ts shape.
+export const updateContentDescription = (_view: any, _forceUpdate?: boolean): string | null => null;
+
+export function applyContentDescription(_view: any, _forceUpdate?: boolean) {
+	return null;
+}
+
+export function androidGetCurrentActivity() {}
+export function androidGetForegroundActivity() {}
+export function androidSetForegroundActivity(_activity: any): void {}
+export function androidGetStartActivity() {}
+export function androidSetStartActivity(_activity: any): void {}
+
+export function setupAccessibleView(_view: any): void {}
diff --git a/packages/core/application/index.windows.ts b/packages/core/application/index.windows.ts
new file mode 100644
index 0000000000..c912854dcd
--- /dev/null
+++ b/packages/core/application/index.windows.ts
@@ -0,0 +1,2 @@
+export * from './application.windows';
+export * from './application-shims';
diff --git a/packages/core/application/window-helper.windows.ts b/packages/core/application/window-helper.windows.ts
new file mode 100644
index 0000000000..c9bed0e6d8
--- /dev/null
+++ b/packages/core/application/window-helper.windows.ts
@@ -0,0 +1,170 @@
+type WindowLike = {
+	Content?: Microsoft.UI.Xaml.UIElement | null;
+	Bounds?: { Width?: number; Height?: number } | null;
+	Activate?: () => void;
+	Title?: string;
+};
+
+type FrameworkElementLike = Microsoft.UI.Xaml.FrameworkElement & {
+	XamlRoot?: {
+		Size?: { Width?: number; Height?: number } | null;
+		RasterizationScale?: number | null;
+	} | null;
+};
+
+function getPositiveNumber(value: unknown): number | null {
+	return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : null;
+}
+
+function getBoundsFromSize(size: { Width?: number; Height?: number } | null | undefined): { Width: number; Height: number } | null {
+	const width = getPositiveNumber(size?.Width);
+	const height = getPositiveNumber(size?.Height);
+	if (width == null || height == null) {
+		return null;
+	}
+
+	return { Width: width, Height: height };
+}
+
+function getFirstWindow(collection: any): WindowLike | null {
+	if (!collection) {
+		return null;
+	}
+
+	try {
+		if (typeof collection.Size === 'number' && typeof collection.GetAt === 'function' && collection.Size > 0) {
+			return collection.GetAt(0) as WindowLike;
+		}
+	} catch (_e) { }
+
+	try {
+		if (typeof collection.Length === 'number' && collection.Length > 0) {
+			return collection[0] as WindowLike;
+		}
+	} catch (_e) { }
+
+	try {
+		if (Array.isArray(collection) && collection.length > 0) {
+			return collection[0] as WindowLike;
+		}
+	} catch (_e) { }
+
+	return null;
+}
+
+function getApplicationWindow(): WindowLike | null {
+	try {
+		const app = Microsoft.UI.Xaml.Application?.Current as any;
+		if (!app) {
+			return null;
+		}
+
+		// These are only visible if a host surfaces them on a projectable surface; the base
+		// Microsoft.UI.Xaml.Application projection exposes none of them, so this usually yields null.
+		return (app.MainWindow as WindowLike) || (app.Window as WindowLike) || getFirstWindow(app.Windows);
+	} catch (_e) {
+		return null;
+	}
+}
+
+function getLegacyCurrentWindow(): WindowLike | null {
+	try {
+		return ((Microsoft.UI.Xaml.Window as any)?.Current as WindowLike) ?? null;
+	} catch (_e) {
+		return null;
+	}
+}
+
+let _ownedWindow: WindowLike | null = null;
+
+export function getCurrentWindow(): WindowLike | null {
+	const found = getApplicationWindow() || getLegacyCurrentWindow();
+	if (found) {
+		return found;
+	}
+
+	// WinUI3 desktop has no Window.Current and the host's derived App.MainWindow isn't visible
+	// through the base Application projection. As a last resort create (once) and own a Window.
+	if (!_ownedWindow) {
+		try {
+			_ownedWindow = new Microsoft.UI.Xaml.Window() as unknown as WindowLike;
+		} catch (_e) {
+			_ownedWindow = null;
+		}
+	}
+	return _ownedWindow;
+}
+
+export function getCurrentWindowContent<T = Microsoft.UI.Xaml.UIElement>(): T | null {
+	const window = getCurrentWindow();
+	return (window?.Content as T) ?? null;
+}
+
+export function setCurrentWindowContent(content: Microsoft.UI.Xaml.UIElement): boolean {
+	const window = getCurrentWindow();
+	if (!window) {
+		return false;
+	}
+
+	window.Content = content;
+	return true;
+}
+
+export function activateCurrentWindow(): boolean {
+	const window = getCurrentWindow();
+	if (!window?.Activate) {
+		return false;
+	}
+
+	window.Activate();
+	return true;
+}
+
+// A WinUI3 Window created in code (which is how the host and this helper create it) has an EMPTY
+// Title by default — the package manifest's DisplayName does NOT propagate to a code-created
+// window's title bar. So unless someone sets Window.Title explicitly the caption shows the host
+// executable's name, which looks wrong. Set it to the provided title (the app's display name).
+export function setCurrentWindowTitle(title: string): boolean {
+	if (!title) {
+		return false;
+	}
+	const window = getCurrentWindow();
+	if (!window) {
+		return false;
+	}
+	try {
+		window.Title = title;
+		return true;
+	} catch (_e) {
+		return false;
+	}
+}
+
+// Per-window DPI scale from XamlRoot (WinUI3 desktop has no DisplayInformation.GetForCurrentView()).
+export function getCurrentWindowScale(preferredElement?: FrameworkElementLike | null): number {
+	const content = (getCurrentWindowContent<FrameworkElementLike>() ?? preferredElement) as FrameworkElementLike | null;
+	const scale = content?.XamlRoot?.RasterizationScale;
+	return typeof scale === 'number' && Number.isFinite(scale) && scale > 0 ? scale : 1;
+}
+
+export function getCurrentWindowBounds(preferredElement?: FrameworkElementLike | null): { Width: number; Height: number } | null {
+	const window = getCurrentWindow();
+	const windowBounds = getBoundsFromSize(window?.Bounds);
+	if (windowBounds) {
+		return windowBounds;
+	}
+
+	const xamlRootBounds = getBoundsFromSize(preferredElement?.XamlRoot?.Size);
+	if (xamlRootBounds) {
+		return xamlRootBounds;
+	}
+
+	const content = (window?.Content ?? preferredElement) as any;
+	const width = getPositiveNumber(content?.ActualWidth ?? content?.Width);
+	const height = getPositiveNumber(content?.ActualHeight ?? content?.Height);
+	if (width == null || height == null) {
+		return null;
+	}
+
+	return { Width: width, Height: height };
+}
\ No newline at end of file
diff --git a/packages/core/color/index.d.ts b/packages/core/color/index.d.ts
index 6e2b10a65c..f73a46e2ce 100644
--- a/packages/core/color/index.d.ts
+++ b/packages/core/color/index.d.ts
@@ -52,6 +52,11 @@ export declare class Color {
 	 */
 	ios: any /* UIColor */;
 
+	/**
+	 * Gets the Windows-specific Color value representation. This is a read-only property.
+	 */
+	windows: any /* Windows.UI.Color */;
+
 	/**
 	 * Specifies whether this Color is equal to the Color parameter.
 	 * @param value The Color to test.
diff --git a/packages/core/color/index.windows.ts b/packages/core/color/index.windows.ts
new file mode 100644
index 0000000000..5149878bb9
--- /dev/null
+++ b/packages/core/color/index.windows.ts
@@ -0,0 +1,24 @@
+import { ColorBase } from './color-common';
+import type { IColor } from './color-types';
+
+export class Color extends ColorBase implements IColor {
+    private _windows: Windows.UI.Color | undefined;
+
+    get windows(): Windows.UI.Color {
+        if (!this._windows) {
+            // Windows.UI.Color is a plain {A,R,G,B} struct — bridge reads fields directly,
+            // no need to round-trip through ColorHelper.FromArgb.
+            this._windows = { A: Math.round(this.a), R: Math.round(this.r), G: Math.round(this.g), B: Math.round(this.b) } as unknown as Windows.UI.Color;
+        }
+        return this._windows;
+    }
+
+    get windowsArgb(): number {
+        // _argb already stores the packed unsigned ARGB integer — no WinRT round-trip needed.
+        return this.argb;
+    }
+
+    public static fromWindowsColor(value: Windows.UI.Color): Color {
+        return new Color(Math.round(value.A), Math.round(value.R), Math.round(value.G), Math.round(value.B));
+    }
+}
diff --git a/packages/core/connectivity/index.windows.ts b/packages/core/connectivity/index.windows.ts
new file mode 100644
index 0000000000..7076c332aa
--- /dev/null
+++ b/packages/core/connectivity/index.windows.ts
@@ -0,0 +1,58 @@
+export enum connectionType {
+	none = 0,
+	wifi = 1,
+	mobile = 2,
+	ethernet = 3,
+	bluetooth = 4,
+	vpn = 5,
+}
+
+function parseConnectionProfile(profile?: Windows.Networking.Connectivity.ConnectionProfile) {
+	if (!profile) return connectionType.none;
+
+	const adapter = profile.NetworkAdapter;
+	if (!adapter) return connectionType.none;
+
+	const type = adapter.IanaInterfaceType;
+
+	switch (type) {
+		case 71:
+			return connectionType.wifi;
+		case 6:
+			return connectionType.ethernet;
+	}
+
+	if (profile.IsWwanConnectionProfile) {
+		return connectionType.mobile;
+	}
+
+	if (profile.IsWlanConnectionProfile && profile.GetNetworkConnectivityLevel?.() === 3) {
+		return connectionType.vpn;
+	}
+
+	return connectionType.none;
+}
+
+export function getConnectionType(): number {
+	const profile = Windows.Networking.Connectivity.NetworkInformation.GetInternetConnectionProfile();
+	return parseConnectionProfile(profile);
+}
+
+let callback;
+let delegate;
+
+export function startMonitoring(connectionTypeChangedCallback: (newConnectionType: number) => void): void {
+	const zoneCallback = zonedCallback(connectionTypeChangedCallback);
+	delegate = NSWinRT.asDelegate(() => {
+		const newConnectionType = getConnectionType();
+		zoneCallback(newConnectionType);
+	});
+
+	Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged = delegate;
+}
+
+export function stopMonitoring(): void {
+	Windows.Networking.Connectivity.NetworkInformation.NetworkStatusChanged = null as never;
+	delegate = null;
+	callback = null;
+}
diff --git a/packages/core/debugger/webinspector-network.windows.ts b/packages/core/debugger/webinspector-network.windows.ts
new file mode 100644
index 0000000000..ab510a648b
--- /dev/null
+++ b/packages/core/debugger/webinspector-network.windows.ts
@@ -0,0 +1,350 @@
+import * as inspectorCommands from './InspectorBackendCommands';
+import { File, knownFolders } from '../file-system';
+
+import * as debuggerDomains from '.';
+
+declare let __inspectorSendEvent;
+
+declare let __inspectorTimestamp;
+
+const frameId = 'NativeScriptMainFrameIdentifier';
+const loaderId = 'Loader Identifier';
+
+const resources_datas = [];
+
+const documentTypeByMimeType = {
+    'text/xml': 'Document',
+    'text/plain': 'Document',
+    'text/html': 'Document',
+    'application/xml': 'Document',
+    'application/xhtml+xml': 'Document',
+    'text/css': 'Stylesheet',
+    'text/javascript': 'Script',
+    'text/ecmascript': 'Script',
+    'application/javascript': 'Script',
+    'application/ecmascript': 'Script',
+    'application/x-javascript': 'Script',
+    'application/json': 'Script',
+    'application/x-json': 'Script',
+    'text/x-javascript': 'Script',
+    'text/x-json': 'Script',
+    'text/typescript': 'Script',
+};
+
+export class Request {
+    private _resourceType: string;
+    private _data: any;
+    private _mimeType: string;
+
+    constructor(
+        private _networkDomainDebugger: NetworkDomainDebugger,
+        private _requestID: string,
+    ) {}
+
+    get mimeType(): string {
+        return this._mimeType;
+    }
+
+    set mimeType(value: string) {
+        if (this._mimeType !== value) {
+            if (!value) {
+                this._mimeType = 'text/plain';
+                this._resourceType = 'Other';
+
+                return;
+            }
+
+            this._mimeType = value;
+
+            let resourceType = 'Other';
+
+            if (this._mimeType in documentTypeByMimeType) {
+                resourceType = documentTypeByMimeType[this._mimeType];
+            }
+
+            if (this._mimeType.indexOf('image/') !== -1) {
+                resourceType = 'Image';
+            }
+
+            if (this._mimeType.indexOf('font/') !== -1) {
+                resourceType = 'Font';
+            }
+
+            this._resourceType = resourceType;
+        }
+    }
+
+    get requestID(): string {
+        return this._requestID;
+    }
+
+    get hasTextContent(): boolean {
+        return ['Document', 'Stylesheet', 'Script', 'XHR'].indexOf(this._resourceType) !== -1;
+    }
+
+    get data(): any {
+        return this._data;
+    }
+
+    set data(value: any) {
+        if (this._data !== value) {
+            this._data = value;
+        }
+    }
+
+    get resourceType() {
+        return this._resourceType;
+    }
+
+    set resourceType(value: string) {
+        if (this._resourceType !== value) {
+            this._resourceType = value;
+        }
+    }
+
+    public responseReceived(response: inspectorCommands.NetworkDomain.Response): void {
+        if (this._networkDomainDebugger.enabled) {
+            this._networkDomainDebugger.events.responseReceived(this.requestID, frameId, loaderId, __inspectorTimestamp(), <any>this.resourceType, response);
+        }
+    }
+
+    public loadingFinished(): void {
+        if (this._networkDomainDebugger.enabled) {
+            this._networkDomainDebugger.events.loadingFinished(this.requestID, __inspectorTimestamp());
+        }
+    }
+
+    public requestWillBeSent(request: inspectorCommands.NetworkDomain.Request): void {
+        if (this._networkDomainDebugger.enabled) {
+            this._networkDomainDebugger.events.requestWillBeSent(this.requestID, frameId, loaderId, request.url, request, __inspectorTimestamp(), { type: 'Script' });
+        }
+    }
+}
+
+function arrayBufferToString(buf: ArrayBuffer | Uint8Array): string {
+    try {
+        if (typeof Buffer !== 'undefined' && Buffer.from) {
+            if (buf instanceof ArrayBuffer) {
+                return Buffer.from(new Uint8Array(buf)).toString('utf8');
+            }
+            return Buffer.from(buf as Uint8Array).toString('utf8');
+        }
+
+        if (typeof TextDecoder !== 'undefined') {
+            return new TextDecoder('utf-8').decode(buf instanceof ArrayBuffer ? new Uint8Array(buf) : (buf as Uint8Array));
+        }
+
+        const bytes = buf instanceof ArrayBuffer ? new Uint8Array(buf) : (buf as Uint8Array);
+        let str = '';
+        for (let i = 0; i < bytes.length; i++) {
+            str += String.fromCharCode(bytes[i]);
+        }
+        return str;
+    } catch (e) {
+        return '';
+    }
+}
+
+function arrayBufferToBase64(buf: ArrayBuffer | Uint8Array): string {
+    try {
+        if (typeof Buffer !== 'undefined' && Buffer.from) {
+            if (buf instanceof ArrayBuffer) {
+                return Buffer.from(new Uint8Array(buf)).toString('base64');
+            }
+            return Buffer.from(buf as Uint8Array).toString('base64');
+        }
+
+        try {
+            if (typeof Windows !== 'undefined' && Windows.Security && Windows.Security.Cryptography) {
+                const writer = new Windows.Storage.Streams.DataWriter();
+                if (buf instanceof ArrayBuffer) {
+                    writer.WriteBytes(new Uint8Array(buf) as never);
+                } else {
+                    writer.WriteBytes(buf as never);
+                }
+                const iBuf = writer.DetachBuffer();
+                return Windows.Security.Cryptography.CryptographicBuffer.EncodeToBase64String(iBuf as any);
+            }
+        } catch (e) {}
+
+        const bytes = buf instanceof ArrayBuffer ? new Uint8Array(buf) : (buf as Uint8Array);
+        let binary = '';
+        const chunkSize = 0x8000;
+        for (let i = 0; i < bytes.length; i += chunkSize) {
+            const chunk = bytes.subarray(i, i + chunkSize);
+            binary += String.fromCharCode.apply(null, Array.prototype.slice.call(chunk));
+        }
+        if (typeof btoa !== 'undefined') {
+            return btoa(binary);
+        }
+        return '';
+    } catch (e) {
+        return '';
+    }
+}
+
+@inspectorCommands.DomainDispatcher('Network')
+export class NetworkDomainDebugger implements inspectorCommands.NetworkDomain.NetworkDomainDispatcher {
+    private _enabled: boolean;
+    public events: inspectorCommands.NetworkDomain.NetworkFrontend;
+
+    constructor() {
+        this.events = new inspectorCommands.NetworkDomain.NetworkFrontend();
+
+        // By default start enabled because we can miss the "enable" event when
+        // running with `--debug-brk` -- the frontend will send it before we've been created
+        this.enable();
+    }
+
+    get enabled(): boolean {
+        return this._enabled;
+    }
+
+    /**
+     * Enables network tracking, network events will now be delivered to the client.
+     */
+    enable(): void {
+        if (debuggerDomains.getNetwork()) {
+            throw new Error('One NetworkDomainDebugger may be enabled at a time.');
+        } else {
+            debuggerDomains.setNetwork(this);
+        }
+        this._enabled = true;
+    }
+
+    /**
+     * Disables network tracking, prevents network events from being sent to the client.
+     */
+    disable(): void {
+        if (debuggerDomains.getNetwork() === this) {
+            debuggerDomains.setNetwork(null);
+        }
+        this._enabled = false;
+    }
+
+    /**
+     * Specifies whether to always send extra HTTP headers with the requests from this page.
+     */
+    setExtraHTTPHeaders(params: inspectorCommands.NetworkDomain.SetExtraHTTPHeadersMethodArguments): void {
+        //
+    }
+
+    /**
+     * Returns content served for the given request.
+     */
+    getResponseBody(params: inspectorCommands.NetworkDomain.GetResponseBodyMethodArguments): { body: string; base64Encoded: boolean } {
+        const resource_data = resources_datas[params.requestId];
+        if (!resource_data) {
+            return { body: '', base64Encoded: false };
+        }
+
+        try {
+            if (resource_data.hasTextContent) {
+                if (typeof resource_data.data === 'string') {
+                    return { body: resource_data.data, base64Encoded: false };
+                }
+                if (resource_data.data instanceof ArrayBuffer || resource_data.data instanceof Uint8Array) {
+                    return { body: arrayBufferToString(resource_data.data), base64Encoded: false };
+                }
+                return { body: resource_data.data?.toString() ?? '', base64Encoded: false };
+            } else {
+                if (resource_data.data instanceof ArrayBuffer || resource_data.data instanceof Uint8Array) {
+                    return { body: arrayBufferToBase64(resource_data.data), base64Encoded: true };
+                }
+
+                // If the platform returned a WinRT IBuffer (has .Length), encode it directly.
+                try {
+                    if (typeof Windows !== 'undefined' && Windows.Security && Windows.Security.Cryptography && resource_data.data && (resource_data.data as any).Length !== undefined) {
+                        return { body: Windows.Security.Cryptography.CryptographicBuffer.EncodeToBase64String(resource_data.data as any), base64Encoded: true };
+                    }
+                } catch (e) {}
+
+                if (typeof Buffer !== 'undefined' && Buffer.from) {
+                    try {
+                        return { body: Buffer.from(resource_data.data as any).toString('base64'), base64Encoded: true };
+                    } catch (e) {}
+                }
+                return { body: '', base64Encoded: true };
+            }
+        } catch (e) {
+            return { body: '', base64Encoded: !resource_data.hasTextContent };
+        }
+    }
+
+    /**
+     * Tells whether clearing browser cache is supported.
+     */
+    canClearBrowserCache(): { result: boolean } {
+        return {
+            result: false,
+        };
+    }
+
+    /**
+     * Clears browser cache.
+     */
+    clearBrowserCache(): void {
+        //
+    }
+
+    /**
+     * Tells whether clearing browser cookies is supported.
+     */
+    canClearBrowserCookies(): { result: boolean } {
+        return {
+            result: false,
+        };
+    }
+
+    /**
+     * Clears browser cookies.
+     */
+    clearBrowserCookies(): void {
+        //
+    }
+
+    /**
+     * Toggles ignoring cache for each request. If <code>true</code>, cache will not be used.
+     */
+    setCacheDisabled(params: inspectorCommands.NetworkDomain.SetCacheDisabledMethodArguments): void {
+        //
+    }
+
+    /**
+     * Loads a resource in the context of a frame on the inspected page without cross origin checks.
+     */
+    loadResource(params: inspectorCommands.NetworkDomain.LoadResourceMethodArguments): { content: string; mimeType: string; status: number } {
+        const appPath = knownFolders.currentApp().path;
+        // Normalize incoming url like: file:// or file:///app/...
+        let rel = params.url.replace(/^file:\/\/?/, '');
+        if (rel.startsWith('app/')) {
+            rel = rel.substr(4);
+        }
+        const pathUrl = `${appPath}/${rel}`;
+        const file = File.exists(pathUrl) ? File.fromPath(pathUrl) : undefined;
+        let content = '';
+        try {
+            if (file) {
+                // Prefer text read for resources; binary consumers will request via getResponseBody
+                content = file.readTextSync();
+            }
+        } catch (e) {
+            content = '';
+        }
+
+        return {
+            content: content.toString(),
+            mimeType: 'application/octet-stream',
+            status: 200,
+        };
+    }
+
+    public static idSequence = 0;
+    create(): Request {
+        const id = (++NetworkDomainDebugger.idSequence).toString();
+        const resourceData = new Request(this, id);
+        resources_datas[id] = resourceData;
+
+        return resourceData;
+    }
+}
diff --git a/packages/core/file-system/file-system-access.windows.ts b/packages/core/file-system/file-system-access.windows.ts
new file mode 100644
index 0000000000..bb0a3b741a
--- /dev/null
+++ b/packages/core/file-system/file-system-access.windows.ts
@@ -0,0 +1,450 @@
+import { encoding as textEncoding } from '../text';
+
+function getPathSep(): string {
+	return '\\';
+}
+
+function getFileName(path: string): string {
+	const sep = path.lastIndexOf('\\') !== -1 ? '\\' : '/';
+	return path.substring(path.lastIndexOf(sep) + 1);
+}
+
+function getExtension(name: string): string {
+	const dot = name.lastIndexOf('.');
+	return dot >= 0 ? name.substring(dot) : '';
+}
+
+export class FileSystemAccess {
+	public getLastModified(path: string): Date {
+		try {
+			const file = Windows.Storage.StorageFile.GetFileFromPathAsync(path) as any;
+			return file?.DateCreated ? new Date(file.DateCreated) : new Date();
+		} catch {
+			return new Date();
+		}
+	}
+
+	public getFileSize(path: string): number {
+		try {
+			const props = (Windows.Storage.StorageFile.GetFileFromPathAsync(path) as any)?.GetBasicPropertiesAsync?.();
+			return props?.Size ?? 0;
+		} catch {
+			return 0;
+		}
+	}
+
+	public getParent(path: string, onError?: (error: any) => any): { path: string; name: string } {
+		try {
+			const sep = path.lastIndexOf('\\') !== -1 ? '\\' : '/';
+			const parentPath = path.substring(0, path.lastIndexOf(sep)) || path;
+			const name = getFileName(parentPath);
+			return { path: parentPath, name };
+		} catch (ex) {
+			if (onError) onError(ex);
+			return undefined;
+		}
+	}
+
+	public getFile(path: string, onError?: (error: any) => any): { path: string; name: string; extension: string } {
+		try {
+			if (!this.fileExists(path)) {
+				this._ensureParentDir(path);
+				Windows.Storage.PathIO.WriteTextAsync(path, '');
+			}
+			const name = getFileName(path);
+			return { path, name, extension: getExtension(name) };
+		} catch (ex) {
+			if (onError) onError(ex);
+			return undefined;
+		}
+	}
+
+	public getFolder(path: string, onError?: (error: any) => any): { path: string; name: string } {
+		try {
+			if (!this.folderExists(path)) {
+				Windows.Storage.StorageFolder.GetFolderFromPathAsync(path);
+			}
+			return { path, name: getFileName(path) };
+		} catch (ex) {
+			if (onError) onError(ex);
+			return undefined;
+		}
+	}
+
+	public getExistingFolder(path: string, onError?: (error: any) => any): { path: string; name: string } {
+		try {
+			if (this.folderExists(path)) {
+				return { path, name: getFileName(path) };
+			}
+			return undefined;
+		} catch (ex) {
+			if (onError) onError(ex);
+			return undefined;
+		}
+	}
+
+	public eachEntity(path: string, onEntity: (file: { path: string; name: string; extension: string }) => any, onError?: (error: any) => any) {
+		if (!onEntity) return;
+		this._enumEntities(path, onEntity, onError);
+	}
+
+	public getEntities(path: string, onError?: (error: any) => any): Array<{ path: string; name: string; extension: string }> {
+		const results: Array<{ path: string; name: string; extension: string }> = [];
+		let errored = false;
+		this._enumEntities(
+			path,
+			(entity) => {
+				results.push(entity);
+				return true;
+			},
+			(err) => {
+				if (onError) onError(err);
+				errored = true;
+			},
+		);
+		return errored ? null : results;
+	}
+
+	public fileExists(path: string): boolean {
+		try {
+			Windows.Storage.StorageFile.GetFileFromPathAsync(path);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+
+	public folderExists(path: string): boolean {
+		try {
+			Windows.Storage.StorageFolder.GetFolderFromPathAsync(path);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+
+	public deleteFile(path: string, onError?: (error: any) => any) {
+		try {
+			const file = Windows.Storage.StorageFile.GetFileFromPathAsync(path) as any;
+			file?.DeleteAsync?.();
+		} catch (ex) {
+			if (onError) onError(ex);
+		}
+	}
+
+	public deleteFolder(path: string, onError?: (error: any) => any) {
+		try {
+			const folder = Windows.Storage.StorageFolder.GetFolderFromPathAsync(path) as any;
+			folder?.DeleteAsync?.();
+		} catch (ex) {
+			if (onError) onError(ex);
+		}
+	}
+
+	public emptyFolder(path: string, onError?: (error: any) => any) {
+		const entities = this.getEntities(path, onError);
+		if (!entities) return;
+		for (const entity of entities) {
+			try {
+				this.deleteFile(entity.path, onError);
+			} catch (ex) {
+				if (onError) onError(ex);
+				return;
+			}
+		}
+	}
+
+	public rename(path: string, newPath: string, onError?: (error: any) => any) {
+		try {
+			const file = Windows.Storage.StorageFile.GetFileFromPathAsync(path) as any;
+			const newName = getFileName(newPath);
+			file?.RenameAsync?.(newName);
+		} catch (ex) {
+			if (onError) onError(new Error(`Failed to rename '${path}' to '${newPath}': ${ex}`));
+		}
+	}
+
+	public readText = this.readTextSync.bind(this);
+
+	public readTextAsync(path: string, encoding?: any): Promise<string> {
+		const enc = encoding ?? textEncoding.UTF_8;
+		return new Promise<string>((resolve, reject) => {
+			try {
+				NSWinRT.toPromise(Windows.Storage.PathIO.ReadTextAsync(path)).then(resolve, reject);
+			} catch (ex) {
+				reject(new Error(`Failed to read file at path '${path}': ${ex}`));
+			}
+		});
+	}
+
+	public readTextSync(path: string, onError?: (error: any) => any, _encoding?: any): string {
+		try {
+			let result: string;
+			(Windows.Storage.PathIO.ReadTextAsync(path) as any).done((text: string) => {
+				result = text;
+			});
+			return result ?? '';
+		} catch (ex) {
+			if (onError) onError(new Error(`Failed to read file at path '${path}': ${ex}`));
+			return undefined;
+		}
+	}
+
+	public writeText = this.writeTextSync.bind(this);
+
+	public writeTextAsync(path: string, content: string, _encoding?: any): Promise<void> {
+		return new Promise<void>((resolve, reject) => {
+			try {
+				NSWinRT.toPromise(Windows.Storage.PathIO.WriteTextAsync(path, content)).then(resolve, reject);
+			} catch (ex) {
+				reject(new Error(`Failed to write file at path '${path}': ${ex}`));
+			}
+		});
+	}
+
+	public writeTextSync(path: string, content: string, onError?: (error: any) => any, _encoding?: any) {
+		try {
+			(Windows.Storage.PathIO.WriteTextAsync(path, content) as any).done();
+		} catch (ex) {
+			if (onError) onError(new Error(`Failed to write file at path '${path}': ${ex}`));
+		}
+	}
+
+	public appendText = this.appendTextSync.bind(this);
+
+	public appendTextAsync(path: string, content: string, _encoding?: any): Promise<void> {
+		return new Promise<void>((resolve, reject) => {
+			try {
+				NSWinRT.toPromise(Windows.Storage.PathIO.AppendTextAsync(path, content)).then(resolve, reject);
+			} catch (ex) {
+				reject(new Error(`Failed to append to file at path '${path}': ${ex}`));
+			}
+		});
+	}
+
+	public appendTextSync(path: string, content: string, onError?: (error: any) => any, _encoding?: any) {
+		try {
+			(Windows.Storage.PathIO.AppendTextAsync(path, content) as any).done();
+		} catch (ex) {
+			if (onError) onError(new Error(`Failed to append to file at path '${path}': ${ex}`));
+		}
+	}
+
+	public readBuffer = this.readBufferSync.bind(this);
+
+	public readBufferAsync(path: string): Promise<ArrayBuffer> {
+		return new Promise<ArrayBuffer>((resolve, reject) => {
+			try {
+				NSWinRT.toPromise(Windows.Storage.PathIO.ReadBufferAsync(path)).then((buffer: any) => {
+					const reader = Windows.Storage.Streams.DataReader.FromBuffer(buffer);
+					const bytes = new Uint8Array(buffer.Length);
+					reader.ReadBytes(bytes as any);
+					resolve(bytes.buffer);
+				}, reject);
+			} catch (ex) {
+				reject(new Error(`Failed to read buffer at path '${path}': ${ex}`));
+			}
+		});
+	}
+
+	public readBufferSync(path: string, onError?: (error: any) => any): ArrayBuffer {
+		try {
+			let result: ArrayBuffer;
+			(Windows.Storage.PathIO.ReadBufferAsync(path) as any).done((buffer: any) => {
+				const reader = Windows.Storage.Streams.DataReader.FromBuffer(buffer);
+				const bytes = new Uint8Array(buffer.Length);
+				reader.ReadBytes(bytes as any);
+				result = bytes.buffer;
+			});
+			return result;
+		} catch (ex) {
+			if (onError) onError(new Error(`Failed to read buffer at path '${path}': ${ex}`));
+			return undefined;
+		}
+	}
+
+	public writeBuffer = this.writeBufferSync.bind(this);
+
+	public writeBufferAsync(path: string, content: ArrayBuffer): Promise<void> {
+		return new Promise<void>((resolve, reject) => {
+			try {
+				const writer = new Windows.Storage.Streams.DataWriter();
+				writer.WriteBytes(new Uint8Array(content) as any);
+				const buf = writer.DetachBuffer();
+				NSWinRT.toPromise(Windows.Storage.PathIO.WriteBufferAsync(path, buf)).then(resolve, reject);
+			} catch (ex) {
+				reject(new Error(`Failed to write buffer at path '${path}': ${ex}`));
+			}
+		});
+	}
+
+	public writeBufferSync(path: string, content: ArrayBuffer, onError?: (error: any) => any) {
+		try {
+			const writer = new Windows.Storage.Streams.DataWriter();
+			writer.WriteBytes(new Uint8Array(content) as any);
+			const buf = writer.DetachBuffer();
+			(Windows.Storage.PathIO.WriteBufferAsync(path, buf) as any).done();
+		} catch (ex) {
+			if (onError) onError(new Error(`Failed to write buffer at path '${path}': ${ex}`));
+		}
+	}
+
+	public read = this.readSync.bind(this);
+
+	public readAsync(path: string): Promise<any> {
+		return this.readBufferAsync(path);
+	}
+
+	public readSync(path: string, onError?: (error: any) => any): any {
+		return this.readBufferSync(path, onError);
+	}
+
+	public write = this.writeSync.bind(this);
+
+	public writeAsync(path: string, content: any): Promise<void> {
+		return this.writeBufferAsync(path, content);
+	}
+
+	public writeSync(path: string, content: any, onError?: (error: any) => any) {
+		return this.writeBufferSync(path, content, onError);
+	}
+
+	public append = this.appendSync.bind(this);
+
+	public appendAsync(path: string, content: any): Promise<void> {
+		return new Promise<void>((resolve, reject) => {
+			try {
+				const writer = new Windows.Storage.Streams.DataWriter();
+				writer.WriteBytes(new Uint8Array(content) as any);
+				const buf = writer.DetachBuffer();
+				NSWinRT.toPromise(Windows.Storage.PathIO.WriteBufferAsync(path, buf)).then(resolve, reject);
+			} catch (ex) {
+				reject(ex);
+			}
+		});
+	}
+
+	public appendSync(path: string, content: any, onError?: (error: any) => any) {
+		try {
+			const writer = new Windows.Storage.Streams.DataWriter();
+			writer.WriteBytes(new Uint8Array(content) as any);
+			const buf = writer.DetachBuffer();
+			(Windows.Storage.PathIO.WriteBufferAsync(path, buf) as any).done();
+		} catch (ex) {
+			if (onError) onError(ex);
+		}
+	}
+
+	public copy = this.copySync.bind(this);
+
+	public copySync(src: string, dest: string, onError?: (error: any) => any): boolean {
+		try {
+			const srcFile = Windows.Storage.StorageFile.GetFileFromPathAsync(src) as any;
+			const destParent = this.getParent(dest)?.path;
+			const destFolder = Windows.Storage.StorageFolder.GetFolderFromPathAsync(destParent) as any;
+			const destName = getFileName(dest);
+			srcFile?.CopyAsync?.(destFolder, destName, Windows.Storage.NameCollisionOption.ReplaceExisting);
+			return true;
+		} catch (ex) {
+			if (onError) onError(ex);
+			return false;
+		}
+	}
+
+	public copyAsync(src: string, dest: string): Promise<boolean> {
+		const destParent = this.getParent(dest)?.path;
+		const destName = getFileName(dest);
+		return NSWinRT.toPromise(Windows.Storage.StorageFile.GetFileFromPathAsync(src))
+			.then((srcFile: any) => NSWinRT.toPromise(Windows.Storage.StorageFolder.GetFolderFromPathAsync(destParent))
+				.then((destFolder: any) => NSWinRT.toPromise(srcFile.CopyAsync(destFolder, destName, Windows.Storage.NameCollisionOption.ReplaceExisting)))
+			)
+			.then(() => true);
+	}
+
+	public getPathSeparator(): string {
+		return getPathSep();
+	}
+
+	public normalizePath(path: string): string {
+		return path.replace(/\//g, '\\');
+	}
+
+	public joinPath(left: string, right: string): string {
+		const l = left.endsWith('\\') || left.endsWith('/') ? left.slice(0, -1) : left;
+		const r = right.startsWith('\\') || right.startsWith('/') ? right.slice(1) : right;
+		return `${l}\\${r}`;
+	}
+
+	public joinPaths(...paths: string[]): string {
+		return paths.reduce((acc, p) => this.joinPath(acc, p));
+	}
+
+	public getDocumentsFolderPath(): string {
+		try {
+			return Windows.Storage.ApplicationData.Current.LocalFolder.Path;
+		} catch {
+			return '';
+		}
+	}
+
+	public getExternalDocumentsFolderPath(): string {
+		return this.getDocumentsFolderPath();
+	}
+
+	public getTempFolderPath(): string {
+		try {
+			return Windows.Storage.ApplicationData.Current.TemporaryFolder.Path;
+		} catch {
+			return '';
+		}
+	}
+
+	public getCurrentAppPath(): string {
+		try {
+			return Windows.ApplicationModel.Package.Current.InstalledLocation.Path;
+		} catch {
+			if (!global.__dirname) {
+				global.__dirname = typeof __dirname !== 'undefined' ? __dirname : '';
+			}
+			return global.__dirname;
+		}
+	}
+
+	public getLogicalRootPath(): string {
+		return this.getCurrentAppPath();
+	}
+
+	private _ensureParentDir(path: string): void {
+		const parent = this.getParent(path)?.path;
+		if (parent && !this.folderExists(parent)) {
+			try {
+				const parts = parent.split('\\');
+				let current = parts[0];
+				for (let i = 1; i < parts.length; i++) {
+					current += '\\' + parts[i];
+					if (!this.folderExists(current)) {
+						(Windows.Storage.StorageFolder.GetFolderFromPathAsync(current) as any);
+					}
+				}
+			} catch {}
+		}
+	}
+
+	private _enumEntities(path: string, onEntity: (file: { path: string; name: string; extension: string }) => any, onError?: (error: any) => any) {
+		try {
+			(Windows.Storage.StorageFolder.GetFolderFromPathAsync(path) as any).done((folder: any) => {
+				(folder.GetItemsAsync() as any).done((items: any) => {
+					for (let i = 0; i < items.Size; i++) {
+						const item = items.GetAt(i);
+						const name = item.Name;
+						const itemPath = item.Path;
+						const cont = onEntity({ path: itemPath, name, extension: getExtension(name) });
+						if (cont === false) break;
+					}
+				});
+			});
+		} catch (ex) {
+			if (onError) onError(ex);
+		}
+	}
+}
diff --git a/packages/core/fps-meter/fps-native.windows.ts b/packages/core/fps-meter/fps-native.windows.ts
new file mode 100644
index 0000000000..e9c22a9732
--- /dev/null
+++ b/packages/core/fps-meter/fps-native.windows.ts
@@ -0,0 +1,42 @@
+export class FPSCallback {
+	public running: boolean = false;
+	private onFrame: (currentTimeMillis: number) => void;
+	private _delegate: any = null;
+
+	constructor(onFrame: (currentTimeMillis: number) => void) {
+		this.onFrame = onFrame;
+	}
+
+	public start() {
+		if (this.running) {
+			return;
+		}
+		this.running = true;
+
+		try {
+			// CompositionTarget.Rendering fires once per compositor frame at the display's
+			// native refresh rate (60/120/144/240 Hz), unlike a fixed-interval DispatcherTimer
+			// which caps at ~62 fps regardless of display refresh rate.
+			this._delegate = NSWinRT.asDelegate('Windows.Foundation.EventHandler`1<Object>', () => {
+				if (this.running) {
+					this.onFrame(Date.now());
+				}
+			});
+			Microsoft.UI.Xaml.Media.CompositionTarget.Rendering = this._delegate;
+		} catch {
+		}
+	}
+
+	public stop() {
+		if (!this.running) {
+			return;
+		}
+		this.running = false;
+		if (this._delegate) {
+			try {
+				Microsoft.UI.Xaml.Media.CompositionTarget.Rendering = null;
+			} catch {}
+			this._delegate = null;
+		}
+	}
+}
diff --git a/packages/core/global-types.d.ts b/packages/core/global-types.d.ts
index 78ca864489..d003c79cec 100644
--- a/packages/core/global-types.d.ts
+++ b/packages/core/global-types.d.ts
@@ -135,6 +135,7 @@ declare const __ANDROID__: boolean;
 declare const __IOS__: boolean;
 declare const __VISIONOS__: boolean;
 declare const __APPLE__: boolean;
+declare const __WINDOWS__: boolean;
 
 declare function setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): number;
 declare function clearTimeout(timeoutId: number): void;
diff --git a/packages/core/http/http-request-internal/index.windows.ts b/packages/core/http/http-request-internal/index.windows.ts
new file mode 100644
index 0000000000..89ad808b43
--- /dev/null
+++ b/packages/core/http/http-request-internal/index.windows.ts
@@ -0,0 +1,145 @@
+import type { HttpRequestOptions, HttpResponse, Headers } from '../http-interfaces';
+import { HttpResponseEncoding } from '../http-interfaces';
+import { BaseHttpContent } from '.';
+import { addHeader } from './http-request-internal-common';
+import { isMainThread, dispatchToMainThread } from '../../utils/mainthread-helper';
+export { addHeader } from './http-request-internal-common';
+
+export function requestInternal<T extends object>(options: HttpRequestOptions, contentHandler?: T): Promise<HttpResponse<BaseHttpContent & T>> {
+	return new Promise<HttpResponse<BaseHttpContent & T>>((resolve, reject) => {
+		if (!options.url) {
+			reject(new Error('Request url was empty.'));
+			return;
+		}
+
+		try {
+			const httpClient = new Windows.Web.Http.HttpClient();
+			const uri = new Windows.Foundation.Uri(options.url.trim());
+			const method = new Windows.Web.Http.HttpMethod(options.method || 'GET');
+			const requestMessage = new Windows.Web.Http.HttpRequestMessage(method, uri);
+
+			if (options.headers) {
+				for (const key in options.headers) {
+					try {
+						requestMessage.Headers.TryAppendWithoutValidation(key, options.headers[key] + '');
+					} catch { }
+				}
+			}
+
+			if (options.content) {
+				if (typeof options.content === 'string') {
+					requestMessage.Content = new Windows.Web.Http.HttpStringContent(options.content);
+				} else if (options.content instanceof FormData) {
+					requestMessage.Content = new Windows.Web.Http.HttpStringContent(options.content.toString());
+				} else if (options.content instanceof ArrayBuffer) {
+					const writer = new Windows.Storage.Streams.DataWriter();
+					writer.WriteBytes(new Uint8Array(options.content as ArrayBuffer) as never);
+					requestMessage.Content = new Windows.Web.Http.HttpBufferContent(writer.DetachBuffer());
+				}
+			}
+
+
+			NSWinRT.toPromise(httpClient.SendRequestAsync(requestMessage)).then(
+				(response: Windows.Web.Http.HttpResponseMessage) => {
+					const statusCode: number = response.StatusCode as unknown as number;
+					const headers: Headers = {};
+
+					try {
+						const Headers = response.Headers;
+						const first = Headers.First();
+						while (first && first.HasCurrent) {
+							const header = first.Current;
+							addHeader(headers, header.Key, header.Value);
+							first.MoveNext();
+						}
+					} catch { }
+					try {
+						const Headers = response.Content.Headers;
+						const first = Headers.First();
+						while (first && first.HasCurrent) {
+							const header = first.Current;
+							addHeader(headers, header.Key, header.Value);
+							first.MoveNext();
+						}
+					} catch { }
+
+					NSWinRT.toPromise(response.Content.ReadAsBufferAsync()).then(
+						(buffer: Windows.Storage.Streams.IBuffer) => {
+							let bytes: Uint8Array;
+							try {
+								const reader = Windows.Storage.Streams.DataReader.FromBuffer(buffer);
+								bytes = new Uint8Array(buffer.Length);
+								reader.ReadBytes(bytes as never);
+							} catch {
+								bytes = new Uint8Array(0);
+							}
+
+							const rawBuffer = bytes.buffer as ArrayBuffer;
+
+							const content = {
+								raw: rawBuffer,
+								requestURL: options.url,
+								toNativeImage: (): Promise<any> => {
+									return new Promise((resolve, reject) => {
+										try {
+											const writer = new Windows.Storage.Streams.DataWriter();
+											writer.WriteBytes(bytes as never);
+											const freshBuffer = writer.DetachBuffer();
+											const stream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
+											NSWinRT.toPromise((stream as any).WriteAsync(freshBuffer)).then(() => {
+												const createBitmap = () => {
+													try {
+														(stream as any).Seek(0);
+														const bmp = new Microsoft.UI.Xaml.Media.Imaging.BitmapImage();
+														NSWinRT.toPromise(bmp.SetSourceAsync(stream)).then(
+															() => { stream.Close(); resolve(bmp); },
+															reject
+														);
+													} catch (e) { reject(e); }
+												};
+												if (isMainThread()) {
+													createBitmap();
+												} else {
+													dispatchToMainThread(createBitmap);
+												}
+											}, reject);
+										} catch (e) { reject(e); }
+									});
+								},
+								toNativeString: (encoding?: HttpResponseEncoding) => {
+									return BufferToString(buffer, encoding);
+								},
+							};
+
+							if (contentHandler != null && typeof contentHandler === 'object' && !Array.isArray(contentHandler)) {
+								Object.assign(content, contentHandler);
+							}
+
+							resolve({
+								content: content as BaseHttpContent & T,
+								statusCode,
+								headers,
+							});
+						},
+						(err: any) => reject(new Error(err?.message ?? String(err)))
+					);
+				},
+			).catch((err: any) => {
+				reject(new Error(err?.message ?? String(err)));
+			});
+		} catch (ex) {
+			reject(ex);
+		}
+	});
+}
+
+
+function BufferToString(buffer: Windows.Storage.Streams.IBuffer, encoding?: HttpResponseEncoding): string {
+	let encodingType = Windows.Security.Cryptography.BinaryStringEncoding.Utf8;
+	if (encoding === HttpResponseEncoding.GBK) {
+		encodingType = Windows.Security.Cryptography.BinaryStringEncoding.Utf8; // Windows does not support GBK, fallback to UTF-8
+	}
+	return Windows.Security.Cryptography.CryptographicBuffer.ConvertBinaryToString(
+		encodingType,
+		buffer);
+}
\ No newline at end of file
diff --git a/packages/core/http/http-request/index.windows.ts b/packages/core/http/http-request/index.windows.ts
new file mode 100644
index 0000000000..4e5fe961cd
--- /dev/null
+++ b/packages/core/http/http-request/index.windows.ts
@@ -0,0 +1,44 @@
+import type { HttpResponse, HttpRequestOptions, HttpContentHandler } from '../../http';
+import { ImageSource } from '../../image-source';
+import { File } from '../../file-system';
+import type { HttpResponseEncoding } from '../http-interfaces';
+import { BaseHttpContent, requestInternal } from '../http-request-internal';
+import { getFilenameFromUrl, parseJSON } from './http-request-common';
+
+const contentHandler: HttpContentHandler = {
+	toArrayBuffer(this: BaseHttpContent): ArrayBuffer {
+		if (this.raw instanceof ArrayBuffer) {
+			return this.raw;
+		}
+		if (this.raw instanceof Uint8Array) {
+			return this.raw.buffer as ArrayBuffer;
+		}
+		return new ArrayBuffer(0);
+	},
+	toString(this: BaseHttpContent, _encoding?: HttpResponseEncoding) {
+		const str = this.toNativeString(_encoding);
+		if (typeof str === 'string') {
+			return str;
+		}
+		throw new Error('Response content may not be converted to string');
+	},
+	toJSON(this: BaseHttpContent, encoding?: HttpResponseEncoding) {
+		return parseJSON(this.toNativeString(encoding));
+	},
+	toImage(this: BaseHttpContent) {
+		return this.toNativeImage().then((value) => new ImageSource(value));
+	},
+	toFile(this: BaseHttpContent, destinationFilePath?: string) {
+		if (!destinationFilePath) {
+			destinationFilePath = getFilenameFromUrl(this.requestURL);
+		}
+		const file = File.fromPath(destinationFilePath);
+		const data = this.raw instanceof ArrayBuffer ? this.raw : (this.raw instanceof Uint8Array ? this.raw.buffer : new ArrayBuffer(0));
+		file.writeSync(data);
+		return file;
+	},
+};
+
+export function request(options: HttpRequestOptions): Promise<HttpResponse> {
+	return requestInternal(options, contentHandler);
+}
diff --git a/packages/core/image-asset/index.windows.ts b/packages/core/image-asset/index.windows.ts
new file mode 100644
index 0000000000..92e5cf0650
--- /dev/null
+++ b/packages/core/image-asset/index.windows.ts
@@ -0,0 +1,44 @@
+import { ImageAssetBase } from './image-asset-common';
+import { path as fsPath, knownFolders } from '../file-system';
+
+export * from './image-asset-common';
+
+export class ImageAsset extends ImageAssetBase {
+	private _windows: any;
+
+	constructor(asset: string | any) {
+		super();
+		if (typeof asset === 'string') {
+			if (asset.indexOf('~/') === 0) {
+				asset = fsPath.join(knownFolders.currentApp().path, asset.replace('~/', ''));
+			}
+			this._windows = asset;
+		} else {
+			this._windows = asset;
+		}
+	}
+
+	get windows(): any {
+		return this._windows;
+	}
+
+	set windows(value: any) {
+		this._windows = value;
+	}
+
+	public getImageAsync(callback: (image: any, error: any) => void) {
+		try {
+			// Use _windows first, fall back to base-class nativeImage (set via asset.nativeImage = x).
+			// fromAsset dispatches on type: string paths go through fromFile, StorageFile objects
+			// go through OpenAsync — no conversion needed here.
+			const image = this._windows ?? this.nativeImage;
+			if (image == null) {
+				callback(null, new Error('ImageAsset: no image data'));
+				return;
+			}
+			callback(image, null);
+		} catch (ex) {
+			callback(null, ex);
+		}
+	}
+}
diff --git a/packages/core/image-source/index.android.ts b/packages/core/image-source/index.android.ts
index 3637c05182..56fdf7e76e 100644
--- a/packages/core/image-source/index.android.ts
+++ b/packages/core/image-source/index.android.ts
@@ -18,6 +18,7 @@ function getApplication() {
 export class ImageSource implements ImageSourceDefinition {
 	public android: android.graphics.Bitmap;
 	public ios: UIImage;
+	public windows: any;
 
 	public get height(): number {
 		if (this.android) {
diff --git a/packages/core/image-source/index.d.ts b/packages/core/image-source/index.d.ts
index 95d086d474..86157737e2 100644
--- a/packages/core/image-source/index.d.ts
+++ b/packages/core/image-source/index.d.ts
@@ -31,6 +31,11 @@ export class ImageSource {
 	 */
 	android: any /* android.graphics.Bitmap */;
 
+	/**
+	 * The Windows-specific [image](https://learn.microsoft.com/en-us/uwp/api/windows.ui.xaml.media.imagesource) instance. Will be undefined when running on iOS or Android.
+	 */
+	windows: any /* Windows.UI.Xaml.Media.ImageSource */;
+
 	/**
 	 * Loads this instance from the specified asset asynchronously.
 	 * @param asset The ImageAsset instance used to create ImageSource.
diff --git a/packages/core/image-source/index.ios.ts b/packages/core/image-source/index.ios.ts
index bc2fd473c1..b1b14de251 100644
--- a/packages/core/image-source/index.ios.ts
+++ b/packages/core/image-source/index.ios.ts
@@ -14,6 +14,7 @@ export { isFileOrResourcePath };
 export class ImageSource implements ImageSourceDefinition {
 	public android: android.graphics.Bitmap;
 	public ios: UIImage;
+	public windows: any;
 
 	get height(): number {
 		if (this.ios) {
diff --git a/packages/core/image-source/index.windows.ts b/packages/core/image-source/index.windows.ts
new file mode 100644
index 0000000000..f4b1030d81
--- /dev/null
+++ b/packages/core/image-source/index.windows.ts
@@ -0,0 +1,409 @@
+import type { ImageSource as ImageSourceDefinition } from '.';
+import { ImageAsset } from '../image-asset';
+import { path as fsPath, knownFolders } from '../file-system';
+import { isFileOrResourcePath } from '../utils';
+import { Trace } from '../trace';
+import { isMainThread, dispatchToMainThread } from '../utils/mainthread-helper';
+import { requestInternal as httpRequest } from '../http/http-request-internal';
+export { isFileOrResourcePath };
+
+// Cached constants for resource name handling
+const RES_PREFIX = 'res://';
+const LEADING_SLASHES_RE = /^[\\/]+/;
+const BACKSLASH_RE = /\\/g;
+
+function resolveAppPath(filePath: string): string {
+	if (filePath.startsWith('~/')) {
+		return fsPath.join(knownFolders.currentApp().path, filePath.substring(2));
+	}
+	return filePath;
+}
+
+function makeBitmapImage() {
+	return new Microsoft.UI.Xaml.Media.Imaging.BitmapImage();
+}
+
+function bitmapFromUriAsync(uriStr: string): Promise<Microsoft.UI.Xaml.Media.Imaging.BitmapImage> {
+	return new Promise((resolve, reject) => {
+		try {
+			const bmp = makeBitmapImage();
+			const onOpened = () => {
+				resolve(bmp);
+			};
+			const onFailed = (s: any, e: any) => {
+				reject(e || new Error('Image load failed'));
+			};
+			bmp.ImageOpened = onOpened;
+			bmp.ImageFailed = onFailed;
+			bmp.UriSource = new Windows.Foundation.Uri(uriStr);
+		} catch (err) { reject(err); }
+	});
+}
+
+function fileUri(filePath: string): string {
+	if (/^(ms-|http|file:)/i.test(filePath)) return filePath;
+	return 'file:///' + filePath.replace(/\\/g, '/');
+}
+
+function bytesToStream(bytes: Uint8Array): Promise<any> {
+	return new Promise((resolve, reject) => {
+		try {
+			const writer = new Windows.Storage.Streams.DataWriter();
+			writer.WriteBytes(bytes as never);
+			const buffer = writer.DetachBuffer();
+			const stream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
+			NSWinRT.toPromise((stream as any).WriteAsync(buffer)).then(
+				() => { try { (stream as any).Seek(0); resolve(stream); } catch (e) { reject(e); } },
+				reject
+			);
+		} catch (e) { reject(e); }
+	});
+}
+
+function bitmapFromStream(stream: any): Promise<any> {
+	return new Promise((resolve, reject) => {
+		// BitmapImage has UI thread affinity — create and load on the UI thread.
+		const create = () => {
+			try {
+				(stream as any).Seek(0);
+				const bmp = makeBitmapImage();
+				NSWinRT.toPromise(bmp.SetSourceAsync(stream)).then(
+					() => resolve(bmp),
+					reject
+				);
+			} catch (e) { reject(e); }
+		};
+		if (isMainThread()) {
+			create();
+		} else {
+			dispatchToMainThread(create);
+		}
+	});
+}
+
+function bitmapFromBytesAsync(bytes: Uint8Array): Promise<any> {
+	return bytesToStream(bytes).then((stream) => {
+		return bitmapFromStream(stream);
+	});
+}
+
+function fetchBytesAsync(url: string): Promise<Uint8Array> {
+	return new Promise((resolve, reject) => {
+		try {
+			const httpClient = new Windows.Web.Http.HttpClient();
+			const uri = new Windows.Foundation.Uri(url);
+			NSWinRT.toPromise(httpClient.GetBufferAsync(uri)).then(
+				(buffer: any) => {
+					try {
+						const reader = Windows.Storage.Streams.DataReader.FromBuffer(buffer);
+						const bytes = new Uint8Array(buffer.Length);
+						reader.ReadBytes(bytes as never);
+						resolve(bytes);
+					} catch (e) { reject(e); }
+				},
+				(err: any) => { reject(err); }
+			);
+		} catch (e) { reject(e); }
+	});
+}
+
+function bytesToBase64(bytes: Uint8Array): string {
+	let binary = '';
+	const len = bytes.byteLength;
+	for (let i = 0; i < len; i++) {
+		binary += String.fromCharCode(bytes[i]);
+	}
+	return btoa(binary);
+}
+
+function readFileBytes(filePath: string): Promise<Uint8Array> {
+	return new Promise((resolve, reject) => {
+		try {
+			NSWinRT.toPromise((Windows.Storage.PathIO as any).ReadBufferAsync(filePath)).then(
+				(buffer: any) => {
+					try {
+						const reader = Windows.Storage.Streams.DataReader.FromBuffer(buffer);
+						const bytes = new Uint8Array(buffer.Length);
+						reader.ReadBytes(bytes as never);
+						resolve(bytes);
+					} catch (e) { reject(e); }
+				},
+				reject
+			);
+		} catch (e) { reject(e); }
+	});
+}
+
+function writeBytesToFile(filePath: string, bytes: Uint8Array): Promise<boolean> {
+	return new Promise((resolve, reject) => {
+		NSWinRT.toPromise(
+			NativeScript.Widgets.ImageHelper.SaveToFileAsync(bytes as never, filePath)
+		).then(
+			(result) => resolve(result),
+			(err) => reject(err)
+		);
+	});
+}
+
+function resizeBitmapAsync(bytes: Uint8Array, maxSize: number): Promise<{ bmp: any; bytes: Uint8Array; width: number; height: number }> {
+	return new Promise((resolve, reject) => {
+		NSWinRT.toPromise(
+			NativeScript.Widgets.ImageHelper.ResizeAsync(bytes as never, maxSize)
+		).then(
+			(result: NativeScript.Widgets.ImageResult) => {
+				resolve({
+					bmp: result.Bitmap,
+					bytes: bytes,
+					width: result.Width,
+					height: result.Height,
+				});
+			})
+			.catch((err) => reject(err));
+
+	});
+}
+
+export class ImageSource implements ImageSourceDefinition {
+	public android: any;
+	public ios: any;
+	public windows: any; // BitmapImage or raw Uint8Array (lazy)
+
+	private _rawBytes: Uint8Array | null = null;
+	private _width: number = 0;
+	private _height: number = 0;
+	private _rotationAngle: number = 0;
+
+	public get height(): number { return this._height; }
+	public get width(): number { return this._width; }
+	public get rotationAngle(): number { return this._rotationAngle; }
+	public set rotationAngle(value: number) { this._rotationAngle = value; }
+
+	constructor(nativeSource?: any) {
+		if (nativeSource) {
+			this.setNativeSource(nativeSource);
+		}
+	}
+
+	static fromAsset(asset: ImageAsset): Promise<ImageSource> {
+		return new Promise<ImageSource>((resolve, reject) => {
+			asset.getImageAsync((fileOrNative: any, err: any) => {
+				if (err) { reject(err); return; }
+				if (!fileOrNative) { reject(new Error('No image from asset')); return; }
+				try {
+					if (typeof fileOrNative === 'string') {
+						ImageSource.fromFile(fileOrNative).then(resolve, reject);
+						return;
+					}
+					NSWinRT.toPromise(fileOrNative.OpenAsync(0 /* FileAccessMode.Read */)).then(
+						(stream: any) => bitmapFromStream(stream).then(
+							(bmp) => resolve(new ImageSource(bmp)),
+							reject
+						),
+						reject
+					);
+				} catch (e) { reject(e); }
+			});
+		});
+	}
+
+	static fromUrl(url: string): Promise<ImageSource> {
+		return httpRequest({ url, method: 'GET' }).then((response) => response.content.toNativeImage().then((value) => new ImageSource(value)));
+	}
+
+	static fromResourceSync(name: string): ImageSource {
+		if (!name) return null as any;
+		try {
+			const resourceName = name.startsWith(RES_PREFIX) ? name.slice(RES_PREFIX.length) : name;
+			const normalized = resourceName.replace(LEADING_SLASHES_RE, '').replace(BACKSLASH_RE, '/');
+			const exts = ['', '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.svg', '.webp'];
+			const resolve = (globalThis as any).__nsMsAppxResolve;
+			if (typeof resolve === 'function') {
+				for (const ext of exts) {
+					const uri = `ms-appx:///Assets/${normalized}${ext}`;
+					if (resolve(uri) != null) {
+						return ImageSource.fromFileSync(uri);
+					}
+				}
+				return null as any;
+			}
+			// Fallback when runtime hasn't registered the resolver yet
+			return ImageSource.fromFileSync(`ms-appx:///Assets/${normalized}`);
+		} catch {
+			return null as any;
+		}
+	}
+
+	static async fromResource(name: string): Promise<ImageSource> {
+		if (!name) return null as any;
+		try {
+			const resourceName = name.startsWith(RES_PREFIX) ? name.slice(RES_PREFIX.length) : name;
+			const normalized = resourceName.replace(LEADING_SLASHES_RE, '').replace(BACKSLASH_RE, '/');
+			const exts = ['', '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.svg', '.webp'];
+
+			for (const ext of exts) {
+				try {
+					const bmp = await bitmapFromUriAsync(`ms-appx:///Assets/${normalized}${ext}`);
+					if (bmp) {
+						const src = new ImageSource(bmp);
+						src._width = bmp.PixelWidth ?? 0;
+						src._height = bmp.PixelHeight ?? 0;
+						return src;
+					}
+				} catch { /* try next extension */ }
+			}
+
+			return null as any;
+		} catch {
+			return null as any;
+		}
+	}
+
+	static fromFileSync(filePath: string): ImageSource {
+		try {
+			const resolved = resolveAppPath(filePath);
+			const bmp = makeBitmapImage();
+			const src = new ImageSource();
+			bmp.ImageOpened = () => {
+				src._width = bmp.PixelWidth ?? 0;
+				src._height = bmp.PixelHeight ?? 0;
+				//@ts-ignore
+				bmp.ImageOpened = null;
+			};
+			bmp.ImageFailed = () => {
+				//@ts-ignore
+				bmp.ImageOpened = null;
+				//@ts-ignore
+				bmp.ImageFailed = null;
+			}
+			bmp.UriSource = new Windows.Foundation.Uri(fileUri(resolved));
+			src.windows = bmp;
+			return src;
+		} catch {
+			return null as any;
+		}
+	}
+
+	static fromFile(filePath: string): Promise<ImageSource> {
+		const resolved = resolveAppPath(filePath);
+		return readFileBytes(resolved).then((bytes) => {
+			return bitmapFromBytesAsync(bytes).then((bmp) => {
+				const src = new ImageSource(bmp);
+				src._rawBytes = bytes;
+				src._width = bmp.PixelWidth ?? 0;
+				src._height = bmp.PixelHeight ?? 0;
+				return src;
+			});
+		}).catch(() => {
+			return bitmapFromUriAsync(fileUri(resolved)).then((bmp) => {
+				const src = new ImageSource(bmp);
+				src._width = bmp.PixelWidth ?? 0;
+				src._height = bmp.PixelHeight ?? 0;
+				return src;
+			});
+		});
+	}
+
+	static fromDataSync(data: ArrayBuffer | Uint8Array): ImageSource {
+		const src = new ImageSource();
+		const bytes = data instanceof Uint8Array ? data : new Uint8Array(data as ArrayBuffer);
+		src.windows = bytes;
+		src._rawBytes = bytes;
+		return src;
+	}
+
+	static fromData(data: ArrayBuffer | Uint8Array): Promise<ImageSource> {
+		const bytes = data instanceof Uint8Array ? data : new Uint8Array(data as ArrayBuffer);
+		return bitmapFromBytesAsync(bytes).then((bmp) => {
+			const src = new ImageSource(bmp);
+			src._rawBytes = bytes;
+			src._width = bmp.PixelWidth ?? 0;
+			src._height = bmp.PixelHeight ?? 0;
+			return src;
+		});
+	}
+
+	static fromBase64Sync(source: string): ImageSource {
+		try {
+			const bytes = Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
+			return ImageSource.fromDataSync(bytes);
+		} catch {
+			return null as any;
+		}
+	}
+
+	static fromBase64(source: string): Promise<ImageSource> {
+		try {
+			const bytes = Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
+			return ImageSource.fromData(bytes);
+		} catch (e) {
+			return Promise.reject(e);
+		}
+	}
+
+	static fromSystemImageSync(name: string): ImageSource {
+		return ImageSource.fromResourceSync(name);
+	}
+
+	static fromSystemImage(name: string): Promise<ImageSource> {
+		return ImageSource.fromResource(name);
+	}
+
+	static fromFontIconCodeSync(_source: string, _font: any, _color: any): ImageSource {
+		return null as any;
+	}
+
+	public getNativeSource(): any {
+		return this.windows ?? this._rawBytes;
+	}
+
+	public setNativeSource(source: any): void {
+		this.windows = source;
+		try {
+			if (source && typeof source.PixelWidth === 'number') {
+				this._width = source.PixelWidth;
+				this._height = source.PixelHeight;
+			}
+		} catch { }
+	}
+
+	public saveToFile(_path: string, _format: string, _quality?: number): boolean {
+		return false;
+	}
+
+	public saveToFileAsync(path: string, _format: string, _quality?: number): Promise<boolean> {
+		if (!this._rawBytes) {
+			return Promise.resolve(false);
+		}
+		return writeBytesToFile(path, this._rawBytes).catch(() => false);
+	}
+
+	public toBase64String(_format: string, _quality?: number): string {
+		if (!this._rawBytes) return '';
+		try {
+			return bytesToBase64(this._rawBytes);
+		} catch {
+			return '';
+		}
+	}
+
+	public toBase64StringAsync(format: string, quality?: number): Promise<string> {
+		return Promise.resolve(this.toBase64String(format, quality));
+	}
+
+	public resize(_maxSize: number, _options?: any): ImageSource {
+		return this;
+	}
+
+	public resizeAsync(maxSize: number, _options?: any): Promise<any> {
+		if (!this._rawBytes) {
+			return Promise.resolve(this);
+		}
+		return resizeBitmapAsync(this._rawBytes, maxSize).then(({ bmp, bytes, width, height }) => {
+			const src = new ImageSource(bmp);
+			src._rawBytes = bytes;
+			src._width = width;
+			src._height = height;
+			return src;
+		}).catch(() => this);
+	}
+}
diff --git a/packages/core/package.json b/packages/core/package.json
index 937baae32a..3d6d550920 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -20,6 +20,9 @@
 		"**/platforms/ios/**",
 		"platforms/android/**",
 		"!platforms/android/core.aar",
+		"platforms/windows/**",
+		"plugin.props",
+		"plugin.targets",
 		"**/package.json"
 	],
 	"keywords": [
@@ -73,7 +76,8 @@
 	"nativescript": {
 		"platforms": {
 			"ios": "6.0.0",
-			"android": "6.0.0"
+			"android": "6.0.0",
+			"windows": "9.1.0"
 		},
 		"hooks": [
 			{
diff --git a/packages/core/platform/common.ts b/packages/core/platform/common.ts
index 3e5b4c4c58..8e20253584 100644
--- a/packages/core/platform/common.ts
+++ b/packages/core/platform/common.ts
@@ -6,9 +6,11 @@ export const platformNames = {
 	ios: 'iOS',
 	visionos: 'visionOS',
 	apple: 'apple',
+	windows: 'Windows',
 };
 
 export const isAndroid = !!__ANDROID__;
 export const isIOS = !!__IOS__ || !!__VISIONOS__;
 export const isVisionOS = !!__VISIONOS__;
 export const isApple = !!__APPLE__;
+export const isWindows = typeof __WINDOWS__ !== 'undefined' && !!__WINDOWS__;
diff --git a/packages/core/platform/device/index.windows.ts b/packages/core/platform/device/index.windows.ts
new file mode 100644
index 0000000000..1b42bd9fea
--- /dev/null
+++ b/packages/core/platform/device/index.windows.ts
@@ -0,0 +1,103 @@
+import { Screen } from '../screen';
+
+const MIN_TABLET_PIXELS = 600;
+
+class DeviceRef {
+	private _manufacturer: string;
+	private _model: string;
+	private _osVersion: string;
+	private _uuid: string;
+
+	get manufacturer(): string {
+		if (!this._manufacturer) {
+			try {
+				this._manufacturer = Windows.System.Profile.SystemManufacturerInfo.SmbiosInfo.SystemManufacturer || 'Microsoft';
+			} catch {
+				this._manufacturer = 'Microsoft';
+			}
+		}
+		return this._manufacturer;
+	}
+
+	get os(): string {
+		return 'Windows';
+	}
+
+	get osVersion(): string {
+		if (!this._osVersion) {
+			try {
+				const versionStr = Windows.System.Profile.AnalyticsInfo.VersionInfo.DeviceFamilyVersion;
+				const version = parseInt(versionStr, 10);
+				if (!isNaN(version)) {
+					const major = (version / 0x1000000000000) & 0xffff;
+					const minor = (version / 0x100000000) & 0xffff;
+					const build = (version / 0x10000) & 0xffff;
+					this._osVersion = `${major}.${minor}.${build}`;
+				} else {
+					this._osVersion = versionStr || 'unknown';
+				}
+			} catch {
+				this._osVersion = 'unknown';
+			}
+		}
+		return this._osVersion;
+	}
+
+	get model(): string {
+		if (!this._model) {
+			try {
+				this._model = Windows.System.Profile.SystemManufacturerInfo.SmbiosInfo.SystemProductName || 'Windows PC';
+			} catch {
+				this._model = 'Windows PC';
+			}
+		}
+		return this._model;
+	}
+
+	get sdkVersion(): string {
+		return this.osVersion;
+	}
+
+	get deviceType(): 'Phone' | 'Tablet' {
+		const dips = Math.min(Screen.mainScreen.widthPixels, Screen.mainScreen.heightPixels) / Screen.mainScreen.scale;
+		return dips >= MIN_TABLET_PIXELS ? 'Tablet' : 'Phone';
+	}
+
+	get uuid(): string {
+		if (!this._uuid) {
+			try {
+				const systemId = Windows.System.Profile.SystemIdentification.GetSystemIdForPublisher();
+				const buffer = systemId.Id;
+				const reader = Windows.Storage.Streams.DataReader.FromBuffer(buffer);
+				const bytes = new Uint8Array(buffer.Length);
+				reader.ReadBytes(bytes);
+				this._uuid = Array.from(bytes)
+					.map((b) => b.toString(16).padStart(2, '0'))
+					.join('');
+			} catch {
+				this._uuid = 'windows-' + Math.random().toString(36).substr(2, 9);
+			}
+		}
+		return this._uuid;
+	}
+
+	get language(): string {
+		try {
+			return Windows.Globalization.Language.CurrentInputMethodLanguageTag || 'en';
+		} catch {
+			return 'en';
+		}
+	}
+
+	get region(): string {
+		try {
+			return Windows.System.UserProfile.GlobalizationPreferences.HomeGeographicRegion || 'US';
+		} catch {
+			return 'US';
+		}
+	}
+}
+
+export const Device = new DeviceRef();
+
+export const device = Device;
diff --git a/packages/core/platform/screen/index.windows.ts b/packages/core/platform/screen/index.windows.ts
new file mode 100644
index 0000000000..3da0e2a920
--- /dev/null
+++ b/packages/core/platform/screen/index.windows.ts
@@ -0,0 +1,32 @@
+import { getCurrentWindowBounds, getCurrentWindowScale } from '../../application/window-helper.windows';
+
+class MainScreen {
+	// Metrics derived from the current window's XamlRoot (WinUI3 has no GetForCurrentView()).
+	get widthPixels(): number {
+		return Math.round(this.widthDIPs * this.scale);
+	}
+
+	get heightPixels(): number {
+		return Math.round(this.heightDIPs * this.scale);
+	}
+
+	get scale(): number {
+		return getCurrentWindowScale();
+	}
+
+	get widthDIPs(): number {
+		return getCurrentWindowBounds()?.Width ?? 1920;
+	}
+
+	get heightDIPs(): number {
+		return getCurrentWindowBounds()?.Height ?? 1080;
+	}
+
+	public _updateMetrics(): void {}
+}
+
+export class Screen {
+	static mainScreen = new MainScreen();
+}
+
+export const screen = Screen;
diff --git a/packages/core/platforms/windows/arm64/NativeScript.Widgets.dll b/packages/core/platforms/windows/arm64/NativeScript.Widgets.dll
new file mode 100644
index 0000000000..3c162daac3
Binary files /dev/null and b/packages/core/platforms/windows/arm64/NativeScript.Widgets.dll differ
diff --git a/packages/core/platforms/windows/arm64/NativeScript.Widgets.winmd b/packages/core/platforms/windows/arm64/NativeScript.Widgets.winmd
new file mode 100644
index 0000000000..8d15c6ab27
Binary files /dev/null and b/packages/core/platforms/windows/arm64/NativeScript.Widgets.winmd differ
diff --git a/packages/core/platforms/windows/x64/NativeScript.Widgets.dll b/packages/core/platforms/windows/x64/NativeScript.Widgets.dll
new file mode 100644
index 0000000000..4687ab3b1b
Binary files /dev/null and b/packages/core/platforms/windows/x64/NativeScript.Widgets.dll differ
diff --git a/packages/core/platforms/windows/x64/NativeScript.Widgets.winmd b/packages/core/platforms/windows/x64/NativeScript.Widgets.winmd
new file mode 100644
index 0000000000..8d6a6a4eeb
Binary files /dev/null and b/packages/core/platforms/windows/x64/NativeScript.Widgets.winmd differ
diff --git a/packages/core/plugin.props b/packages/core/plugin.props
new file mode 100644
index 0000000000..cb544b194c
--- /dev/null
+++ b/packages/core/plugin.props
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  @nativescript/core — Windows plugin props.
+
+  Intentionally empty. The NativeScript.Widgets C++/WinRT component is copied to
+  the package root by plugin.targets (an explicit Copy that survives MSIX Content
+  interception), so no <Content> items are declared here. This file exists so the
+  CLI uses it verbatim instead of auto-generating a <Content> include that would
+  stage both architectures into plugins/@nativescript/core/.
+-->
+<Project>
+</Project>
diff --git a/packages/core/plugin.targets b/packages/core/plugin.targets
new file mode 100644
index 0000000000..5c1b35d594
--- /dev/null
+++ b/packages/core/plugin.targets
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  @nativescript/core — Windows plugin targets.
+
+  Copies the active-architecture NativeScript.Widgets C++/WinRT component (its
+  native .dll + .winmd metadata) to the package root ($(OutDir)). The runtime
+  resolves the winmd there via RoGetMetaDataFile and activates the in-proc server
+  (registered as windows.activatableClass.inProcessServer in the app's
+  Package.appxmanifest). An explicit Copy (rather than Content) is used so the
+  files survive EnableMsixTooling Content interception.
+
+  Native DLLs are per-architecture (no universal binary on Windows), so the
+  matching arch folder is chosen from $(Platform). The CLI stages this plugin's
+  platforms/windows/{x64,arm64}/ next to this file, so $(MSBuildThisFileDirectory)
+  resolves the arch subfolders.
+-->
+<Project>
+  <Target Name="CopyNativeScriptWidgets" AfterTargets="Build">
+    <PropertyGroup>
+      <_NSWidgetsArchDir Condition="'$(Platform)'=='ARM64' or '$(Platform)'=='arm64'">$(MSBuildThisFileDirectory)arm64\</_NSWidgetsArchDir>
+      <_NSWidgetsArchDir Condition="'$(Platform)'=='x64' or '$(Platform)'=='x86_64'">$(MSBuildThisFileDirectory)x64\</_NSWidgetsArchDir>
+      <!-- Fallback to x64 when $(Platform) is unset/AnyCPU during evaluation. -->
+      <_NSWidgetsArchDir Condition="'$(_NSWidgetsArchDir)'==''">$(MSBuildThisFileDirectory)x64\</_NSWidgetsArchDir>
+    </PropertyGroup>
+    <ItemGroup>
+      <_NSWidgetsFiles Include="$(_NSWidgetsArchDir)NativeScript.Widgets.dll" Condition="Exists('$(_NSWidgetsArchDir)NativeScript.Widgets.dll')" />
+      <_NSWidgetsFiles Include="$(_NSWidgetsArchDir)NativeScript.Widgets.winmd" Condition="Exists('$(_NSWidgetsArchDir)NativeScript.Widgets.winmd')" />
+    </ItemGroup>
+    <Message Text="[@nativescript/core] Copying NativeScript.Widgets ($(Platform)) to $(OutDir)" Importance="normal" Condition="'@(_NSWidgetsFiles)' != ''" />
+    <Copy SourceFiles="@(_NSWidgetsFiles)"
+          DestinationFolder="$(OutDir)"
+          SkipUnchangedFiles="true"
+          Condition="'@(_NSWidgetsFiles)' != ''" />
+  </Target>
+</Project>
diff --git a/packages/core/references.d.ts b/packages/core/references.d.ts
index 4300b64aee..338626a101 100644
--- a/packages/core/references.d.ts
+++ b/packages/core/references.d.ts
@@ -8,3 +8,7 @@
 /// <reference path="./platforms/ios/typings/objc!MaterialComponents.d.ts" />
 /// <reference path="./platforms/ios/typings/objc!NativeScriptUtils.d.ts" />
 /// <reference path="./global-types.d.ts" />
+/// <reference path="../types-minimal/src/lib/windows/windows.d.ts" />
+/// <reference path="../types-minimal/src/lib/windows/microsoft.ui.d.ts" />
+/// <reference path="../types-minimal/src/lib/windows/winrt-helpers.d.ts" />
+/// <reference path="../types-minimal/src/lib/windows/NativeScript.Widgets.d.ts" />
diff --git a/packages/core/text/index.windows.ts b/packages/core/text/index.windows.ts
new file mode 100644
index 0000000000..e1377eb270
--- /dev/null
+++ b/packages/core/text/index.windows.ts
@@ -0,0 +1,13 @@
+export * from './text-common';
+
+export namespace encoding {
+	export const UTF_16LE = 1200; // UTF-16LE
+	export const UTF_16BE = 1201; // UTF-16BE
+	export const UTF_8 = 65001; // CP_UTF8
+
+	export const US_ASCII = 20127; // US-ASCII
+	export const ISO_8859_1 = 28591; // ISO-8859-1
+
+	// UTF-16 on Windows is effectively UTF-16LE.
+	export const UTF_16 = UTF_16LE;
+}
\ No newline at end of file
diff --git a/packages/core/timer/index.windows.ts b/packages/core/timer/index.windows.ts
new file mode 100644
index 0000000000..f54a9c3c19
--- /dev/null
+++ b/packages/core/timer/index.windows.ts
@@ -0,0 +1,25 @@
+// __ns__setTimeout / __ns__setInterval are Rust-backed timers registered by
+// the windows-runtime. They use a background scheduler thread and post
+// callbacks back to the V8 thread via a per-thread channel that is drained
+// on every pump() tick — no XAML dispatcher required.
+declare function __ns__setTimeout(callback: Function, ms: number): number;
+declare function __ns__setInterval(callback: Function, ms: number): number;
+declare function __ns__clearTimeout(id: number): void;
+declare function __ns__clearInterval(id: number): void;
+
+export function setTimeout(callback: Function, milliseconds = 0, ...args: any[]): number {
+    milliseconds += 0;
+    const invoke = args.length ? () => callback(...args) : callback;
+    return __ns__setTimeout(zonedCallback(invoke), milliseconds);
+}
+
+export function clearTimeout(id: number): void {
+    __ns__clearTimeout(id);
+}
+
+export function setInterval(callback: Function, milliseconds = 0, ...args: []): number {
+    const invoke = args.length ? () => callback(...args) : callback;
+    return __ns__setInterval(zonedCallback(invoke), milliseconds);
+}
+
+export const clearInterval = clearTimeout;
diff --git a/packages/core/tsconfig.lib.json b/packages/core/tsconfig.lib.json
index 8d9d904e7b..c2c9160909 100644
--- a/packages/core/tsconfig.lib.json
+++ b/packages/core/tsconfig.lib.json
@@ -1,7 +1,7 @@
 {
 	"extends": "./tsconfig.json",
 	"compilerOptions": {
-		"noEmitOnError": true,
+		"noEmitOnError": false,
 		"noEmitHelpers": true,
 		"declaration": true,
 		"ignoreDeprecations": "5.0",
diff --git a/packages/core/ui/action-bar/index.windows.ts b/packages/core/ui/action-bar/index.windows.ts
new file mode 100644
index 0000000000..935f427db9
--- /dev/null
+++ b/packages/core/ui/action-bar/index.windows.ts
@@ -0,0 +1,36 @@
+export * from './action-bar-common';
+
+import { ActionBarBase, ActionItemBase } from './action-bar-common';
+import { View } from '../core/view';
+
+export class ActionItem extends ActionItemBase {}
+
+export class NavigationButton extends ActionItem {}
+
+export class ActionBar extends ActionBarBase {
+	get windows(): undefined {
+		return undefined;
+	}
+
+	public _addChildFromBuilder(name: string, value: any): void {
+		if (value instanceof NavigationButton) {
+			this.navigationButton = value;
+		} else if (value instanceof ActionItemBase) {
+			this.actionItems?.addItem(value);
+		} else if (value instanceof View) {
+			this.titleView = value;
+		}
+	}
+
+	public update(): void {
+		const page = this.parent as any;
+		if (!page) return;
+		const frame = page.frame as any;
+		if (!frame?._updateActionBar) return;
+		frame._updateActionBar(page);
+	}
+
+	public _onTitlePropertyChanged(): void {
+		this.update();
+	}
+}
diff --git a/packages/core/ui/activity-indicator/index.windows.ts b/packages/core/ui/activity-indicator/index.windows.ts
new file mode 100644
index 0000000000..3abc750bb4
--- /dev/null
+++ b/packages/core/ui/activity-indicator/index.windows.ts
@@ -0,0 +1,71 @@
+import { colorProperty, visibilityProperty } from '../styling/style-properties';
+import { CoreTypes } from '../../core-types';
+import { ActivityIndicatorBase, busyProperty } from './activity-indicator-common';
+import { Color } from '../../color';
+export * from './activity-indicator-common';
+
+// ProgressBar is not WinRT-activatable in this WinAppSDK build: ActivateInstance/RoActivateInstance return E_NOTIMPL,
+// so `new ProgressBar()` throws. Create via XamlReader instead; attempt `new` only until first failure, then remember.
+let _progressBarActivatable: boolean | undefined;
+function createProgressBar(): Microsoft.UI.Xaml.Controls.ProgressBar {
+	if (_progressBarActivatable !== false) {
+		try {
+			const pb = new Microsoft.UI.Xaml.Controls.ProgressBar();
+			_progressBarActivatable = true;
+			return pb;
+		} catch (_e) {
+			_progressBarActivatable = false;
+		}
+	}
+	return Microsoft.UI.Xaml.Markup.XamlReader.Load('<ProgressBar xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" />') as Microsoft.UI.Xaml.Controls.ProgressBar;
+}
+
+export class ActivityIndicator extends ActivityIndicatorBase {
+	nativeViewProtected: Microsoft.UI.Xaml.Controls.ProgressBar;
+
+	public createNativeView(): Microsoft.UI.Xaml.Controls.ProgressBar {
+		const indicator = createProgressBar();
+		indicator.IsIndeterminate = true;
+		indicator.Visibility = Microsoft.UI.Xaml.Visibility.Collapsed;
+		return indicator;
+	}
+
+	[busyProperty.getDefault](): boolean {
+		return false;
+	}
+
+	[busyProperty.setNative](value: boolean) {
+		if (this.visibility === CoreTypes.Visibility.visible) {
+			this.nativeViewProtected.Visibility = value ? Microsoft.UI.Xaml.Visibility.Visible : Microsoft.UI.Xaml.Visibility.Collapsed;
+		}
+	}
+
+	[visibilityProperty.getDefault](): CoreTypes.VisibilityType {
+		return CoreTypes.Visibility.hidden;
+	}
+
+	[visibilityProperty.setNative](value: CoreTypes.VisibilityType) {
+		switch (value) {
+			case CoreTypes.Visibility.visible:
+				this.nativeViewProtected.Visibility = this.busy ? Microsoft.UI.Xaml.Visibility.Visible : Microsoft.UI.Xaml.Visibility.Collapsed;
+				break;
+			case CoreTypes.Visibility.hidden:
+			case CoreTypes.Visibility.collapse:
+				this.nativeViewProtected.Visibility = Microsoft.UI.Xaml.Visibility.Collapsed;
+				break;
+			default:
+				throw new Error(`Invalid visibility value: ${value}. Valid values are: "${CoreTypes.Visibility.visible}", "${CoreTypes.Visibility.hidden}", "${CoreTypes.Visibility.collapse}".`);
+		}
+	}
+
+	[colorProperty.getDefault](): number {
+		return -1;
+	}
+	[colorProperty.setNative](value: Color | number) {
+		if (value instanceof Color) {
+			this.nativeViewProtected.Foreground = new Microsoft.UI.Xaml.Media.SolidColorBrush(value.windows);
+		} else {
+			this.nativeViewProtected.Foreground = null;
+		}
+	}
+}
diff --git a/packages/core/ui/animation/index.windows.ts b/packages/core/ui/animation/index.windows.ts
new file mode 100644
index 0000000000..1acb70f4ab
--- /dev/null
+++ b/packages/core/ui/animation/index.windows.ts
@@ -0,0 +1,482 @@
+export * from './animation-common';
+export * from './animation-shared';
+export * from './animation-types';
+
+export function _resolveAnimationCurve(curve: any): any {
+	return curve;
+}
+
+import { AnimationBase, Properties } from './animation-common';
+import type { View } from '../core/view';
+import { _ensureNativeTransforms } from '../core/view';
+
+function _applyFinalValue(target: any, property: string, to: any): void {
+	try {
+		switch (property) {
+			case Properties.opacity: target.opacity = to; break;
+			case Properties.translate: target.translateX = to?.x ?? 0; target.translateY = to?.y ?? 0; break;
+			case Properties.scale: target.scaleX = to?.x ?? 1; target.scaleY = to?.y ?? 1; break;
+			case Properties.rotate: target.rotate = to?.z ?? to; break;
+			case Properties.width: target.width = typeof to === 'object' ? (to?.value ?? to) : to; break;
+			case Properties.height: target.height = typeof to === 'object' ? (to?.value ?? to) : to; break;
+			default: break;
+		}
+	} catch (_e) {}
+}
+
+// Per-native-view, per-property storyboard conflict tracking.
+// When a new animation starts on the same native element + property, the previous
+// storyboard is stopped immediately and its promise resolved so the chain continues.
+const _activeStoryboards = new WeakMap<object, Map<string, () => void>>();
+
+function _cancelActiveStoryboard(native: object, property: string): void {
+	const map = _activeStoryboards.get(native);
+	if (!map) return;
+	const cancel = map.get(property);
+	if (cancel) { cancel(); map.delete(property); }
+}
+
+function _registerActiveStoryboard(native: object, property: string, cancel: () => void): void {
+	let map = _activeStoryboards.get(native);
+	if (!map) { map = new Map(); _activeStoryboards.set(native, map); }
+	map.set(property, cancel);
+}
+
+function _clearActiveStoryboard(native: object, property: string): void {
+	_activeStoryboards.get(native)?.delete(property);
+}
+
+const num = (v: any, d = 0) => (typeof v === 'number' ? v : (v && typeof v.value === 'number' ? v.value : (v && typeof v.x === 'number' ? v.x : d)));
+
+// Duration struct: { TimeSpan: { Duration: <100ns ticks> }, Type: 1 (DurationType.TimeSpan) }.
+// Keep ticks as a JS number — the struct marshaler uses number_value; a BigInt would read as 0.
+function _duration(ms: number): Microsoft.UI.Xaml.Duration {
+	return { TimeSpan: { Duration: Math.max(0, Math.round(ms)) * 10000 }, Type: 1 } as never;
+}
+
+// Easing function objects are stateless in XAML — the same CubicEase/BackEase can be shared
+// across all concurrent animations that use the same curve. Cache per curve name so 100
+// simultaneous animations only pay the WinRT construction cost once.
+const _xamlEasingCache = new Map<string, any>();
+
+export class Animation extends AnimationBase {
+	constructor(animationDefinitions: any[], playSequentially?: boolean) {
+		super(animationDefinitions, playSequentially);
+	}
+
+	// Per-instance cancel hooks for in-flight storyboards.
+	private _activeCancels: Array<() => void> = [];
+
+	// Maps a NativeScript curve to a XAML easing function; returns null for linear/unknown (native linear).
+	// Results are cached in the module-level _xamlEasingCache — easing objects are stateless in XAML
+	// so 100 animations with the same curve share one object instead of paying 100× WinRT construction.
+	private _xamlEasing(curve: any): any {
+		try {
+			const A: any = Microsoft.UI.Xaml.Media.Animation;
+			const EM: any = A.EasingMode;
+			let name: string | null = null;
+			if (typeof curve === 'string') name = curve;
+			else if (curve && typeof curve === 'object' && typeof curve.name === 'string') name = curve.name;
+			// Normalise 'ease' (CSS) → 'easeInOut' so both map to the same cache entry.
+			const cacheKey = (name === 'ease' ? 'easeInOut' : (name ?? 'linear'));
+			if (_xamlEasingCache.has(cacheKey)) return _xamlEasingCache.get(cacheKey);
+			let ease: any = null;
+			switch (name) {
+				case 'easeIn': { const e = new A.CubicEase(); e.EasingMode = EM.EaseIn; ease = e; break; }
+				case 'easeOut': { const e = new A.CubicEase(); e.EasingMode = EM.EaseOut; ease = e; break; }
+				case 'ease':
+				case 'easeInOut': { const e = new A.CubicEase(); e.EasingMode = EM.EaseInOut; ease = e; break; }
+				case 'spring': { const e = new A.BackEase() as Microsoft.UI.Xaml.Media.Animation.BackEase; e.EasingMode = EM.EaseOut; e.Amplitude = 0.3; ease = e; break; }
+				default: ease = null; break; // 'linear', cubic-bezier objects, raw functions → linear
+			}
+			_xamlEasingCache.set(cacheKey, ease);
+			return ease;
+		} catch (_e) { return null; }
+	}
+
+	// Native WinUI3 Storyboard animation (compositor-thread, vsync-aligned). Animates the SAME
+	// TransformGroup objects that _ensureNativeTransforms creates (scale/rotate/translate) so animated
+	// and static transforms stay consistent. Replaces the old setTimeout interpolation loop.
+	private _startStoryboardForProperty(native: any, property: string, to: any, dur: number, del: number, _tid2: string, target?: any, curve?: any, iterations?: number) {
+		return new Promise<void>((resolve) => {
+			const A: any = Microsoft.UI.Xaml.Media.Animation;
+			const dur2 = Math.max(0, Math.round(dur || 0));
+			const del2 = Math.max(0, Math.round(del || 0));
+			const ease = this._xamlEasing(curve);
+			const infinite = typeof iterations === 'number' && (iterations <= 0 || !isFinite(iterations));
+			const reps = typeof iterations === 'number' && iterations > 1 && isFinite(iterations) ? iterations : 1;
+
+			_cancelActiveStoryboard(native, property);
+
+			let sb: any;
+			try {
+				sb = new A.Storyboard();
+
+				// addDouble accepts an optional per-call ease override (pass null to force linear).
+				// The default (undefined) falls through to the outer `ease` computed from `curve`.
+				const addDouble = (targetObj: any, prop: string, toVal: number, dependent?: boolean, fromVal?: number, easeOverride?: any) => {
+					const da = new A.DoubleAnimation();
+					// Width/Height start as NaN (Auto) when not explicitly sized, so the animation must be
+					// seeded with an explicit From (the rendered size) or it can't interpolate.
+					if (typeof fromVal === 'number' && isFinite(fromVal)) da.From = fromVal;
+					da.To = toVal;
+					da.Duration = _duration(dur2) as never;
+					if (dependent) da.EnableDependentAnimation = true;
+					const effectiveEase = easeOverride !== undefined ? easeOverride : ease;
+					if (effectiveEase) da.EasingFunction = effectiveEase;
+					A.Storyboard.SetTarget(da, targetObj);
+					A.Storyboard.SetTargetProperty(da, prop);
+					sb.Children.Append(da);
+				};
+
+				const measuredSize = (actual: number, explicit: number): number | undefined => {
+					if (typeof actual === 'number' && actual > 0) return actual;
+					if (typeof explicit === 'number' && isFinite(explicit) && explicit > 0) return explicit;
+					return undefined;
+				};
+
+				// BackEase (spring) overshoots its target value.  For Height/Width this means the
+				// animated value can go negative mid-animation, which WinUI3 rejects with
+				// "Invalid attribute value Unknown for property Height/Width".
+				// Substitute null (linear) for dimensional properties when the curve is spring.
+				const isSpring = curve === 'spring' || (curve && typeof curve === 'object' && curve.name === 'spring');
+				const dimEase = isSpring ? null : ease;
+
+				switch (property) {
+					case Properties.opacity:
+						addDouble(native, 'Opacity', num(to, 1));
+						break;
+					case Properties.width:
+						addDouble(native, 'Width', num(to, 0), true, measuredSize(native.ActualWidth, native.Width), dimEase);
+						break;
+					case Properties.height:
+						addDouble(native, 'Height', num(to, 0), true, measuredSize(native.ActualHeight, native.Height), dimEase);
+						break;
+					case Properties.translate: {
+						const tr = _ensureNativeTransforms(native);
+						if (!tr) { resolve(); return; }
+						const toX = num(to && to.x !== undefined ? to.x : to, 0);
+						const toY = (to && typeof to.y === 'number') ? to.y : 0;
+						addDouble(tr.translate, 'X', toX);
+						addDouble(tr.translate, 'Y', toY);
+						break;
+					}
+					case Properties.scale: {
+						const tr = _ensureNativeTransforms(native);
+						if (!tr) { resolve(); return; }
+						const sx = num(to && to.x !== undefined ? to.x : to, 1);
+						const sy = (to && typeof to.y === 'number') ? to.y : sx;
+						addDouble(tr.scale, 'ScaleX', sx);
+						addDouble(tr.scale, 'ScaleY', sy);
+						break;
+					}
+					case Properties.rotate: {
+						const tr = _ensureNativeTransforms(native);
+						if (!tr) { resolve(); return; }
+						const ang = (to && typeof to.z === 'number') ? to.z : num(to, 0);
+						addDouble(tr.rotate, 'Angle', ang);
+						break;
+					}
+					case Properties.backgroundColor: {
+						const toColor = to && typeof to === 'object' && to.r !== undefined ? to : null;
+						if (!toColor) { resolve(); return; }
+						// Fast path: the View caches its SolidColorBrush in _colorAnimBrush, set by
+						// _setNativeSolidColor. Avoids native.Background getter + instanceof QI (2 WinRT calls).
+						let brush: any = (target as any)?._colorAnimBrush ?? null;
+						if (!brush) {
+							try { if (native.Background instanceof Microsoft.UI.Xaml.Media.SolidColorBrush) brush = native.Background; } catch (_e) {}
+							if (!brush) {
+								brush = new Microsoft.UI.Xaml.Media.SolidColorBrush({ A: 255, R: 0, G: 0, B: 0 } as any);
+								try { native.Background = brush; } catch (_e) {}
+							}
+						}
+						// Resources.Insert wires Button VSM theme brushes — only needed for actual Button
+						// controls. `'IsDefault' in native` is a free prototype check (no WinRT getter).
+						if ('IsDefault' in native) {
+							try { (native as any).Resources.Insert('ButtonBackground', brush); } catch (_e) {}
+							try { (native as any).Resources.Insert('ButtonBackgroundPointerOver', brush); } catch (_e) {}
+							try { (native as any).Resources.Insert('ButtonBackgroundPressed', brush); } catch (_e) {}
+						}
+						// Use ColorAnimationUsingKeyFrames + EasingColorKeyFrame/LinearColorKeyFrame instead
+						// of ColorAnimation.  ColorAnimation.To requires IReference<Windows.UI.Color> (a COM
+						// nullable wrapper) which the JS→Rust bridge cannot produce from a plain JS object.
+						// EasingColorKeyFrame.Value is a plain Windows.UI.Color struct — the bridge handles
+						// it via append_struct_object_bytes without any COM boxing.
+						const cauk = new A.ColorAnimationUsingKeyFrames();
+						cauk.EnableDependentAnimation = true;
+						let kf: any;
+						if (ease) {
+							kf = new A.EasingColorKeyFrame();
+							kf.EasingFunction = ease;
+						} else {
+							kf = new A.LinearColorKeyFrame();
+						}
+						kf.Value = { A: Math.round(toColor.a ?? 255), R: Math.round(toColor.r ?? 0), G: Math.round(toColor.g ?? 0), B: Math.round(toColor.b ?? 0) } as any;
+						// KeyTime is a struct: { TimeSpan: { Duration: 100ns-ticks } }
+						kf.KeyTime = { TimeSpan: { Duration: Math.max(0, dur2) * 10000 } } as any;
+						cauk.KeyFrames.Append(kf);
+						A.Storyboard.SetTarget(cauk, brush);
+						A.Storyboard.SetTargetProperty(cauk, 'Color');
+						sb.Children.Append(cauk);
+						break;
+					}
+					default: resolve(); return;
+				}
+
+				// RepeatBehavior: Type 0=Count, 1=Duration, 2=Forever; nested TimeSpan unused.
+				const repeatBehavior = (count: number, type: number) =>
+					({ Count: count, Duration: { Duration: 0 }, Type: type } as never);
+				if (infinite) {
+					try { sb.RepeatBehavior = repeatBehavior(0, 2); } catch (_e) {}
+				} else if (reps > 1) {
+					try { sb.RepeatBehavior = repeatBehavior(reps, 0); } catch (_e) {}
+				}
+			} catch (_e) {
+				resolve();
+				return;
+			}
+
+			let settled = false;
+			let safety: any;
+			const finalize = () => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(safety);
+				_clearActiveStoryboard(native, property);
+				if (target) { try { _applyFinalValue(target, property, to); } catch (_e) {} }
+				resolve();
+			};
+			const cancel = () => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(safety);
+				_clearActiveStoryboard(native, property);
+				try { sb.Stop(); } catch (_e) {}
+				resolve();
+			};
+
+			// Completed fires once for a finite storyboard (after all iterations); never for Forever.
+			try { sb.Completed = (() => finalize()) as never; } catch (_e) {}
+
+			_registerActiveStoryboard(native, property, cancel);
+			this._activeCancels.push(cancel);
+
+			const begin = () => { try { sb.Begin(); } catch (_e) { finalize(); } };
+			if (del2 > 0) setTimeout(begin, del2); else begin();
+
+			// Safety net so the promise can't hang if Completed never fires (element detached, etc.).
+			// Skipped for infinite animations — those resolve only via cancel().
+			if (!infinite) {
+				const total = del2 + dur2 * Math.max(1, reps) + 400;
+				safety = setTimeout(finalize, total);
+			}
+		});
+	}
+
+	// Batched single-Storyboard path for homogeneous backgroundColor animation sets.
+	// Instead of spawning N storyboards (one per target), this builds ONE Storyboard with N
+	// ColorAnimations, each having a BeginTime for its cascade delay.  This reduces WinRT
+	// crossings from ~8N to ~5N+2 and, more importantly, cuts the number of Storyboard.Begin()
+	// calls from N to 1 — eliminating the ~4ms-per-tick setTimeout storm on large batches.
+	//
+	// BeginTime is a nullable TimeSpan (IReference<TimeSpan> in ABI).  Pass null for del=0
+	// (immediate start) and Windows.Foundation.PropertyValue.CreateTimeSpan() to box a
+	// non-zero delay into the reference wrapper the compositor expects.
+	private _playBatchedColorAnims(anims: any[]): Promise<void> {
+		const A: any = Microsoft.UI.Xaml.Media.Animation;
+		let sb: any;
+		try { sb = new A.Storyboard(); } catch (_e) { return Promise.resolve(); }
+
+		let maxEnd = 0;
+		// Collect (native, property) pairs for conflict-tracking registration after cancel is created.
+		const registered: Array<{ native: any; prop: string }> = [];
+
+		for (const anim of anims) {
+			const target = anim.target;
+			const native = target?.nativeViewProtected;
+			if (!native) continue;
+
+			const to = anim.value;
+			const toColor = to && typeof to === 'object' && to.r !== undefined ? to : null;
+			if (!toColor) continue;
+
+			const dur2 = Math.max(0, Math.round(anim.duration ?? 300));
+			const del2 = Math.max(0, Math.round(anim.delay ?? 0));
+			const ease = this._xamlEasing(anim.curve);
+
+			// Cancel any previous storyboard running on this element+property.
+			_cancelActiveStoryboard(native, anim.property);
+			registered.push({ native, prop: anim.property });
+
+			let brush: any = target._colorAnimBrush ?? null;
+			if (!brush) {
+				try { if (native.Background instanceof Microsoft.UI.Xaml.Media.SolidColorBrush) brush = native.Background; } catch (_e) {}
+				if (!brush) {
+					brush = new Microsoft.UI.Xaml.Media.SolidColorBrush({ A: 255, R: 0, G: 0, B: 0 } as any);
+					try { native.Background = brush; } catch (_e) {}
+				}
+			}
+			if ('IsDefault' in native) {
+				try { (native as any).Resources.Insert('ButtonBackground', brush); } catch (_e) {}
+				try { (native as any).Resources.Insert('ButtonBackgroundPointerOver', brush); } catch (_e) {}
+				try { (native as any).Resources.Insert('ButtonBackgroundPressed', brush); } catch (_e) {}
+			}
+
+			try {
+				// ColorAnimationUsingKeyFrames: EasingColorKeyFrame.Value is a plain Windows.UI.Color
+				// struct — no IReference<Color> boxing needed (unlike ColorAnimation.To).
+				const cauk = new A.ColorAnimationUsingKeyFrames();
+				cauk.EnableDependentAnimation = true;
+				// BeginTime is IReference<TimeSpan> — box via PropertyValue for non-zero delays.
+				// For del2=0, leave unset (null → immediate start).
+				if (del2 > 0) {
+					try {
+						const ts = Windows.Foundation.PropertyValue.CreateTimeSpan({ Duration: del2 * 10000 } as any);
+						cauk.BeginTime = ts as never;
+					} catch (_e) {
+						// PropertyValue unavailable — animation will start at t=0 instead of del2
+					}
+				}
+				let kf: any;
+				if (ease) {
+					kf = new A.EasingColorKeyFrame();
+					kf.EasingFunction = ease;
+				} else {
+					kf = new A.LinearColorKeyFrame();
+				}
+				kf.Value = { A: Math.round(toColor.a ?? 255), R: Math.round(toColor.r ?? 0), G: Math.round(toColor.g ?? 0), B: Math.round(toColor.b ?? 0) } as any;
+				// KeyTime drives the per-animation duration: { TimeSpan: { Duration: 100ns-ticks } }
+				kf.KeyTime = { TimeSpan: { Duration: Math.max(0, dur2) * 10000 } } as any;
+				cauk.KeyFrames.Append(kf);
+				A.Storyboard.SetTarget(cauk, brush);
+				A.Storyboard.SetTargetProperty(cauk, 'Color');
+				sb.Children.Append(cauk);
+			} catch (_e) {}
+
+			if (del2 + dur2 > maxEnd) maxEnd = del2 + dur2;
+		}
+
+		return new Promise<void>((resolve) => {
+			let settled = false;
+			let safety: any;
+			const finalize = () => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(safety);
+				for (const { native, prop } of registered) { _clearActiveStoryboard(native, prop); }
+				for (const anim of anims) {
+					try { _applyFinalValue(anim.target, anim.property, anim.value); } catch (_e) {}
+				}
+				resolve();
+			};
+			const cancel = () => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(safety);
+				for (const { native, prop } of registered) { _clearActiveStoryboard(native, prop); }
+				try { sb.Stop(); } catch (_e) {}
+				resolve();
+			};
+
+			try { sb.Completed = (() => finalize()) as never; } catch (_e) {}
+
+			// Register one shared cancel on every element+property so a subsequent animation
+			// on any of these elements will correctly stop this batch storyboard first.
+			for (const { native, prop } of registered) { _registerActiveStoryboard(native, prop, cancel); }
+			this._activeCancels.push(cancel);
+
+			// Safety net: max(BeginTime + Duration) + 400ms buffer.
+			safety = setTimeout(finalize, maxEnd + 400);
+
+			try { sb.Begin(); } catch (_e) { finalize(); }
+		});
+	}
+
+	play(_resetDelay?: boolean): any {
+		const playPromise = super.play();
+
+		const run = async () => {
+			try {
+				if (this._playSequentially) {
+					for (const anim of this._propertyAnimations) {
+						await this._playKeyframeAnimation(anim);
+					}
+				} else {
+					const anims = this._propertyAnimations;
+					// Fast path: all parallel animations target backgroundColor with finite iterations.
+					// Merge into one Storyboard with per-animation BeginTime — single Begin() call,
+					// no per-animation setTimeout storm, compositor handles all cascade timing.
+					const canBatch = anims.length > 1 && anims.every(a =>
+						a.property === Properties.backgroundColor &&
+						a.target?.nativeViewProtected &&
+						a.value && typeof a.value === 'object' && a.value.r !== undefined &&
+						!(typeof a.iterations === 'number' && (a.iterations <= 0 || !isFinite(a.iterations)))
+					);
+					if (canBatch) {
+						await this._playBatchedColorAnims(anims);
+					} else {
+						await Promise.all(anims.map((anim) => this._playKeyframeAnimation(anim)));
+					}
+				}
+
+				this._resolveAnimationFinishedPromise();
+			} catch (err) {
+				this._rejectAnimationFinishedPromise();
+			}
+		};
+
+		run();
+		return playPromise;
+	}
+
+	public cancel(): void {
+		// Stop in-flight storyboards and resolve their promises.
+		try {
+			const cancels = this._activeCancels.splice(0);
+			for (const c of cancels) { try { c(); } catch (_e) { } }
+		} catch (_e) { }
+
+		super.cancel();
+		// Only reject if play() set _reject via super.play().
+		if (this.isPlaying) {
+			this._rejectAnimationFinishedPromise();
+		}
+	}
+
+	_resolveAnimationCurve(curve: any): any {
+		return curve;
+	}
+
+	_playKeyframeAnimation(animation: any, _delay?: number): any {
+		return new Promise<void>((resolve, _reject) => {
+			if (!animation || !animation.target) {
+				resolve();
+				return;
+			}
+
+			const target = animation.target as View;
+			const property = animation.property;
+			const to = animation.value;
+			const duration = typeof animation.duration === 'number' ? animation.duration : 300;
+			const delay = typeof animation.delay === 'number' ? animation.delay : 0;
+			const iterations = typeof animation.iterations === 'number' && animation.iterations !== 0 ? animation.iterations : 1;
+
+			const native = (target as any).nativeViewProtected;
+			if (native) {
+				this._startStoryboardForProperty(native, property, to, duration, delay, '', target, animation.curve, iterations).then(() => resolve());
+			} else {
+				// No native view yet — apply final value immediately so the animation doesn't hang.
+				_applyFinalValue(target, property, to);
+				resolve();
+			}
+		});
+	}
+
+	_createiOSAnimationFunction(_animation: Properties, _delay?: number): any {
+		return null;
+	}
+
+	static _getTransformAnimationInfo(_view: View, _transformation: any): any {
+		return {};
+	}
+}
diff --git a/packages/core/ui/builder/index.ts b/packages/core/ui/builder/index.ts
index 764d10919c..025dc68595 100644
--- a/packages/core/ui/builder/index.ts
+++ b/packages/core/ui/builder/index.ts
@@ -41,6 +41,7 @@ export const ios = platformNames.ios.toLowerCase();
 export const android = platformNames.android.toLowerCase();
 export const visionos = platformNames.visionos.toLowerCase();
 export const apple = platformNames.apple.toLowerCase();
+export const windows = platformNames.windows.toLowerCase();
 export const defaultNameSpaceMatcher = /tns\.xsd$/i;
 
 export interface LoadOptions {
@@ -432,7 +433,7 @@ export namespace xml2ui {
 			if (value) {
 				const toLower = value.toLowerCase();
 
-				return toLower === android || toLower === ios || toLower === visionos || toLower === apple;
+				return toLower === android || toLower === ios || toLower === visionos || toLower === apple || toLower === windows;
 			}
 
 			return false;
diff --git a/packages/core/ui/button/index.windows.ts b/packages/core/ui/button/index.windows.ts
new file mode 100644
index 0000000000..2ef9dbb8db
--- /dev/null
+++ b/packages/core/ui/button/index.windows.ts
@@ -0,0 +1,75 @@
+export * from './button-common';
+
+import { ButtonBase } from './button-common';
+import { PseudoClassHandler } from '../core/view';
+import { TouchGestureEventData, TouchAction, GestureTypes } from '../gestures';
+
+function onButtonStateChange(args: any) {
+	const button = args.object as Button;
+
+	switch (args.action) {
+		case TouchAction.up:
+		case TouchAction.cancel:
+			button._removeVisualState('highlighted');
+			if (typeof button._defaultOpacity === 'number' && button.nativeViewProtected) {
+				button.nativeViewProtected.Opacity = button._defaultOpacity;
+			}
+			break;
+		case TouchAction.down:
+			button._addVisualState('highlighted');
+			if (button.nativeViewProtected) {
+				if (typeof button._defaultOpacity !== 'number') {
+					button._defaultOpacity = button.nativeViewProtected.Opacity || 1;
+				}
+				button.nativeViewProtected.Opacity = Math.max(0, (button._defaultOpacity || 1) * 0.85);
+			}
+			break;
+	}
+}
+
+
+export class Button extends ButtonBase {
+	nativeViewProtected: Microsoft.UI.Xaml.Controls.Button;
+	private _delegate: any = null;
+	private _windows: Microsoft.UI.Xaml.Controls.Button;
+	private _defaultOpacity?: number;
+
+	public createNativeView() {
+		this._windows = new Microsoft.UI.Xaml.Controls.Button();
+		return this._windows;
+	}
+
+	get windows(): Microsoft.UI.Xaml.Controls.Button {
+		return this._windows;
+	}
+
+	public initNativeView(): void {
+		super.initNativeView();
+		const nativeView = this.nativeViewProtected;
+		const that = new WeakRef(this);
+		this._delegate = NSWinRT.asDelegate('Microsoft.UI.Xaml.RoutedEventHandler', () => {
+			const owner = that.deref();
+			if (owner) owner.notify({ eventName: ButtonBase.tapEvent, object: owner });
+		});
+		nativeView.Click = this._delegate as never;
+		this._defaultOpacity = nativeView.Opacity || 1;
+	}
+
+	public disposeNativeView(): void {
+		if (this._delegate) {
+			this.nativeViewProtected.Click = null as never;
+			this._delegate = null;
+		}
+		super.disposeNativeView();
+	}
+
+	@PseudoClassHandler('normal', 'highlighted', 'pressed', 'active')
+	_updateButtonStateChangeHandler(subscribe: boolean) {
+		if (subscribe) {
+			this.on(GestureTypes[GestureTypes.touch], onButtonStateChange);
+		} else {
+			this.off(GestureTypes[GestureTypes.touch], onButtonStateChange);
+			this._removeVisualState('highlighted');
+		}
+	}
+}
diff --git a/packages/core/ui/core/control-state-change/index.windows.ts b/packages/core/ui/core/control-state-change/index.windows.ts
new file mode 100644
index 0000000000..804f5d0b18
--- /dev/null
+++ b/packages/core/ui/core/control-state-change/index.windows.ts
@@ -0,0 +1,5 @@
+// Windows stub — ControlStateChangeListener is iOS-only.
+export class ControlStateChangeListener {
+	constructor(_view: any, _callback: (v: any, s: string) => void) {}
+	stop() {}
+}
diff --git a/packages/core/ui/core/view-base/index.ts b/packages/core/ui/core/view-base/index.ts
index e4b2cd051e..dc0ea90b62 100644
--- a/packages/core/ui/core/view-base/index.ts
+++ b/packages/core/ui/core/view-base/index.ts
@@ -336,6 +336,7 @@ export abstract class ViewBase extends Observable {
 	private _onUnloadedCalled = false;
 	private _iosView: Object;
 	private _androidView: Object;
+	private _windowsView: Object;
 	private _style: Style;
 	private _isLoaded: boolean;
 
@@ -1196,6 +1197,8 @@ export abstract class ViewBase extends Observable {
 					}
 				}
 			}
+		}else if(__WINDOWS__){
+			this._windowsView = nativeView;
 		} else {
 			this._iosView = nativeView;
 		}
diff --git a/packages/core/ui/core/view/index.windows.ts b/packages/core/ui/core/view/index.windows.ts
new file mode 100644
index 0000000000..f0bbeb9826
--- /dev/null
+++ b/packages/core/ui/core/view/index.windows.ts
@@ -0,0 +1,1873 @@
+export * from './view-common';
+export * from './view-helper';
+export * from '../properties';
+
+import { ViewCommon, originXProperty, originYProperty } from './view-common';
+import type { CoreTypes } from '../../../core-types';
+import { visibilityProperty, opacityProperty, backgroundInternalProperty, translateXProperty, translateYProperty, scaleXProperty, scaleYProperty, rotateProperty, rotateXProperty, rotateYProperty, perspectiveProperty, horizontalAlignmentProperty, verticalAlignmentProperty, paddingTopProperty, paddingRightProperty, paddingBottomProperty, paddingLeftProperty } from '../../styling/style-properties';
+import { LinearGradient } from '../../styling/linear-gradient';
+import { widthProperty, heightProperty, minWidthProperty, minHeightProperty, marginLeftProperty, marginTopProperty, marginRightProperty, marginBottomProperty } from '../../styling/style-properties';
+import { layout } from '../../../utils';
+import { unsetValue } from '../properties/property-shared';
+import { Background } from '../../styling/background';
+import { BoxShadow } from '../../styling/box-shadow';
+import { Color } from '../../../color';
+import { hiddenProperty } from '../view-base';
+import { getCurrentWindowBounds, getCurrentWindowContent } from '../../../application/window-helper.windows';
+import { ImageSource } from '../../../image-source';
+type WindowsColor = Color & { windows: Windows.UI.Color, windowsArgb: number };
+
+// Windows.UI.Color is a plain {A,R,G,B} struct — bridge reads fields directly, no WinRT call needed.
+const _defaultBackground: Windows.UI.Color = { A: 0, R: 0, G: 0, B: 0 } as unknown as Windows.UI.Color;
+export function getDefaultBackground() {
+	return _defaultBackground;
+}
+
+// `_nativeBackgroundState` is initialized on the prototype after the class definition
+
+function toXamlLength(value: CoreTypes.PercentLengthType | CoreTypes.LengthType): number {
+	if (!value || value === 'auto') return NaN;
+	if (typeof value === 'number') return value;
+	if (typeof value === 'object' && 'value' in value) {
+		if ((value as any).unit === '%') return NaN; // percent not directly settable
+		return (value as any).value ?? NaN;
+	}
+	return NaN;
+}
+
+// Color struct cache: Windows.UI.Color is {A,R,G,B} bytes — construct directly, no ColorHelper.FromArgb().
+// Cache avoids allocating a new object for every border/shadow color update with the same color.
+const _winColorCache = new Map<number, Windows.UI.Color>();
+function _argbToWinColor(argb: number): Windows.UI.Color {
+	const cached = _winColorCache.get(argb);
+	if (cached !== undefined) return cached;
+	const c = { A: (argb >>> 24) & 0xFF, R: (argb >> 16) & 0xFF, G: (argb >> 8) & 0xFF, B: argb & 0xFF } as unknown as Windows.UI.Color;
+	if (_winColorCache.size >= 32) _winColorCache.delete(_winColorCache.keys().next().value);
+	_winColorCache.set(argb, c);
+	return c;
+}
+
+
+function _resolveToWinColor(color: any): Windows.UI.Color | null {
+	if (!color) return null;
+
+	if (typeof color.windows !== 'undefined') {
+		try { return color.windows; } catch (_e) { }
+	}
+
+	if (typeof color.A === 'number' && typeof color.R === 'number') {
+		return color as Windows.UI.Color;
+	}
+
+	if (typeof color === 'number') {
+		return _argbToWinColor(color >>> 0);
+	}
+
+	if (typeof color === 'string') {
+		try {
+			return new Color(color).windows;
+		} catch (_e) { }
+	}
+	return null;
+}
+
+
+export function _ensureNativeTransforms(native: any): { scale: any; rotate: any; translate: any } | null {
+	try {
+		if (native.__ns_transforms) return native.__ns_transforms;
+
+		const tg = new Microsoft.UI.Xaml.Media.TransformGroup();
+		const scale = new Microsoft.UI.Xaml.Media.ScaleTransform();
+		const rotate = new Microsoft.UI.Xaml.Media.RotateTransform();
+		const translate = new Microsoft.UI.Xaml.Media.TranslateTransform();
+		tg.Children.Append(scale);
+		tg.Children.Append(rotate);
+		tg.Children.Append(translate);
+		native.RenderTransform = tg;
+		const result = { scale, rotate, translate };
+		native.__ns_transforms = result;
+		return result;
+	} catch (_e) {
+		return null;
+	}
+}
+
+const hidden = Symbol('[[hidden]]');
+function setVisibility(nativeView: Microsoft.UI.Xaml.UIElement & { [hidden]?: boolean }, value: CoreTypes.VisibilityType) {
+	switch (value) {
+		case "collapse":
+		case "collapsed":
+			nativeView[hidden] = true;
+			nativeView.Visibility = Microsoft.UI.Xaml.Visibility.Collapsed;
+			try { (nativeView as any).IsHitTestVisible = true; } catch (_e) { } // moot while collapsed; correct once shown
+			break;
+		case "hidden":
+			// 'hidden' = invisible but STILL TAKES LAYOUT SPACE — must stay Visibility=Visible (not
+			// Collapsed). An invisible element that still captures pointer input blocks taps on whatever
+			// it overlaps, so also disable hit-testing.
+			nativeView[hidden] = true;
+			nativeView.Opacity = 0;
+			nativeView.Visibility = Microsoft.UI.Xaml.Visibility.Visible;
+			try { (nativeView as any).IsHitTestVisible = false; } catch (_e) { }
+			break;
+		case "visible":
+			if (!nativeView[hidden]) return; // symbol unset = native default (Visible/Opacity=1/HitTest=true) — skip 4 WinRT calls
+			nativeView[hidden] = false;
+			nativeView.Opacity = 1;
+			nativeView.Visibility = Microsoft.UI.Xaml.Visibility.Visible;
+			try { (nativeView as any).IsHitTestVisible = true; } catch (_e) { } // restore (in case it was 'hidden' before)
+			break;
+		default:
+	}
+}
+
+function getVisibility(nativeView: Microsoft.UI.Xaml.UIElement & { [hidden]?: boolean }): CoreTypes.VisibilityType {
+	if (nativeView[hidden]) {
+		if (nativeView.Opacity === 0) {
+			return "hidden";
+		} else {
+			if (nativeView.Visibility === Microsoft.UI.Xaml.Visibility.Collapsed) {
+				return "collapse";
+			}
+		}
+	}
+	return "visible";
+}
+
+// Box-shadow uses native Microsoft.UI.Composition DropShadow (GPU, per element). Shadow hosts are
+// inserted as siblings behind the target in its parent panel. NativeScript.Widgets.ShadowHelper
+// handles the CPU blur fallback path on a thread-pool thread (never touches JS/UI thread).
+
+class CompositionBorderHandler {
+	private _element: Microsoft.UI.Xaml.UIElement;
+	private _rootVisual: Microsoft.UI.Composition.Visual;
+	private _container: Microsoft.UI.Composition.ContainerVisual;
+	// Border SpriteVisuals are created lazily in _ensureBorderSprites() — only when UpdateBorder()
+	// is first called with a non-zero width. Shadow-only handlers never allocate these (~18 WinRT
+	// objects saved per shadow-only view, eliminating most of the launch/nav freeze).
+	private _top: Microsoft.UI.Composition.SpriteVisual | null = null;
+	private _bottom: Microsoft.UI.Composition.SpriteVisual | null = null;
+	private _left: Microsoft.UI.Composition.SpriteVisual | null = null;
+	private _right: Microsoft.UI.Composition.SpriteVisual | null = null;
+	private _topBrush: Microsoft.UI.Composition.CompositionColorBrush | null = null;
+	private _bottomBrush: Microsoft.UI.Composition.CompositionColorBrush | null = null;
+	private _leftBrush: Microsoft.UI.Composition.CompositionColorBrush | null = null;
+	private _rightBrush: Microsoft.UI.Composition.CompositionColorBrush | null = null;
+	private _clipGeometry: Microsoft.UI.Composition.CompositionRoundedRectangleGeometry | null = null;
+	// Sig of last applied border geometry (w×h + all widths/colors/radius). UpdateBorder is called
+	// on every SizeChanged; this guard short-circuits the 12 WinRT property sets when nothing changed.
+	private _lastBorderUpdateSig: string | null = null;
+	// One host per CSS shadow, stacked behind element (first-listed shadow nearest/highest z).
+	private _shadowImages: Microsoft.UI.Xaml.FrameworkElement[] = [];
+	// Compositor objects kept alive alongside each host for fast-path size-only updates.
+	// Parallel array to _shadowImages (same length, same index correspondence).
+	private _shadowEntries: Array<{ layer: any; shapeVisual: any; geo: any }> = [];
+	// Children collection captured at insert time — re-reading el.Parent at removal returns undefined
+	// on this host, causing old shadows to accumulate.
+	private _shadowKids: unknown = null;
+	// Signature of last applied shadow render. UpdateBoxShadow runs on SizeChanged; re-inserting
+	// hosts re-invalidates layout → LayoutCycleException. Only mutate the tree when sig changes.
+	private _lastShadowSig: string | null = null;
+	// Config-only sig (no size). When only w×h changes the host Border and all Compositor objects
+	// are updated in-place — no XAML tree mutation, no new WinRT allocations.
+	private _lastShadowConfigSig: string | null = null;
+	// Per-side colored border drawn as a bitmap overlay ON TOP of the element (native XAML BorderBrush
+	// is one color, so 4-color borders need a separate bitmap). Inserted right after the element (higher z).
+	private _borderOverlayActive = false;
+	private _borderKids: unknown = null;
+	private _lastBorderSig: string | null = null;
+
+	constructor(element: Microsoft.UI.Xaml.UIElement, rootVisual: Microsoft.UI.Composition.Visual) {
+		this._element = element;
+		this._rootVisual = rootVisual;
+		const c = rootVisual.Compositor;
+
+		this._container = c.CreateContainerVisual();
+		// Expression animations on `Size` throw E_INVALIDARG in this V8/UWP composition projection;
+		// RelativeSizeAdjustment(1,1) tracks the parent size natively without an animation.
+		this._container.RelativeSizeAdjustment = new Windows.Foundation.Numerics.Vector2(1, 1);
+
+		// Border SpriteVisuals NOT created here — see _ensureBorderSprites().
+		Microsoft.UI.Xaml.Hosting.ElementCompositionPreview.SetElementChildVisual(element, this._container);
+	}
+
+	// Lazily allocate the 4 border SpriteVisuals. Only called by UpdateBorder when a real border
+	// width is present. Returns false if allocation fails (handler unusable for borders).
+	private _ensureBorderSprites(): boolean {
+		if (this._top) return true;
+		try {
+			const c = this._rootVisual.Compositor;
+			this._topBrush = c.CreateColorBrush();
+			this._bottomBrush = c.CreateColorBrush();
+			this._leftBrush = c.CreateColorBrush();
+			this._rightBrush = c.CreateColorBrush();
+			this._top = c.CreateSpriteVisual(); this._top.Brush = this._topBrush;
+			this._bottom = c.CreateSpriteVisual(); this._bottom.Brush = this._bottomBrush;
+			this._left = c.CreateSpriteVisual(); this._left.Brush = this._leftBrush;
+			this._right = c.CreateSpriteVisual(); this._right.Brush = this._rightBrush;
+			this._container.Children.InsertAtTop(this._top);
+			this._container.Children.InsertAtTop(this._bottom);
+			this._container.Children.InsertAtTop(this._left);
+			this._container.Children.InsertAtTop(this._right);
+			return true;
+		} catch (_e) {
+			return false;
+		}
+	}
+
+	static Create(element: any): CompositionBorderHandler | null {
+		try {
+			const rootVisual = Microsoft.UI.Xaml.Hosting.ElementCompositionPreview.GetElementVisual(element);
+			return new CompositionBorderHandler(element, rootVisual);
+		} catch (_e) {
+			return null;
+		}
+	}
+
+	private _animate(target: Microsoft.UI.Composition.Visual, prop: string, expr: string): void {
+		// Expression animations throw E_INVALIDARG in this V8/UWP composition projection; guard so a
+		// failure can't abort background setup (which would blank the page).
+		try {
+			const anim = this._rootVisual.Compositor.CreateExpressionAnimation(expr);
+			anim.SetReferenceParameter('host', this._rootVisual);
+			target.StartAnimation(prop, anim);
+		} catch (_e) { }
+	}
+
+	// Four explicitly-sized SpriteVisuals (one per side) for per-side widths/colors; rounded geometric
+	// clip for corner radius. Explicit sizing avoids E_INVALIDARG from expression animations. Works on
+	// plain panels (no native BorderThickness/BorderBrush) and renders above the element edge.
+	UpdateBorder(w: number, h: number, tW: number, rW: number, bW: number, lW: number, tC: number, rC: number, bC: number, lC: number, radius: number): void {
+		if (w <= 0 || h <= 0) {
+			return; // not laid out yet — _redrawNativeBackground re-runs on SizeChanged
+		}
+		// Sig guards the 12 WinRT property sets below. UpdateBorder is called on every SizeChanged;
+		// skipping when nothing changed eliminates the dominant per-frame bridge cost for bordered views.
+		const sig = `${Math.round(w)}x${Math.round(h)}|${tW},${rW},${bW},${lW},${tC},${rC},${bC},${lC},${radius}`;
+		if (sig === this._lastBorderUpdateSig) return;
+		this._lastBorderUpdateSig = sig;
+		if (!this._ensureBorderSprites()) return;
+		try {
+			const N = Windows.Foundation.Numerics;
+			const tWc = Math.max(0, tW), rWc = Math.max(0, rW), bWc = Math.max(0, bW), lWc = Math.max(0, lW);
+			const midH = Math.max(0, h - tWc - bWc);
+
+			this._top.Offset = new N.Vector3(0, 0, 0);
+			this._top.Size = new N.Vector2(w, tWc);
+			this._topBrush.Color = _argbToWinColor(tC);
+
+			this._bottom.Offset = new N.Vector3(0, Math.max(0, h - bWc), 0);
+			this._bottom.Size = new N.Vector2(w, bWc);
+			this._bottomBrush.Color = _argbToWinColor(bC);
+
+			this._left.Offset = new N.Vector3(0, tWc, 0);
+			this._left.Size = new N.Vector2(lWc, midH);
+			this._leftBrush.Color = _argbToWinColor(lC);
+
+			this._right.Offset = new N.Vector3(Math.max(0, w - rWc), tWc, 0);
+			this._right.Size = new N.Vector2(rWc, midH);
+			this._rightBrush.Color = _argbToWinColor(rC);
+
+			const c = this._rootVisual.Compositor;
+			if (radius > 0) {
+				if (!this._clipGeometry) {
+					this._clipGeometry = c.CreateRoundedRectangleGeometry();
+					this._container.Clip = c.CreateGeometricClip(this._clipGeometry);
+				}
+				this._clipGeometry.Size = new N.Vector2(w, h);
+				this._clipGeometry.CornerRadius = new N.Vector2(radius, radius);
+			} else if (this._clipGeometry) {
+				try { this._container.Clip = null as never; } catch (_e) { }
+				this._clipGeometry = null;
+			}
+		} catch (_e) { }
+	}
+
+	ClearBorder(): void {
+		// No sprites ever created (shadow-only handler) or already cleared — nothing to do.
+		if (!this._top || this._lastBorderUpdateSig === 'none') return;
+		this._lastBorderUpdateSig = 'none';
+		try {
+			const z = new Windows.Foundation.Numerics.Vector2(0, 0);
+			this._top.Size = z; this._bottom.Size = z; this._left.Size = z; this._right.Size = z;
+			if (this._clipGeometry) {
+				try { this._container.Clip = null as never; } catch (_e) { }
+				this._clipGeometry = null;
+			}
+		} catch (_e) { }
+	}
+
+	UpdateBoxShadow(shadows: BoxShadow[] | BoxShadow | null, cornerRadius = 0): void {
+		// One element-sized DropShadow host per CSS shadow, inserted as a sibling behind the target.
+		// Overlap-capable parents only — StackPanel would stack the host as a new row (skipped below).
+		const el = this._element as Microsoft.UI.Xaml.FrameworkElement;
+		if (!el) {
+			return;
+		}
+		try {
+			const list = shadows == null ? [] : (Array.isArray(shadows) ? shadows : [shadows]);
+
+			// No shadows → clear (only mutate tree if we currently have images).
+			if (!list.length) {
+				if (this._lastShadowSig === 'none') {
+					return;
+				}
+				this._lastShadowSig = 'none';
+				this._lastShadowConfigSig = null;
+				this._removeShadowImages();
+				return;
+			}
+
+			const w = el.ActualWidth || 0;
+			const h = el.ActualHeight || 0;
+			if (w <= 0 || h <= 0) {
+				return; // not laid out yet — re-applied on the next SizeChanged redraw (sig not cached)
+			}
+
+			// Signature guards against LayoutCycleException: inserting/removing hosts re-invalidates
+			// layout. Only mutate the XAML tree when the shadow config changes. When only w×h changes
+			// (size-only path) update Compositor objects in-place — no tree mutation, no new WinRT allocs.
+			// Use pure-JS `.argb` for the sig — `.windows` would call ColorHelper.FromArgb() + 4 struct
+			// reads per shadow color on every call, even when the sig matches and work is skipped.
+			const configSig = `${cornerRadius}|` + list.map((s) => {
+				const a = (s.color as any)?.argb ?? 0;
+				return `${a}:${s.offsetX || 0},${s.offsetY || 0},${s.blurRadius || 0},${s.spreadRadius || 0}`;
+			}).join(';');
+			const sig = `${Math.round(w)}x${Math.round(h)}|${configSig}`;
+			if (sig === this._lastShadowSig && this._shadowImages.length > 0) {
+				return;
+			}
+
+			// Fast path: only w×h changed, same shadow config, same count → update sizes in-place.
+			const configUnchanged = configSig === this._lastShadowConfigSig
+				&& this._shadowImages.length === list.length
+				&& this._shadowEntries.length === list.length
+				&& this._shadowImages.length > 0;
+			this._lastShadowSig = sig;
+			// _lastShadowConfigSig is set AFTER _removeShadowImages() in the full-rebuild path so that
+			// a mid-rebuild exception can't leave a stale configSig that fools the fast path.
+
+			if (configUnchanged) {
+				try {
+					const N = Windows.Foundation.Numerics;
+					const cssOrder = list.slice().reverse();
+					for (let i = 0; i < this._shadowEntries.length; i++) {
+						const entry = this._shadowEntries[i];
+						const s = cssOrder[i];
+						const spread = Math.max(0, layout.toDeviceIndependentPixels(s.spreadRadius || 0));
+						const cw = Math.max(0, w + 2 * spread);
+						const chh = Math.max(0, h + 2 * spread);
+						(this._shadowImages[i] as any).Width = w;
+						(this._shadowImages[i] as any).Height = h;
+						entry.layer.Size = new N.Vector2(cw, chh);
+						entry.shapeVisual.Size = new N.Vector2(cw, chh);
+						entry.geo.Size = new N.Vector2(cw, chh);
+					}
+					return; // no tree mutation needed
+				} catch (_e) { /* fall through to full rebuild on error */ }
+			}
+
+			this._removeShadowImages();
+			// Now safe to record the new configSig — hosts have been removed, rebuild is starting.
+			this._lastShadowConfigSig = configSig;
+
+			const parent = el.Parent as unknown as Microsoft.UI.Xaml.Controls.Panel;
+			const kids = parent?.Children;
+			if (!kids || typeof kids.Size !== 'number') {
+				return;
+			}
+			if (typeof (parent as unknown as Microsoft.UI.Xaml.Controls.StackPanel).Orientation !== 'undefined') {
+				return; // StackPanel — sibling overlap not possible
+			}
+
+			const G = Microsoft.UI.Xaml.Controls.Grid;
+
+			// style-properties stores shadows in reverse CSS order; restore so built[0] is first-listed
+			// (nearest the element after insertion).
+			const cssOrder = list.slice().reverse();
+
+			// CRITICAL: ActualWidth/Height and cornerRadius are in DIPs, but blurRadius/spreadRadius/
+			// offsetX/offsetY are in device pixels (style system converts via Length.toDevicePixels).
+			// Convert back to DIPs — mixing units over-blurs and swamps the offset (flat halo artifact).
+			const built: Array<{ host: Microsoft.UI.Xaml.FrameworkElement; layer: any; shapeVisual: any; geo: any }> = [];
+			for (const s of cssOrder) {
+				const entry = this._buildShadowHost(s, w, h, cornerRadius);
+				if (!entry) {
+					continue;
+				}
+				const host = entry.host;
+				// Match grid cell + alignment of the element. Composition shadow overflows host bounds
+				// (XAML doesn't clip child visuals), so element-sized host is sufficient.
+				try {
+					host.HorizontalAlignment = el.HorizontalAlignment;
+					host.VerticalAlignment = el.VerticalAlignment;
+					G.SetRow(host, G.GetRow(el));
+					G.SetColumn(host, G.GetColumn(el));
+					G.SetRowSpan(host, G.GetRowSpan(el));
+					G.SetColumnSpan(host, G.GetColumnSpan(el));
+				} catch (_e) { }
+
+				built.push(entry);
+			}
+			if (!built.length) {
+				return;
+			}
+
+			// Insert behind the element (lower index = lower z). Always inserting at the element's index
+			// pushes earlier-inserted images up, so the first-listed shadow ends up nearest (per CSS).
+			let idx = -1;
+			for (let i = 0; i < kids.Size; i++) {
+				if (kids.GetAt(i) === el) {
+					idx = i;
+					break;
+				}
+			}
+			for (const entry of built) {
+				if (idx < 0) {
+					kids.Append(entry.host);
+				} else {
+					kids.InsertAt(idx, entry.host);
+				}
+			}
+			this._shadowImages = built.map(e => e.host);
+			this._shadowEntries = built.map(e => ({ layer: e.layer, shapeVisual: e.shapeVisual, geo: e.geo }));
+			this._shadowKids = kids; // remember the exact collection for removal (el.Parent is unreliable later)
+		} catch (_e) { }
+	}
+
+	// Element-sized host carrying one DropShadow per CSS box-shadow entry. The opaque shadow caster is
+	// covered by the (opaque) element, so only the blurred shadow shows. Spread inflates the caster and
+	// its corner radius. Uses LayerVisual + ShapeVisual (a GeometricClip would clip the shadow away).
+	private _buildShadowHost(s: BoxShadow, w: number, h: number, cornerRadius: number): { host: Microsoft.UI.Xaml.FrameworkElement; layer: any; shapeVisual: any; geo: any } | null {
+		try {
+			const winColor = (s.color as Color & { windows?: Windows.UI.Color })?.windows;
+			if (!winColor) {
+				return null;
+			}
+			const N = Windows.Foundation.Numerics;
+			const CH = Windows.UI.ColorHelper;
+			const blur = Math.max(0, layout.toDeviceIndependentPixels(s.blurRadius || 0));
+			const spread = Math.max(0, layout.toDeviceIndependentPixels(s.spreadRadius || 0));
+			const offX = layout.toDeviceIndependentPixels(s.offsetX || 0);
+			const offY = layout.toDeviceIndependentPixels(s.offsetY || 0);
+			const cr = Math.max(0, cornerRadius);
+			const cw = Math.max(0, w + 2 * spread);
+			const chh = Math.max(0, h + 2 * spread);
+
+			// DropShadow.Color carries the alpha for CSS opacity; caster fill is opaque for full-strength shadow.
+			const shadowColor = CH.FromArgb(winColor.A ?? 255, winColor.R ?? 0, winColor.G ?? 0, winColor.B ?? 0);
+			const casterColor = CH.FromArgb(255, winColor.R ?? 0, winColor.G ?? 0, winColor.B ?? 0);
+
+			const host = new Microsoft.UI.Xaml.Controls.Border();
+			host.Width = w;
+			host.Height = h;
+			try { (host as Microsoft.UI.Xaml.UIElement).IsHitTestVisible = false; } catch (_e) { }
+
+			const ECP = Microsoft.UI.Xaml.Hosting.ElementCompositionPreview;
+			const c = ECP.GetElementVisual(host).Compositor;
+
+			const drop = c.CreateDropShadow();
+			drop.BlurRadius = blur;
+			drop.Color = shadowColor;
+			drop.Offset = new N.Vector3(offX, offY, 0);
+
+			// LayerVisual content isn't painted — only its DropShadow is — giving a pure soft shadow
+			// with no visible opaque caster edge (the old SpriteVisual caster painted a hard edge at spread).
+			const cornerR = cr > 0 ? cr + spread : 0;
+			const layer = c.CreateLayerVisual();
+			layer.Size = new N.Vector2(cw, chh);
+			layer.Offset = new N.Vector3(-spread, -spread, 0);
+			const shapeVisual = c.CreateShapeVisual();
+			shapeVisual.Size = new N.Vector2(cw, chh);
+			const geo = c.CreateRoundedRectangleGeometry();
+			geo.Size = new N.Vector2(cw, chh);
+			geo.CornerRadius = new N.Vector2(cornerR, cornerR);
+			const shape = c.CreateSpriteShape(geo);
+			const fb = c.CreateColorBrush();
+			fb.Color = casterColor;
+			shape.FillBrush = fb;
+			shapeVisual.Shapes.Append(shape);
+			layer.Children.InsertAtTop(shapeVisual);
+			layer.Shadow = drop;
+
+			ECP.SetElementChildVisual(host, layer);
+			return { host, layer, shapeVisual, geo };
+		} catch (_e) {
+			return null;
+		}
+	}
+
+	private _removeShadowImages(): void {
+		const count = this._shadowImages.length;
+		this._shadowImages = [];
+		this._shadowEntries = [];
+		if (count <= 0) {
+			return;
+		}
+		// Remove by position, not identity: collection has no Remove()/IndexOf; GetAt returns a fresh
+		// JS wrapper per call so `=== img` is false. Only `GetAt(i) === el` is stable. Shadow images
+		// are the `count` siblings immediately before the element — find el, RemoveAt the slots before it.
+		const kids = this._shadowKids as { Size: number; GetAt: (i: number) => unknown; RemoveAt: (i: number) => void } | null;
+		const el = this._element;
+		if (!kids || typeof kids.Size !== 'number' || !el) {
+			return;
+		}
+		try {
+			let elIdx = -1;
+			for (let i = 0; i < kids.Size; i++) {
+				if (kids.GetAt(i) === el) { elIdx = i; break; }
+			}
+			if (elIdx < 0) {
+				return;
+			}
+			for (let k = 1; k <= count; k++) {
+				const idx = elIdx - k;
+				if (idx >= 0) {
+					try { kids.RemoveAt(idx); } catch (_e) { }
+				}
+			}
+		} catch (_e) { }
+	}
+
+	// Per-side ("colorful") border drawn as a bitmap overlay on top of the element. Pass null to clear.
+	UpdateColorfulBorder(b: { w: number; h: number; tW: number; rW: number; bW: number; lW: number; tC: number; rC: number; bC: number; lC: number; radius: number } | null): void {
+		const el = this._element as Microsoft.UI.Xaml.FrameworkElement;
+		if (!el) {
+			return;
+		}
+		try {
+			if (!b || (b.tW <= 0 && b.rW <= 0 && b.bW <= 0 && b.lW <= 0)) {
+				if (this._lastBorderSig === 'none') {
+					return;
+				}
+				this._lastBorderSig = 'none';
+				this._removeBorderOverlay();
+				return;
+			}
+			// Not laid out yet — do NOT touch the existing overlay; a transient w=0 pass must not
+			// tear down a valid overlay (would flicker/vanish).
+			if (b.w <= 0 || b.h <= 0) {
+				return;
+			}
+			const sig = `${Math.round(b.w)}x${Math.round(b.h)}|${b.radius}|${b.tW},${b.rW},${b.bW},${b.lW}|${b.tC},${b.rC},${b.bC},${b.lC}`;
+			if (sig === this._lastBorderSig && this._borderOverlayActive) {
+				return;
+			}
+			this._lastBorderSig = sig;
+			this._removeBorderOverlay();
+			const parent = el.Parent as unknown as Microsoft.UI.Xaml.Controls.Panel;
+			const kids = parent?.Children;
+			if (!kids || typeof kids.Size !== 'number') {
+				return;
+			}
+			if (typeof (parent as unknown as Microsoft.UI.Xaml.Controls.StackPanel).Orientation !== 'undefined') {
+				return; // StackPanel — overlay positioning not supported
+			}
+			const result = NativeScript.Widgets.ShadowHelper.CreateBorder(b.w, b.h, b.tW, b.rW, b.bW, b.lW, b.tC as never, b.rC as never, b.bC as never, b.lC as never, b.radius);
+			const img = result?.Image;
+			if (!img) {
+				return;
+			}
+			try {
+				img.HorizontalAlignment = el.HorizontalAlignment;
+				img.VerticalAlignment = el.VerticalAlignment;
+				const G = Microsoft.UI.Xaml.Controls.Grid;
+				G.SetRow(img, G.GetRow(el));
+				G.SetColumn(img, G.GetColumn(el));
+				G.SetRowSpan(img, G.GetRowSpan(el));
+				G.SetColumnSpan(img, G.GetColumnSpan(el));
+			} catch (_e) { }
+			// Insert immediately AFTER the element (just above it in z-order).
+			let elIdx = -1;
+			for (let i = 0; i < kids.Size; i++) {
+				if (kids.GetAt(i) === el) { elIdx = i; break; }
+			}
+			if (elIdx < 0 || elIdx + 1 >= kids.Size) {
+				kids.Append(img);
+			} else {
+				kids.InsertAt(elIdx + 1, img);
+			}
+			this._borderKids = kids;
+			this._borderOverlayActive = true;
+		} catch (_e) { }
+	}
+
+	private _removeBorderOverlay(): void {
+		if (!this._borderOverlayActive) {
+			return;
+		}
+		this._borderOverlayActive = false;
+		const kids = this._borderKids as { Size: number; GetAt: (i: number) => unknown; RemoveAt: (i: number) => void } | null;
+		const el = this._element;
+		if (!kids || typeof kids.Size !== 'number' || !el) {
+			return;
+		}
+		try {
+			// Overlay sits immediately after the element (or last if appended). Position-based removal
+			// since wrapper identity for our Image is unreliable (fresh wrapper per GetAt).
+			let elIdx = -1;
+			for (let i = 0; i < kids.Size; i++) {
+				if (kids.GetAt(i) === el) { elIdx = i; break; }
+			}
+			if (elIdx >= 0 && elIdx + 1 < kids.Size) {
+				kids.RemoveAt(elIdx + 1);
+			} else if (kids.Size > 0) {
+				kids.RemoveAt(kids.Size - 1); // was appended as last
+			}
+		} catch (_e) { }
+	}
+
+	Free(): void {
+		this._removeShadowImages();
+		this._removeBorderOverlay();
+		if (this._element) {
+			try { Microsoft.UI.Xaml.Hosting.ElementCompositionPreview.SetElementChildVisual(this._element, null as never); } catch (_e) { }
+		}
+		this._element = null;
+		this._rootVisual = null;
+		this._container = null;
+		this._top = null; this._bottom = null; this._left = null; this._right = null;
+		this._topBrush = null; this._bottomBrush = null; this._leftBrush = null; this._rightBrush = null;
+	}
+}
+
+export class View extends ViewCommon {
+	nativeViewProtected: Microsoft.UI.Xaml.FrameworkElement;
+
+	_nativeBackgroundState: 'invalid' | 'drawn' = 'invalid';
+
+	private _percentWidth: number | null = null; // null = not set
+	private _percentHeight: number | null = null;
+	// Held SizeChanged delegate (prevents GC — see _ensureSizeWatch).
+	private _sizeChangedDelegate: any = null;
+	private _sizeWatchWired = false;
+	private _sizeRedrawPending = false;
+	// Background-application caches — prevent redundant WinRT calls across repeated _redrawNativeBackground calls.
+	// IMPORTANT: all sigs are value-based (not object-reference-based) because Background uses a clone pattern:
+	// every withBorderWidth/withBorderRadius/withColor call creates a new object, so reference equality
+	// is always false and would never skip anything.
+	private _lastStaticSig: string | null = null;  // skip color/gradient rebuild when color+image unchanged
+	private _lastRadiusSig: string | null = null;  // skip CornerRadius set when unchanged
+	private _lastBorderSig: string | null = null;  // skip BorderThickness/UpdateBorder when unchanged
+	private _isNativeButton: boolean | null = null; // cached once in initNativeView — avoids per-call 'in' check
+	private _lastMarginSig: string | null = null;  // coalesce the 4 individual margin setNative calls into 1 WinRT set
+	private _lastPaddingSig: string | null = null; // coalesce the 4 individual padding setNative calls into 1 WinRT set
+	_colorAnimBrush: any = null; // the current SolidColorBrush used as Background; lets animation reuse it without QI
+
+	public measure(widthMeasureSpec: number, heightMeasureSpec: number): void {
+		super.measure(widthMeasureSpec, heightMeasureSpec);
+		this.onMeasure(widthMeasureSpec, heightMeasureSpec);
+	}
+
+	public layout(left: number, top: number, right: number, bottom: number, setFrame = true): void {
+		super.layout(left, top, right, bottom);
+		if (setFrame) {
+			this.layoutNativeView(left, top, right, bottom);
+		}
+		this.onLayout(left, top, right, bottom);
+	}
+
+	public onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void {
+		const view = this.nativeViewProtected;
+		const width = layout.getMeasureSpecSize(widthMeasureSpec);
+		const widthMode = layout.getMeasureSpecMode(widthMeasureSpec);
+		const height = layout.getMeasureSpecSize(heightMeasureSpec);
+		const heightMode = layout.getMeasureSpecMode(heightMeasureSpec);
+
+		let nativeWidth = 0;
+		let nativeHeight = 0;
+		if (view) {
+			const nativeSize = layout.measureNativeView(view, width, widthMode, height, heightMode);
+			nativeWidth = nativeSize.width;
+			nativeHeight = nativeSize.height;
+		}
+
+		const measureWidth = Math.max(nativeWidth, this.effectiveMinWidth);
+		const measureHeight = Math.max(nativeHeight, this.effectiveMinHeight);
+
+		const widthAndState = View.resolveSizeAndState(measureWidth, width, widthMode, 0);
+		const heightAndState = View.resolveSizeAndState(measureHeight, height, heightMode, 0);
+
+		this.setMeasuredDimension(widthAndState, heightAndState);
+	}
+
+	public onLayout(_left: number, _top: number, _right: number, _bottom: number): void {
+		// Native panels (StackPanel, Grid, etc.) position children; Canvas layouts set positions in their own handlers.
+	}
+
+	public layoutNativeView(left: number, top: number, right: number, bottom: number): void {
+		const native = this.nativeViewProtected;
+		if (!native) {
+			return;
+		}
+
+		const w = layout.toDeviceIndependentPixels(right - left);
+		const h = layout.toDeviceIndependentPixels(bottom - top);
+		const l = layout.toDeviceIndependentPixels(left);
+		const t = layout.toDeviceIndependentPixels(top);
+
+		try {
+			if (native.Parent) {
+				Microsoft.UI.Xaml.Controls.Canvas.SetLeft(native, l);
+				Microsoft.UI.Xaml.Controls.Canvas.SetTop(native, t);
+			}
+		} catch (_e) { }
+
+		try {
+			if (w > 0) {
+				native.Width = w;
+			}
+			if (h > 0) {
+				native.Height = h;
+			}
+		} catch (_e) { }
+	}
+
+	_redrawNativeBackground(value: any): void {
+		const native = this.nativeViewProtected as any;
+		if (!native) return;
+
+		const background = value as Background;
+
+		if (!(background && typeof background === 'object')) {
+			return;
+		}
+
+		// Wire size watcher for size-dependent backgrounds (border/shadow/clip/radius/image). Not wired
+		// on every view so plain views skip SizeChanged and fast scroll stays cheap.
+		const depends = !!(
+			(background.borderTopWidth || background.borderRightWidth || background.borderBottomWidth || background.borderLeftWidth) ||
+			(background.clipPath) ||
+			(background.image && background.image !== 'none') ||
+			(typeof background.hasBorderRadius === 'function' && background.hasBorderRadius()) ||
+			(typeof background.hasBoxShadows === 'function' && background.hasBoxShadows())
+		);
+		if (depends) {
+			this._ensureSizeWatch();
+		}
+
+		// ── Phase 1: Static background (color / gradient / image) ────────────────────────────────
+		// Guards via a value-based sig rather than object identity — Background uses a clone
+		// pattern (each withBorderWidth/withRadius/withColor returns a new object), so reference
+		// equality is always false and would never skip anything.
+		// Sig encodes just color+image because those are the only static parts; border/radius/shadow
+		// are size-dependent and handled in Phase 2 with their own per-value sigs.
+		// Use pure-JS `color.argb` (returns the stored _argb integer) — NOT `color.windowsArgb`
+		// which calls Windows.UI.ColorHelper.FromArgb() + 4 WinRT struct reads on every call.
+		const _colorArgb = (background.color as any)?.argb ?? 0;
+		const _imageKey  = background.image
+			? (typeof background.image === 'string' ? background.image : 'lg')
+			: '';
+		const _staticSig = `${_colorArgb}|${_imageKey}`;
+		// Save prior sig BEFORE updating — used below to detect first call (fresh view).
+		const _prevStaticSig = this._lastStaticSig;
+		if (_staticSig !== this._lastStaticSig) {
+			this._lastStaticSig = _staticSig;
+			// When color/image changes, invalidate Phase-2 sigs — the composition handler may not
+			// yet exist (element newly created), so stale radius/border sigs must not persist.
+			this._lastRadiusSig = null;
+			this._lastBorderSig = null;
+			// Clear cached solid-color brush; re-set only if background is still a solid color.
+			this._colorAnimBrush = null;
+
+			if (background.image && typeof background.image === 'object' && 'colorStops' in background.image) {
+				try {
+					const lg: LinearGradient = background.image as any;
+					const cs = lg.colorStops || [];
+					// Create brush first to access its built-in GradientStops collection
+					// (GradientStopCollection is not directly constructable in WinRT JS projection).
+					const brush = new Microsoft.UI.Xaml.Media.LinearGradientBrush();
+					const stopsCol = brush.GradientStops;
+					for (let i = 0; i < cs.length; i++) {
+						const entry = cs[i];
+						const stop = new Microsoft.UI.Xaml.Media.GradientStop();
+						const resolvedColor = _resolveToWinColor(entry.color);
+						stop.Color = resolvedColor ?? Windows.UI.Colors.Transparent;
+						if (entry.offset && typeof (entry.offset as any).value === 'number') {
+							stop.Offset = (entry.offset as any).value;
+						} else {
+							stop.Offset = cs.length > 1 ? i / (cs.length - 1) : 0;
+						}
+						stopsCol.Append(stop);
+					}
+					// angle: 0 = top-to-bottom, 90deg = left-to-right (NS convention matches CSS)
+					const angleRad = typeof lg.angle === 'number' ? lg.angle : 0;
+					const dx = Math.sin(angleRad);
+					const dy = -Math.cos(angleRad);
+					brush.StartPoint = Microsoft.UI.Xaml.PointHelper.FromCoordinates(0.5 - dx / 2, 0.5 - dy / 2);
+					brush.EndPoint = Microsoft.UI.Xaml.PointHelper.FromCoordinates(0.5 + dx / 2, 0.5 + dy / 2);
+					brush.MappingMode = Microsoft.UI.Xaml.Media.BrushMappingMode.RelativeToBoundingBox;
+					native.Background = brush;
+				} catch (_e) { /* fallback to solid color below */ }
+			} else if (background.image && typeof background.image === 'string' && background.image !== 'none') {
+				// Raster background-image: url(...). Rendered via an ImageBrush (XAML can't tile, so CSS
+				// background-repeat beyond no-repeat is approximated by stretch/alignment).
+				this._applyBackgroundImage(native, background.image as string, background);
+			} else if (background && background.color) {
+				const winColor = _resolveToWinColor(background.color);
+				if (winColor) {
+					try {
+						const brush = new Microsoft.UI.Xaml.Media.SolidColorBrush(winColor);
+						native.Background = brush;
+						// Cache the brush so backgroundColor animations can reuse it without a WinRT QI.
+						this._colorAnimBrush = brush;
+						// For Button controls the default XAML template ignores Background via its VSM
+						// Normal-state animation. Override the ButtonBackground theme resource on the
+						// instance so the template binding picks up our colour.
+						// IMPORTANT: only do this for actual Button-type controls — Resources.Insert on
+						// a non-Button creates a useless ResourceDictionary (~15ms one-time overhead).
+						if (this._isNativeButton) {
+							try { native.Resources.Insert('ButtonBackground', brush); } catch (_re) { }
+							try { native.Resources.Insert('ButtonBackgroundPointerOver', brush); } catch (_re) { }
+							try { native.Resources.Insert('ButtonBackgroundPressed', brush); } catch (_re) { }
+						}
+					} catch (bgErr) {
+						console.error('[Windows] Background SolidColorBrush failed:', bgErr);
+					}
+				} else {
+					// Transparent color (winColor = null) — XAML default Background is null for non-buttons.
+					// Skip the no-op setter on fresh views to save 1 WinRT call per transparent view.
+					if (this._isNativeButton || _prevStaticSig !== null) {
+						native.Background = null;
+					}
+				}
+			} else {
+				// No color, no image — same result as transparent.
+				// Skip null-set on fresh non-button views (XAML default is already null).
+				if (this._isNativeButton || _prevStaticSig !== null) {
+					native.Background = null;
+				}
+			}
+		}
+
+		// ── Phase 2: Size-dependent work (composition, border, radius, shadow) ───────────────────
+		this._applySizeDependentNativeBackground(native, background);
+	}
+
+	// Size-dependent half of background rendering — called from both _redrawNativeBackground
+	// (full redraw) and _onSizeChanged (size-change-only redraw, skips Phase 1 above).
+	private _applySizeDependentNativeBackground(native: any, background: Background): void {
+		let radius = 0;
+		if (typeof background.getUniformBorderRadius === 'function') {
+			radius = background.getUniformBorderRadius();
+		}
+
+		// Read border-color argb early (pure JS, no WinRT) — used for both needsComposition and
+		// the border sig / native XAML path below.
+		const tCArgb = (background.borderTopColor as any)?.argb ?? 0;
+		const rCArgb = (background.borderRightColor as any)?.argb ?? 0;
+		const bCArgb = (background.borderBottomColor as any)?.argb ?? 0;
+		const lCArgb = (background.borderLeftColor as any)?.argb ?? 0;
+		const _anyBorderWidth = !!(background.borderTopWidth || background.borderRightWidth || background.borderBottomWidth || background.borderLeftWidth);
+		// Per-side different colors → XAML BorderBrush (single color) can't handle it.
+		const _hasNonUniformBorderColor = _anyBorderWidth && (tCArgb !== rCArgb || tCArgb !== bCArgb || tCArgb !== lCArgb);
+		const _hasBoxShadow = typeof background.hasBoxShadows === 'function' && background.hasBoxShadows();
+		// Whether XAML has native BorderThickness + BorderBrush on this element.
+		// Controls (Button, TextBox, etc.) and Border do; layout panels (Grid, StackPanel) do NOT.
+		// `'BorderThickness' in native` is a free prototype check — no WinRT getter invoked.
+		const _nativeHasBorderSupport = 'BorderThickness' in native;
+		// Only create the Compositor handler for features XAML can't handle natively:
+		//   • box-shadows (no XAML equivalent at the NativeScript level)
+		//   • per-side different border colors (XAML BorderBrush is a single uniform color)
+		//   • layout panels: Grid/StackPanel/etc. have no BorderThickness, so they need Compositor
+		//     for any border regardless of uniformity
+		// Controls with uniform-color borders are handled natively via BorderThickness + BorderBrush
+		// + CornerRadius — no WinRT Compositor overhead (~20 WinRT calls per element) needed.
+		const needsComposition = !!(_hasBoxShadow || _hasNonUniformBorderColor || (_anyBorderWidth && !_nativeHasBorderSupport));
+		if (needsComposition && !this._viewCompositionHandler) {
+			this._viewCompositionHandler = CompositionBorderHandler.Create(native);
+		}
+
+		// Borders/radius via native XAML CornerRadius. Use `'CornerRadius' in native` (JS prototype
+		// chain check, no getter invocation) instead of `typeof native.CornerRadius !== 'undefined'`
+		// (which would invoke the WinRT getter). Sig-guard skips the WinRT set when nothing changed.
+		const tlr = background.borderTopLeftRadius || 0;
+		const trr = background.borderTopRightRadius || 0;
+		const brr = background.borderBottomRightRadius || 0;
+		const blr = background.borderBottomLeftRadius || 0;
+		const radiusSig = `${radius}|${tlr}|${trr}|${brr}|${blr}`;
+		if (radiusSig !== this._lastRadiusSig) {
+			this._lastRadiusSig = radiusSig;
+			try {
+				if ('CornerRadius' in native) {
+					if (radius > 0) {
+						const radiusDp = layout.toDeviceIndependentPixels(radius);
+						native.CornerRadius = Microsoft.UI.Xaml.CornerRadiusHelper.FromUniformRadius(radiusDp);
+					} else {
+						native.CornerRadius = Microsoft.UI.Xaml.CornerRadiusHelper.FromRadii(
+							layout.toDeviceIndependentPixels(tlr),
+							layout.toDeviceIndependentPixels(trr),
+							layout.toDeviceIndependentPixels(brr),
+							layout.toDeviceIndependentPixels(blr)
+						);
+					}
+				}
+			} catch (_e) { }
+		}
+
+		// Border rendering: XAML-native path (BorderThickness + BorderBrush) or composition path.
+		// Only access native.ActualWidth/Height when a composition handler actually exists —
+		// those are WinRT getter calls and are wasted on elements with no handler.
+		// (tCArgb / rCArgb / bCArgb / lCArgb computed above before needsComposition check.)
+		try {
+			const lW = layout.toDeviceIndependentPixels(background.borderLeftWidth || 0);
+			const tW = layout.toDeviceIndependentPixels(background.borderTopWidth || 0);
+			const rW = layout.toDeviceIndependentPixels(background.borderRightWidth || 0);
+			const bW = layout.toDeviceIndependentPixels(background.borderBottomWidth || 0);
+			const anyWidth = lW > 0 || tW > 0 || rW > 0 || bW > 0;
+			const radiusDp = layout.toDeviceIndependentPixels(radius || 0);
+			// Border config sig excludes size — size is only needed inside UpdateBorder (lazy).
+			// Including size would force ActualWidth/Height reads even for elements with no handler.
+			const borderConfigSig = `${tW},${rW},${bW},${lW},${tCArgb},${rCArgb},${bCArgb},${lCArgb},${radiusDp}`;
+			if (borderConfigSig !== this._lastBorderSig) {
+				this._lastBorderSig = borderConfigSig;
+				if (!this._viewCompositionHandler) {
+					// XAML-native path: uniform-color border via BorderThickness + BorderBrush.
+					// CornerRadius already set above. No WinRT Compositor objects needed.
+					// `'BorderThickness' in native` is a free prototype check (no WinRT getter).
+					try {
+						if ('BorderThickness' in native) {
+							if (anyWidth) {
+								native.BorderThickness = { Left: lW, Top: tW, Right: rW, Bottom: bW } as any;
+								// All 4 colors are equal (enforced by needsComposition → use top as canonical).
+								const borderBrush = tCArgb
+									? new Microsoft.UI.Xaml.Media.SolidColorBrush(_argbToWinColor(tCArgb))
+									: null;
+								native.BorderBrush = borderBrush;
+								// Button VSM overrides BorderBrush via {ThemeResource ButtonBorderBrush}.
+								// Insert into the instance ResourceDictionary so the binding resolves our value.
+								if (this._isNativeButton && borderBrush) {
+									try { native.Resources.Insert('ButtonBorderBrush', borderBrush); } catch (_re) { }
+									try { native.Resources.Insert('ButtonBorderBrushPointerOver', borderBrush); } catch (_re) { }
+									try { native.Resources.Insert('ButtonBorderBrushPressed', borderBrush); } catch (_re) { }
+								}
+							} else {
+								native.BorderThickness = { Left: 0, Top: 0, Right: 0, Bottom: 0 } as any;
+								native.BorderBrush = null;
+							}
+						}
+					} catch (_e) { }
+				} else {
+					// Composition path: clear native XAML border (composition draws its own).
+					try {
+						if ('BorderThickness' in native) {
+							native.BorderThickness = { Left: 0, Top: 0, Right: 0, Bottom: 0 } as any;
+						}
+					} catch (_e) { }
+					this._viewCompositionHandler?.UpdateColorfulBorder(null);
+				}
+			}
+			// ActualWidth/Height reads gated inside the anyWidth branch — shadow-only handlers never
+			// pay these 2 WinRT getter calls. _argbToWinColor uses the module-level cache.
+			if (this._viewCompositionHandler) {
+				if (anyWidth) {
+					const aw = native.ActualWidth || 0;
+					const ah = native.ActualHeight || 0;
+					this._viewCompositionHandler.UpdateBorder(aw, ah, tW, rW, bW, lW, tCArgb, rCArgb, bCArgb, lCArgb, radiusDp);
+				} else {
+					this._viewCompositionHandler.ClearBorder();
+				}
+			}
+		} catch (_e) { }
+
+		this._nativeBackgroundState = 'drawn';
+
+		if (this._viewCompositionHandler) {
+			const hasShadow = background && typeof background.hasBoxShadows === 'function' && background.hasBoxShadows();
+			if (hasShadow) {
+				const boxShadows = typeof background.getBoxShadows === 'function' ? background.getBoxShadows() : (background as any).boxShadows;
+				this._viewCompositionHandler.UpdateBoxShadow(boxShadows?.length ? boxShadows : null, layout.toDeviceIndependentPixels(radius || 0));
+			} else {
+				this._viewCompositionHandler.UpdateBoxShadow(null);
+			}
+		}
+	}
+
+	// Last layout size we reacted to. LayoutUpdated fires on every layout pass (including scrolling);
+	// tracking size avoids expensive _onSizeChanged (tree mutation via box-shadow/border Images) when unchanged.
+	private _lastLayoutW = NaN;
+	private _lastLayoutH = NaN;
+
+	initNativeView(): void {
+		super.initNativeView();
+		// Size-dependent work (percent sizing, border/shadow/clip redraw) is wired ON DEMAND via
+		// _ensureSizeWatch(). SizeChanged fires for every recycled cell + child during fast scroll;
+		// wiring it unconditionally crossed the JS bridge per cell and blocked scrolling.
+		//
+		// Cache whether this native control is a Button-family control. The JS `in` operator checks
+		// the prototype chain without invoking a getter — free. We use this to gate the
+		// ButtonBackground ResourceDictionary inserts (button-template-only VSM resource).
+		try {
+			const nv = this.nativeViewProtected as any;
+			// `in` is unreliable on COM proxy objects — use direct property access instead.
+			// ClickMode is declared on ButtonBase (Button/AppBarButton/etc.) and returns 0 (Release)
+			// by default; non-button controls return `undefined` for absent properties.
+			this._isNativeButton = !!(nv && nv.ClickMode !== undefined);
+		} catch (_e) {
+			this._isNativeButton = false;
+		}
+	}
+
+	// Renders CSS background-image as a native ImageBrush. Resolves NS path forms (res://, ~/, data:,
+	// http(s) async, ms-appx). background-size → Stretch, background-position → alignment. CSS tiling
+	// (repeat) isn't expressible with ImageBrush; only single no-repeat is supported.
+	private _applyBackgroundImage(native: any, src: string, background: Background): void {
+		const Media: any = Microsoft.UI.Xaml.Media;
+		const apply = (bmp: any) => {
+			if (!bmp || !native) {
+				return;
+			}
+			try {
+				const brush = new Media.ImageBrush();
+				brush.ImageSource = bmp;
+				// Map background-size → Stretch (default no-repeat shows the image at natural size).
+				const size = ((background as any).backgroundSize || '').toString().toLowerCase();
+				try {
+					if (size === 'cover') {
+						brush.Stretch = Media.Stretch.UniformToFill;
+					} else if (size === 'contain') {
+						brush.Stretch = Media.Stretch.Uniform;
+					} else if (size === '100% 100%' || size === 'fill') {
+						brush.Stretch = Media.Stretch.Fill;
+					} else {
+						brush.Stretch = Media.Stretch.None;
+					}
+				} catch (_e) { }
+				// Map background-position keywords → alignment (CSS default is top-left).
+				const pos = ((background as any).backgroundPosition || '').toString().toLowerCase();
+				try {
+					brush.AlignmentX = pos.includes('right') ? Media.AlignmentX.Right : pos.includes('center') ? Media.AlignmentX.Center : Media.AlignmentX.Left;
+					brush.AlignmentY = pos.includes('bottom') ? Media.AlignmentY.Bottom : pos.includes('center') ? Media.AlignmentY.Center : Media.AlignmentY.Top;
+				} catch (_e) { }
+				native.Background = brush;
+				// Buttons ignore Background in their default template (VSM); override the template brush too.
+				try { (native as any).Resources.Insert('ButtonBackground', brush); } catch (_e) { }
+				try { (native as any).Resources.Insert('ButtonBackgroundPointerOver', brush); } catch (_e) { }
+				try { (native as any).Resources.Insert('ButtonBackgroundPressed', brush); } catch (_e) { }
+			} catch (_e) { }
+		};
+
+		try {
+			let url = (src || '').trim();
+			const m = url.match(/^url\(\s*['"]?([^'")]+)['"]?\s*\)$/i);
+			if (m) {
+				url = m[1];
+			}
+			if (url.startsWith('~/')) {
+				url = 'ms-appx:///app/' + url.slice(2);
+			}
+
+			if (/^data:/i.test(url)) {
+				const is = ImageSource.fromBase64Sync(url.replace(/^data:[^,]*,/, ''));
+				apply(is && (is as any).windows);
+			} else if (/^https?:/i.test(url)) {
+				ImageSource.fromUrl(url).then((is) => apply(is && (is as any).windows)).catch(() => { });
+			} else if (url.startsWith('res://')) {
+				const is = ImageSource.fromResourceSync(url);
+				apply(is && (is as any).windows);
+			} else {
+				const is = ImageSource.fromFileSync(url);
+				apply(is && (is as any).windows);
+			}
+		} catch (_e) { }
+	}
+
+	// Lazily wire SizeChanged via asDelegate (the only event that reliably subscribes in this host;
+	// raw-fn LayoutUpdated does not). Idempotent. Only called for views that need it.
+	private _ensureSizeWatch(): void {
+		if (this._sizeWatchWired) return;
+		const nv = this.nativeViewProtected as Microsoft.UI.Xaml.FrameworkElement;
+		if (!nv) return;
+		this._sizeWatchWired = true;
+		const ref = new WeakRef(this);
+		const onSize = () => {
+			const owner = ref.deref();
+			if (!owner) return;
+			const n = owner.nativeViewProtected as Microsoft.UI.Xaml.FrameworkElement;
+			if (!n) return;
+			// NOTE: _applyPercentSizing() is intentionally NOT called here synchronously.
+			// Setting Width/Height from within a SizeChanged handler mutates the layout tree
+			// mid-pass and triggers XAML's LayoutCycleException (0x80000003 fail-fast).
+			// The deferred _onSizeChanged() path calls it safely after the layout pass ends.
+			let w = NaN, h = NaN;
+			try { w = n.ActualWidth; h = n.ActualHeight; } catch (_e) { return; }
+			if (Math.abs(w - owner._lastLayoutW) < 0.5 && Math.abs(h - owner._lastLayoutH) < 0.5) {
+				return; // size unchanged (e.g. scrolling) — nothing to redraw
+			}
+			owner._lastLayoutW = w;
+			owner._lastLayoutH = h;
+			// Coalesce rapid size changes into one deferred redraw; defer out of the layout callback
+			// (tree mutation inside it risks a 0xC000027B fail-fast).
+			if (owner._sizeRedrawPending) return;
+			owner._sizeRedrawPending = true;
+			setTimeout(() => { const o = ref.deref(); if (o) { o._sizeRedrawPending = false; try { o._onSizeChanged(); } catch (_e) { } } }, 0);
+		};
+		try {
+			this._sizeChangedDelegate = NSWinRT.asDelegate('Microsoft.UI.Xaml.SizeChangedEventHandler', onSize);
+			nv.SizeChanged = this._sizeChangedDelegate;
+		} catch (_e) { }
+		// LayoutUpdated intentionally NOT wired: it fires on every layout pass (scrolling, sibling
+		// changes, etc.) causing bridge round-trips per element per frame. SizeChanged is sufficient —
+		// it only fires when the element's actual pixel size changes.
+		// Apply immediately + once on load (covers percent before SizeChanged fires).
+		try { this._applyPercentSizing(); } catch (_e) { }
+	}
+
+	private _easeOutCubic(t: number) {
+		return 1 - Math.pow(1 - t, 3);
+	}
+
+	private _animateNativeOpacity(nativeElem: any, from: number, to: number, durationMs: number, done?: () => void) {
+		try {
+			nativeElem.Opacity = from;
+		} catch (_e) { }
+
+		const start = Date.now();
+		const step = () => {
+			const now = Date.now();
+			const elapsed = now - start;
+			const t = Math.min(1, elapsed / Math.max(1, durationMs));
+			const val = from + (to - from) * this._easeOutCubic(t);
+			try { nativeElem.Opacity = val; } catch (_e) { }
+			if (t < 1) {
+				if (typeof requestAnimationFrame === 'function') {
+					requestAnimationFrame(step as any);
+				} else {
+					setTimeout(step, 16);
+				}
+			} else {
+				done && done();
+			}
+		};
+		step();
+	}
+
+	disposeNativeView(): void {
+		const nativeView = this.nativeViewProtected as any;
+		if (nativeView) {
+			nativeView.SizeChanged = null;
+		}
+		// Reset so a recycled view re-wires on the next size-dependent property set.
+		this._sizeWatchWired = false;
+		this._sizeChangedDelegate = null;
+		// Reset background caches so recycled view re-applies on next use.
+		this._lastStaticSig = null;
+		this._lastRadiusSig = null;
+		this._lastBorderSig = null;
+		this._isNativeButton = null;
+		this._lastMarginSig = null;
+		this._lastPaddingSig = null;
+		this._colorAnimBrush = null;
+		super.disposeNativeView();
+	}
+
+	_onSizeChanged(): void {
+		const nativeView = this.nativeViewProtected;
+		if (!nativeView) {
+			return;
+		}
+
+		try { this._applyPercentSizing(); } catch (_e) { }
+
+		const background = this.style.backgroundInternal;
+		// Any border width makes the background size-dependent (composition border needs measured size).
+		const anyBorderWidth = !!(background && (background.borderTopWidth || background.borderRightWidth || background.borderBottomWidth || background.borderLeftWidth));
+		const backgroundDependsOnSize = (background && background.image && background.image !== 'none') || (background && background.clipPath) || anyBorderWidth || (background && !background.hasUniformBorder()) || (background && background.hasBorderRadius && background.hasBorderRadius()) || (background && background.hasBoxShadows && background.hasBoxShadows());
+
+		if (this._nativeBackgroundState === 'invalid') {
+			// Full redraw needed (background property changed while view had no size yet).
+			this._redrawNativeBackground(background);
+		} else if (this._nativeBackgroundState === 'drawn' && backgroundDependsOnSize) {
+			// Size changed — only re-run the size-dependent phase.  The static background
+			// (brush creation, native.Background=, Resources.Insert) is unchanged and
+			// skipping it saves ~15ms per element on every SizeChanged fire.
+			const native = this.nativeViewProtected as any;
+			if (native && background && typeof background === 'object') {
+				this._applySizeDependentNativeBackground(native, background);
+			}
+		}
+
+		try {
+			if (nativeView.Clip && nativeView.Clip instanceof Microsoft.UI.Xaml.Media.RectangleGeometry) {
+				const rectGeom = nativeView.Clip as Microsoft.UI.Xaml.Media.RectangleGeometry;
+				const w = nativeView.ActualWidth || nativeView.Width || 0;
+				const h = nativeView.ActualHeight || nativeView.Height || 0;
+
+				const location = Microsoft.UI.Xaml.PointHelper.FromCoordinates(0, 0);
+				const size = Microsoft.UI.Xaml.SizeHelper.FromDimensions(w, h);
+				rectGeom.Rect = Microsoft.UI.Xaml.RectHelper.FromLocationAndSize(location, size);
+
+			}
+
+		} catch (_e) { }
+	}
+
+	private _applyPercentSizing(): void {
+		const nativeView = this.nativeViewProtected as any;
+		if (!nativeView) {
+			return;
+		}
+
+		try {
+			const parentNative = (this.parent as any)?.nativeViewProtected as any;
+			const parentWidth = parentNative?.ActualWidth || 0;
+			const parentHeight = parentNative?.ActualHeight || 0;
+
+			// Only apply when parent has a real layout size. Using Window.Bounds as fallback when
+			// parent is 0 causes nested height="100%" views to overflow the container and cover
+			// sibling rows; LayoutUpdated fires again once the parent is properly sized.
+			if (this._percentWidth != null && parentWidth > 0) {
+				const w = parentWidth * (this._percentWidth);
+				nativeView.Width = isFinite(w) ? w : NaN;
+			}
+
+			if (this._percentHeight != null && parentHeight > 0) {
+				const h = parentHeight * (this._percentHeight);
+				nativeView.Height = isFinite(h) ? h : NaN;
+			}
+		} catch (_e) { }
+	}
+
+	[backgroundInternalProperty.getDefault](): any {
+		const native = this.nativeViewProtected as any;
+		if (!native) return null;
+		try {
+			return native.Background ?? null;
+		} catch (_e) {
+			return null;
+		}
+	}
+
+	private _viewCompositionHandler: any;
+
+	[backgroundInternalProperty.setNative](value: any) {
+		this._nativeBackgroundState = 'invalid';
+		this._redrawNativeBackground(value);
+	}
+
+	//@ts-ignore
+	[widthProperty.setNative](value: CoreTypes.PercentLengthType) {
+		if (!this.nativeViewProtected) {
+			return;
+		}
+
+		if (value && typeof value === 'object' && (value as any).unit === '%') {
+			const pct = (value as any).value;
+			this._percentWidth = pct;
+			this._ensureSizeWatch(); // re-apply percent when the parent resizes
+			this.nativeViewProtected.Width = NaN;
+			if (pct >= 1) {
+				// 100% → let the container size it natively (NativeScript.Widgets.StackLayout gives
+				// a Stretch child the remaining bounded extent; Grid Stretch fills the cell).
+				(this.nativeViewProtected as any).HorizontalAlignment = 3; // Stretch
+			} else {
+				try { this._applyPercentSizing(); } catch (_e) { }
+			}
+			// Feed FlexBasisPercent so the C++ FlexboxLayout panel's MeasureOverride sets
+			// item.MainSize = containerWidth * pct, which triggers a line break on flexWrap:wrap.
+			// pct is stored as a 0..1 fraction; the C++ property expects 0..100.
+			try {
+				(NativeScript as any).Widgets.FlexboxLayout.SetFlexBasisPercent(
+					this.nativeViewProtected as any, pct * 100
+				);
+			} catch (_e) {}
+			return;
+		}
+
+		this._percentWidth = null;
+		// Clear any previously set flex-basis so the C++ widget falls back to DesiredSize.
+		try {
+			(NativeScript as any).Widgets.FlexboxLayout.SetFlexBasisPercent(
+				this.nativeViewProtected as any, -1
+			);
+		} catch (_e) {}
+		this.nativeViewProtected.Width = toXamlLength(value);
+	}
+
+	//@ts-ignore
+	[heightProperty.setNative](value: CoreTypes.PercentLengthType) {
+		if (!this.nativeViewProtected) {
+			return;
+		}
+
+		if (value && typeof value === 'object' && (value as any).unit === '%') {
+			const pct = (value as any).value;
+			this._percentHeight = pct;
+			this._ensureSizeWatch(); // re-apply percent when the parent resizes
+			this.nativeViewProtected.Height = NaN;
+			if (pct >= 1) {
+				// 100% → let the container size it natively (NativeScript.Widgets.StackLayout sizes a
+				// Stretch child to remaining bounded extent; a Grid Stretch fills the cell).
+				(this.nativeViewProtected as any).VerticalAlignment = 3; // Stretch
+				// VerticalAlignment is ARRANGE-only; changing it doesn't re-run MeasureOverride.
+				// Force a re-measure so the panel re-evaluates this child as a fill child.
+				try { this.nativeViewProtected.InvalidateMeasure(); } catch (_e) { }
+			} else {
+				try { this._applyPercentSizing(); } catch (_e) { }
+			}
+			return;
+		}
+
+		this._percentHeight = null;
+		this.nativeViewProtected.Height = toXamlLength(value);
+	}
+
+	//@ts-ignore
+	[minWidthProperty.setNative](value: CoreTypes.LengthType) {
+		if (this.nativeViewProtected) {
+			const v = toXamlLength(value);
+			(this.nativeViewProtected as any).MinWidth = isNaN(v) ? 0 : v;
+		}
+	}
+
+	//@ts-ignore
+	[minHeightProperty.setNative](value: CoreTypes.LengthType) {
+		if (this.nativeViewProtected) {
+			const v = toXamlLength(value);
+			(this.nativeViewProtected as any).MinHeight = isNaN(v) ? 0 : v;
+		}
+	}
+
+	[opacityProperty.setNative](value: number) {
+		if (this.nativeViewProtected) {
+			this.nativeViewProtected.Opacity = value;
+		}
+	}
+
+
+	[hiddenProperty.getDefault](): boolean {
+		return getVisibility(this.nativeViewProtected as any) !== 'visible';
+	}
+
+	[hiddenProperty.setNative](value: boolean) {
+		setVisibility(this.nativeViewProtected as any, value ? 'hidden' : 'visible');
+	}
+
+
+	[visibilityProperty.setNative](value: CoreTypes.VisibilityType) {
+		if (this.nativeViewProtected) {
+			setVisibility(this.nativeViewProtected as any, value);
+		}
+	}
+
+	//@ts-ignore
+	[marginLeftProperty.setNative](_value: CoreTypes.PercentLengthType) {
+		this._applyMargin();
+	}
+	//@ts-ignore
+	[marginTopProperty.setNative](_value: CoreTypes.PercentLengthType) {
+		this._applyMargin();
+	}
+	//@ts-ignore
+	[marginRightProperty.setNative](_value: CoreTypes.PercentLengthType) {
+		this._applyMargin();
+	}
+	//@ts-ignore
+	[marginBottomProperty.setNative](_value: CoreTypes.PercentLengthType) {
+		this._applyMargin();
+	}
+
+	private _applyMargin(): void {
+		if (!this.nativeViewProtected) return;
+		try {
+			const l = toXamlLength(this.style.marginLeft) || 0;
+			const t = toXamlLength(this.style.marginTop) || 0;
+			const r = toXamlLength(this.style.marginRight) || 0;
+			const b = toXamlLength(this.style.marginBottom) || 0;
+			// All 4 margin properties share this helper — CSS `margin:` decomposes into 4 separate
+			// setNative calls in the same synchronous applyAllNativeSetters loop. The sig check
+			// coalesces them: the first call does the WinRT set; the remaining 3 are no-ops.
+			const sig = `${l},${t},${r},${b}`;
+			if (sig === this._lastMarginSig) return;
+			const prev = this._lastMarginSig;
+			this._lastMarginSig = sig;
+			// Skip the WinRT call on the very first zero-margin assignment: XAML default Margin is
+			// already {0,0,0,0}, so setting it is a no-op. Only safe when prev===null (native never
+			// touched); if margin was previously non-zero and is now reset to 0, we still call WinRT.
+			if (l === 0 && t === 0 && r === 0 && b === 0 && prev === null) return;
+			// Thickness is a plain value struct {Left,Top,Right,Bottom: f64} — pass as a plain JS
+			// object via the bridge's append_struct_object_bytes path (same as Windows.UI.Color).
+			// Saves the ThicknessHelper.FromLengths WinRT static call on every margin change.
+			(this.nativeViewProtected as any).Margin = { Left: l, Top: t, Right: r, Bottom: b } as any;
+		} catch (_e) { }
+	}
+
+	//@ts-ignore
+	[paddingTopProperty.setNative](_value: CoreTypes.LengthType) { this._applyPadding(); }
+	//@ts-ignore
+	[paddingRightProperty.setNative](_value: CoreTypes.LengthType) { this._applyPadding(); }
+	//@ts-ignore
+	[paddingBottomProperty.setNative](_value: CoreTypes.LengthType) { this._applyPadding(); }
+	//@ts-ignore
+	[paddingLeftProperty.setNative](_value: CoreTypes.LengthType) { this._applyPadding(); }
+
+	private _applyPadding(): void {
+		const native = this.nativeViewProtected as any;
+		if (!native) return;
+		try {
+			const l = toXamlLength(this.style.paddingLeft) || 0;
+			const t = toXamlLength(this.style.paddingTop) || 0;
+			const r = toXamlLength(this.style.paddingRight) || 0;
+			const b = toXamlLength(this.style.paddingBottom) || 0;
+			const sig = `${l},${t},${r},${b}`;
+			if (sig === this._lastPaddingSig) return;
+			const prev = this._lastPaddingSig;
+			this._lastPaddingSig = sig;
+			// XAML default Padding is {0,0,0,0} — skip the WinRT call on the first zero-padding set.
+			if (l === 0 && t === 0 && r === 0 && b === 0 && prev === null) return;
+			native.Padding = { Left: l, Top: t, Right: r, Bottom: b } as any;
+		} catch (_e) { }
+	}
+
+	//@ts-ignore
+	[horizontalAlignmentProperty.setNative](value: CoreTypes.HorizontalAlignmentType) {
+		const native = this.nativeViewProtected as any;
+		if (!native) return;
+		// WinUI HorizontalAlignment: Left=0, Center=1, Right=2, Stretch=3
+		switch (value) {
+			case 'left': native.HorizontalAlignment = 0; break;
+			case 'center': native.HorizontalAlignment = 1; break;
+			case 'right': native.HorizontalAlignment = 2; break;
+			case 'stretch': native.HorizontalAlignment = 3; break;
+		}
+	}
+
+	//@ts-ignore
+	[verticalAlignmentProperty.setNative](value: CoreTypes.VerticalAlignmentTextType) {
+		const native = this.nativeViewProtected as any;
+		if (!native) return;
+		// WinUI VerticalAlignment: Top=0, Center=1, Bottom=2, Stretch=3
+		switch (value) {
+			case 'top': native.VerticalAlignment = 0; break;
+			case 'middle': native.VerticalAlignment = 1; break;
+			case 'center': native.VerticalAlignment = 1; break;
+			case 'bottom': native.VerticalAlignment = 2; break;
+			case 'stretch': native.VerticalAlignment = 3; break;
+		}
+	}
+
+	[originXProperty.getDefault](): number {
+		const native = this.nativeViewProtected as any;
+		if (!native) return 0.5;
+		try {
+			const origin = native.RenderTransformOrigin;
+			return origin ? origin.X ?? 0.5 : 0.5;
+		} catch (_e) {
+			return 0.5;
+		}
+	}
+	[originXProperty.setNative](value: number) {
+		try {
+			const native = this.nativeViewProtected as any;
+			const y = this.originY ?? 0.5;
+			if (native && typeof Windows !== 'undefined' && Windows.UI && Microsoft.UI.Xaml && Microsoft.UI.Xaml.PointHelper) {
+				native.RenderTransformOrigin = Microsoft.UI.Xaml.PointHelper.FromCoordinates(value, y);
+			}
+		} catch (_e) { }
+	}
+
+	[originYProperty.getDefault](): number {
+		const native = this.nativeViewProtected as any;
+		if (!native) return 0.5;
+		try {
+			const origin = native.RenderTransformOrigin;
+			return origin ? origin.Y ?? 0.5 : 0.5;
+		} catch (_e) {
+			return 0.5;
+		}
+	}
+	[originYProperty.setNative](value: number) {
+		try {
+			const native = this.nativeViewProtected as any;
+			const x = this.originX ?? 0.5;
+			if (native && typeof Windows !== 'undefined' && Windows.UI && Microsoft.UI.Xaml && Microsoft.UI.Xaml.PointHelper) {
+				native.RenderTransformOrigin = Microsoft.UI.Xaml.PointHelper.FromCoordinates(x, value);
+			}
+		} catch (_e) { }
+	}
+
+	[rotateProperty.getDefault](): number {
+		return 0;
+	}
+	[rotateProperty.setNative](value: number) {
+		this.updateNativeTransform();
+	}
+
+	[rotateXProperty.getDefault](): number {
+		return 0;
+	}
+	[rotateXProperty.setNative](value: number) {
+		this.updateNativeTransform();
+	}
+
+	[rotateYProperty.getDefault](): number {
+		return 0;
+	}
+	[rotateYProperty.setNative](value: number) {
+		this.updateNativeTransform();
+	}
+
+	[perspectiveProperty.getDefault](): number {
+		return 300;
+	}
+	[perspectiveProperty.setNative](value: number) {
+		this.updateNativeTransform();
+	}
+
+	[scaleXProperty.getDefault](): number {
+		return 1;
+	}
+	[scaleXProperty.setNative](value: number) {
+		this.updateNativeTransform();
+	}
+
+	[scaleYProperty.getDefault](): number {
+		return 1;
+	}
+	[scaleYProperty.setNative](value: number) {
+		this.updateNativeTransform();
+	}
+
+	[translateXProperty.getDefault](): CoreTypes.dip {
+		return 0;
+	}
+	[translateXProperty.setNative](value: CoreTypes.dip) {
+		this.updateNativeTransform();
+	}
+
+	[translateYProperty.getDefault](): CoreTypes.dip {
+		return 0;
+	}
+	[translateYProperty.setNative](value: CoreTypes.dip) {
+		this.updateNativeTransform();
+	}
+
+	public updateNativeTransform(): void {
+		const native = this.nativeViewProtected as any;
+		if (!native) return;
+		try {
+			const transforms = _ensureNativeTransforms(native);
+			if (!transforms) return;
+
+			const sx = typeof (this as any).scaleX === 'number' ? (this as any).scaleX : typeof (this as any).scale === 'number' ? (this as any).scale : 1;
+			const sy = typeof (this as any).scaleY === 'number' ? (this as any).scaleY : typeof (this as any).scale === 'number' ? (this as any).scale : 1;
+			transforms.scale.ScaleX = sx;
+			transforms.scale.ScaleY = sy;
+
+			transforms.rotate.Angle = (this as any).rotate || 0;
+
+			// translateX/Y are in DIPs — WinUI TranslateTransform also uses DIPs. No conversion.
+			transforms.translate.X = (this as any).translateX || 0;
+			transforms.translate.Y = (this as any).translateY || 0;
+
+			try {
+				const ox = this.originX ?? 0.5;
+				const oy = this.originY ?? 0.5;
+				native.RenderTransformOrigin = Microsoft.UI.Xaml.PointHelper.FromCoordinates(ox, oy);
+			} catch (_e) { }
+		} catch (_e) { }
+	}
+
+	// Modal implemented as a Popup overlay (ContentDialog callbacks never reach V8).
+	private _modalPopup: any;
+	private _modalOverlay: any;
+	private _modalAnimatedOptions: Array<boolean>;
+	// Saved layout/size/alignment to restore after modal closes.
+	private _modalPrevHorizontalAlignment: any;
+	private _modalPrevVerticalAlignment: any;
+	private _modalPrevWidth: number;
+	private _modalPrevHeight: number;
+	private _modalPrevNativeHorizontalAlignment: any;
+	private _modalPrevNativeVerticalAlignment: any;
+	private _modalPrevNativeWidth: any;
+	private _modalPrevNativeHeight: any;
+	private _modalPopupClosedHandler: any;
+	private _isModalClosing: boolean;
+
+	protected _showNativeModalView(parent: ViewCommon, options: any) {
+		this._setupAsRootView({});
+		super._showNativeModalView(parent, options);
+
+		this._raiseShowingModallyEvent();
+
+		try {
+			const popup = new Microsoft.UI.Xaml.Controls.Primitives.Popup();
+			const overlay = new Microsoft.UI.Xaml.Controls.Grid();
+			overlay.HorizontalAlignment = 3; // Stretch
+			overlay.VerticalAlignment = 3; // Stretch
+			overlay.Background = new Microsoft.UI.Xaml.Media.SolidColorBrush(Windows.UI.Colors.Transparent);
+
+			try {
+				const bounds = getCurrentWindowBounds(this.nativeViewProtected);
+				if (bounds) {
+					overlay.Width = bounds.Width;
+					overlay.Height = bounds.Height;
+				}
+			} catch (_e) { }
+
+			const showAnimated = options && options.animated === undefined ? true : !!options.animated;
+			try { overlay.Opacity = showAnimated ? 0 : 1; } catch (_e) { }
+
+			try {
+				try {
+					this._modalPrevHorizontalAlignment = this.horizontalAlignment;
+					this._modalPrevVerticalAlignment = this.verticalAlignment;
+					this._modalPrevWidth = this.width;
+					this._modalPrevHeight = this.height;
+					try {
+						this._modalPrevNativeHorizontalAlignment = (this.nativeViewProtected as any).HorizontalAlignment;
+						this._modalPrevNativeVerticalAlignment = (this.nativeViewProtected as any).VerticalAlignment;
+						this._modalPrevNativeWidth = (this.nativeViewProtected as any).Width;
+						this._modalPrevNativeHeight = (this.nativeViewProtected as any).Height;
+					} catch (_e) { }
+				} catch (_e) { }
+
+				const isStretch = options && (options.fullscreen || options.stretched);
+
+				if (isStretch) {
+					this.horizontalAlignment = 'stretch';
+					this.verticalAlignment = 'stretch';
+					try {
+						(this.nativeViewProtected as any).HorizontalAlignment = 3; // Stretch
+						(this.nativeViewProtected as any).VerticalAlignment = 3; // Stretch
+						try {
+							const bounds = getCurrentWindowBounds(this.nativeViewProtected);
+							if (bounds) {
+								this.width = bounds.Width;
+								this.height = bounds.Height;
+								(this.nativeViewProtected as any).Width = bounds.Width;
+								(this.nativeViewProtected as any).Height = bounds.Height;
+							}
+						} catch (_e) { }
+					} catch (_e) { }
+				} else {
+					this.horizontalAlignment = 'center';
+					this.verticalAlignment = 'middle';
+					try {
+						(this.nativeViewProtected as any).HorizontalAlignment = 1; // Center
+						(this.nativeViewProtected as any).VerticalAlignment = 1; // Center
+					} catch (_e) { }
+
+					try {
+						const w = options && typeof options.width === 'number' ? options.width : options && options.ios && typeof options.ios.width === 'number' ? options.ios.width : undefined;
+						const h = options && typeof options.height === 'number' ? options.height : options && options.ios && typeof options.ios.height === 'number' ? options.ios.height : undefined;
+						if (typeof w === 'number' && w > 0) {
+							this.width = w;
+							try { (this.nativeViewProtected as any).Width = w; } catch (_e) { }
+						} else {
+							this.width = unsetValue;
+							try { (this.nativeViewProtected as any).Width = NaN; } catch (_e) { }
+						}
+						if (typeof h === 'number' && h > 0) {
+							this.height = h;
+							try { (this.nativeViewProtected as any).Height = h; } catch (_e) { }
+						} else {
+							this.height = unsetValue;
+							try { (this.nativeViewProtected as any).Height = NaN; } catch (_e) { }
+						}
+					} catch (_e) { }
+				}
+
+				overlay.Children.Append(this.nativeViewProtected);
+			} catch (_e) { }
+
+			popup.Child = overlay;
+			popup.IsLightDismissEnabled = options && options.cancelable !== undefined ? !!options.cancelable : true;
+			this._modalPopup = popup;
+			this._modalOverlay = overlay;
+
+
+			// Closed handler forwards light-dismiss to modal close logic.
+			try {
+				this._modalPopupClosedHandler = () => {
+					if (this._isModalClosing) {
+						return;
+					}
+					if (this._closeModalCallback) {
+						this._closeModalCallback();
+					}
+				};
+				//@ts-ignore
+				popup.AddHandler(Microsoft.UI.Xaml.Controls.Primitives.Popup.ClosedEvent, this._modalPopupClosedHandler, true);
+
+			} catch (_e) { }
+
+			// A Popup with no XamlRoot throws E_UNEXPECTED (0x8000FFFF) on open. Anchor to the XamlRoot
+			// of an element already in the live tree (the modal element isn't attached yet).
+			try {
+				const xamlRoot = (parent as any)?.nativeViewProtected?.XamlRoot
+					|| (getCurrentWindowContent() as any)?.XamlRoot
+					|| (this.nativeViewProtected as any)?.XamlRoot;
+				if (xamlRoot && typeof (popup as any).XamlRoot !== 'undefined') {
+					(popup as any).XamlRoot = xamlRoot;
+				}
+			} catch (_e) { }
+
+			popup.IsOpen = true;
+
+			try {
+				this.callLoaded();
+			} catch (_e) { }
+
+			const animated = showAnimated;
+			if (!this._modalAnimatedOptions) {
+				this._modalAnimatedOptions = [];
+			}
+			this._modalAnimatedOptions.push(animated);
+			this._raiseShownModallyEvent();
+			try {
+				if (showAnimated && this._modalOverlay) {
+					this._animateNativeOpacity(this._modalOverlay, 0, 1, 240);
+				}
+			} catch (_e) { }
+		} catch (e) {
+			console.error('[View._showNativeModalView] failed to open popup modal:', e);
+		}
+	}
+
+	protected _hideNativeModalView(_parent: ViewCommon, whenClosedCallback: () => void) {
+		if (this._isModalClosing) {
+			whenClosedCallback();
+			return;
+		}
+		this._isModalClosing = true;
+		try {
+			try {
+				if (this._modalPopup && this._modalPopupClosedHandler && typeof this._modalPopup.removeEventListener === 'function') {
+					try { this._modalPopup.removeEventListener('Closed', this._modalPopupClosedHandler); } catch (_e) { }
+				}
+			} catch (_e) { }
+
+			const animated = this._modalAnimatedOptions && this._modalAnimatedOptions.length ? !!this._modalAnimatedOptions.pop() : true;
+
+			const finalize = () => {
+				try {
+					if (this._modalPrevHorizontalAlignment !== undefined) {
+						this.horizontalAlignment = this._modalPrevHorizontalAlignment;
+					}
+					if (this._modalPrevVerticalAlignment !== undefined) {
+						this.verticalAlignment = this._modalPrevVerticalAlignment;
+					}
+					if (this._modalPrevWidth !== undefined) {
+						this.width = this._modalPrevWidth;
+					}
+					if (this._modalPrevHeight !== undefined) {
+						this.height = this._modalPrevHeight;
+					}
+					try {
+						if (this._modalPrevNativeHorizontalAlignment !== undefined) {
+							(this.nativeViewProtected as any).HorizontalAlignment = this._modalPrevNativeHorizontalAlignment;
+						}
+						if (this._modalPrevNativeVerticalAlignment !== undefined) {
+							(this.nativeViewProtected as any).VerticalAlignment = this._modalPrevNativeVerticalAlignment;
+						}
+						if (this._modalPrevNativeWidth !== undefined) {
+							(this.nativeViewProtected as any).Width = this._modalPrevNativeWidth;
+						}
+						if (this._modalPrevNativeHeight !== undefined) {
+							(this.nativeViewProtected as any).Height = this._modalPrevNativeHeight;
+						}
+					} catch (_e) { }
+				} catch (_e) { }
+
+				try {
+					if (this._modalPopup) {
+						this._modalPopup.IsOpen = false;
+						this._modalPopup.Child = null;
+						this._modalPopup = null;
+					}
+					if (this._modalOverlay) {
+						this._modalOverlay.Children.Clear();
+						this._modalOverlay = null;
+					}
+				} catch (_e) { }
+
+				this._isModalClosing = false;
+
+				whenClosedCallback();
+			};
+
+			if (animated && this._modalOverlay) {
+				try {
+					const from = typeof this._modalOverlay.Opacity === 'number' ? this._modalOverlay.Opacity : 1;
+					this._animateNativeOpacity(this._modalOverlay, from, 0, 240, finalize);
+				} catch (_e) {
+					finalize();
+				}
+			} else {
+				finalize();
+			}
+
+		} catch (_e) { }
+	}
+}
+
+try {
+	(View.prototype as any)._nativeBackgroundState = 'unset';
+} catch (_e) { }
+
+export class ContainerView extends View { }
+
+export class CustomLayoutView extends ContainerView {
+
+	createNativeView() {
+		return new Microsoft.UI.Xaml.Controls.StackPanel();
+	}
+
+	public _addViewToNativeVisualTree(child: ViewCommon, _atIndex: number = Number.MAX_SAFE_INTEGER): boolean {
+		super._addViewToNativeVisualTree(child);
+		const nativeParent = this.nativeViewProtected as any;
+		const nativeChild = child.nativeViewProtected as any;
+		if (nativeParent && nativeChild) {
+			const children = nativeParent.Children;
+			if (children) {
+				const size = children.Size;
+				try {
+					if (_atIndex >= 0 && _atIndex < size && _atIndex < Number.MAX_SAFE_INTEGER) {
+						children.InsertAt(_atIndex, nativeChild);
+					} else {
+						children.Append(nativeChild);
+					}
+				} catch {
+					return false;
+				}
+
+				try { if (!(nativeChild as any).__ns_view) (nativeChild as any).__ns_view = child; } catch (_e) { }
+
+				// Do NOT call UpdateLayout() / InvalidateMeasure() / InvalidateArrange() here.
+				// XAML's Children.Append() / InsertAt() already marks both the new child and
+				// the parent panel dirty for the next layout pass. Calling these explicitly:
+				//   • nativeChild.UpdateLayout()  — forces a synchronous measure+arrange on the
+				//     child's full template tree immediately after insertion (wasteful)
+				//   • nativeParent.UpdateLayout() — forces a full synchronous layout of the
+				//     entire panel after EACH child add, making construction O(n²): a page with
+				//     50 children triggers 1+2+…+50 = 1275 forced layout passes.
+				// XAML batches and defers layout to a single pass at frame time — trust it.
+
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	public _removeViewFromNativeVisualTree(child: ViewCommon): void {
+		const nativeParent = this.nativeViewProtected as any;
+		const nativeChild = child.nativeViewProtected as any;
+
+		if (nativeParent && nativeChild) {
+			const children = nativeParent.Children;
+			if (children) {
+				const count = children.Size;
+				for (let i = 0; i < count; i++) {
+					if (children.GetAt(i) === nativeChild) {
+						children.RemoveAt(i);
+						break;
+					}
+				}
+			}
+		}
+
+		super._removeViewFromNativeVisualTree(child);
+	}
+}
diff --git a/packages/core/ui/core/view/view-helper/index.windows.ts b/packages/core/ui/core/view/view-helper/index.windows.ts
new file mode 100644
index 0000000000..7301b36623
--- /dev/null
+++ b/packages/core/ui/core/view/view-helper/index.windows.ts
@@ -0,0 +1,3 @@
+export * from './view-helper-common';
+export const AndroidHelper = 0;
+export const IOSHelper = 0;
diff --git a/packages/core/ui/date-picker/index.windows.ts b/packages/core/ui/date-picker/index.windows.ts
new file mode 100644
index 0000000000..18be0d32cd
--- /dev/null
+++ b/packages/core/ui/date-picker/index.windows.ts
@@ -0,0 +1,99 @@
+export * from './date-picker-common';
+
+import { DatePickerBase, dateProperty, yearProperty, monthProperty, dayProperty, minDateProperty, maxDateProperty } from './date-picker-common';
+
+export class DatePicker extends DatePickerBase {
+	nativeViewProtected: Microsoft.UI.Xaml.Controls.DatePicker;
+	private _windows: Microsoft.UI.Xaml.Controls.DatePicker;
+	private _dateChangedHandler: any = null;
+
+	public createNativeView(): Microsoft.UI.Xaml.Controls.DatePicker {
+		this._windows = new Microsoft.UI.Xaml.Controls.DatePicker();
+		return this._windows;
+	}
+
+	get windows(): Microsoft.UI.Xaml.Controls.DatePicker {
+		return this._windows;
+	}
+
+	public initNativeView(): void {
+		super.initNativeView();
+		const that = new WeakRef(this);
+		const handler = (_sender: Microsoft.UI.Xaml.Controls.DatePicker, args: Microsoft.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs) => {
+			const owner = that.deref();
+			if (!owner) return;
+			const raw = args.NewDate as any; // IReference<DateTime>
+			if (!raw) return;
+			const jsDate = NSWinRT.interop.fromWinRTDateTimeTicks(raw);
+			dateProperty.nativeValueChange(owner, jsDate);
+			yearProperty.nativeValueChange(owner, jsDate.getFullYear());
+			monthProperty.nativeValueChange(owner, jsDate.getMonth() + 1);
+			dayProperty.nativeValueChange(owner, jsDate.getDate());
+			owner.notify({
+				eventName: DatePickerBase.dateChangeEvent,
+				object: owner,
+				value: { year: jsDate.getFullYear(), month: jsDate.getMonth() + 1, day: jsDate.getDate() },
+			});
+		};
+		this._dateChangedHandler = NSWinRT.asDelegate(
+			'Windows.Foundation.TypedEventHandler`2<Microsoft.UI.Xaml.Controls.DatePicker,Microsoft.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs>',
+			handler
+		);
+		this._windows.SelectedDateChanged = this._dateChangedHandler;
+	}
+
+	public disposeNativeView(): void {
+		if (this._windows && this._dateChangedHandler) {
+			this._windows.SelectedDateChanged = null;
+			this._dateChangedHandler = null;
+		}
+		super.disposeNativeView();
+	}
+
+	[dateProperty.getDefault](): Date {
+		return new Date();
+	}
+
+	// Build a Date from the current year/month/day JS properties so that each individual
+	// setNative sees the full combined value, regardless of XML attribute order.
+	private _fromYMD(): Date {
+		return new Date(this.year, this.month - 1, this.day);
+	}
+
+	private _setDate(value: Date): void {
+		const dt = NSWinRT.interop.dateTime(value);
+		this._windows.Date = dt;
+		// SelectedDate (IReference<DateTime>) makes the picker show the date as selected rather
+		// than showing placeholder dashes. Pass the original Date; the runtime handles boxing.
+		this._windows.SelectedDate = NSWinRT.interop.reference('Windows.Foundation.DateTime', value);
+	}
+
+	[dateProperty.setNative](value: Date) {
+		this._setDate(value);
+	}
+
+	//@ts-ignore
+	[yearProperty.setNative](value: number) {
+		this._setDate(this._fromYMD());
+	}
+
+	//@ts-ignore
+	[monthProperty.setNative](value: number) {
+		this._setDate(this._fromYMD());
+	}
+
+	//@ts-ignore
+	[dayProperty.setNative](value: number) {
+		this._setDate(this._fromYMD());
+	}
+
+	//@ts-ignore
+	[minDateProperty.setNative](value: Date) {
+		this._windows.MinYear = NSWinRT.interop.dateTime(value);
+	}
+
+	//@ts-ignore
+	[maxDateProperty.setNative](value: Date) {
+		this._windows.MaxYear = NSWinRT.interop.dateTime(value);
+	}
+}
diff --git a/packages/core/ui/dialogs/index.windows.ts b/packages/core/ui/dialogs/index.windows.ts
new file mode 100644
index 0000000000..12223c866e
--- /dev/null
+++ b/packages/core/ui/dialogs/index.windows.ts
@@ -0,0 +1,460 @@
+export * from './dialogs-common';
+
+import { type PromptResult, type LoginResult, type ActionOptions, DialogStrings, isDialogOptions, PromptOptions, inputType, capitalizationType, parseLoginOptions } from './dialogs-common';
+import { getCurrentWindowContent, getCurrentWindowBounds } from '../../application/window-helper.windows';
+import { Color } from '../../color';
+
+function isString(value: any): value is string {
+	return typeof value === 'string';
+}
+
+// ContentDialog cannot be used here: the dialog renders but NONE of its callbacks (Closed,
+// PrimaryButtonClick, ShowAsync Completed, etc.) reach V8. Event subscription succeeds; the
+// templated-popup surface simply never invokes the JsDelegate. Fix: use a plain Popup overlay —
+// Popup-hosted Buttons DO fire Click in this host (same pattern as View._showNativeModalView).
+const _activeOverlays = new Set<any>();
+
+/** Reads ElementTheme of the current window content: 1 = Light, 2 = Dark, else default(treat as light). */
+function isDarkTheme(content: any): boolean {
+	try {
+		// ElementTheme: Default=0, Light=1, Dark=2
+		return content?.ActualTheme === 2;
+	} catch (_e) {
+		return false;
+	}
+}
+
+/** Looks up a theme brush from the app resources; falls back to a solid brush of `fallback`. */
+function themeBrush(key: string, fallback: Color): Microsoft.UI.Xaml.Media.Brush {
+	try {
+		const res = (Microsoft.UI.Xaml.Application.Current as any)?.Resources;
+		if (res && typeof res.HasKey === 'function' && res.HasKey(key)) {
+			const v = res.Lookup(key);
+			if (v) {
+				return v as Microsoft.UI.Xaml.Media.Brush;
+			}
+		}
+	} catch (_e) {}
+	return new Microsoft.UI.Xaml.Media.SolidColorBrush(fallback.windows);
+}
+
+interface OverlayButtonSpec {
+	text: string;
+	isPrimary?: boolean;
+	/** Produces the value the dialog promise resolves with when this button is tapped. */
+	result: () => any;
+}
+
+interface OverlayDialogOptions {
+	title?: string;
+	message?: string;
+	/** Extra content elements (text inputs etc.) inserted between the message and the buttons. */
+	extra?: Microsoft.UI.Xaml.UIElement[];
+	buttons: OverlayButtonSpec[];
+	/** 'row' = right-aligned horizontal footer (alert/confirm/prompt/login); 'stack' = full-width vertical (action). */
+	buttonLayout?: 'row' | 'stack';
+}
+
+function showOverlayDialog(opts: OverlayDialogOptions): Promise<any> {
+	return new Promise<any>((resolve, reject) => {
+		try {
+			const M = Microsoft.UI.Xaml;
+			const content = getCurrentWindowContent<Microsoft.UI.Xaml.FrameworkElement>();
+			const xamlRoot = (content as any)?.XamlRoot;
+			const dark = isDarkTheme(content);
+
+			const popup = new M.Controls.Primitives.Popup();
+			const overlay = new M.Controls.Grid();
+			overlay.HorizontalAlignment = 3; // Stretch
+			overlay.VerticalAlignment = 3; // Stretch
+			overlay.Background = new M.Media.SolidColorBrush(new Color('#99000000').windows); // dim shade
+
+			try {
+				const bounds = getCurrentWindowBounds(content as any);
+				if (bounds) {
+					overlay.Width = bounds.Width;
+					overlay.Height = bounds.Height;
+				}
+			} catch (_e) {}
+
+			const card = new M.Controls.Border();
+			card.Background = themeBrush('SolidBackgroundFillColorBaseBrush', new Color(dark ? '#FF2B2B2B' : '#FFFFFFFF'));
+			try { card.CornerRadius = M.CornerRadiusHelper.FromUniformRadius(8); } catch (_e) {}
+			try { (card as any).Padding = M.ThicknessHelper.FromUniformLength(24); } catch (_e) {}
+			card.HorizontalAlignment = 1; // Center
+			card.VerticalAlignment = 1; // Center
+			try { (card as any).MinWidth = 320; } catch (_e) {}
+			try { (card as any).MaxWidth = 460; } catch (_e) {}
+
+			const stack = new M.Controls.StackPanel();
+			const kids = (stack as any).Children as Windows.Foundation.Collections.IVector<Microsoft.UI.Xaml.UIElement>;
+			const textBrush = themeBrush('TextFillColorPrimaryBrush', new Color(dark ? '#FFFFFFFF' : '#FF000000'));
+
+			if (isString(opts.title) && opts.title.length) {
+				const t = new M.Controls.TextBlock();
+				(t as any).Text = opts.title;
+				(t as any).FontSize = 20;
+				(t as any).Foreground = textBrush;
+				(t as any).TextWrapping = 2; // WrapWholeWords
+				try { (t as any).FontWeight = Microsoft.UI.Text.FontWeights.SemiBold; } catch (_e) {}
+				try { (t as any).Margin = M.ThicknessHelper.FromLengths(0, 0, 0, 12); } catch (_e) {}
+				kids.Append(t);
+			}
+			if (isString(opts.message) && opts.message.length) {
+				const m = new M.Controls.TextBlock();
+				(m as any).Text = opts.message;
+				(m as any).Foreground = textBrush;
+				(m as any).TextWrapping = 2; // WrapWholeWords
+				try { (m as any).Margin = M.ThicknessHelper.FromLengths(0, 0, 0, 12); } catch (_e) {}
+				kids.Append(m);
+			}
+			if (opts.extra) {
+				for (const el of opts.extra) {
+					try { (el as any).Margin = M.ThicknessHelper.FromLengths(0, 0, 0, 12); } catch (_e) {}
+					kids.Append(el);
+				}
+			}
+
+			let settled = false;
+			const close = () => {
+				popup.IsOpen = false;
+				popup.Child = null;
+				overlay.Children.Clear();
+				_activeOverlays.delete(popup);
+			};
+			const settle = (val: any) => {
+				if (settled) { return; }
+				settled = true;
+				close();
+				resolve(val);
+			};
+
+			// Hold the click delegates + popup alive for the dialog's lifetime (GC guard — mirrors how the
+			// modal path keeps its popup on the instance).
+			const held: any[] = [];
+			(popup as any).__nsHeldDelegates = held;
+			_activeOverlays.add(popup);
+
+			const stackButtons = opts.buttonLayout === 'stack';
+			const btnRow = new M.Controls.StackPanel();
+			(btnRow as any).Orientation = stackButtons ? 0 : 1; // Orientation enum: Vertical = 0, Horizontal = 1
+			(btnRow as any).HorizontalAlignment = stackButtons ? 3 : 2; // stack: Stretch, row: Right
+			try { (btnRow as any).Spacing = 8; } catch (_e) {}
+			const btnKids = (btnRow as any).Children as Windows.Foundation.Collections.IVector<Microsoft.UI.Xaml.UIElement>;
+
+			for (const b of opts.buttons) {
+				const btn = new M.Controls.Button();
+				(btn as any).Content = b.text;
+				if (stackButtons) {
+					(btn as any).HorizontalAlignment = 3; // Stretch
+				} else {
+					try { (btn as any).MinWidth = 90; } catch (_e) {}
+				}
+				if (b.isPrimary) {
+					try {
+						const res = (Microsoft.UI.Xaml.Application.Current as any)?.Resources;
+						if (res && typeof res.HasKey === 'function' && res.HasKey('AccentButtonStyle')) {
+							(btn as any).Style = res.Lookup('AccentButtonStyle');
+						}
+					} catch (_e) {}
+				}
+				// Same RoutedEventHandler shape proven to fire inside a Popup.
+				const handler = NSWinRT.asDelegate('Microsoft.UI.Xaml.RoutedEventHandler', () => settle(b.result()));
+				held.push(handler);
+				(btn as any).Click = handler as never;
+				btnKids.Append(btn);
+			}
+			kids.Append(btnRow);
+
+			card.Child = stack;
+			overlay.Children.Append(card);
+			popup.Child = overlay;
+			popup.IsLightDismissEnabled = false; // modal — dismissal is via the dialog's own buttons
+			if (xamlRoot && typeof (popup as any).XamlRoot !== 'undefined') {
+				try { (popup as any).XamlRoot = xamlRoot; } catch (_e) {}
+			}
+			popup.IsOpen = true;
+		} catch (e) {
+			reject(e);
+		}
+	});
+}
+
+const letterReg = /\p{L}/u;
+const digitReg = /\p{N}/u;
+const whiteSpaceReg = /\s/;
+
+export const isLetter = (ch: string) => letterReg.test(ch);
+export const isDigit = (ch: string) => digitReg.test(ch);
+export const isWhiteSpace = (ch: string) => whiteSpaceReg.test(ch);
+
+function capitalizeSentences(text: string): string {
+	let result = '';
+	let capitalize = true;
+	let afterPunct = false;
+	let changed = false;
+	for (let i = 0; i < text.length; i++) {
+		const ch = text[i];
+		if (capitalize && isLetter(ch)) {
+			const upper = ch.toUpperCase();
+			if (upper !== ch) changed = true;
+			result += upper;
+			capitalize = false;
+			afterPunct = false;
+		} else {
+			result += ch;
+			if (ch === '.' || ch === '!' || ch === '?') afterPunct = true;
+			else if (afterPunct && isWhiteSpace(ch)) capitalize = true;
+			else if (!isWhiteSpace(ch)) afterPunct = false;
+		}
+	}
+	return changed ? result : text;
+}
+
+function capitalizeWords(text: string): string {
+	let result = '';
+	let capitalize = true;
+	let changed = false;
+	for (let i = 0; i < text.length; i++) {
+		const ch = text[i];
+		if (capitalize && isLetter(ch)) {
+			const upper = ch.toUpperCase();
+			if (upper !== ch) changed = true;
+			result += upper;
+			capitalize = false;
+		} else {
+			result += ch;
+			capitalize = isWhiteSpace(ch);
+		}
+	}
+	return changed ? result : text;
+}
+
+export function alert(arg: any): Promise<void> {
+	const options = !isDialogOptions(arg) ? { title: DialogStrings.ALERT, okButtonText: DialogStrings.OK, message: arg + '' } : arg;
+
+	return showOverlayDialog({
+		title: options.title ?? '',
+		message: options.message,
+		buttons: [{ text: options.okButtonText ?? DialogStrings.OK, isPrimary: true, result: () => undefined }],
+	}).then(() => undefined);
+}
+
+export function confirm(arg: any): Promise<boolean> {
+	const options = !isDialogOptions(arg)
+		? {
+			title: DialogStrings.CONFIRM,
+			okButtonText: DialogStrings.OK,
+			cancelButtonText: DialogStrings.CANCEL,
+			message: arg + '',
+		}
+		: arg;
+
+	const buttons: OverlayButtonSpec[] = [];
+	// Neutral button (parity with Android/iOS): resolves undefined.
+	if (isString((options as any).neutralButtonText)) {
+		buttons.push({ text: (options as any).neutralButtonText, result: () => undefined as never });
+	}
+	buttons.push({ text: options.cancelButtonText ?? DialogStrings.CANCEL, result: () => false });
+	buttons.push({ text: options.okButtonText ?? DialogStrings.OK, isPrimary: true, result: () => true });
+
+	return showOverlayDialog({ title: options.title ?? '', message: options.message, buttons });
+}
+
+export function prompt(...args: any[]): Promise<PromptResult> {
+	let options: PromptOptions;
+
+	const defaultOptions = {
+		title: DialogStrings.PROMPT,
+		okButtonText: DialogStrings.OK,
+		cancelButtonText: DialogStrings.CANCEL,
+		inputType: inputType.text,
+	};
+	const arg = args[0];
+	if (args.length === 1) {
+		if (isString(arg)) {
+			options = defaultOptions;
+			options.message = arg;
+		} else {
+			options = arg;
+		}
+	} else if (args.length === 2) {
+		if (isString(arg) && isString(args[1])) {
+			options = defaultOptions;
+			options.message = arg;
+			options.defaultText = args[1];
+		}
+	}
+
+	return new Promise((resolve, reject) => {
+		try {
+			let input: Microsoft.UI.Xaml.Controls.Control;
+			if (options?.inputType === inputType.password) {
+				const pwd = new Microsoft.UI.Xaml.Controls.PasswordBox();
+				(pwd as any).PlaceholderText = options.message ?? '';
+				if (isString(options.defaultText)) (pwd as any).Password = options.defaultText;
+				input = pwd;
+			} else {
+				const ctrl = new Microsoft.UI.Xaml.Controls.TextBox();
+				(ctrl as any).PlaceholderText = options?.message ?? '';
+				if (isString(options?.defaultText)) (ctrl as any).Text = options.defaultText;
+
+				try {
+					let scopeValue: number | undefined;
+					if (options?.inputType === inputType.email) scopeValue = 7; // EmailSmtpAddress
+					else if (options?.inputType === inputType.number) scopeValue = 29; // Number
+					else if (options?.inputType === inputType.decimal) scopeValue = 8; // Digits
+					else if (options?.inputType === inputType.phone) scopeValue = 3; // TelephoneNumber
+
+					if (scopeValue !== undefined) {
+						const scope = new Microsoft.UI.Xaml.Input.InputScope();
+						const scopeName = new Microsoft.UI.Xaml.Input.InputScopeName();
+						(scopeName as any).NameValue = scopeValue;
+						((scope as any).Names as Windows.Foundation.Collections.IVector<Microsoft.UI.Xaml.Input.InputScopeName>).Append(scopeName);
+						(ctrl as any).InputScope = scope;
+					}
+				} catch (_e) {}
+
+				try {
+					switch (options?.capitalizationType) {
+						case capitalizationType.all:
+							(ctrl as any).CharacterCasing = 1; // Upper
+							break;
+						case capitalizationType.sentences: {
+							let updatingSentences = false;
+							(ctrl as any).TextChanged = NSWinRT.asDelegate('Microsoft.UI.Xaml.Controls.TextChangedEventHandler', (s: any) => {
+								if (updatingSentences) return;
+								const text: string = s?.Text;
+								if (!text) return;
+								const transformed = capitalizeSentences(text);
+								if (transformed !== text) {
+									updatingSentences = true;
+									const sel = s.SelectionStart;
+									s.Text = transformed;
+									s.SelectionStart = sel;
+									updatingSentences = false;
+								}
+							});
+							break;
+						}
+						case capitalizationType.words: {
+							let updatingWords = false;
+							(ctrl as any).TextChanged = NSWinRT.asDelegate('Microsoft.UI.Xaml.Controls.TextChangedEventHandler', (s: any) => {
+								if (updatingWords) return;
+								const text: string = s?.Text;
+								if (!text) return;
+								const transformed = capitalizeWords(text);
+								if (transformed !== text) {
+									updatingWords = true;
+									const sel = s.SelectionStart;
+									s.Text = transformed;
+									s.SelectionStart = sel;
+									updatingWords = false;
+								}
+							});
+							break;
+						}
+					}
+				} catch (_e) {}
+
+				input = ctrl;
+			}
+
+			const readText = () => (input instanceof Microsoft.UI.Xaml.Controls.TextBox ? (input as any).Text : (input as any).Password) ?? '';
+
+			showOverlayDialog({
+				title: options?.title ?? '',
+				message: options?.message,
+				extra: [input],
+				buttons: [
+					{ text: options?.cancelButtonText ?? DialogStrings.CANCEL, result: () => ({ result: false, text: '' }) },
+					{ text: options?.okButtonText ?? DialogStrings.OK, isPrimary: true, result: () => ({ result: true, text: readText() }) },
+				],
+			}).then(resolve, reject);
+		} catch (e) {
+			reject(e);
+		}
+	});
+}
+
+export function login(...args: any[]): Promise<LoginResult> {
+	const options = parseLoginOptions(args);
+
+	return new Promise((resolve, reject) => {
+		try {
+			const userNameBox = new Microsoft.UI.Xaml.Controls.TextBox();
+			(userNameBox as any).PlaceholderText = options.userNameHint ?? '';
+			(userNameBox as any).Text = isString(options.userName) ? options.userName : '';
+
+			const passwordBox = new Microsoft.UI.Xaml.Controls.PasswordBox();
+			(passwordBox as any).PlaceholderText = options.passwordHint ?? '';
+			(passwordBox as any).Password = isString(options.password) ? options.password : '';
+
+			showOverlayDialog({
+				title: options.title ?? DialogStrings.LOGIN,
+				message: options.message,
+				extra: [userNameBox, passwordBox],
+				buttons: [
+					{ text: options.cancelButtonText ?? DialogStrings.CANCEL, result: () => ({ result: false, userName: '', password: '' }) },
+					{ text: options.okButtonText ?? DialogStrings.OK, isPrimary: true, result: () => ({ result: true, userName: (userNameBox as any).Text, password: (passwordBox as any).Password }) },
+				],
+			}).then(resolve, reject);
+		} catch (e) {
+			reject(e);
+		}
+	});
+}
+
+export function action(...args: any[]): Promise<string> {
+	let options: ActionOptions;
+
+	const defaultOptions: ActionOptions = { title: undefined, cancelButtonText: DialogStrings.CANCEL };
+
+	if (args.length === 1) {
+		if (isString(args[0])) {
+			options = { ...defaultOptions, message: args[0] };
+		} else {
+			options = args[0];
+		}
+	} else if (args.length === 2) {
+		if (isString(args[0]) && isString(args[1])) {
+			options = { ...defaultOptions, message: args[0], cancelButtonText: args[1] };
+		}
+	} else if (args.length === 3) {
+		if (isString(args[0]) && isString(args[1])) {
+			options = { ...defaultOptions, message: args[0], cancelButtonText: args[1], actions: args[2] };
+		}
+	}
+
+	return new Promise((resolve, reject) => {
+		try {
+			const buttons: OverlayButtonSpec[] = [];
+			if (options.actions) {
+				for (const actionTitle of options.actions) {
+					if (!isString(actionTitle)) { continue; }
+					buttons.push({ text: actionTitle, result: () => actionTitle });
+				}
+			}
+			if (isString(options.cancelButtonText)) {
+				buttons.push({ text: options.cancelButtonText, result: () => options.cancelButtonText ?? '' });
+			}
+
+			showOverlayDialog({
+				title: options.title,
+				message: options.message,
+				buttons,
+				buttonLayout: 'stack', // full-width vertical list, like an action sheet
+			}).then(resolve, reject);
+		} catch (e) {
+			reject(e);
+		}
+	});
+}
+
+export const Dialogs = {
+	alert,
+	confirm,
+	prompt,
+	login,
+	action,
+};
diff --git a/packages/core/ui/editable-text-base/index.windows.ts b/packages/core/ui/editable-text-base/index.windows.ts
new file mode 100644
index 0000000000..021975dccd
--- /dev/null
+++ b/packages/core/ui/editable-text-base/index.windows.ts
@@ -0,0 +1,148 @@
+export * from './editable-text-base-common';
+
+import { EditableTextBase as EditableTextBaseCommon, autofillTypeProperty, keyboardTypeProperty, returnKeyTypeProperty, editableProperty, autocapitalizationTypeProperty, autocorrectProperty, hintProperty, placeholderColorProperty, maxLengthProperty } from './editable-text-base-common';
+import { textProperty, resetSymbol } from '../text-base';
+
+export * from './editable-text-base-common';
+
+export abstract class EditableTextBase extends EditableTextBaseCommon {
+	public nativeViewProtected: Microsoft.UI.Xaml.Controls.TextBox | Microsoft.UI.Xaml.Controls.PasswordBox;
+
+	// Guards against the native TextChanged firing while we write text from JS (avoids loops).
+	private _changeFromCode = false;
+	private _textChangeDelegate: any = null; // held so the handler isn't GC'd (would go dead)
+
+	public initNativeView(): void {
+		super.initNativeView();
+		this._attachTextChangeListener();
+	}
+
+	// Wires the native text-change event so typing flows back into the framework (valueFormatter,
+	// `textChange`). Re-callable because TextField swaps its native view on `secure`.
+	public _attachTextChangeListener(): void {
+		const nv = this.nativeViewProtected;
+		if (!nv) {
+			return;
+		}
+		const ref = new WeakRef(this);
+		const asTextBox = nv as Microsoft.UI.Xaml.Controls.TextBox;
+		const asPassword = nv as Microsoft.UI.Xaml.Controls.PasswordBox;
+		if (typeof asTextBox.Text !== 'undefined') {
+			this._textChangeDelegate = NSWinRT.asDelegate('Microsoft.UI.Xaml.Controls.TextChangedEventHandler', (sender: any) => {
+				const owner = ref.deref();
+				if (owner) owner._onNativeTextChanged((sender as Microsoft.UI.Xaml.Controls.TextBox).Text ?? '');
+			});
+			asTextBox.TextChanged = this._textChangeDelegate;
+		} else if (typeof asPassword.Password !== 'undefined') {
+			this._textChangeDelegate = NSWinRT.asDelegate('Microsoft.UI.Xaml.RoutedEventHandler', (sender: any) => {
+				const owner = ref.deref();
+				if (owner) owner._onNativeTextChanged((sender as Microsoft.UI.Xaml.Controls.PasswordBox).Password ?? '');
+			});
+			asPassword.PasswordChanged = this._textChangeDelegate;
+		}
+	}
+
+	private _onNativeTextChanged(rawText: string): void {
+		if (this._changeFromCode) {
+			return;
+		}
+
+		let value = rawText;
+		const formatter = this.valueFormatter;
+		if (typeof formatter === 'function') {
+			// valueFormatter is user code — guard it so a throw can't break native input.
+			let formatted = rawText;
+			try {
+				formatted = formatter(rawText);
+			} catch (_e) {}
+			if (formatted !== rawText) {
+				const asTextBox = this.nativeViewProtected as Microsoft.UI.Xaml.Controls.TextBox;
+				const asPassword = this.nativeViewProtected as Microsoft.UI.Xaml.Controls.PasswordBox;
+				this._changeFromCode = true;
+				try {
+					if (typeof asTextBox.Text !== 'undefined') {
+						asTextBox.Text = formatted;
+						asTextBox.SelectionStart = formatted.length; // keep the caret at the end
+					} else if (typeof asPassword.Password !== 'undefined') {
+						asPassword.Password = formatted;
+					}
+				} finally {
+					this._changeFromCode = false;
+				}
+			}
+			value = formatted;
+		}
+
+		textProperty.nativeValueChange(this, value);
+	}
+
+	//@ts-ignore — guard native writes so our own TextChanged handler ignores them.
+	[textProperty.setNative](value: string | symbol) {
+		this._changeFromCode = true;
+		try {
+			this._setNativeText(value === resetSymbol);
+		} finally {
+			this._changeFromCode = false;
+		}
+	}
+
+	public dismissSoftInput() {
+		const nativeView = this.nativeViewProtected;
+		if (nativeView) {
+			// Toggling focusability is the only way to drop focus from a TextBox/PasswordBox.
+			nativeView.IsEnabled = false;
+			nativeView.IsEnabled = true;
+		}
+	}
+
+	public focus(): boolean {
+		const result = super.focus();
+		if (result && this.nativeViewProtected) {
+			this.nativeViewProtected.Focus(Microsoft.UI.Xaml.FocusState.Programmatic);
+		}
+
+		return result;
+	}
+
+	[keyboardTypeProperty.getDefault](): string {
+		return '';
+	}
+	[keyboardTypeProperty.setNative](_value: string) {
+		// Handled by TextField implementation using InputScope
+	}
+
+	[autofillTypeProperty.setNative](_value: any) {}
+
+	[returnKeyTypeProperty.getDefault]() {
+		return 'done';
+	}
+	[returnKeyTypeProperty.setNative](_value: any) {}
+
+	// @ts-ignore — setNative is a symbol index whose value type is widened across properties.
+	[editableProperty.setNative](value: boolean) {
+		// IsReadOnly only exists on TextBox; on a (secure) PasswordBox this is a no-op.
+		const nativeView = this.nativeViewProtected as Microsoft.UI.Xaml.Controls.TextBox;
+		if (typeof nativeView.IsReadOnly !== 'undefined') {
+			nativeView.IsReadOnly = !value;
+		}
+	}
+
+	[autocapitalizationTypeProperty.setNative](_value: any) {}
+
+	[autocorrectProperty.setNative](_value: any) {}
+
+	[hintProperty.setNative](value: string) {
+		const nativeView = this.nativeViewProtected as Microsoft.UI.Xaml.Controls.TextBox;
+		if (typeof nativeView.PlaceholderText !== 'undefined') {
+			nativeView.PlaceholderText = value ?? '';
+		}
+	}
+
+	// @ts-ignore — setNative is a symbol index whose value type is widened across properties.
+	[maxLengthProperty.setNative](value: number) {
+		const nativeView = this.nativeViewProtected as Microsoft.UI.Xaml.Controls.TextBox;
+		if (typeof nativeView.MaxLength !== 'undefined') {
+			nativeView.MaxLength = value ?? 0;
+		}
+	}
+}
diff --git a/packages/core/ui/embedding/index.windows.ts b/packages/core/ui/embedding/index.windows.ts
new file mode 100644
index 0000000000..c368298952
--- /dev/null
+++ b/packages/core/ui/embedding/index.windows.ts
@@ -0,0 +1,3 @@
+export function isEmbedded(): boolean {
+	return false;
+}
diff --git a/packages/core/ui/frame/index.windows.ts b/packages/core/ui/frame/index.windows.ts
new file mode 100644
index 0000000000..a35ded5c88
--- /dev/null
+++ b/packages/core/ui/frame/index.windows.ts
@@ -0,0 +1,667 @@
+import type { BackstackEntry } from './frame-common';
+import { FrameBase, NavigationType } from './frame-common';
+import { profile } from '../../profiling';
+import type { Page } from '../page';
+import { SharedTransition } from '../transition/shared-transition';
+import { SharedTransitionHelper } from '../transition/shared-transition-helper';
+
+export * from './frame-common';
+
+// GC guard: hold running Storyboards until Completed fires (an unheld local sb can be collected,
+// dropping the Completed callback that restores the final transform/opacity).
+const _activeTransitions = new Set<Microsoft.UI.Xaml.Media.Animation.Storyboard>();
+
+export class Frame extends FrameBase {
+	declare nativeViewProtected: Microsoft.UI.Xaml.Controls.Grid; // container
+	// Single-cell Grid hosting the current page; Grid.Children.Append() avoids template/binding issues.
+	private _pageHost: Microsoft.UI.Xaml.Controls.Grid;
+	// Backward-compat alias so _navigateCore and _goBackCore work unchanged.
+	private get _windows(): Microsoft.UI.Xaml.Controls.Grid { return this._pageHost; }
+	// Plain Grid (not CommandBar) — CommandBar constrains its Content to the left side via its
+	// template's ContentPresenter, preventing the title's Star column from actually filling the bar.
+	private _topBar: Microsoft.UI.Xaml.Controls.Grid | null = null;
+	private _backButton: Microsoft.UI.Xaml.Controls.Button | null = null;
+	private _titleBlock: Microsoft.UI.Xaml.Controls.TextBlock | null = null;
+	// Grid container for the title area. We swap its single child between _titleBlock (string
+	// title) and the titleView's nativeViewProtected (custom View child of ActionBar).
+	private _titleArea: Microsoft.UI.Xaml.Controls.Grid | null = null;
+	// The native element currently shown in _titleArea (null when showing _titleBlock).
+	private _titleViewNative: Microsoft.UI.Xaml.UIElement | null = null;
+	// StackPanel in column 2 of _topBar; holds Button elements for ActionItems.
+	private _actionArea: Microsoft.UI.Xaml.Controls.StackPanel | null = null;
+	private _backButtonDelegate: any = null;
+	// GC guard: delegates held only by btn.Click can be collected before the user taps.
+	private _actionItemDelegates: any[] = [];
+	// LRU native-view cache. Keeps the last N pages' XAML trees alive so navigating
+	// back — or forward — to a previously-visited page skips the entire view-creation +
+	// applyAllNativeSetters pipeline. This mirrors what iOS UINavigationController and
+	// Android FragmentManager provide natively: visited pages stay in memory until evicted.
+	// Map insertion order = arrival order; oldest entry is keys().next().value (LRU eviction).
+	private _nativePageCache = new Map<string, any>(); // moduleName → Page
+	private static readonly _PAGE_CACHE_LIMIT = 5;
+
+	constructor() {
+		super();
+		this._pageHost = new Microsoft.UI.Xaml.Controls.Grid();
+	}
+
+	public createNativeView(): any {
+		this._buildTopBar();
+		return this._buildContainer();
+	}
+
+	private _buildTopBar(): void {
+		// WinRT collection mutations can throw; on failure _topBar stays null.
+		try {
+			// Plain Grid instead of CommandBar: CommandBar's template ContentPresenter is left-aligned,
+			// so setting Content = grid doesn't let the Star column expand to fill the bar width.
+			// A bare Grid gives us full-width layout control directly.
+			this._topBar = new Microsoft.UI.Xaml.Controls.Grid();
+			this._topBar.HorizontalAlignment = 3; // Stretch
+			this._topBar.Height = 48;
+
+			const colBack = new Microsoft.UI.Xaml.Controls.ColumnDefinition();
+			colBack.Width = Microsoft.UI.Xaml.GridLengthHelper.FromValueAndType(1, Microsoft.UI.Xaml.GridUnitType.Auto);
+			const colTitle = new Microsoft.UI.Xaml.Controls.ColumnDefinition();
+			colTitle.Width = Microsoft.UI.Xaml.GridLengthHelper.FromValueAndType(1, Microsoft.UI.Xaml.GridUnitType.Star);
+			const colActions = new Microsoft.UI.Xaml.Controls.ColumnDefinition();
+			colActions.Width = Microsoft.UI.Xaml.GridLengthHelper.FromValueAndType(1, Microsoft.UI.Xaml.GridUnitType.Auto);
+			this._topBar.ColumnDefinitions.Append(colBack);
+			this._topBar.ColumnDefinitions.Append(colTitle);
+			this._topBar.ColumnDefinitions.Append(colActions);
+
+			this._backButton = new Microsoft.UI.Xaml.Controls.Button();
+			this._backButton.Content = '←';
+			Microsoft.UI.Xaml.Controls.Grid.SetColumn(this._backButton, 0);
+			this._topBar.Children.Append(this._backButton);
+
+			this._titleBlock = new Microsoft.UI.Xaml.Controls.TextBlock();
+			this._titleBlock.VerticalAlignment = 1; // Center
+
+			this._titleArea = new Microsoft.UI.Xaml.Controls.Grid();
+			this._titleArea.VerticalAlignment = 1; // Center
+			this._titleArea.Children.Append(this._titleBlock);
+			Microsoft.UI.Xaml.Controls.Grid.SetColumn(this._titleArea, 1);
+			this._topBar.Children.Append(this._titleArea);
+
+			this._actionArea = new Microsoft.UI.Xaml.Controls.StackPanel();
+			this._actionArea.Orientation = Microsoft.UI.Xaml.Controls.Orientation.Horizontal;
+			this._actionArea.VerticalAlignment = 1; // Center
+			Microsoft.UI.Xaml.Controls.Grid.SetColumn(this._actionArea, 2);
+			this._topBar.Children.Append(this._actionArea);
+
+			this._topBar.Visibility = 1; // Collapsed
+		} catch (_e) {
+			this._topBar = null;
+			this._titleArea = null;
+			this._actionArea = null;
+		}
+	}
+
+	private _buildContainer(): any {
+		if (!this._topBar) {
+			return this._pageHost;
+		}
+
+		// Two-row Grid: row 0 (Auto) for CommandBar, row 1 (*) for page content.
+		// WinRT collection mutations can throw; on failure fall back to the bare page host.
+		try {
+			const outerGrid = new Microsoft.UI.Xaml.Controls.Grid();
+
+			const autoRow = new Microsoft.UI.Xaml.Controls.RowDefinition();
+			autoRow.Height = Microsoft.UI.Xaml.GridLengthHelper.FromValueAndType(1, Microsoft.UI.Xaml.GridUnitType.Auto);
+			const starRow = new Microsoft.UI.Xaml.Controls.RowDefinition();
+			starRow.Height = Microsoft.UI.Xaml.GridLengthHelper.FromValueAndType(1, Microsoft.UI.Xaml.GridUnitType.Star);
+			outerGrid.RowDefinitions.Append(autoRow);
+			outerGrid.RowDefinitions.Append(starRow);
+
+			this._topBar.HorizontalAlignment = 3; // Stretch
+			Microsoft.UI.Xaml.Controls.Grid.SetRow(this._topBar, 0);
+			outerGrid.Children.Append(this._topBar);
+
+			this._pageHost.HorizontalAlignment = 3; // Stretch
+			Microsoft.UI.Xaml.Controls.Grid.SetRow(this._pageHost, 1);
+			outerGrid.Children.Append(this._pageHost);
+
+			return outerGrid;
+		} catch (_e) {
+			return this._pageHost;
+		}
+	}
+
+	get windows(): any {
+		return this._pageHost;
+	}
+
+	public initNativeView(): void {
+		super.initNativeView();
+		this._setupTransitions();
+		this._setupBackButton();
+		this._setupBackNavigationShortcuts();
+	}
+
+	private _backAccelHandlers: any[] = [];
+
+	// On Windows desktop there is no hardware/gesture back, so a page with `actionBarHidden` (no action
+	// bar → no back button) traps the user. Register the standard desktop back shortcuts (Alt+Left and the
+	// browser Back key) on the frame root so back navigation always works regardless of the action bar.
+	private _setupBackNavigationShortcuts(): void {
+		const root = this.nativeViewProtected as any;
+		if (!root || !root.KeyboardAccelerators) return;
+		// Suppress the WinUI3 "Alt+←" accelerator tooltip bubble that shows on hover.
+		// KeyboardAcceleratorPlacementMode.Hidden = 1.
+		try { root.KeyboardAcceleratorPlacementMode = 1; } catch (_e) { }
+		const that = new WeakRef(this);
+		const addAccel = (key: number, modifiers: number) => {
+			try {
+				const accel = new Microsoft.UI.Xaml.Input.KeyboardAccelerator();
+				(accel as any).Key = key;
+				(accel as any).Modifiers = modifiers;
+				const handler = NSWinRT.asDelegate(
+					'Windows.Foundation.TypedEventHandler`2<Microsoft.UI.Xaml.Input.KeyboardAccelerator,Microsoft.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs>',
+					(_s: any, e: any) => {
+						const owner = that.deref();
+						if (owner?.canGoBack()) {
+							owner.goBack();
+							try { (e as any).Handled = true; } catch (_e) {}
+						}
+					}
+				);
+				(accel as any).Invoked = handler as never;
+				this._backAccelHandlers.push(handler);
+				root.KeyboardAccelerators.Append(accel);
+			} catch (_e) { }
+		};
+		// VirtualKey: Left = 37, GoBack (browser back) = 166. VirtualKeyModifiers: None = 0, Menu (Alt) = 2.
+		addAccel(37, 2); // Alt+Left
+		addAccel(166, 0); // browser Back key / mouse back button
+	}
+
+	private _setupBackButton(): void {
+		if (!this._backButton) return;
+		const that = new WeakRef(this);
+		this._backButtonDelegate = NSWinRT.asDelegate('Microsoft.UI.Xaml.RoutedEventHandler', () => {
+			const owner = that.deref();
+			if (owner?.canGoBack()) owner.goBack();
+		});
+		this._backButton.Click = this._backButtonDelegate;
+	}
+
+	private _setupTransitions(): void {
+		// ContentControl doesn't support ContentTransitions — transitions skipped.
+	}
+
+	// Override frame-common._removeEntry to cache module-based pages instead of tearing
+	// them down. The default path calls frame._removeView(page) → _removeViewCore →
+	// _tearDownUI, which nulls nativeViewProtected and _context. Cached pages skip
+	// _tearDownUI entirely — their native views remain alive in memory so re-navigating
+	// to the same module path is instant (no view creation, no applyAllNativeSetters).
+	public _removeEntry(removed: any): void {
+		const page = removed?.resolvedPage;
+		if (page) {
+			const moduleName = removed?.entry?.moduleName;
+			if (moduleName && (page as any)._context && (page as any).frame === this) {
+				// Cacheable: preserve native views, fire JS lifecycle only.
+				this._cacheNativePage(moduleName, page);
+			} else if ((page as any)._context) {
+				// Non-cacheable (create()-fn page or different frame): deferred teardown.
+				const frame = (page as any).frame;
+				if (frame && typeof (frame as any)._removeView === 'function') {
+					(frame as any)._removeView(page);
+				} else {
+					setTimeout(() => {
+						try { if ((page as any)._context) (page as any)._tearDownUI?.(); } catch (_e) { }
+					}, 0);
+				}
+			}
+			// else: already torn down — nothing to do.
+		}
+		if (removed) removed.resolvedPage = null;
+	}
+
+	private _cacheNativePage(moduleName: string, page: any): void {
+		// LRU eviction: oldest entry (first key) is deferred-torn-down and removed.
+		if (this._nativePageCache.size >= Frame._PAGE_CACHE_LIMIT) {
+			const oldestKey = this._nativePageCache.keys().next().value as string;
+			const evicted = this._nativePageCache.get(oldestKey);
+			this._nativePageCache.delete(oldestKey);
+			if (evicted) {
+				setTimeout(() => {
+					try { if ((evicted as any)._context) (evicted as any)._tearDownUI?.(); } catch (_e) { }
+				}, 0);
+			}
+		}
+		this._nativePageCache.set(moduleName, page);
+		// Fire JS unloaded lifecycle (CSS transitions + observers need this).
+		// _tearDownUI is deliberately NOT called — native views stay alive.
+		try { (page as any).callUnloaded?.(); } catch (_e) { }
+	}
+
+	//@ts-ignore
+	public setCurrent(entry: BackstackEntry, navigationType: NavigationType): void {
+		const current = this._currentEntry;
+		const currentEntryChanged = current !== entry;
+		if (entry?.resolvedPage && currentEntryChanged) {
+			// If a navigatedTo handler throws, the base never clears _executingContext, permanently
+			// jamming the navigation queue. Guard so a faulty handler can't wedge navigation.
+			try {
+				this._updateBackstack(entry, navigationType);
+				super.setCurrent(entry, navigationType);
+			} catch (err) {
+				console.error('[Frame.Windows] setCurrent failed; recovering navigation:', err, (err as any)?.stack);
+				this._executingContext = null;
+				// Restore previous page visually so the user isn't left on a blank screen.
+				if (current?.resolvedPage?.nativeViewProtected) {
+					try { this._setPageContent(current.resolvedPage.nativeViewProtected); } catch (_e) {}
+					this._currentEntry = current;
+					this._updateActionBar(current.resolvedPage as Page);
+				}
+			}
+			this._processNavigationQueue(entry.resolvedPage);
+		} else {
+			// No resolved page (module failed to load) or page already current.
+			// _executingContext was set by performNavigation — must clear it unconditionally or
+			// all future navigations are permanently blocked.
+			this._executingContext = null;
+			const queue = (this as any)._navigationQueue as Array<any>;
+			if (queue?.length > 0 && queue[0]?.entry === entry) queue.shift();
+			(this as any)._processNextNavigationEntry?.();
+		}
+	}
+
+	@profile
+	public _navigateCore(backstackEntry: BackstackEntry) {
+		// Restore cached native page before frame-common resolves to a freshly-created one.
+		// performNavigation sets backstackEntry.resolvedPage via _resolvePageFromEntry (pure JS,
+		// no WinRT), then calls _navigateCore — we replace the just-created page with the cached
+		// one here. The cached page's _context is intact, so setCurrent → _addView → _setupUI
+		// returns early (page.frame === this), keeping all native views alive with zero WinRT cost.
+		const moduleName = (backstackEntry as any)?.entry?.moduleName;
+		if (moduleName) {
+			const cached = this._nativePageCache.get(moduleName);
+			if (cached && (cached as any)._context) {
+				this._nativePageCache.delete(moduleName);
+				backstackEntry.resolvedPage = cached;
+			}
+		}
+
+		const fromPage = this.currentPage as Page; // capture before setCurrent swaps it
+		// Capture pending queue depth before setCurrent drains it. If taps arrived faster than
+		// animations finish, queue.length > 1 here — animate only the final destination.
+		const pendingAhead = ((this as any)._navigationQueue?.length ?? 1) - 1;
+		super._navigateCore(backstackEntry);
+
+		const navigationType = this._executingContext?.navigationType ?? NavigationType.forward;
+		this.setCurrent(backstackEntry, navigationType);
+
+		const page = backstackEntry.resolvedPage;
+		if (!this._pageHost || !page?.nativeViewProtected) return;
+
+		// Back-nav doesn't re-fire `loaded` on the restored page's subtree; views stay unloaded with
+		// _suspendNativeUpdatesCount set, queuing every setNative (visibility, etc.) indefinitely.
+		this._ensureLoaded(page as Page);
+
+		const isForward = navigationType !== NavigationType.back;
+		const navTransition = (this as any)._getNavigationTransition?.(backstackEntry.entry);
+		const transitionInst = navTransition?.instance;
+		const durMs = (transitionInst?.getDuration?.() ?? 0) * 1000 || 180;
+		const transName: string = transitionInst?.constructor?.name ?? '';
+
+		// Shared-element morph; returns false when not applicable (falls through to slide/fade).
+		if (this._runSharedTransition(fromPage, page as Page, transitionInst, durMs)) {
+			this._updateActionBar(page as Page);
+			return;
+		}
+
+		this._setPageContent(page.nativeViewProtected);
+		// Skip animation for intermediate navigations — stacking 250ms Storyboards causes
+		// the app to appear frozen while the queue drains.
+		const effectiveDur = pendingAhead > 0 ? 0 : durMs;
+		// Default to slide; fade only when explicitly requested.
+		if (transName.toLowerCase().includes('fade')) {
+			this._fadeIn(page.nativeViewProtected, effectiveDur);
+		} else {
+			this._slideIn(page.nativeViewProtected, isForward, effectiveDur);
+		}
+		this._updateActionBar(page as Page);
+	}
+
+	// Captures each FROM-element's rect before the page swap, then does a normal _setPageContent swap
+	// and animates only the incoming elements' transforms. Does NOT keep both pages mounted — that
+	// earlier approach collided with frame page management and froze later navigation.
+	private _runSharedTransition(fromPage: Page, toPage: Page, transitionInst: any, durMs: number): boolean {
+		try {
+			if (!transitionInst || !fromPage || !toPage) return false;
+			const state = SharedTransition.getState(transitionInst.id);
+			if (!state) return false;
+
+			const toNative = toPage.nativeViewProtected as Microsoft.UI.Xaml.UIElement;
+			if (!toNative) return false;
+
+			state.page = fromPage;
+			state.toPage = toPage;
+			const { sharedElements, presented } = SharedTransition.getSharedElements(fromPage, toPage);
+			if (!sharedElements || sharedElements.length === 0) return false;
+
+			const host = this._pageHost;
+			// Capture FROM-element rects (host coords) BEFORE the page swap removes them.
+			const pairs: Array<{ toNative: any; fromRect: { x: number; y: number; w: number; h: number }; tag: string }> = [];
+			for (const fromView of sharedElements) {
+				const tag = (fromView as any).sharedTransitionTag;
+				const toView = presented.find((v) => v.sharedTransitionTag === tag);
+				const fromNative = (fromView as any).nativeViewProtected;
+				const toEl = toView && (toView as any).nativeViewProtected;
+				if (!fromNative || !toEl) continue;
+				const r = this._rectInHost(fromNative, host);
+				if (!r || r.w <= 0 || r.h <= 0) continue;
+				pairs.push({ toNative: toEl, fromRect: r, tag });
+			}
+			if (pairs.length === 0) return false;
+
+			// Normal page swap — frame keeps full control of the host.
+			this._setPageContent(toNative);
+			try { host.UpdateLayout(); } catch (_e) { }
+
+			SharedTransitionHelper.animate(state, { host, pairs, durationMs: durMs }, 'page');
+			return true;
+		} catch (_e) {
+			return false;
+		}
+	}
+
+	private _rectInHost(nativeEl: any, host: any): { x: number; y: number; w: number; h: number } | null {
+		try {
+			const gt = (nativeEl as any).TransformToVisual(host);
+			const p = gt.TransformPoint(new Windows.Foundation.Point(0, 0));
+			return { x: p.X, y: p.Y, w: (nativeEl as any).ActualWidth || 0, h: (nativeEl as any).ActualHeight || 0 };
+		} catch (_e) {
+			return null;
+		}
+	}
+
+	// Override _removeViewCore to decouple the JS lifecycle from the native teardown.
+	// ViewBase._removeViewCore calls both unloadView (JS) and _tearDownUI (native) synchronously.
+	// _tearDownUI on a 40-view page fires ~100 WinRT calls (disposeNativeView + Children.RemoveAt
+	// per child) while the page is still on screen — this blocks the animation start by 10-20ms.
+	// Fix: fire callUnloaded() synchronously (CSS animations + observers depend on it), but defer
+	// _tearDownUI to a setTimeout(0). By then _setPageContent has already removed the root from
+	// _pageHost, so the WinRT calls operate on a detached subtree with no XAML layout cascade.
+	public _removeViewCore(view: any): void {
+		try { view.callUnloaded?.(); } catch (_e) { }
+		if (view._context) {
+			setTimeout(() => {
+				try { if (view._context) view._tearDownUI?.(); } catch (_e) { }
+			}, 0);
+		}
+	}
+
+	// Windows back-nav restores a cached page without re-firing the `loaded` lifecycle, leaving the
+	// subtree with _suspendNativeUpdatesCount set (every setNative queued, never applied). callLoaded()
+	// flips isLoaded and flushes the queued setNatives via _resumeNativeUpdates.
+	// Early-exit: if a view is already loaded, NativeScript guarantees its entire subtree is also
+	// loaded — skip the O(N) recursion entirely. This is the common case on back navigation.
+	private _ensureLoaded(view: any): void {
+		if (!view || view.isLoaded) return;
+		try {
+			if (typeof view.callLoaded === 'function') view.callLoaded();
+		} catch (_e) { }
+		try {
+			if (typeof view.eachChildView === 'function') {
+				view.eachChildView((c: any) => { this._ensureLoaded(c); return true; });
+			}
+		} catch (_e) { }
+	}
+
+	private _setPageContent(nativePageView: Microsoft.UI.Xaml.UIElement): void {
+		const children = this._pageHost.Children;
+		if (!children) return;
+		const count = children.Size ?? 0;
+		for (let i = count - 1; i >= 0; i--) {
+			try { children.RemoveAt(i); } catch (_e) { }
+		}
+		try { children.Append(nativePageView); } catch (_e) { }
+	}
+
+	// WinUI Duration: { TimeSpan: { Duration: <100ns ticks> }, Type: 1 (DurationType.TimeSpan) }.
+	// The runtime now marshals nested structs correctly; plain object replaces the old ArrayBuffer hack.
+	private _duration(ms: number): Microsoft.UI.Xaml.Duration {
+		return { TimeSpan: { Duration: Math.max(1, Math.round(ms)) * 10000 }, Type: 1 } as never;
+	}
+
+	// Page transitions run as native Storyboards (compositor-driven). The previous
+	// requestAnimationFrame/setTimeout interpolation was effectively instant in this host.
+	private _runStoryboard(sb: Microsoft.UI.Xaml.Media.Animation.Storyboard, onDone: () => void): void {
+		_activeTransitions.add(sb);
+		let done = false;
+		const finish = () => {
+			if (done) return;
+			done = true;
+			_activeTransitions.delete(sb);
+			try { onDone(); } catch (_e) { }
+		};
+		try { sb.Completed = (() => finish()) as never; } catch (_e) { }
+		try { sb.Begin(); } catch (_e) { finish(); return; }
+		// Safety timeout: final state must land even if Completed never fires (element detached, etc.).
+		setTimeout(finish, 400);
+	}
+
+	private _fadeIn(native: Microsoft.UI.Xaml.UIElement, durationMs: number): void {
+		if (durationMs <= 0) {
+			try { native.Opacity = 1; } catch (_e) { }
+			return;
+		}
+		try {
+			native.Opacity = 0;
+			const sb = new Microsoft.UI.Xaml.Media.Animation.Storyboard();
+			const da = new Microsoft.UI.Xaml.Media.Animation.DoubleAnimation();
+			da.From = 0;
+			da.To = 1;
+			da.Duration = this._duration(durationMs) as never;
+			Microsoft.UI.Xaml.Media.Animation.Storyboard.SetTarget(da, native);
+			Microsoft.UI.Xaml.Media.Animation.Storyboard.SetTargetProperty(da, 'Opacity');
+			sb.Children.Append(da);
+			this._runStoryboard(sb, () => { native.Opacity = 1; });
+		} catch (_e) {
+			native.Opacity = 1;
+		}
+	}
+
+	// Slides in from right (forward) or left (back). Uses TranslateTransform.X — CompositeTransform.TranslateX
+	// did not animate reliably in this host.
+	private _slideIn(native: Microsoft.UI.Xaml.UIElement, fromRight: boolean, durationMs: number): void {
+		if (durationMs <= 0) {
+			try { native.Opacity = 1; } catch (_e) { }
+			return;
+		}
+		try {
+			const startX = fromRight ? 380 : -380;
+			const tt = new Microsoft.UI.Xaml.Media.TranslateTransform();
+			tt.X = startX;
+			native.RenderTransform = tt;
+			native.Opacity = 0;
+			const sb = new Microsoft.UI.Xaml.Media.Animation.Storyboard();
+			const slide = new Microsoft.UI.Xaml.Media.Animation.DoubleAnimation();
+			slide.From = startX;
+			slide.To = 0;
+			slide.Duration = this._duration(durationMs) as never;
+			const ease = new Microsoft.UI.Xaml.Media.Animation.CubicEase();
+			ease.EasingMode = Microsoft.UI.Xaml.Media.Animation.EasingMode.EaseOut;
+			slide.EasingFunction = ease;
+			Microsoft.UI.Xaml.Media.Animation.Storyboard.SetTarget(slide, tt);
+			Microsoft.UI.Xaml.Media.Animation.Storyboard.SetTargetProperty(slide, 'X');
+			sb.Children.Append(slide);
+			// Fade in alongside the slide to avoid a flash at the gap.
+			const fade = new Microsoft.UI.Xaml.Media.Animation.DoubleAnimation();
+			fade.From = 0;
+			fade.To = 1;
+			fade.Duration = this._duration(Math.min(durationMs, 160)) as never;
+			Microsoft.UI.Xaml.Media.Animation.Storyboard.SetTarget(fade, native);
+			Microsoft.UI.Xaml.Media.Animation.Storyboard.SetTargetProperty(fade, 'Opacity');
+			sb.Children.Append(fade);
+			this._runStoryboard(sb, () => { try { tt.X = 0; } catch (_e) { } native.Opacity = 1; });
+		} catch (_e) {
+			this._fadeIn(native, durationMs);
+		}
+	}
+
+	public _goBackCore(backstackEntry: BackstackEntry) {
+		const fromPage = this.currentPage as Page; // capture before setCurrent swaps it
+		const pendingAhead = ((this as any)._navigationQueue?.length ?? 1) - 1;
+		super._goBackCore(backstackEntry);
+
+		this.setCurrent(backstackEntry, NavigationType.back);
+
+		const page = backstackEntry.resolvedPage;
+		if (!this._pageHost || !page?.nativeViewProtected) return;
+
+		// Re-load the restored page's subtree (see _navigateCore).
+		this._ensureLoaded(page as Page);
+
+		const navTransition = (this as any)._getNavigationTransition?.(backstackEntry.entry);
+		const transitionInst = navTransition?.instance;
+		const durMs = (transitionInst?.getDuration?.() ?? 0) * 1000 || 180;
+		const transName: string = transitionInst?.constructor?.name ?? '';
+
+		// Reverse shared-element morph on back; falls back to slide/fade if not applicable.
+		if (this._runSharedTransition(fromPage, page as Page, transitionInst, durMs)) {
+			this._updateActionBar(page as Page);
+			return;
+		}
+
+		this._setPageContent(page.nativeViewProtected);
+		const effectiveDur = pendingAhead > 0 ? 0 : durMs;
+		// Default to slide; fade only when explicitly requested.
+		if (transName.toLowerCase().includes('fade')) {
+			this._fadeIn(page.nativeViewProtected, effectiveDur);
+		} else {
+			this._slideIn(page.nativeViewProtected, false, effectiveDur);
+		}
+		this._updateActionBar(page as Page);
+	}
+
+	public _updateActionBar(page?: Page): void {
+		super._updateActionBar(page);
+		if (!this._topBar) return;
+
+		page = page ?? (this.currentPage as Page);
+		if (!page) return;
+
+		const visible = this._isNavBarVisible(page);
+		this._topBar.Visibility = visible ? 0 : 1;
+
+		if (!visible) return;
+
+		if (this._backButton) {
+			const navBtn = (page as any).actionBar?.navigationButton;
+			this._backButton.Content = navBtn?.text || '←';
+			this._backButton.Visibility = this.canGoBack() ? 0 : 1;
+		}
+
+		if (this._titleArea) {
+			const actionBar = (page as any).actionBar;
+			const titleView = actionBar?.titleView;
+			const newNative: Microsoft.UI.Xaml.UIElement | null = titleView?.nativeViewProtected ?? null;
+			if (newNative !== this._titleViewNative) {
+				// Swap the child in the title Grid: remove the old one, add the new one.
+				try {
+					const children = this._titleArea.Children;
+					const count = children.Size ?? 0;
+					for (let i = count - 1; i >= 0; i--) {
+						try { children.RemoveAt(i); } catch (_e) {}
+					}
+					if (newNative) {
+						children.Append(newNative);
+					} else if (this._titleBlock) {
+						children.Append(this._titleBlock);
+					}
+					this._titleViewNative = newNative;
+				} catch (_e) {}
+			}
+			if (!newNative && this._titleBlock) {
+				this._titleBlock.Text = actionBar?.title ?? '';
+			}
+		}
+
+		this._rebuildActionItems(page);
+	}
+
+	public disposeNativeView(): void {
+		this._flushPageCache();
+		this._titleArea = null;
+		this._titleViewNative = null;
+		this._titleBlock = null;
+		this._actionArea = null;
+		this._actionItemDelegates.length = 0;
+		super.disposeNativeView?.();
+	}
+
+	private _flushPageCache(): void {
+		for (const [, page] of this._nativePageCache) {
+			try { if ((page as any)._context) (page as any)._tearDownUI?.(); } catch (_e) { }
+		}
+		this._nativePageCache.clear();
+	}
+
+	private _isNavBarVisible(page: Page): boolean {
+		if (this.actionBarVisibility === 'always') return true;
+		if (this.actionBarVisibility === 'never') return false;
+		if ((page as any).actionBarHidden) return false;
+		return !(page as any).actionBar?._isEmpty() || this.canGoBack();
+	}
+
+	private _rebuildActionItems(page: Page): void {
+		const area = this._actionArea;
+		if (!area) return;
+		// Clear existing buttons and release old delegate GC-guards.
+		this._actionItemDelegates.length = 0;
+		const children = area.Children;
+		const size = children.Size ?? 0;
+		for (let i = size - 1; i >= 0; i--) {
+			try { children.RemoveAt(i); } catch (_e) {}
+		}
+		const items: any[] = (page as any).actionBar?.actionItems?.getVisibleItems() ?? [];
+		for (const item of items) {
+			try {
+				const btn = new Microsoft.UI.Xaml.Controls.Button();
+				const del = NSWinRT.asDelegate('Microsoft.UI.Xaml.RoutedEventHandler', () => item._raiseTap());
+				this._actionItemDelegates.push(del); // keep alive until next rebuild
+				btn.Click = del as never;
+				if (item.actionView?.nativeViewProtected) {
+					btn.Content = item.actionView.nativeViewProtected as never;
+				} else {
+					const label: string = item.text ?? '';
+					const iconSrc: string = item.windows?.icon ?? item.icon ?? '';
+					if (label) {
+						btn.Content = label as never;
+					} else if (iconSrc && !iconSrc.startsWith('res://') && !iconSrc.startsWith('font://')) {
+						try {
+							const img = new Microsoft.UI.Xaml.Controls.Image();
+							img.Width = 24; img.Height = 24;
+							img.Stretch = 2 as never; // Uniform
+							let uri = iconSrc;
+							if (uri.startsWith('~/')) uri = 'ms-appx:///app/' + uri.substring(2);
+							else if (!uri.startsWith('ms-appx') && !uri.startsWith('http')) uri = 'ms-appx:///app/' + uri;
+							const bmp = new Microsoft.UI.Xaml.Media.Imaging.BitmapImage();
+							(bmp as any).UriSource = new Windows.Foundation.Uri(uri);
+							img.Source = bmp;
+							btn.Content = img as never;
+						} catch (_e) {
+							btn.Content = '▶' as never;
+						}
+					} else {
+						// No text and no usable icon (ios.systemIcon / android.systemIcon are ignored on Windows).
+						// Show a generic visible marker so the button is tappable.
+						btn.Content = '▶' as never;
+					}
+				}
+				children.Append(btn);
+			} catch (_e) {}
+		}
+	}
+}
+
+// attach on global, so it can be overwritten in NativeScript Angular
+global.__onLiveSyncCore = Frame.reloadPage;
+
+export function setActivityCallbacks(_callbacks: any): void { }
+export function setWindowContent(_view: any): void { }
\ No newline at end of file
diff --git a/packages/core/ui/gestures/index.windows.ts b/packages/core/ui/gestures/index.windows.ts
new file mode 100644
index 0000000000..a202a001dd
--- /dev/null
+++ b/packages/core/ui/gestures/index.windows.ts
@@ -0,0 +1,521 @@
+export * from './gestures-common';
+export * from './gestures-types';
+export * from './touch-manager';
+
+import { GesturesObserverBase, GestureTypes, GestureEvents, GestureStateTypes, toString } from './gestures-common';
+import type { View } from '../core/view';
+import { layout } from '../../utils/layout-helper';
+import * as timer from '../../timer';
+
+// Per-view hover tracking to enable CSS :hover pseudo-class.
+const _hoverViews = new WeakSet<View>();
+
+function _attachHoverHandlers(view: View): void {
+	const native = (view as any).nativeViewProtected as any;
+	if (!native || native.__ns_hover_attached) return;
+
+	const onEnter = () => {
+		if (_hoverViews.has(view)) return;
+		_hoverViews.add(view);
+		try { (view as any)._addVisualState?.('hover'); } catch (_e) { }
+		try { (view as any).notify?.({ eventName: 'mouseEnter', object: view }); } catch (_e) { }
+	};
+	const onLeave = () => {
+		if (!_hoverViews.has(view)) return;
+		_hoverViews.delete(view);
+		try { (view as any)._removeVisualState?.('hover'); } catch (_e) { }
+		try { (view as any).notify?.({ eventName: 'mouseLeave', object: view }); } catch (_e) { }
+	};
+
+	const enterDelegate = _wrapPointerHandler(onEnter);
+	const leaveDelegate = _wrapPointerHandler(onLeave);
+
+	let usingAddHandler = false;
+	try {
+		const UIElement = Microsoft.UI.Xaml.UIElement;
+		const pee = UIElement?.PointerEnteredEvent ?? native.PointerEnteredEvent;
+		const pxe = UIElement?.PointerExitedEvent ?? native.PointerExitedEvent;
+		if (!pee || !pxe) throw new Error('RoutedEvent statics unavailable');
+		native.AddHandler(pee, enterDelegate, true);
+		native.AddHandler(pxe, leaveDelegate, true);
+		usingAddHandler = true;
+	} catch (_e) {
+		try {
+			_assignPointerHandler(native, 'PointerEntered', enterDelegate);
+			_assignPointerHandler(native, 'PointerExited', leaveDelegate);
+		} catch (_e2) { }
+	}
+
+	native.__ns_hover_attached = true;
+	native.__ns_hover_using_add_handler = usingAddHandler;
+	native.__ns_hover_enter_fn = onEnter;
+	native.__ns_hover_leave_fn = onLeave;
+	native.__ns_hover_enter_delegate = enterDelegate;
+	native.__ns_hover_leave_delegate = leaveDelegate;
+}
+
+function _detachHoverHandlers(view: View): void {
+	const native = (view as any).nativeViewProtected as any;
+	if (!native || !native.__ns_hover_attached) return;
+
+	if (native.__ns_hover_using_add_handler) {
+		try {
+			if (native.__ns_hover_enter_delegate) native.RemoveHandler(native.PointerEnteredEvent, native.__ns_hover_enter_delegate);
+			if (native.__ns_hover_leave_delegate) native.RemoveHandler(native.PointerExitedEvent, native.__ns_hover_leave_delegate);
+		} catch (_e) { }
+	}
+
+	native.__ns_hover_attached = false;
+	native.__ns_hover_using_add_handler = false;
+	native.__ns_hover_enter_fn = null;
+	native.__ns_hover_leave_fn = null;
+	native.__ns_hover_enter_delegate = null;
+	native.__ns_hover_leave_delegate = null;
+	_hoverViews.delete(view);
+}
+
+/** Returns true if the view is currently in a hover state (mouse over). */
+export function isHovered(view: View): boolean {
+	return _hoverViews.has(view);
+}
+
+const DOUBLE_TAP_TIMEOUT = 300;
+const LONG_PRESS_TIMEOUT = 500;
+const TAP_SLOP = 20; // pixels
+
+function _wrapPointerHandler(fn: (s: any, e: any) => void): any {
+	return NSWinRT.asDelegate('Microsoft.UI.Xaml.Input.PointerEventHandler', fn);
+}
+
+function _wrapRightTappedHandler(fn: (s: any, e: any) => void): any {
+	return NSWinRT.asDelegate('Microsoft.UI.Xaml.Input.RightTappedEventHandler', fn);
+}
+
+function _assignPointerHandler(native: any, prop: string, del: any): void {
+	native[prop] = del as never;
+}
+
+function _assignRightTappedHandler(native: any, del: any): void {
+	native.RightTapped = del as never;
+}
+
+function _executeCallback(observer: GesturesObserver, args: any) {
+	if (observer && observer.callback) {
+		observer.callback.call(observer.context, args);
+	}
+}
+
+class WindowsPointer {
+	public id: number;
+	private event: any;
+	constructor(id: number, event: any) {
+		this.id = id;
+		this.event = event;
+	}
+	getX(): number {
+		try {
+			const p = extractPoint(this.event);
+			return p.x ?? 0;
+		} catch (_e) {
+			return 0;
+		}
+	}
+	getY(): number {
+		try {
+			const p = extractPoint(this.event);
+			return p.y ?? 0;
+		} catch (_e) {
+			return 0;
+		}
+	}
+}
+
+function extractPoint(e: any, relativeTo?: any) {
+	try {
+		if (e.getCurrentPoint) {
+			const pt = e.getCurrentPoint(relativeTo || null);
+			const pos = pt.Position || pt.position || pt; // fallback
+			return { x: pos.X ?? pos.x ?? (pos.Position && pos.Position.X) ?? 0, y: pos.Y ?? pos.y ?? (pos.Position && pos.Position.Y) ?? 0 };
+		}
+	} catch (_e) { }
+
+	try {
+		const cp = e.currentPoint || e.CurrentPoint;
+		if (cp) {
+			const pos = cp.Position || cp.position || cp;
+			return { x: pos.X ?? pos.x ?? 0, y: pos.Y ?? pos.y ?? 0 };
+		}
+	} catch (_e) { }
+
+	try {
+		if (e.clientX !== undefined && e.clientY !== undefined) {
+			return { x: e.clientX, y: e.clientY };
+		}
+	} catch (_e) { }
+
+	return { x: 0, y: 0 };
+}
+
+export class GesturesObserver extends GesturesObserverBase {
+	private _onTargetLoaded: () => void;
+	private _onTargetUnloaded: () => void;
+
+	private _pointerPressedHandler: any;
+	private _pointerMovedHandler: any;
+	private _pointerReleasedHandler: any;
+	private _pointerCanceledHandler: any;
+	private _rightTappedHandler: any;
+
+	// Wrapped WinRT delegates (needed for RemoveHandler calls)
+	private _pointerPressedDelegate: any;
+	private _pointerMovedDelegate: any;
+	private _pointerReleasedDelegate: any;
+	private _rightTappedDelegate: any;
+	private _usingAddHandler = false;
+
+	private _pointerDownMap: Map<number, { x: number; y: number; t: number; nativeTs: number | null }> = new Map();
+	private _lastUpTime = 0;
+	private _tapTimeoutId: any;
+	private _longPressTimeouts: Map<number, any> = new Map();
+
+	public observe(type: GestureTypes) {
+		this.type = type;
+
+		if (!this.target) {
+			return;
+		}
+
+		this._onTargetLoaded = () => this._attach(this.target, type);
+		this._onTargetUnloaded = () => this._detach();
+
+		this.target.on('loaded', this._onTargetLoaded);
+		this.target.on('unloaded', this._onTargetUnloaded);
+
+		if (this.target.isLoaded) {
+			this._attach(this.target, type);
+		}
+	}
+
+	public disconnect() {
+		this._detach();
+
+		if (this.target) {
+			this.target.off('loaded', this._onTargetLoaded);
+			this.target.off('unloaded', this._onTargetUnloaded);
+
+			this._onTargetLoaded = null;
+			this._onTargetUnloaded = null;
+		}
+
+		super.disconnect();
+	}
+
+	private _detach() {
+		try {
+			const native = (this.target && (this.target as any).nativeViewProtected) as any;
+			if (native) {
+				if (this._usingAddHandler) {
+					try {
+						if (this._pointerPressedDelegate) native.RemoveHandler(native.PointerPressedEvent, this._pointerPressedDelegate);
+						if (this._pointerMovedDelegate) native.RemoveHandler(native.PointerMovedEvent, this._pointerMovedDelegate);
+						if (this._pointerReleasedDelegate) native.RemoveHandler(native.PointerReleasedEvent, this._pointerReleasedDelegate);
+						if (this._rightTappedDelegate) native.RemoveHandler(native.RightTappedEvent, this._rightTappedDelegate);
+					} catch (_e) { }
+				} else {
+					native.PointerPressed = null as never;
+					native.PointerMoved = null as never;
+					native.PointerReleased = null as never;
+					native.RightTapped = null as never;
+				}
+			}
+		} catch (_e) { }
+
+		if (this.target) {
+			_detachHoverHandlers(this.target);
+		}
+
+		this._pointerPressedHandler = null;
+		this._pointerMovedHandler = null;
+		this._pointerReleasedHandler = null;
+		this._pointerCanceledHandler = null;
+		this._rightTappedHandler = null;
+		this._pointerPressedDelegate = null;
+		this._pointerMovedDelegate = null;
+		this._pointerReleasedDelegate = null;
+		this._rightTappedDelegate = null;
+		this._usingAddHandler = false;
+		this._pointerDownMap.clear();
+		this._longPressTimeouts.forEach((id) => timer.clearTimeout(id));
+		this._longPressTimeouts.clear();
+		if (this._tapTimeoutId) {
+			timer.clearTimeout(this._tapTimeoutId);
+			this._tapTimeoutId = null;
+		}
+	}
+
+	private _attach(target: View, type: GestureTypes) {
+		this._detach();
+
+		const native = (target as any).nativeViewProtected as any;
+		if (!native) {
+			return;
+		}
+
+		this._pointerPressedHandler = (s: any, e: any) => this._onPointerPressed(e || s);
+		this._pointerMovedHandler = (s: any, e: any) => this._onPointerMoved(e || s);
+		this._pointerReleasedHandler = (s: any, e: any) => this._onPointerReleased(e || s);
+
+		this._pointerPressedDelegate = _wrapPointerHandler(this._pointerPressedHandler);
+		this._pointerMovedDelegate = _wrapPointerHandler(this._pointerMovedHandler);
+		this._pointerReleasedDelegate = _wrapPointerHandler(this._pointerReleasedHandler);
+
+		// Use AddHandler with handledEventsToo=true so events fire even when Button (and other
+		// controls) mark pointer events as handled internally.
+		// PointerPressedEvent is a STATIC property on UIElement, not an instance property —
+		// access it from the class namespace so it resolves correctly in the V8 WinRT projection.
+		this._usingAddHandler = false;
+		try {
+			const UIElement = Microsoft.UI.Xaml.UIElement;
+			const ppe = UIElement?.PointerPressedEvent ?? native.PointerPressedEvent;
+			const pme = UIElement?.PointerMovedEvent ?? native.PointerMovedEvent;
+			const pre = UIElement?.PointerReleasedEvent ?? native.PointerReleasedEvent;
+			if (!ppe || !pme || !pre) throw new Error('RoutedEvent statics unavailable');
+			native.AddHandler(ppe, this._pointerPressedDelegate, true);
+			native.AddHandler(pme, this._pointerMovedDelegate, true);
+			native.AddHandler(pre, this._pointerReleasedDelegate, true);
+			this._usingAddHandler = true;
+		} catch (_e) {
+			// Fallback: plain property assignment (only one handler per event, can be overwritten).
+			_assignPointerHandler(native, 'PointerPressed', this._pointerPressedDelegate);
+			_assignPointerHandler(native, 'PointerMoved', this._pointerMovedDelegate);
+			_assignPointerHandler(native, 'PointerReleased', this._pointerReleasedDelegate);
+		}
+
+		// RightTapped (mouse right-click) fires longPress for mouse/touchpad users.
+		if (type === GestureTypes.longPress) {
+			this._rightTappedHandler = (s: any, e: any) => this._onRightTapped(e || s);
+			this._rightTappedDelegate = _wrapRightTappedHandler(this._rightTappedHandler);
+			try {
+				if (this._usingAddHandler) {
+					const rte = native.RightTappedEvent;
+					if (!rte) throw new Error('RightTappedEvent unavailable');
+					native.AddHandler(rte, this._rightTappedDelegate, true);
+				} else {
+					_assignRightTappedHandler(native, this._rightTappedDelegate);
+				}
+			} catch (_e) { }
+		}
+
+		// Always attach hover handlers for CSS :hover and mouseEnter/mouseLeave events.
+		_attachHoverHandlers(target);
+
+		target.notify({
+			eventName: GestureEvents.gestureAttached,
+			object: target,
+			type: type,
+			view: target,
+			windows: native,
+		});
+	}
+
+	// Required by GesturesObserverDefinition (Android compatibility).
+	public androidOnTouchEvent(_motionEvent: any): void { }
+
+	private _onPointerPressed(e: any) {
+		try {
+			const id = (e && (e.pointerId || (e.getCurrentPoint && e.getCurrentPoint(null)?.PointerId))) || 0;
+			const pt = extractPoint(e);
+			// Capture WinRT hardware timestamp (µs since device boot) alongside JS time.
+			// If V8 is busy when PointerReleased arrives, Date.now() will be inflated by the
+			// scheduling delay — the WinRT timestamp is immune to this and gives the real gesture duration.
+			const nativeTs: number | null = typeof e?.Timestamp === 'number' ? e.Timestamp : null;
+			this._pointerDownMap.set(id, { x: pt.x, y: pt.y, t: Date.now(), nativeTs });
+
+			if (this.type === GestureTypes.longPress) {
+				const timeoutId = timer.setTimeout(() => {
+					const args = {
+						type: GestureTypes.longPress,
+						view: this.target,
+						windows: e,
+						ios: undefined,
+						android: undefined,
+						object: this.target,
+						eventName: toString(GestureTypes.longPress),
+						state: GestureStateTypes.began,
+					};
+					_executeCallback(this, args);
+				}, LONG_PRESS_TIMEOUT);
+				this._longPressTimeouts.set(id, timeoutId);
+			}
+
+			if (this.type === GestureTypes.touch) {
+				const args: any = {
+					type: GestureTypes.touch,
+					view: this.target,
+					ios: undefined,
+					android: undefined,
+					object: this.target,
+					eventName: toString(GestureTypes.touch),
+					action: 'down',
+					getPointerCount: () => 1,
+					getActivePointers: () => [new WindowsPointer(id, e)],
+					getAllPointers: () => [new WindowsPointer(id, e)],
+					getX: () => pt.x ?? 0,
+					getY: () => pt.y ?? 0,
+				};
+
+				_executeCallback(this, args);
+			}
+		} catch (_e) { }
+	}
+
+	private _onPointerMoved(e: any) {
+		try {
+			const id = (e && (e.pointerId || (e.getCurrentPoint && e.getCurrentPoint(null)?.PointerId))) || 0;
+			const pt = extractPoint(e);
+			if (this.type === GestureTypes.touch) {
+				const args: any = {
+					type: GestureTypes.touch,
+					view: this.target,
+					ios: undefined,
+					android: undefined,
+					object: this.target,
+					eventName: toString(GestureTypes.touch),
+					action: 'move',
+					getPointerCount: () => 1,
+					getActivePointers: () => [new WindowsPointer(id, e)],
+					getAllPointers: () => [new WindowsPointer(id, e)],
+					getX: () => pt.x ?? 0,
+					getY: () => pt.y ?? 0,
+				};
+
+				_executeCallback(this, args);
+			}
+		} catch (_e) { }
+	}
+
+	private _onPointerReleased(e: any) {
+		try {
+			const id = (e && (e.pointerId || (e.getCurrentPoint && e.getCurrentPoint(null)?.PointerId))) || 0;
+			const pt = extractPoint(e);
+			const start = this._pointerDownMap.get(id);
+			const now = Date.now();
+			// Use WinRT hardware timestamps when available so the tap-duration check reflects the actual
+			// gesture time, not V8 scheduling latency. When JS is busy (e.g. processing a navigation),
+			// Date.now() at release can be 300ms+ later than the real release time, causing valid fast
+			// taps to be silently dropped by the dt < DOUBLE_TAP_TIMEOUT guard below.
+			const upNativeTs: number | null = typeof e?.Timestamp === 'number' ? e.Timestamp : null;
+			const dt = (upNativeTs !== null && start?.nativeTs !== null && start?.nativeTs !== undefined)
+				? (upNativeTs - start.nativeTs) / 1000 // µs → ms, V8-latency-free
+				: now - (start?.t ?? now);
+
+			const lp = this._longPressTimeouts.get(id);
+			if (lp) {
+				timer.clearTimeout(lp);
+				this._longPressTimeouts.delete(id);
+			}
+
+			if (this.type === GestureTypes.touch) {
+				const args: any = {
+					type: GestureTypes.touch,
+					view: this.target,
+					ios: undefined,
+					android: undefined,
+					object: this.target,
+					eventName: toString(GestureTypes.touch),
+					action: 'up',
+					getPointerCount: () => 1,
+					getActivePointers: () => [new WindowsPointer(id, e)],
+					getAllPointers: () => [new WindowsPointer(id, e)],
+					getX: () => pt.x ?? 0,
+					getY: () => pt.y ?? 0,
+				};
+
+				_executeCallback(this, args);
+			}
+
+			if (start) {
+				const dx = pt.x - start.x;
+				const dy = pt.y - start.y;
+				const dist = Math.sqrt(dx * dx + dy * dy);
+
+				if (dt < DOUBLE_TAP_TIMEOUT && dist < TAP_SLOP) {
+						if (this.target.getGestureObservers && this.target.getGestureObservers(GestureTypes.doubleTap) && this.target.getGestureObservers(GestureTypes.doubleTap).length) {
+							this._tapTimeoutId = timer.setTimeout(() => {
+							const args = {
+								type: GestureTypes.tap,
+								view: this.target,
+								ios: undefined,
+								android: undefined,
+								object: this.target,
+								eventName: toString(GestureTypes.tap),
+								getPointerCount: () => 1,
+								getX: () => pt.x ?? 0,
+								getY: () => pt.y ?? 0,
+							};
+							_executeCallback(this, args);
+						}, DOUBLE_TAP_TIMEOUT);
+					} else {
+						const args = {
+							type: GestureTypes.tap,
+							view: this.target,
+							ios: undefined,
+							android: undefined,
+							object: this.target,
+							eventName: toString(GestureTypes.tap),
+							getPointerCount: () => 1,
+							getX: () => pt.x ?? 0,
+							getY: () => pt.y ?? 0,
+						};
+						_executeCallback(this, args);
+					}
+
+						if (this.target.getGestureObservers && this.target.getGestureObservers(GestureTypes.doubleTap) && this.target.getGestureObservers(GestureTypes.doubleTap).length) {
+						const nowUp = Date.now();
+						if (this._lastUpTime && nowUp - this._lastUpTime <= DOUBLE_TAP_TIMEOUT) {
+								const args = {
+								type: GestureTypes.doubleTap,
+								view: this.target,
+								ios: undefined,
+								android: undefined,
+								object: this.target,
+								eventName: toString(GestureTypes.doubleTap),
+								getPointerCount: () => 1,
+								getX: () => pt.x ?? 0,
+								getY: () => pt.y ?? 0,
+							};
+							_executeCallback(this, args);
+						}
+						this._lastUpTime = nowUp;
+					}
+				}
+			}
+
+			this._pointerDownMap.delete(id);
+		} catch (_e) { }
+	}
+
+	private _onRightTapped(e: any) {
+		try {
+			const pt = extractPoint(e);
+			const args: any = {
+				type: GestureTypes.longPress,
+				view: this.target,
+				ios: undefined,
+				android: undefined,
+				object: this.target,
+				eventName: toString(GestureTypes.longPress),
+				state: GestureStateTypes.ended,
+				getX: () => pt.x ?? 0,
+				getY: () => pt.y ?? 0,
+			};
+			_executeCallback(this, args);
+		} catch (_e) { }
+	}
+}
+
+export function observe(target: View, type: GestureTypes, callback: (args: any) => void, context?: any): GesturesObserver {
+	const observer = new GesturesObserver(target, callback, context);
+	observer.observe(type);
+	return observer;
+}
diff --git a/packages/core/ui/html-view/index.windows.ts b/packages/core/ui/html-view/index.windows.ts
new file mode 100644
index 0000000000..a9c60e7390
--- /dev/null
+++ b/packages/core/ui/html-view/index.windows.ts
@@ -0,0 +1,213 @@
+export * from './html-view-common';
+
+import { Color } from '../../color';
+import { colorProperty, fontInternalProperty } from '../styling/style-properties';
+import { HtmlViewBase, htmlProperty, selectableProperty, linkColorProperty } from './html-view-common';
+
+type HtmlToken =
+	| { kind: 'text'; text: string }
+	| { kind: 'open'; tag: string; attrs: Record<string, string> }
+	| { kind: 'close'; tag: string }
+	| { kind: 'void'; tag: string };
+
+const VOID_TAGS = new Set(['br', 'hr', 'img', 'input', 'meta', 'link']);
+
+function tokenize(html: string): HtmlToken[] {
+	const tokens: HtmlToken[] = [];
+	const re = /<(\/?)([a-zA-Z][a-zA-Z0-9]*)((?:[^>"']|"[^"]*"|'[^']*')*)(\/?)\s*>/g;
+	let last = 0;
+	let m: RegExpExecArray | null;
+	while ((m = re.exec(html)) !== null) {
+		if (m.index > last) {
+			tokens.push({ kind: 'text', text: html.slice(last, m.index) });
+		}
+		const [, closing, rawTag, attrStr, selfClose] = m;
+		const tag = rawTag.toLowerCase();
+		if (closing) {
+			tokens.push({ kind: 'close', tag });
+		} else if (selfClose || VOID_TAGS.has(tag)) {
+			tokens.push({ kind: 'void', tag });
+		} else {
+			tokens.push({ kind: 'open', tag, attrs: parseAttrs(attrStr) });
+		}
+		last = re.lastIndex;
+	}
+	if (last < html.length) {
+		tokens.push({ kind: 'text', text: html.slice(last) });
+	}
+	return tokens;
+}
+
+function parseAttrs(s: string): Record<string, string> {
+	const attrs: Record<string, string> = {};
+	const re = /([a-zA-Z][a-zA-Z0-9-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|(\S+)))?/g;
+	let m: RegExpExecArray | null;
+	while ((m = re.exec(s)) !== null) {
+		attrs[m[1].toLowerCase()] = m[2] ?? m[3] ?? m[4] ?? '';
+	}
+	return attrs;
+}
+
+function decodeEntities(s: string): string {
+	return s
+		.replace(/&amp;/g, '&')
+		.replace(/&lt;/g, '<')
+		.replace(/&gt;/g, '>')
+		.replace(/&quot;/g, '"')
+		.replace(/&#(\d+);/g, (_, n) => String.fromCharCode(+n))
+		.replace(/&nbsp;/g, ' ');
+}
+
+type InlineParent = Microsoft.UI.Xaml.Documents.Paragraph | Microsoft.UI.Xaml.Documents.Span;
+
+function buildParagraphs(html: string, linkColor?: Color): Microsoft.UI.Xaml.Documents.Paragraph[] {
+	const tokens = tokenize(html);
+	const paragraphs: Microsoft.UI.Xaml.Documents.Paragraph[] = [];
+	let para = new Microsoft.UI.Xaml.Documents.Paragraph();
+	paragraphs.push(para);
+	const stack: InlineParent[] = [para];
+
+	const top = () => stack[stack.length - 1];
+
+	function appendInline(inline: Microsoft.UI.Xaml.Documents.Inline): void {
+		top().Inlines.Append(inline);
+	}
+
+	function pushSpan(span: Microsoft.UI.Xaml.Documents.Span): void {
+		appendInline(span as unknown as Microsoft.UI.Xaml.Documents.Inline);
+		stack.push(span);
+	}
+
+	for (const token of tokens) {
+		switch (token.kind) {
+			case 'text': {
+				const text = decodeEntities(token.text);
+				if (text) {
+					const run = new Microsoft.UI.Xaml.Documents.Run();
+					run.Text = text;
+					appendInline(run);
+				}
+				break;
+			}
+			case 'void':
+				if (token.tag === 'br') {
+					appendInline(new Microsoft.UI.Xaml.Documents.LineBreak());
+				}
+				break;
+			case 'open':
+				switch (token.tag) {
+					case 'p': {
+						para = new Microsoft.UI.Xaml.Documents.Paragraph();
+						paragraphs.push(para);
+						stack.length = 1;
+						stack[0] = para;
+						break;
+					}
+					case 'b':
+					case 'strong':
+						pushSpan(new Microsoft.UI.Xaml.Documents.Bold());
+						break;
+					case 'i':
+					case 'em':
+						pushSpan(new Microsoft.UI.Xaml.Documents.Italic());
+						break;
+					case 'u':
+						pushSpan(new Microsoft.UI.Xaml.Documents.Underline());
+						break;
+					case 'a': {
+						const link = new Microsoft.UI.Xaml.Documents.Hyperlink();
+						const href = (token as { kind: 'open'; tag: string; attrs: Record<string, string> }).attrs['href'];
+						if (href) {
+							try { link.NavigateUri = new Windows.Foundation.Uri(href); } catch (_) { }
+						}
+						if (linkColor) {
+							link.Foreground = new Microsoft.UI.Xaml.Media.SolidColorBrush(linkColor.windows);
+						}
+						pushSpan(link);
+						break;
+					}
+					case 'span':
+						pushSpan(new Microsoft.UI.Xaml.Documents.Span());
+						break;
+				}
+				break;
+			case 'close':
+				switch (token.tag) {
+					case 'p': {
+						para = new Microsoft.UI.Xaml.Documents.Paragraph();
+						paragraphs.push(para);
+						stack.length = 1;
+						stack[0] = para;
+						break;
+					}
+					case 'b':
+					case 'strong':
+					case 'i':
+					case 'em':
+					case 'u':
+					case 'a':
+					case 'span':
+						if (stack.length > 1) stack.pop();
+						break;
+				}
+				break;
+		}
+	}
+
+	const nonEmpty = paragraphs.filter(p => p.Inlines.Size > 0);
+	return nonEmpty.length > 0 ? nonEmpty : [paragraphs[0]];
+}
+
+export class HtmlView extends HtmlViewBase {
+	declare nativeViewProtected: Microsoft.UI.Xaml.Controls.RichTextBlock;
+
+	public createNativeView() {
+		const nativeView = new Microsoft.UI.Xaml.Controls.RichTextBlock();
+		nativeView.IsTextSelectionEnabled = true;
+		return nativeView;
+	}
+
+	get windows(): Microsoft.UI.Xaml.Controls.RichTextBlock {
+		return this.nativeViewProtected;
+	}
+
+	private _rebuildBlocks(): void {
+		const native = this.nativeViewProtected;
+		native.Blocks.Clear();
+		for (const p of buildParagraphs(this.html ?? '', this.linkColor)) {
+			native.Blocks.Append(p);
+		}
+	}
+
+	[htmlProperty.getDefault](): string {
+		return '';
+	}
+	[htmlProperty.setNative](_value: string) {
+		this._rebuildBlocks();
+	}
+
+	[selectableProperty.getDefault](): boolean {
+		return true;
+	}
+	[selectableProperty.setNative](value: boolean) {
+		this.nativeViewProtected.IsTextSelectionEnabled = value;
+	}
+
+	[colorProperty.getDefault](): Microsoft.UI.Xaml.Media.Brush {
+		return this.nativeViewProtected.Foreground;
+	}
+	[colorProperty.setNative](value: Color | Microsoft.UI.Xaml.Media.Brush) {
+		this.nativeViewProtected.Foreground = value instanceof Color
+			? new Microsoft.UI.Xaml.Media.SolidColorBrush(value.windows)
+			: value;
+	}
+
+	[linkColorProperty.setNative](_value: Color) {
+		this._rebuildBlocks();
+	}
+
+	[fontInternalProperty.setNative](value: any) {
+		const native = this.nativeViewProtected as any;
+		value?.applyWindowsFont?.(native);
+	}
+}
diff --git a/packages/core/ui/image-cache/index.windows.ts b/packages/core/ui/image-cache/index.windows.ts
new file mode 100644
index 0000000000..211c19ad57
--- /dev/null
+++ b/packages/core/ui/image-cache/index.windows.ts
@@ -0,0 +1,60 @@
+export * from './image-cache-common';
+
+import * as common from './image-cache-common';
+import { request as httpRequest } from '../../http/http-request';
+import { Trace } from '../../trace';
+
+export class Cache extends common.Cache {
+	private _cache = new Map<string, any>();
+
+	constructor() {
+		super();
+	}
+
+	public _downloadCore(request: common.DownloadRequest) {
+		httpRequest({ url: request.url, method: 'GET', responseType: 'arraybuffer' }).then(
+			(response) => {
+				try {
+					const raw = response.content?.raw;
+					const bytes = raw instanceof Uint8Array ? raw : raw instanceof ArrayBuffer ? new Uint8Array(raw) : null;
+					if (!bytes) {
+						this._onDownloadError(request.key, new Error('No data'));
+						return;
+					}
+
+					NSWinRT.toPromise(NativeScript.Widgets.ImageHelper.LoadFromBufferAsync(bytes as never)).then(
+						(bmp) => this._onDownloadCompleted(request.key, bmp),
+						(err) => this._onDownloadError(request.key, err)
+					);
+				} catch (err) {
+					this._onDownloadError(request.key, err);
+				}
+			},
+			(err) => {
+				this._onDownloadError(request.key, err);
+			}
+		);
+	}
+
+	public get(key: string): any {
+		return this._cache.get(key);
+	}
+
+	public set(key: string, image: any): void {
+		try {
+			if (key && image) {
+				this._cache.set(key, image);
+			}
+		} catch (err) {
+			Trace.write('Cache set error: ' + err, Trace.categories.Error, Trace.messageType.error);
+		}
+	}
+
+	public remove(key: string): void {
+		this._cache.delete(key);
+	}
+
+	public clear() {
+		this._cache.clear();
+	}
+}
diff --git a/packages/core/ui/image/index.windows.ts b/packages/core/ui/image/index.windows.ts
new file mode 100644
index 0000000000..b1b12aba38
--- /dev/null
+++ b/packages/core/ui/image/index.windows.ts
@@ -0,0 +1,150 @@
+export * from './image-common';
+
+import { ImageBase, stretchProperty, imageSourceProperty, srcProperty } from './image-common';
+import { ImageSource } from '../../image-source';
+import { ImageAsset } from '../../image-asset';
+import { Trace } from '../../trace';
+import { dispatchToMainThread, isMainThread } from '../../utils/mainthread-helper';
+
+const STRETCH_MAP: Record<string, number> = {
+	none: 0,         // Stretch.None
+	fill: 1,         // Stretch.Fill
+	aspectFit: 2,    // Stretch.Uniform
+	aspectFill: 3,   // Stretch.UniformToFill
+};
+
+function bitmapFromBytesAsync(bytes: Uint8Array): Promise<Microsoft.UI.Xaml.Media.Imaging.BitmapImage> {
+	return new Promise((resolve, reject) => {
+		const createOnUIThread = (stream: Windows.Storage.Streams.InMemoryRandomAccessStream) => {
+			const create = () => {
+				try {
+					stream.Seek(0);
+					const bmp = new Microsoft.UI.Xaml.Media.Imaging.BitmapImage();
+					NSWinRT.toPromise(bmp.SetSourceAsync(stream)).then(
+						() => resolve(bmp),
+						(err: any) => reject(err)
+					);
+				} catch (e) {
+					reject(e);
+				}
+			};
+			if (isMainThread()) {
+				create();
+			} else {
+				dispatchToMainThread(create);
+			}
+		};
+
+		try {
+			const writer = new Windows.Storage.Streams.DataWriter();
+			writer.WriteBytes(bytes as never);
+			const buffer = writer.DetachBuffer();
+			const stream = new Windows.Storage.Streams.InMemoryRandomAccessStream();
+			NSWinRT.toPromise(stream.WriteAsync(buffer)).then(
+				() => createOnUIThread(stream),
+				(err: any) => reject(err)
+			);
+		} catch (e) {
+			reject(e);
+		}
+	});
+}
+
+export class Image extends ImageBase {
+	nativeViewProtected: Microsoft.UI.Xaml.Controls.Image;
+	private _windows!: Microsoft.UI.Xaml.Controls.Image;
+
+	constructor() {
+		super();
+		this.isLoading = false;
+		// WinRT deferred to createNativeView() — keeps constructor pure-JS.
+	}
+
+	public createNativeView() {
+		this._windows = new Microsoft.UI.Xaml.Controls.Image();
+		return this._windows;
+	}
+
+	get windows(): Microsoft.UI.Xaml.Controls.Image {
+		return this._windows;
+	}
+
+	public disposeImageSource() {
+		if (this.nativeViewProtected?.Source === this.imageSource?.windows) {
+			this.nativeViewProtected.Source = null as never;
+		}
+		if (this.imageSource?.windows) {
+			this.imageSource.windows = null;
+		}
+		this.imageSource = null as never;
+	}
+
+	[imageSourceProperty.setNative](value: ImageSource) {
+		if (value !== this.imageSource) {
+			this.disposeImageSource();
+		}
+		this._setNativeImage(value ? value.windows : null);
+	}
+
+	[srcProperty.setNative](value: string | ImageSource | ImageAsset) {
+		this._createImageSourceFromSrc(value);
+	}
+
+	//@ts-ignore
+	[stretchProperty.setNative](value: string) {
+		if (this.nativeViewProtected) {
+			this.nativeViewProtected.Stretch = STRETCH_MAP[value] ?? 2;
+		}
+	}
+
+	public _setNativeImage(nativeImage: any) {
+		if (!this.nativeViewProtected) {
+			if (Trace.isEnabled()) {
+				Trace.write('Image._setNativeImage: nativeViewProtected missing', Trace.categories.Error);
+			}
+			return;
+		}
+
+		if (this.nativeViewProtected.Source) {
+			this.nativeViewProtected.Source = null as never;
+		}
+
+		if (!nativeImage) {
+			if (Trace.isEnabled()) {
+				Trace.write('Image._setNativeImage: nativeImage is null/undefined', Trace.categories.Debug);
+			}
+			return;
+		}
+
+		if (nativeImage instanceof ArrayBuffer || nativeImage instanceof Uint8Array) {
+			const bytes = nativeImage instanceof Uint8Array ? nativeImage : new Uint8Array(nativeImage);
+			bitmapFromBytesAsync(bytes)
+				.then((bmp: any) => {
+					if (this.nativeViewProtected) {
+						this.nativeViewProtected.Source = bmp;
+						if (Trace.isEnabled()) {
+							Trace.write(`Image._setNativeImage: set Source to BitmapImage (PixelWidth=${bmp?.PixelWidth ?? 'unknown'})`, Trace.categories.Debug);
+						}
+					}
+				})
+				.catch((err) => {
+					if (Trace.isEnabled()) {
+						Trace.write(`Image._setNativeImage: bitmapFromBytesAsync error: ${err}`, Trace.categories.Error);
+					}
+				});
+			return;
+		}
+
+
+		try {
+			this.nativeViewProtected.Source = nativeImage;
+			if (Trace.isEnabled()) {
+				Trace.write(`Image._setNativeImage: set Source to nativeImage (type=${typeof nativeImage}, PixelWidth=${nativeImage?.PixelWidth ?? 'n/a'})`, Trace.categories.Debug);
+			}
+		} catch (err) {
+			if (Trace.isEnabled()) {
+				Trace.write(`Image._setNativeImage: error setting Source: ${err}`, Trace.categories.Error);
+			}
+		}
+	}
+}
diff --git a/packages/core/ui/image/symbol-effects.windows.ts b/packages/core/ui/image/symbol-effects.windows.ts
new file mode 100644
index 0000000000..bd02f2736c
--- /dev/null
+++ b/packages/core/ui/image/symbol-effects.windows.ts
@@ -0,0 +1,8 @@
+import { ImageSymbolEffectCommon } from './symbol-effects-common';
+export { ImageSymbolEffects } from './symbol-effects-common';
+
+export class ImageSymbolEffect extends ImageSymbolEffectCommon {
+	static fromSymbol(symbol: string) {
+		return new ImageSymbolEffect();
+	}
+}
diff --git a/packages/core/ui/label/index.windows.ts b/packages/core/ui/label/index.windows.ts
new file mode 100644
index 0000000000..37339ef718
--- /dev/null
+++ b/packages/core/ui/label/index.windows.ts
@@ -0,0 +1,67 @@
+import { TextBase, maxLinesProperty, textOverflowProperty } from '../text-base';
+import { CSSType } from '../core/view';
+import { booleanConverter } from '../core/view-base';
+
+@CSSType('Label')
+export class Label extends TextBase {
+	// nativeViewProtected is the Border wrapper — carries Background, CornerRadius, and border via CompositionBorderHandler.
+	nativeViewProtected: Microsoft.UI.Xaml.Controls.Border;
+	private _border: Microsoft.UI.Xaml.Controls.Border;
+	private _textBlock: Microsoft.UI.Xaml.Controls.TextBlock;
+
+	constructor() {
+		super();
+		// WinRT objects deferred to createNativeView() so the XML-parse constructor is pure-JS.
+		// This eliminates wasted bridge calls for the orphaned page created by _resolvePageFromEntry
+		// on every cache-hit navigation (the orphaned page is GC'd without ever calling createNativeView).
+	}
+
+	public createNativeView(): Microsoft.UI.Xaml.Controls.Border {
+		this._textBlock = new Microsoft.UI.Xaml.Controls.TextBlock();
+		this._border = new Microsoft.UI.Xaml.Controls.Border();
+		(this._border as any).Child = this._textBlock;
+		return this._border;
+	}
+
+	get nativeTextViewProtected(): Microsoft.UI.Xaml.Controls.TextBlock {
+		return this._textBlock;
+	}
+
+	public initNativeView(): void {
+		super.initNativeView();
+		this._textBlock.VerticalAlignment = 1 as never;
+	}
+
+	get windows(): Microsoft.UI.Xaml.Controls.TextBlock {
+		return this._textBlock;
+	}
+
+	get textWrap(): boolean {
+		return this.style.whiteSpace === 'normal';
+	}
+
+	set textWrap(value: boolean) {
+		if (typeof value === 'string') {
+			value = booleanConverter(value as any);
+		}
+		this.style.whiteSpace = value ? 'normal' : 'nowrap';
+	}
+
+	// MaxLines: 0 = unlimited
+	//@ts-ignore
+	[maxLinesProperty.setNative](value: number) {
+		(this._textBlock as any).MaxLines = value <= 0 ? 0 : value;
+	}
+
+	// TextTrimming: None=0, CharacterEllipsis=1, WordEllipsis=2, Clip=3
+	//@ts-ignore
+	[textOverflowProperty.setNative](value: string) {
+		const nativeView = this._textBlock as any;
+		if (!nativeView) return;
+		switch (value) {
+			case 'ellipsis': nativeView.TextTrimming = 1; break; // CharacterEllipsis
+			case 'clip': nativeView.TextTrimming = 3; break;
+			default: nativeView.TextTrimming = 0; break; // None
+		}
+	}
+}
diff --git a/packages/core/ui/layouts/absolute-layout/index.windows.ts b/packages/core/ui/layouts/absolute-layout/index.windows.ts
new file mode 100644
index 0000000000..e601eb0945
--- /dev/null
+++ b/packages/core/ui/layouts/absolute-layout/index.windows.ts
@@ -0,0 +1,56 @@
+export * from './absolute-layout-common';
+
+import { AbsoluteLayoutBase, leftProperty, topProperty } from './absolute-layout-common';
+import { View } from '../../core/view';
+import { layout } from '../../../utils';
+
+// Canvas does NOT lay out its children — position comes entirely from Canvas.Left/Top attached properties.
+// (Previously this call was missing, causing all children to pile up at 0,0 and breaking the animation-curves demo.)
+// Prefer the static setter; fall back to SetValue(Canvas.*Property) if the runtime doesn't project it.
+function setCanvasAttachedProperty(prop: 'Left' | 'Top', native: any, value: number) {
+	try {
+		const Canvas = Microsoft.UI.Xaml.Controls.Canvas as any;
+		if (!Canvas || !native) {
+			return;
+		}
+		const setter = 'Set' + prop; // SetLeft / SetTop
+		if (typeof Canvas[setter] === 'function') {
+			Canvas[setter](native, value);
+			return;
+		}
+		const dp = Canvas[prop + 'Property']; // LeftProperty / TopProperty
+		if (dp && typeof native.SetValue === 'function') {
+			native.SetValue(dp, value);
+		}
+	} catch (_e) {}
+}
+
+(View.prototype as any)[leftProperty.setNative] = function (value: number) {
+	const native = (this as any).nativeViewProtected as any;
+	if (native) {
+		setCanvasAttachedProperty('Left', native, value);
+	}
+};
+
+(View.prototype as any)[topProperty.setNative] = function (value: number) {
+	const native = (this as any).nativeViewProtected as any;
+	if (native) {
+		setCanvasAttachedProperty('Top', native, value);
+	}
+};
+
+export class AbsoluteLayout extends AbsoluteLayoutBase {
+	nativeViewProtected: Microsoft.UI.Xaml.Controls.Canvas;
+	private _windows: Microsoft.UI.Xaml.Controls.Canvas;
+
+	constructor() {
+		super();
+		// WinRT deferred to createNativeView() — keeps constructor pure-JS.
+	}
+
+	public createNativeView() {
+		this._windows = new Microsoft.UI.Xaml.Controls.Canvas();
+		return this._windows;
+	}
+	
+}
diff --git a/packages/core/ui/layouts/dock-layout/index.windows.ts b/packages/core/ui/layouts/dock-layout/index.windows.ts
new file mode 100644
index 0000000000..9f3c51ff51
--- /dev/null
+++ b/packages/core/ui/layouts/dock-layout/index.windows.ts
@@ -0,0 +1,218 @@
+export * from './dock-layout-common';
+
+import { DockLayoutBase, stretchLastChildProperty } from './dock-layout-common';
+import { View } from '../../core/view';
+import type { CoreTypes } from '../../../core-types';
+
+export class DockLayout extends DockLayoutBase {
+	nativeViewProtected!: Microsoft.UI.Xaml.Controls.Canvas;
+	private _canvas!: Microsoft.UI.Xaml.Controls.Canvas;
+	private _layoutBusy = false;
+
+	constructor() {
+		super();
+		// WinRT deferred to createNativeView() — keeps constructor pure-JS.
+	}
+
+	public createNativeView(): Microsoft.UI.Xaml.Controls.Canvas {
+		this._canvas = new Microsoft.UI.Xaml.Controls.Canvas();
+		return this._canvas;
+	}
+
+	public initNativeView(): void {
+		super.initNativeView();
+		const canvas = this.nativeViewProtected as Microsoft.UI.Xaml.Controls.Canvas;
+		const ref = new WeakRef(this);
+		canvas.SizeChanged = NSWinRT.asDelegate('Microsoft.UI.Xaml.SizeChangedEventHandler', () => {
+			ref.deref()?._runDockLayout();
+		});
+	}
+
+	public disposeNativeView(): void {
+		const native = this.nativeViewProtected as Microsoft.UI.Xaml.Controls.Canvas;
+		if (native) {
+			native.SizeChanged = null;
+			native.LayoutUpdated = null;
+		}
+		super.disposeNativeView();
+	}
+
+	[stretchLastChildProperty.getDefault](): boolean {
+		return true;
+	}
+
+	[stretchLastChildProperty.setNative](value: boolean) {
+		this.stretchLastChild = value;
+		this._runDockLayout();
+	}
+
+	public onDockChanged(_view: View, _oldValue: CoreTypes.DockType, _newValue: CoreTypes.DockType) {
+		this._runDockLayout();
+	}
+
+	public _addViewToNativeVisualTree(child: View, atIndex: number = Number.MAX_SAFE_INTEGER): boolean {
+		super._addViewToNativeVisualTree(child, atIndex);
+		const nativeChild = child.nativeViewProtected as Microsoft.UI.Xaml.UIElement;
+		const children = this._canvas?.Children;
+		if (!nativeChild || !children) {
+			return false;
+		}
+		try {
+			const size: number = children.Size;
+			if (atIndex >= 0 && atIndex < size && atIndex < Number.MAX_SAFE_INTEGER) {
+				children.InsertAt(atIndex, nativeChild);
+			} else {
+				children.Append(nativeChild);
+			}
+			try { (nativeChild as any).__ns_view = child; } catch (_e) { }
+		} catch {
+			return false;
+		}
+		this._runDockLayout();
+		return true;
+	}
+
+	public _removeViewFromNativeVisualTree(child: View): void {
+		const nativeChild = child.nativeViewProtected as Microsoft.UI.Xaml.UIElement;
+		const children = this._canvas?.Children;
+		if (nativeChild && children) {
+			const count: number = children.Size ?? 0;
+			for (let i = 0; i < count; i++) {
+				try {
+					if (children.GetAt(i) === nativeChild) {
+						children.RemoveAt(i);
+						break;
+					}
+				} catch (_e) { }
+			}
+		}
+		super._removeViewFromNativeVisualTree(child);
+		this._runDockLayout();
+	}
+
+	// XAML Canvas has no native dock; children are measured and placed manually (same pattern as Wrap/Flex).
+	private _runDockLayout(): void {
+		if (this._layoutBusy) {
+			return;
+		}
+		const canvas = this.nativeViewProtected as Microsoft.UI.Xaml.Controls.Canvas;
+		if (!canvas) {
+			return;
+		}
+
+		const children = canvas.Children;
+		const count: number = children?.Size ?? 0;
+		if (count === 0) {
+			return;
+		}
+
+		const padLeft = (this.effectiveBorderLeftWidth || 0) + (this.effectivePaddingLeft || 0);
+		const padTop = (this.effectiveBorderTopWidth || 0) + (this.effectivePaddingTop || 0);
+		const padRight = (this.effectiveBorderRightWidth || 0) + (this.effectivePaddingRight || 0);
+		const padBottom = (this.effectiveBorderBottomWidth || 0) + (this.effectivePaddingBottom || 0);
+
+		const availW = Math.max(0, ((canvas.ActualWidth as number) || 0) - padLeft - padRight);
+		const availH = Math.max(0, ((canvas.ActualHeight as number) || 0) - padTop - padBottom);
+
+		this._layoutBusy = true;
+		try {
+			let remainingW = availW;
+			let remainingH = availH;
+			let x = padLeft;
+			let y = padTop;
+
+			const visibleIndices: number[] = [];
+			for (let i = 0; i < count; i++) {
+				const nc = children.GetAt(i) as Microsoft.UI.Xaml.FrameworkElement;
+				if (nc.Visibility !== Microsoft.UI.Xaml.Visibility.Collapsed) {
+					visibleIndices.push(i);
+				}
+			}
+
+			for (let vi = 0; vi < visibleIndices.length; vi++) {
+				const i = visibleIndices[vi];
+				const nc = children.GetAt(i) as Microsoft.UI.Xaml.FrameworkElement;
+				const childView = (nc as any).__ns_view as View;
+				const dock = childView ? DockLayout.getDock(childView) : 'left';
+				const stretch = this.stretchLastChild && vi === visibleIndices.length - 1;
+
+				let childW = 0;
+				let childH = 0;
+
+				if (stretch) {
+					childW = remainingW;
+					childH = remainingH;
+				} else {
+					let measureW = remainingW > 0 ? remainingW : Number.POSITIVE_INFINITY;
+					let measureH = remainingH > 0 ? remainingH : Number.POSITIVE_INFINITY;
+					if (dock === 'top' || dock === 'bottom') {
+						measureW = availW > 0 ? availW : Number.POSITIVE_INFINITY;
+					} else {
+						measureH = availH > 0 ? availH : Number.POSITIVE_INFINITY;
+					}
+					try {
+						nc.Measure(Microsoft.UI.Xaml.SizeHelper.FromDimensions(measureW, measureH));
+						const d = nc.DesiredSize;
+						childW = d.Width;
+						childH = d.Height;
+					} catch (_e) {
+						childW = 0;
+						childH = 0;
+					}
+				}
+
+				let left = x;
+				let top = y;
+				let width = childW;
+				let height = childH;
+
+				switch (dock) {
+					case 'top':
+						width = availW;
+						left = padLeft;
+						top = y;
+						y += childH;
+						remainingH = Math.max(0, remainingH - childH);
+						break;
+					case 'bottom':
+						width = availW;
+						left = padLeft;
+						top = padTop + remainingH - childH;
+						remainingH = Math.max(0, remainingH - childH);
+						break;
+					case 'right':
+						height = availH;
+						left = padLeft + remainingW - childW;
+						top = padTop;
+						remainingW = Math.max(0, remainingW - childW);
+						break;
+					case 'left':
+					default:
+						height = availH;
+						left = x;
+						top = padTop;
+						x += childW;
+						remainingW = Math.max(0, remainingW - childW);
+						break;
+				}
+
+				try {
+					Microsoft.UI.Xaml.Controls.Canvas.SetLeft(nc, left);
+					Microsoft.UI.Xaml.Controls.Canvas.SetTop(nc, top);
+					if (width > 0) {
+						nc.Width = width;
+					}
+					if (height > 0) {
+						nc.Height = height;
+					}
+				} catch (_e) { }
+
+				if (stretch) {
+					break;
+				}
+			}
+		} finally {
+			this._layoutBusy = false;
+		}
+	}
+}
diff --git a/packages/core/ui/layouts/flexbox-layout/flexbox-layout-common.ts b/packages/core/ui/layouts/flexbox-layout/flexbox-layout-common.ts
index 95ff911420..faa30c7c4c 100644
--- a/packages/core/ui/layouts/flexbox-layout/flexbox-layout-common.ts
+++ b/packages/core/ui/layouts/flexbox-layout/flexbox-layout-common.ts
@@ -31,15 +31,16 @@ export namespace FlexWrap {
 	export const parse = makeParser<FlexWrap>(isValid);
 }
 
-export type JustifyContent = 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around';
+export type JustifyContent = 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'space-evenly';
 export namespace JustifyContent {
 	export const FLEX_START = 'flex-start' as const;
 	export const FLEX_END = 'flex-end' as const;
 	export const CENTER = 'center' as const;
 	export const SPACE_BETWEEN = 'space-between';
 	export const SPACE_AROUND = 'space-around';
+	export const SPACE_EVENLY = 'space-evenly';
 
-	export const isValid = makeValidator<JustifyContent>(FLEX_START, FLEX_END, CENTER, SPACE_BETWEEN, SPACE_AROUND);
+	export const isValid = makeValidator<JustifyContent>(FLEX_START, FLEX_END, CENTER, SPACE_BETWEEN, SPACE_AROUND, SPACE_EVENLY);
 	export const parse = makeParser<JustifyContent>(isValid);
 }
 
@@ -60,7 +61,7 @@ export namespace AlignItems {
 	export const parse = makeParser<AlignItems>(isValid);
 }
 
-export type AlignContent = 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'stretch';
+export type AlignContent = 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'stretch' | 'space-evenly';
 export namespace AlignContent {
 	export const FLEX_START = 'flex-start';
 	export const FLEX_END = 'flex-end';
@@ -68,8 +69,9 @@ export namespace AlignContent {
 	export const SPACE_BETWEEN = 'space-between';
 	export const SPACE_AROUND = 'space-around';
 	export const STRETCH = 'stretch';
+	export const SPACE_EVENLY = 'space-evenly';
 
-	export const isValid = makeValidator<AlignContent>(FLEX_START, FLEX_END, CENTER, SPACE_BETWEEN, SPACE_AROUND, STRETCH);
+	export const isValid = makeValidator<AlignContent>(FLEX_START, FLEX_END, CENTER, SPACE_BETWEEN, SPACE_AROUND, STRETCH, SPACE_EVENLY);
 	export const parse = makeParser<AlignContent>(isValid);
 }
 
@@ -181,6 +183,28 @@ export abstract class FlexboxLayoutBase extends LayoutBase {
 		this.style.alignContent = value;
 	}
 
+	get columnGap(): number {
+		return (this.style as any).columnGap ?? 0;
+	}
+	set columnGap(value: number) {
+		(this.style as any).columnGap = value;
+	}
+
+	get rowGap(): number {
+		return (this.style as any).rowGap ?? 0;
+	}
+	set rowGap(value: number) {
+		(this.style as any).rowGap = value;
+	}
+
+	get gap(): number {
+		return this.columnGap;
+	}
+	set gap(value: number) {
+		this.columnGap = value;
+		this.rowGap = value;
+	}
+
 	public static setOrder(view: View, order: number) {
 		validateArgs(view).style.order = order;
 	}
@@ -354,6 +378,58 @@ Object.defineProperty(View.prototype, 'alignSelf', {
 	configurable: true,
 });
 
+export type FlexGapValue = number;
+export namespace FlexGapValue {
+	export function isValid(value: any): boolean {
+		return isFinite(parseFloat(value)) && parseFloat(value) >= 0;
+	}
+	export const parse = parseFloat;
+}
+
+export const columnGapProperty = new CssProperty<Style, number>({
+	name: 'columnGap',
+	cssName: 'column-gap',
+	defaultValue: 0,
+	valueConverter: FlexGapValue.parse,
+});
+columnGapProperty.register(Style);
+
+export const rowGapProperty = new CssProperty<Style, number>({
+	name: 'rowGap',
+	cssName: 'row-gap',
+	defaultValue: 0,
+	valueConverter: FlexGapValue.parse,
+});
+rowGapProperty.register(Style);
+
+// gap: <row-gap> [<column-gap>]  — shorthand
+const gapProperty = new ShorthandProperty<Style, string>({
+	name: 'gap',
+	cssName: 'gap',
+	getter: function (this: Style) {
+		return `${(this as any).rowGap} ${(this as any).columnGap}`;
+	},
+	converter: function (value: string) {
+		const properties: [CssProperty<any, any>, any][] = [];
+		if (value === unsetValue) {
+			properties.push([rowGapProperty, value]);
+			properties.push([columnGapProperty, value]);
+		} else {
+			const parts = (value || '').trim().split(/\s+/);
+			const row = parseFloat(parts[0]);
+			if (isFinite(row) && row >= 0) {
+				properties.push([rowGapProperty, row]);
+				const col = parts.length >= 2 ? parseFloat(parts[1]) : row;
+				if (isFinite(col) && col >= 0) {
+					properties.push([columnGapProperty, col]);
+				}
+			}
+		}
+		return properties;
+	},
+});
+gapProperty.register(Style);
+
 // flex-flow: <flex-direction> || <flex-wrap>
 const flexFlowProperty = new ShorthandProperty<Style, string>({
 	name: 'flexFlow',
diff --git a/packages/core/ui/layouts/flexbox-layout/index.windows.ts b/packages/core/ui/layouts/flexbox-layout/index.windows.ts
new file mode 100644
index 0000000000..1156cbbcd6
--- /dev/null
+++ b/packages/core/ui/layouts/flexbox-layout/index.windows.ts
@@ -0,0 +1,204 @@
+export * from './flexbox-layout-common';
+
+import {
+    FlexboxLayoutBase,
+    FlexDirection, FlexWrap, JustifyContent, AlignItems, AlignContent, AlignSelf,
+    flexDirectionProperty, flexWrapProperty, justifyContentProperty,
+    alignItemsProperty, alignContentProperty,
+    orderProperty, Order,
+    flexGrowProperty, FlexGrow,
+    flexShrinkProperty, FlexShrink,
+    flexWrapBeforeProperty, FlexWrapBefore,
+    alignSelfProperty,
+    columnGapProperty, rowGapProperty,
+} from './flexbox-layout-common';
+import { View } from '../../core/view';
+import { CoreTypes } from '../../../core-types';
+
+type WidgetFlexboxLayout = NativeScript.Widgets.FlexboxLayout;
+
+const flexDirectionMap: Record<FlexDirection, number> = {
+    [FlexDirection.ROW]: 0,
+    [FlexDirection.ROW_REVERSE]: 1,
+    [FlexDirection.COLUMN]: 2,
+    [FlexDirection.COLUMN_REVERSE]: 3,
+};
+
+const flexWrapMap: Record<FlexWrap, number> = {
+    [FlexWrap.NOWRAP]: 0,
+    [FlexWrap.WRAP]: 1,
+    [FlexWrap.WRAP_REVERSE]: 2,
+};
+
+const justifyContentMap: Record<JustifyContent, number> = {
+    [JustifyContent.FLEX_START]: 0,
+    [JustifyContent.FLEX_END]: 1,
+    [JustifyContent.CENTER]: 2,
+    [JustifyContent.SPACE_BETWEEN]: 3,
+    [JustifyContent.SPACE_AROUND]: 4,
+    [JustifyContent.SPACE_EVENLY]: 5,
+};
+
+const alignItemsMap: Record<AlignItems, number> = {
+    [AlignItems.FLEX_START]: 0,
+    [AlignItems.FLEX_END]: 1,
+    [AlignItems.CENTER]: 2,
+    [AlignItems.BASELINE]: 3,
+    [AlignItems.STRETCH]: 4,
+};
+
+const alignContentMap: Record<AlignContent, number> = {
+    [AlignContent.FLEX_START]: 0,
+    [AlignContent.FLEX_END]: 1,
+    [AlignContent.CENTER]: 2,
+    [AlignContent.SPACE_BETWEEN]: 3,
+    [AlignContent.SPACE_AROUND]: 4,
+    [AlignContent.STRETCH]: 5,
+    [AlignContent.SPACE_EVENLY]: 6,
+};
+
+const alignSelfMap: Record<AlignSelf, number> = {
+    [AlignSelf.AUTO]: -1,
+    [AlignSelf.FLEX_START]: 0,
+    [AlignSelf.FLEX_END]: 1,
+    [AlignSelf.CENTER]: 2,
+    [AlignSelf.BASELINE]: 3,
+    [AlignSelf.STRETCH]: 4,
+};
+
+const FlexboxWidget = NativeScript.Widgets.FlexboxLayout;
+
+function makeNativeSetter<T>(setter: (native: Microsoft.UI.Xaml.UIElement, value: T) => void) {
+    return function (this: View, value: T) {
+        const nativeView = this.nativeViewProtected as Microsoft.UI.Xaml.UIElement;
+        if (nativeView) {
+            setter(nativeView, value);
+        }
+    };
+}
+
+(View.prototype as any)[orderProperty.setNative] = makeNativeSetter<Order>((native, value) => {
+    FlexboxWidget.SetOrder(native, value);
+});
+(View.prototype as any)[flexGrowProperty.setNative] = makeNativeSetter<FlexGrow>((native, value) => {
+    FlexboxWidget.SetFlexGrow(native, value);
+});
+(View.prototype as any)[flexShrinkProperty.setNative] = makeNativeSetter<FlexShrink>((native, value) => {
+    FlexboxWidget.SetFlexShrink(native, value);
+});
+(View.prototype as any)[flexWrapBeforeProperty.setNative] = makeNativeSetter<FlexWrapBefore>((native, value) => {
+    FlexboxWidget.SetWrapBefore(native, value);
+});
+(View.prototype as any)[alignSelfProperty.setNative] = makeNativeSetter<AlignSelf>((native, value) => {
+    FlexboxWidget.SetAlignSelf(native, alignSelfMap[value]);
+});
+
+export class FlexboxLayout extends FlexboxLayoutBase {
+    nativeViewProtected!: WidgetFlexboxLayout;
+
+    public createNativeView(): WidgetFlexboxLayout {
+        return new FlexboxWidget() as WidgetFlexboxLayout;
+    }
+
+    public onLoaded(): void {
+        super.onLoaded();
+        // Re-invalidate after entering the visual tree so the C++ MeasureOverride runs
+        // with the actual available size rather than the provisional zero-size pass that
+        // happens while the native view is still detached from _pageHost.
+        try { (this.nativeViewProtected as any)?.InvalidateMeasure(); } catch (_e) {}
+    }
+
+    [flexDirectionProperty.getDefault](): FlexDirection {
+        return flexDirectionProperty.defaultValue;
+    }
+    [flexDirectionProperty.setNative](flexDirection: FlexDirection) {
+        this.nativeViewProtected.FlexDirection = flexDirectionMap[flexDirection];
+        try { (this.nativeViewProtected as any).InvalidateMeasure(); } catch (_e) {}
+    }
+
+    [flexWrapProperty.getDefault](): FlexWrap {
+        return flexWrapProperty.defaultValue;
+    }
+    [flexWrapProperty.setNative](flexWrap: FlexWrap) {
+        this.nativeViewProtected.FlexWrap = flexWrapMap[flexWrap];
+        try { (this.nativeViewProtected as any).InvalidateMeasure(); } catch (_e) {}
+    }
+
+    [justifyContentProperty.getDefault](): JustifyContent {
+        return justifyContentProperty.defaultValue;
+    }
+    [justifyContentProperty.setNative](justifyContent: JustifyContent) {
+        this.nativeViewProtected.JustifyContent = justifyContentMap[justifyContent];
+        try { (this.nativeViewProtected as any).InvalidateMeasure(); } catch (_e) {}
+    }
+
+    [alignItemsProperty.getDefault](): AlignItems {
+        return alignItemsProperty.defaultValue;
+    }
+    [alignItemsProperty.setNative](alignItems: AlignItems) {
+        this.nativeViewProtected.AlignItems = alignItemsMap[alignItems];
+        try { (this.nativeViewProtected as any).InvalidateMeasure(); } catch (_e) {}
+    }
+
+    [alignContentProperty.getDefault](): AlignContent {
+        return alignContentProperty.defaultValue;
+    }
+    [alignContentProperty.setNative](alignContent: AlignContent) {
+        this.nativeViewProtected.AlignContent = alignContentMap[alignContent];
+        try { (this.nativeViewProtected as any).InvalidateMeasure(); } catch (_e) {}
+    }
+
+    [columnGapProperty.getDefault](): number {
+        return 0;
+    }
+    [columnGapProperty.setNative](value: number) {
+        this.nativeViewProtected.ColumnGap = isNaN(value) || value < 0 ? 0 : value;
+        try { (this.nativeViewProtected as any).InvalidateMeasure(); } catch (_e) {}
+    }
+
+    [rowGapProperty.getDefault](): number {
+        return 0;
+    }
+    [rowGapProperty.setNative](value: number) {
+        this.nativeViewProtected.RowGap = isNaN(value) || value < 0 ? 0 : value;
+        try { (this.nativeViewProtected as any).InvalidateMeasure(); } catch (_e) {}
+    }
+
+    public _updateNativeLayoutParams(child: View): void {
+        super._updateNativeLayoutParams(child);
+
+        this._setChildMinWidthNative(child, child.minWidth);
+        this._setChildMinHeightNative(child, child.minHeight);
+
+        const nativeView = child.nativeViewProtected as Microsoft.UI.Xaml.UIElement;
+        if (!nativeView) {
+            return;
+        }
+
+        const style = child.style;
+        FlexboxWidget.SetOrder(nativeView, style.order);
+        FlexboxWidget.SetFlexGrow(nativeView, style.flexGrow);
+        FlexboxWidget.SetFlexShrink(nativeView, style.flexShrink);
+        FlexboxWidget.SetWrapBefore(nativeView, style.flexWrapBefore);
+        FlexboxWidget.SetAlignSelf(nativeView, alignSelfMap[style.alignSelf]);
+
+        // Sync flex-basis-percent so MeasureOverride sets item.MainSize = container * pct.
+        // widthProperty.setNative also does this on every CSS update, so this covers the case
+        // where the child is pre-styled before being added to the layout.
+        const w = style.width as any;
+        if (w && typeof w === 'object' && w.unit === '%' && w.value > 0) {
+            FlexboxWidget.SetFlexBasisPercent(nativeView, w.value * 100);
+        } else {
+            FlexboxWidget.SetFlexBasisPercent(nativeView, -1);
+        }
+    }
+
+    public _setChildMinWidthNative(_child: View, _value: CoreTypes.LengthType): void {
+        // No-op: the C++ FlexboxLayout panel respects FrameworkElement.MinWidth, which is already
+        // set by minWidthProperty.setNative. _setMinWidthNative is not implemented on Windows.
+    }
+
+    public _setChildMinHeightNative(_child: View, _value: CoreTypes.LengthType): void {
+        // No-op: same reason as _setChildMinWidthNative above.
+    }
+}
diff --git a/packages/core/ui/layouts/grid-layout/index.windows.ts b/packages/core/ui/layouts/grid-layout/index.windows.ts
new file mode 100644
index 0000000000..d2ae40a0fb
--- /dev/null
+++ b/packages/core/ui/layouts/grid-layout/index.windows.ts
@@ -0,0 +1,150 @@
+export * from './grid-layout-common';
+
+import { GridLayoutBase, ItemSpec as ItemSpecBase, rowProperty, columnProperty, rowSpanProperty, columnSpanProperty, GridUnitType } from './grid-layout-common';
+import { View } from '../../core/view';
+import { layout } from '../../../utils';
+
+(View.prototype as any)[rowProperty.setNative] = function (value: number) {
+    const native = this.nativeViewProtected as Microsoft.UI.Xaml.FrameworkElement;
+    if (native) {
+        Microsoft.UI.Xaml.Controls.Grid.SetRow(native, value);
+    }
+};
+
+(View.prototype as any)[columnProperty.setNative] = function (value: number) {
+    const native = this.nativeViewProtected as Microsoft.UI.Xaml.FrameworkElement;
+    if (native) {
+        Microsoft.UI.Xaml.Controls.Grid.SetColumn(native, value);
+    }
+};
+
+(View.prototype as any)[rowSpanProperty.setNative] = function (value: number) {
+    const native = this.nativeViewProtected as Microsoft.UI.Xaml.FrameworkElement;
+    if (native) {
+        Microsoft.UI.Xaml.Controls.Grid.SetRowSpan(native, value);
+    }
+};
+
+(View.prototype as any)[columnSpanProperty.setNative] = function (value: number) {
+    const native = this.nativeViewProtected as Microsoft.UI.Xaml.FrameworkElement;
+    if (native) {
+        Microsoft.UI.Xaml.Controls.Grid.SetColumnSpan(native, value);
+    }
+};
+
+export class GridLayout extends GridLayoutBase {
+    nativeViewProtected: Microsoft.UI.Xaml.Controls.Grid;
+    private _windows: Microsoft.UI.Xaml.Controls.Grid;
+
+    constructor() {
+        super();
+        // WinRT deferred to createNativeView() — keeps constructor pure-JS.
+    }
+
+    public createNativeView() {
+        this._windows = new Microsoft.UI.Xaml.Controls.Grid();
+        return this._windows;
+    }
+
+    public initNativeView(): void {
+        super.initNativeView && super.initNativeView();
+        this._updateRowAndColumnDefinitions();
+    }
+
+    public resetNativeView(): void {
+        if (this._windows) {
+            this._windows.RowDefinitions.Clear();
+            this._windows.ColumnDefinitions.Clear();
+        }
+        super.resetNativeView && super.resetNativeView();
+    }
+
+    // GridLength is a plain value struct {Value: f64, GridUnitType: i32} in WinRT ABI.
+    // Pass as a plain JS object via the bridge's append_struct_object_bytes path — same
+    // technique as Windows.UI.Color / Thickness. Skips the GridLengthHelper static WinRT
+    // call that was previously required (constructing GridLength via `new` silently fails).
+    // WinUI GridUnitType enum: Auto=0, Pixel=1, Star=2.
+    private _toGridLength(itemSpec: ItemSpecBase): Microsoft.UI.Xaml.GridLength {
+        if (itemSpec.gridUnitType === GridUnitType.AUTO) {
+            return { Value: 1, GridUnitType: 0 } as any;
+        } else if (itemSpec.gridUnitType === GridUnitType.STAR) {
+            return { Value: itemSpec.value || 1, GridUnitType: 2 } as any;
+        }
+        return { Value: layout.toDeviceIndependentPixels(itemSpec.value), GridUnitType: 1 } as any;
+    }
+
+    private _createRowDefinition(itemSpec: ItemSpecBase): Microsoft.UI.Xaml.Controls.RowDefinition {
+        const rd = new Microsoft.UI.Xaml.Controls.RowDefinition();
+        rd.Height = this._toGridLength(itemSpec);
+        return rd;
+    }
+
+    private _createColumnDefinition(itemSpec: ItemSpecBase): Microsoft.UI.Xaml.Controls.ColumnDefinition {
+        const cd = new Microsoft.UI.Xaml.Controls.ColumnDefinition();
+        cd.Width = this._toGridLength(itemSpec);
+        return cd;
+    }
+
+    private _updateRowAndColumnDefinitions(): void {
+        const native = this._windows;
+        if (!native) return;
+
+        const rowDefs: Microsoft.UI.Xaml.Controls.RowDefinition[] = [];
+        for (let i = 0; i < this.rowsInternal.length; i++) {
+            rowDefs.push(this._createRowDefinition(this.rowsInternal[i]));
+        }
+        // ReplaceAll crosses the WinRT IVector bridge and can throw on some
+        // projections; fall back to Clear + per-item Append when it does.
+        try {
+            native.RowDefinitions.ReplaceAll(rowDefs);
+        } catch (_e) {
+            native.RowDefinitions.Clear();
+            for (const rd of rowDefs) {
+                native.RowDefinitions.Append(rd);
+            }
+        }
+
+        const colDefs: Microsoft.UI.Xaml.Controls.ColumnDefinition[] = [];
+        for (let i = 0; i < this.columnsInternal.length; i++) {
+            colDefs.push(this._createColumnDefinition(this.columnsInternal[i]));
+        }
+        try {
+            native.ColumnDefinitions.ReplaceAll(colDefs);
+        } catch (_e) {
+            native.ColumnDefinitions.Clear();
+            for (const cd of colDefs) {
+                native.ColumnDefinitions.Append(cd);
+            }
+        }
+    }
+
+    public _onRowAdded(itemSpec: ItemSpecBase) {
+        this._updateRowAndColumnDefinitions();
+    }
+
+    public _onColumnAdded(itemSpec: ItemSpecBase) {
+        this._updateRowAndColumnDefinitions();
+    }
+
+    public _onRowRemoved(itemSpec: ItemSpecBase, index: number) {
+        this._updateRowAndColumnDefinitions();
+    }
+
+    public _onColumnRemoved(itemSpec: ItemSpecBase, index: number) {
+        this._updateRowAndColumnDefinitions();
+    }
+
+    public _addViewToNativeVisualTree(child: View, atIndex: number = Number.MAX_SAFE_INTEGER): boolean {
+        const res = super._addViewToNativeVisualTree(child, atIndex);
+
+        const nativeChild = child.nativeViewProtected as Microsoft.UI.Xaml.FrameworkElement;
+        if (res && nativeChild && this._windows) {
+            Microsoft.UI.Xaml.Controls.Grid.SetRow(nativeChild, GridLayout.getRow(child));
+            Microsoft.UI.Xaml.Controls.Grid.SetColumn(nativeChild, GridLayout.getColumn(child));
+            Microsoft.UI.Xaml.Controls.Grid.SetRowSpan(nativeChild, GridLayout.getRowSpan(child));
+            Microsoft.UI.Xaml.Controls.Grid.SetColumnSpan(nativeChild, GridLayout.getColumnSpan(child));
+        }
+
+        return res;
+    }
+}
diff --git a/packages/core/ui/layouts/layout-base.windows.ts b/packages/core/ui/layouts/layout-base.windows.ts
new file mode 100644
index 0000000000..16ff18c7d2
--- /dev/null
+++ b/packages/core/ui/layouts/layout-base.windows.ts
@@ -0,0 +1,5 @@
+import { LayoutBaseCommon } from './layout-base-common';
+
+export * from './layout-base-common';
+
+export class LayoutBase extends LayoutBaseCommon {}
diff --git a/packages/core/ui/layouts/liquid-glass-container/index.windows.ts b/packages/core/ui/layouts/liquid-glass-container/index.windows.ts
new file mode 100644
index 0000000000..66dc25d279
--- /dev/null
+++ b/packages/core/ui/layouts/liquid-glass-container/index.windows.ts
@@ -0,0 +1,5 @@
+export * from './liquid-glass-container-common';
+
+import { LiquidGlassContainerCommon } from './liquid-glass-container-common';
+
+export class LiquidGlassContainer extends LiquidGlassContainerCommon {}
diff --git a/packages/core/ui/layouts/liquid-glass/index.windows.ts b/packages/core/ui/layouts/liquid-glass/index.windows.ts
new file mode 100644
index 0000000000..bdb74c3651
--- /dev/null
+++ b/packages/core/ui/layouts/liquid-glass/index.windows.ts
@@ -0,0 +1,5 @@
+export * from './liquid-glass-common';
+
+import { LiquidGlassCommon } from './liquid-glass-common';
+
+export class LiquidGlass extends LiquidGlassCommon {}
diff --git a/packages/core/ui/layouts/root-layout/index.windows.ts b/packages/core/ui/layouts/root-layout/index.windows.ts
new file mode 100644
index 0000000000..7c1d4cfe3a
--- /dev/null
+++ b/packages/core/ui/layouts/root-layout/index.windows.ts
@@ -0,0 +1,134 @@
+export * from './root-layout-common';
+
+import { Color } from '../../../color';
+import { View } from '../../core/view';
+import { RootLayoutBase, defaultShadeCoverOptions } from './root-layout-common';
+import { TransitionAnimation, ShadeCoverOptions } from '.';
+import { parseLinearGradient } from '../../../css/parser';
+import { LinearGradient } from '../../styling/linear-gradient';
+import { layout } from '../../../utils';
+
+export class RootLayout extends RootLayoutBase {
+	insertChild(view: View, atIndex: number): boolean {
+		return super.insertChild(view, atIndex);
+	}
+
+	removeChild(view: View): void {
+		super.removeChild(view);
+	}
+
+	protected _bringToFront(view: View) {
+		try {
+			const native = view.nativeViewProtected as any;
+			const parentNative = this.nativeViewProtected as any;
+			if (!native || !parentNative || !parentNative.Children) {
+				return;
+			}
+
+			let maxZ = Number.MIN_SAFE_INTEGER;
+			const children = parentNative.Children;
+			for (let i = 0; i < children.Size; i++) {
+				try {
+					const child = children.GetAt(i);
+					const z = Microsoft.UI.Xaml.Controls.Panel.GetZIndex(child) || 0;
+					if (z > maxZ) maxZ = z;
+				} catch (_e) { }
+			}
+
+			const newZ = (maxZ === Number.MIN_SAFE_INTEGER) ? 0 : (maxZ + 1);
+			try {
+				Microsoft.UI.Xaml.Controls.Panel.SetZIndex(native, newZ);
+			} catch (_e) { }
+		} catch (_e) { }
+	}
+
+	protected _initShadeCover(view: View, shadeOptions: ShadeCoverOptions): void {
+		const options: TransitionAnimation = {
+			...defaultShadeCoverOptions.animation.enterFrom,
+			...(shadeOptions && shadeOptions.animation && shadeOptions.animation.enterFrom ? shadeOptions.animation.enterFrom : {}),
+		} as TransitionAnimation;
+
+		try {
+			const native = view.nativeViewProtected as any;
+			if (!native) return;
+
+			// The shared base sets verticalAlignment='bottom', so on Windows the shade cover shrinks to
+			// its (empty) content and the backdrop is invisible. Force Stretch so it actually covers the layout.
+			try { view.horizontalAlignment = 'stretch'; } catch (_e) { }
+			try { view.verticalAlignment = 'stretch'; } catch (_e) { }
+			try { native.HorizontalAlignment = 3; native.VerticalAlignment = 3; } catch (_e) { } // Stretch
+
+			try { native.Opacity = options.opacity; } catch (_e) { }
+
+			try {
+				const ct = new Microsoft.UI.Xaml.Media.CompositeTransform();
+				ct.TranslateX = layout.toDeviceIndependentPixels(options.translateX);
+				ct.TranslateY = layout.toDeviceIndependentPixels(options.translateY);
+				ct.ScaleX = options.scaleX;
+				ct.ScaleY = options.scaleY;
+				ct.Rotation = options.rotate;
+				native.RenderTransform = ct;
+				native.RenderTransformOrigin = Microsoft.UI.Xaml.PointHelper.FromCoordinates(0.5, 0.5);
+			} catch (_e) { }
+		} catch (_e) { }
+	}
+
+	protected _updateShadeCover(view: View, shadeOptions: ShadeCoverOptions = {}): Promise<void> {
+		const options = {
+			...defaultShadeCoverOptions,
+			...(shadeOptions || {}),
+		} as ShadeCoverOptions;
+
+		const isBackgroundGradient = typeof options.color === 'string' && options.color.indexOf('linear-gradient') === 0;
+
+		if (isBackgroundGradient) {
+			try {
+				if (view.backgroundColor) {
+					view.backgroundColor = undefined;
+				}
+				const parsed = parseLinearGradient(options.color as string);
+				view.backgroundImage = LinearGradient.parse(parsed.value);
+			} catch (_e) { }
+		} else {
+			try {
+				if (view.backgroundImage) {
+					view.backgroundImage = undefined;
+				}
+				if (options.color) {
+					view.backgroundColor = (options.color instanceof Color) ? (options.color as Color) : new Color(options.color as any);
+				}
+			} catch (_e) { }
+		}
+
+		// getEnterAnimation animates opacity to 1 (fully opaque), but the intended shade is semi-transparent
+		// (e.g. 0.7) to let page content show through — match iOS by applying targetOpacity as the final state.
+		// Pre-set before play() so a freshly-mounted element doesn't flash opaque.
+		const targetOpacity = typeof options.opacity === 'number' ? options.opacity : 0.5;
+		const enterFrom = options.animation && options.animation.enterFrom ? options.animation.enterFrom : defaultShadeCoverOptions.animation.enterFrom;
+		try { view.opacity = targetOpacity; } catch (_e) { }
+		return this.getEnterAnimation(view as View, enterFrom).play().then(() => {
+			try { view.opacity = targetOpacity; } catch (_e) { }
+		});
+	}
+
+	protected _closeShadeCover(view: View, shadeOptions: ShadeCoverOptions = {}): Promise<void> {
+		const exitState: TransitionAnimation = {
+			...defaultShadeCoverOptions.animation.exitTo,
+			...(shadeOptions && shadeOptions.animation && shadeOptions.animation.exitTo ? shadeOptions.animation.exitTo : {}),
+		} as TransitionAnimation;
+		return this.getExitAnimation(view as View, exitState).play();
+	}
+
+	protected _cleanupPlatformShadeCover(): void {
+		try {
+			if (!this._shadeCover) return;
+			const native = (this._shadeCover as any).nativeViewProtected as any;
+			if (native) {
+				try { native.RenderTransform = null; } catch (_e) { }
+				try { native.Opacity = 1; } catch (_e) { }
+			}
+			try { this._shadeCover.backgroundImage = undefined; } catch (_e) { }
+			try { this._shadeCover.backgroundColor = undefined as any; } catch (_e) { }
+		} catch (_e) { }
+	}
+}
diff --git a/packages/core/ui/layouts/stack-layout/index.windows.ts b/packages/core/ui/layouts/stack-layout/index.windows.ts
new file mode 100644
index 0000000000..d782d15446
--- /dev/null
+++ b/packages/core/ui/layouts/stack-layout/index.windows.ts
@@ -0,0 +1,71 @@
+export * from './stack-layout-common';
+
+import { StackLayoutBase, orientationProperty } from './stack-layout-common';
+import type { ViewCommon } from '../../core/view/view-common';
+
+export class StackLayout extends StackLayoutBase {
+    // Border wrapper carries Padding; the inner NativeScript.Widgets.StackLayout (C++/WinRT, no DotNetBridge)
+    // does the actual measure/arrange. The Border can be dropped once the native panel handles padding.
+    nativeViewProtected!: Microsoft.UI.Xaml.Controls.Border;
+    private _border!: Microsoft.UI.Xaml.Controls.Border;
+    private _panel!: NativeScript.Widgets.StackLayout;
+
+    constructor() {
+        super();
+        // WinRT deferred to createNativeView() — keeps constructor pure-JS.
+    }
+
+    public createNativeView(): Microsoft.UI.Xaml.Controls.Border {
+        this._border = new Microsoft.UI.Xaml.Controls.Border();
+        this._panel = new NativeScript.Widgets.StackLayout();
+        this._panel.Orientation = 0; // 0 = Vertical
+        this._border.HorizontalAlignment = Microsoft.UI.Xaml.HorizontalAlignment.Stretch;
+        this._border.VerticalAlignment = Microsoft.UI.Xaml.VerticalAlignment.Stretch;
+        this._panel.HorizontalAlignment = Microsoft.UI.Xaml.HorizontalAlignment.Stretch;
+        this._panel.VerticalAlignment = Microsoft.UI.Xaml.VerticalAlignment.Top;
+        this._border.Child = this._panel;
+        return this._border;
+    }
+
+    // Children go into the inner panel, not the Border.
+    public _addViewToNativeVisualTree(child: ViewCommon, atIndex: number = Number.MAX_SAFE_INTEGER): boolean {
+        super._addViewToNativeVisualTree(child, atIndex);
+        const nativeChild = child.nativeViewProtected as Microsoft.UI.Xaml.FrameworkElement;
+        if (!nativeChild) return false;
+        const children = this._panel.Children;
+        if (!children) return false;
+        nativeChild.HorizontalAlignment = Microsoft.UI.Xaml.HorizontalAlignment.Stretch;
+        nativeChild.VerticalAlignment = Microsoft.UI.Xaml.VerticalAlignment.Top;
+        // InsertAt/Append cross the WinRT collection projection and can throw.
+        try {
+            const size: number = children.Size;
+            if (atIndex >= 0 && atIndex < size && atIndex < Number.MAX_SAFE_INTEGER) {
+                children.InsertAt(atIndex, nativeChild);
+            } else {
+                children.Append(nativeChild);
+            }
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    public _removeViewFromNativeVisualTree(child: ViewCommon): void {
+        const nativeChild = child.nativeViewProtected as Microsoft.UI.Xaml.UIElement;
+        if (nativeChild) {
+            const children = this._panel.Children;
+            const count: number = children?.Size ?? 0;
+            for (let i = 0; i < count; i++) {
+                if (children.GetAt(i) === nativeChild) {
+                    children.RemoveAt(i);
+                    break;
+                }
+            }
+        }
+        super._removeViewFromNativeVisualTree(child);
+    }
+
+    [orientationProperty.setNative](value: 'horizontal' | 'vertical') {
+        this._panel.Orientation = value === 'vertical' ? 0 : 1;
+    }
+}
diff --git a/packages/core/ui/layouts/wrap-layout/index.windows.ts b/packages/core/ui/layouts/wrap-layout/index.windows.ts
new file mode 100644
index 0000000000..61e18daae9
--- /dev/null
+++ b/packages/core/ui/layouts/wrap-layout/index.windows.ts
@@ -0,0 +1,191 @@
+export * from './wrap-layout-common';
+
+import { WrapLayoutBase, orientationProperty, itemWidthProperty, itemHeightProperty } from './wrap-layout-common';
+import { View } from '../../core/view';
+
+// XAML owns measure/arrange so the shared onMeasure/onLayout is a no-op on Windows.
+// Wrapping is implemented manually (same as FlexboxLayout): a Canvas whose children are
+// measured and placed via Canvas.SetLeft/SetTop, re-running on every size change.
+export class WrapLayout extends WrapLayoutBase {
+	nativeViewProtected!: Microsoft.UI.Xaml.Controls.Canvas;
+	private _canvas!: Microsoft.UI.Xaml.Controls.Canvas;
+	private _layoutBusy = false;
+	// The cross-axis size we set on the Canvas ourselves, so we can tell it apart from a user value.
+	private _ownCross = NaN;
+
+	constructor() {
+		super();
+		// WinRT deferred to createNativeView() — keeps constructor pure-JS.
+	}
+
+	createNativeView(): Microsoft.UI.Xaml.Controls.Canvas {
+		this._canvas = new Microsoft.UI.Xaml.Controls.Canvas();
+		return this._canvas;
+	}
+
+	initNativeView(): void {
+		super.initNativeView(); // preserves LayoutUpdated = _onSizeChanged (background, clip, etc.)
+		const canvas = this.nativeViewProtected as Microsoft.UI.Xaml.Controls.Canvas;
+		const ref = new WeakRef(this);
+		canvas.SizeChanged = NSWinRT.asDelegate('Microsoft.UI.Xaml.SizeChangedEventHandler', () => {
+			ref.deref()?._runWrapLayout();
+		});
+	}
+
+	disposeNativeView(): void {
+		const native = this.nativeViewProtected as Microsoft.UI.Xaml.Controls.Canvas;
+		if (native) {
+			native.SizeChanged = null;
+			native.LayoutUpdated = null;
+		}
+		super.disposeNativeView();
+	}
+
+	public _addViewToNativeVisualTree(child: View, atIndex: number = Number.MAX_SAFE_INTEGER): boolean {
+		super._addViewToNativeVisualTree(child, atIndex);
+		const nativeChild = (child as any).nativeViewProtected as Microsoft.UI.Xaml.UIElement;
+		const children = this._canvas?.Children;
+		if (!nativeChild || !children) return false;
+		try {
+			const size: number = children.Size;
+			if (atIndex >= 0 && atIndex < size && atIndex < Number.MAX_SAFE_INTEGER) {
+				children.InsertAt(atIndex, nativeChild);
+			} else {
+				children.Append(nativeChild);
+			}
+		} catch {
+			return false;
+		}
+		this._runWrapLayout();
+		return true;
+	}
+
+	public _removeViewFromNativeVisualTree(child: View): void {
+		const nativeChild = (child as any).nativeViewProtected as Microsoft.UI.Xaml.UIElement;
+		const children = this._canvas?.Children;
+		if (nativeChild && children) {
+			const count: number = children.Size ?? 0;
+			for (let i = 0; i < count; i++) {
+				try {
+					if (children.GetAt(i) === nativeChild) {
+						children.RemoveAt(i);
+						break;
+					}
+				} catch (_e) {}
+			}
+		}
+		super._removeViewFromNativeVisualTree(child);
+		this._runWrapLayout();
+	}
+
+	[orientationProperty.setNative](_v: 'horizontal' | 'vertical') {
+		this._runWrapLayout();
+	}
+	//@ts-ignore — itemWidth/itemHeight use valueChanged for effective* but we still relayout natively
+	[itemWidthProperty.setNative]() {
+		this._runWrapLayout();
+	}
+	//@ts-ignore
+	[itemHeightProperty.setNative]() {
+		this._runWrapLayout();
+	}
+
+	private _runWrapLayout(): void {
+		if (this._layoutBusy) return;
+		const canvas = this.nativeViewProtected as Microsoft.UI.Xaml.Controls.Canvas;
+		if (!canvas) return;
+
+		const children = canvas.Children;
+		const count: number = children?.Size ?? 0;
+		if (count === 0) return;
+
+		const isVertical = this.orientation === 'vertical';
+
+		const padLeft = (this.effectiveBorderLeftWidth || 0) + (this.effectivePaddingLeft || 0);
+		const padTop = (this.effectiveBorderTopWidth || 0) + (this.effectivePaddingTop || 0);
+		const padRight = (this.effectiveBorderRightWidth || 0) + (this.effectivePaddingRight || 0);
+		const padBottom = (this.effectiveBorderBottomWidth || 0) + (this.effectivePaddingBottom || 0);
+
+		// Canvas does not self-size; in an auto-sized parent the relevant axis can be 0 → treat as unconstrained.
+		const actualW = (canvas.ActualWidth as number) || 0;
+		const actualH = (canvas.ActualHeight as number) || 0;
+		const availW = actualW > 0 ? actualW - padLeft - padRight : Infinity;
+		const availH = actualH > 0 ? actualH - padTop - padBottom : Infinity;
+
+		const mainAvail = isVertical ? availH : availW;
+
+		const fixedW = this.effectiveItemWidth > 0 ? this.effectiveItemWidth : NaN;
+		const fixedH = this.effectiveItemHeight > 0 ? this.effectiveItemHeight : NaN;
+
+		this._layoutBusy = true;
+		try {
+			let mainPos = isVertical ? padTop : padLeft;
+			let crossPos = isVertical ? padLeft : padTop;
+			let lineCross = 0; // max cross-extent of the current line
+			let maxMain = 0; // furthest main extent reached (for self-sizing on vertical)
+
+			for (let i = 0; i < count; i++) {
+				const nc = children.GetAt(i) as Microsoft.UI.Xaml.FrameworkElement;
+				if (nc.Visibility === Microsoft.UI.Xaml.Visibility.Collapsed) continue;
+
+				let w = fixedW;
+				let h = fixedH;
+				if (isNaN(w) || isNaN(h)) {
+					try {
+						nc.Measure(Microsoft.UI.Xaml.SizeHelper.FromDimensions(Infinity, Infinity));
+						const d = nc.DesiredSize;
+						if (isNaN(w)) w = d.Width;
+						if (isNaN(h)) h = d.Height;
+					} catch (_e) {
+						if (isNaN(w)) w = 0;
+						if (isNaN(h)) h = 0;
+					}
+				}
+
+				const itemMain = isVertical ? h : w;
+				const itemCross = isVertical ? w : h;
+
+				const lineStart = isVertical ? padTop : padLeft;
+				const lineHasItems = mainPos > lineStart + 0.001;
+				if (Number.isFinite(mainAvail) && lineHasItems && mainPos + itemMain > (isVertical ? padTop + mainAvail : padLeft + mainAvail) + 0.001) {
+					mainPos = lineStart;
+					crossPos += lineCross;
+					lineCross = 0;
+				}
+
+				Microsoft.UI.Xaml.Controls.Canvas.SetLeft(nc, isVertical ? crossPos : mainPos);
+				Microsoft.UI.Xaml.Controls.Canvas.SetTop(nc, isVertical ? mainPos : crossPos);
+				// Only force size when a uniform itemWidth/itemHeight was requested;
+				// otherwise let the child render at its natural (measured) size.
+				if (!isNaN(fixedW)) nc.Width = fixedW;
+				if (!isNaN(fixedH)) nc.Height = fixedH;
+
+				mainPos += itemMain;
+				if (itemCross > lineCross) lineCross = itemCross;
+				if (mainPos > maxMain) maxMain = mainPos;
+			}
+
+			const contentCross = crossPos + lineCross + (isVertical ? padRight : padBottom);
+			const contentMain = maxMain + (isVertical ? padBottom : padRight);
+
+			// Self-size the Canvas on the unconstrained axis so the parent re-measures correctly (mirrors FlexboxLayout).
+			this._selfSizeCanvas(canvas, isVertical ? contentMain : contentCross, isVertical);
+		} finally {
+			this._layoutBusy = false;
+		}
+	}
+
+	private _selfSizeCanvas(canvas: Microsoft.UI.Xaml.Controls.Canvas, crossContent: number, isVertical: boolean): void {
+		const current = (isVertical ? canvas.Width : canvas.Height) as number;
+		const actual = (isVertical ? canvas.ActualWidth : canvas.ActualHeight) as number;
+		const inAutoMode = isNaN(current) || (!isNaN(this._ownCross) && Math.abs(current - this._ownCross) < 0.5);
+		if (inAutoMode && crossContent > 0 && Math.abs(actual - crossContent) > 0.5) {
+			this._ownCross = crossContent;
+			if (isVertical) {
+				canvas.Width = crossContent;
+			} else {
+				canvas.Height = crossContent;
+			}
+		}
+	}
+}
diff --git a/packages/core/ui/list-picker/index.windows.ts b/packages/core/ui/list-picker/index.windows.ts
new file mode 100644
index 0000000000..f8bdc8c50b
--- /dev/null
+++ b/packages/core/ui/list-picker/index.windows.ts
@@ -0,0 +1,76 @@
+export * from './list-picker-common';
+
+import { ListPickerBase, selectedIndexProperty, itemsProperty, ItemsSource } from './list-picker-common';
+import { colorProperty } from '../styling/style-properties';
+import { Color } from '../../color';
+
+export class ListPicker extends ListPickerBase {
+	nativeViewProtected: Microsoft.UI.Xaml.Controls.ComboBox;
+	private _windows: Microsoft.UI.Xaml.Controls.ComboBox;
+	private _selectionHandler: any = null;
+
+	public createNativeView(): Microsoft.UI.Xaml.Controls.ComboBox {
+		this._windows = new Microsoft.UI.Xaml.Controls.ComboBox();
+		return this._windows;
+	}
+
+	get windows(): Microsoft.UI.Xaml.Controls.ComboBox {
+		return this._windows;
+	}
+
+	public initNativeView(): void {
+		super.initNativeView();
+		const that = new WeakRef(this);
+		this._selectionHandler = NSWinRT.asDelegate('Microsoft.UI.Xaml.Controls.SelectionChangedEventHandler', () => {
+			const owner = that.deref();
+			if (!owner) return;
+			const idx = owner.nativeViewProtected.SelectedIndex;
+			selectedIndexProperty.nativeValueChange(owner, idx);
+			owner.updateSelectedValue(idx);
+		});
+		this.nativeViewProtected.SelectionChanged = this._selectionHandler as never;
+	}
+
+	public disposeNativeView(): void {
+		if (this._selectionHandler) {
+			this.nativeViewProtected.SelectionChanged = null as never;
+			this._selectionHandler = null;
+		}
+		super.disposeNativeView();
+	}
+
+	[selectedIndexProperty.getDefault](): number {
+		return -1;
+	}
+	[selectedIndexProperty.setNative](value: number) {
+		if (value >= 0 && this.nativeViewProtected) {
+			this.nativeViewProtected.SelectedIndex = value;
+		}
+	}
+
+	[itemsProperty.getDefault](): any[] {
+		return null;
+	}
+	[itemsProperty.setNative](value: any[] | ItemsSource) {
+		const native = this.nativeViewProtected;
+		if (!native) return;
+		try { native.Items.Clear(); } catch (_e) {}
+		if (value && Array.isArray(value)) {
+			for (let i = 0; i < value.length; i++) {
+				const dataItem = this._getDataItem(i);
+				const label = dataItem != null ? (dataItem.toString ? dataItem.toString() : String(dataItem)) : '';
+				try { native.Items.Append(label); } catch (_e) {}
+			}
+		}
+		selectedIndexProperty.coerce(this);
+	}
+
+	[colorProperty.getDefault](): number {
+		return -1;
+	}
+	[colorProperty.setNative](value: Color | number) {
+		if (value instanceof Color) {
+			this.nativeViewProtected.Foreground = new Microsoft.UI.Xaml.Media.SolidColorBrush(value.windows) as never;
+		}
+	}
+}
diff --git a/packages/core/ui/list-view/index.windows.ts b/packages/core/ui/list-view/index.windows.ts
new file mode 100644
index 0000000000..ae9bd3d54f
--- /dev/null
+++ b/packages/core/ui/list-view/index.windows.ts
@@ -0,0 +1,372 @@
+export * from './list-view-common';
+
+import { ListViewBase, itemTemplatesProperty, rowHeightProperty, separatorColorProperty } from './list-view-common';
+import { KeyedTemplate, View } from '../core/view';
+import { ChangedData } from '../../data/observable-array';
+import { Color } from '../../color';
+import { Builder } from '../builder';
+
+declare const NSWinRT: any;
+
+const ITEMLOADING = ListViewBase.itemLoadingEvent;
+const ITEMTAP = ListViewBase.itemTapEvent;
+const LOADMOREITEMS = ListViewBase.loadMoreItemsEvent;
+const HEADER_KEY = '__ns_header';
+
+const CHOOSING_TYPE = 'Windows.Foundation.TypedEventHandler`2<Microsoft.UI.Xaml.Controls.ListViewBase,Microsoft.UI.Xaml.Controls.ChoosingItemContainerEventArgs>';
+const CC_TYPE = 'Windows.Foundation.TypedEventHandler`2<Microsoft.UI.Xaml.Controls.ListViewBase,Microsoft.UI.Xaml.Controls.ContainerContentChangingEventArgs>';
+
+interface Row {
+	header: boolean;
+	templateKey: string;
+	globalIndex: number;
+	section?: number;
+	indexInSection?: number;
+	data: any;
+}
+
+// Virtualized + recycling ListView (RecyclerView/UITableView model).
+// ItemsSource is a native IVector<IInspectable> (NSWinRT.makeItemsSource) — JS arrays can't marshal to ItemsSource.
+// ChoosingItemContainer supplies our own ListViewItem containers so WinUI virtualizes + recycles them, avoiding the
+// DataTemplate ContentTemplateRoot typing problem. ContainerContentChanging binds each NS view as a ViewHolder —
+// reusing on rebind, building only on first use or template change.
+export class ListView extends ListViewBase {
+	nativeViewProtected!: Microsoft.UI.Xaml.Controls.ListView;
+
+	private _clickDelegate: Microsoft.UI.Xaml.Controls.ItemClickEventHandler | null = null;
+	// Held so their JS wrappers aren't GC'd. If collected, ChoosingItemContainer/ContainerContentChanging
+	// fire into dead callbacks → rows never bind → blank/white on scroll. (GC problem, NOT thread-marshal;
+	// JS and these XAML events share the UI thread.)
+	private _choosingDelegate: any = null;
+	private _ccDelegate: any = null;
+	private _rows: Row[] = [];
+	private _viewPool = new Map<string, View[]>();
+	private _active = new Set<View>();
+	// Bumped on every refresh() so containers holding a view from a previous data set
+	// (torn down by _teardown) are detected and never reused.
+	private _generation = 0;
+
+	public createNativeView(): Microsoft.UI.Xaml.Controls.ListView {
+		const lv = new Microsoft.UI.Xaml.Controls.ListView();
+		lv.IsItemClickEnabled = true;
+		lv.SelectionMode = 0; // None
+		lv.HorizontalAlignment = 3; // Stretch
+		lv.HorizontalContentAlignment = 3;
+		lv.VerticalAlignment = 3;
+		return lv;
+	}
+
+	public initNativeView(): void {
+		super.initNativeView();
+		const lv = this.nativeViewProtected;
+		if (!lv) return;
+		const ref = new WeakRef(this);
+
+		// ChoosingItemContainer/ContainerContentChanging are generic TypedEventHandlers — runtime can't derive
+		// their parameterized GUID from a plain assignment, so build via asDelegate (can throw; keep guarded).
+		try {
+			this._choosingDelegate = NSWinRT.asDelegate(CHOOSING_TYPE, (_s: any, args: any) => {
+				ref.deref()?._onChoosingItemContainer(args);
+			});
+			lv.ChoosingItemContainer = this._choosingDelegate;
+		} catch (_e) {}
+
+		try {
+			this._ccDelegate = NSWinRT.asDelegate(CC_TYPE, (_s: any, args: any) => {
+				ref.deref()?._onContainerContentChanging(args);
+			});
+			lv.ContainerContentChanging = this._ccDelegate;
+		} catch (_e) {}
+
+		this._clickDelegate = NSWinRT.asDelegate('Microsoft.UI.Xaml.Controls.ItemClickEventHandler', (_s: any, e: any) => {
+			const owner = ref.deref();
+			if (!owner) return;
+			try {
+				const lv2 = owner.nativeViewProtected;
+				const container = lv2.ContainerFromItem(e.ClickedItem);
+				const idx = container ? (container as any).__ns_row_index ?? -1 : -1;
+				const row = owner._rows[idx];
+				if (!row || row.header || row.globalIndex < 0) return;
+				owner.notify({ eventName: ITEMTAP, object: owner, index: row.globalIndex, view: owner._findActive(row.globalIndex), section: row.section });
+			} catch (_e) {}
+		});
+		lv.ItemClick = this._clickDelegate;
+	}
+
+	public disposeNativeView(): void {
+		const lv = this.nativeViewProtected;
+		lv.ChoosingItemContainer = null;
+		lv.ContainerContentChanging = null;
+		lv.ItemClick = null;
+		this._clickDelegate = null;
+		this._choosingDelegate = null;
+		this._ccDelegate = null;
+		this._teardown();
+		super.disposeNativeView?.();
+	}
+
+	public _addViewToNativeVisualTree(_child: View, _atIndex?: number): boolean {
+		return true;
+	}
+
+	private _keyForData(data: any, globalIndex: number): string {
+		const selector = (this as any)._itemTemplateSelector;
+		if (typeof selector === 'function') {
+			try { return selector(data, globalIndex, this.items); } catch (_e) {}
+		}
+		return 'default';
+	}
+
+	private _templateByKey(key: string): KeyedTemplate {
+		for (const t of this._itemTemplatesInternal) {
+			if (t.key === key) return t;
+		}
+		return this._itemTemplatesInternal[0];
+	}
+
+	public refresh(): void {
+		const lv = this.nativeViewProtected as any;
+		if (!lv) return;
+
+		this._teardown();
+
+		const rows: Row[] = [];
+		if (this.sectioned) {
+			let gi = 0;
+			const sections = this._getSectionCount();
+			for (let s = 0; s < sections; s++) {
+				const sectionData = (this as any)._getSectionData ? this._getSectionData(s) : null;
+				if (this.stickyHeaderTemplate) {
+					rows.push({ header: true, templateKey: HEADER_KEY, globalIndex: -1, section: s, data: sectionData ?? { title: '' } });
+				}
+				const itemsInSection = this._getItemsInSection(s) as any;
+				const len = itemsInSection && typeof itemsInSection.length === 'number' ? itemsInSection.length : 0;
+				for (let j = 0; j < len; j++) {
+					const data = this._getDataItemInSection(s, j);
+					rows.push({ header: false, templateKey: this._keyForData(data, gi), globalIndex: gi, section: s, indexInSection: j, data });
+					gi++;
+				}
+			}
+		} else {
+			const src = this.items as any;
+			const count = src && typeof src.length === 'number' ? src.length : 0;
+			for (let i = 0; i < count; i++) {
+				const data = (this as any)._getDataItem ? (this as any)._getDataItem(i) : src[i];
+				rows.push({ header: false, templateKey: this._keyForData(data, i), globalIndex: i, data });
+			}
+		}
+
+		this._rows = rows;
+		try {
+			lv.ItemsSource = typeof NSWinRT !== 'undefined' && NSWinRT.makeItemsSource ? NSWinRT.makeItemsSource(rows.length) : null;
+		} catch (_e) {}
+
+		if (rows.length) {
+			this.notify({ eventName: LOADMOREITEMS, object: this });
+		}
+	}
+
+	private _onChoosingItemContainer(args: any): void {
+		try {
+			if (!args.ItemContainer) {
+				args.ItemContainer = this._makeContainer();
+			}
+			args.IsContainerPrepared = true;
+		} catch (_e) {}
+	}
+
+	private _makeContainer(): Microsoft.UI.Xaml.Controls.ListViewItem {
+		const lvi = new Microsoft.UI.Xaml.Controls.ListViewItem();
+		lvi.HorizontalContentAlignment = 3; // Stretch
+		lvi.VerticalContentAlignment = 0; // Top
+		lvi.Padding = Microsoft.UI.Xaml.ThicknessHelper.FromUniformLength(0);
+		// Reserve a deterministic min height so a recycled container never collapses to 0
+		// before its content re-measures (0-height rows render blank and skew scroll math).
+		lvi.MinHeight = this._effectiveRowHeight && this._effectiveRowHeight > 0 ? this._effectiveRowHeight : 52;
+		return lvi;
+	}
+
+	private _onContainerContentChanging(args: any): void {
+		const container = args?.ItemContainer;
+		if (!container) return;
+
+		// Container leaving the viewport: return its view to the pool (bounded view creation = virtualization).
+		// _detach clears Content so re-attaching to another container doesn't throw "element already has a parent".
+		if (args.InRecycleQueue) {
+			this._detach(container);
+			try { args.Handled = true; } catch (_e) {}
+			return;
+		}
+
+		const idx = args.ItemIndex;
+		const row = this._rows[idx];
+		if (!row) { try { args.Handled = true; } catch (_e) {} return; }
+		(container as any).__ns_row_index = idx;
+
+		// Reuse the container's current view only if it's from this data set AND the same template;
+		// otherwise repool it and obtain the right one.
+		let view = (container as any).__ns_view as View;
+		if (view && ((view as any).__ns_gen !== this._generation || (view as any).__ns_templateKey !== row.templateKey)) {
+			this._detach(container);
+			view = null as any;
+		}
+		if (!view) {
+			view = this._obtain(row);
+			this._attach(container, view);
+		}
+
+		this._bind(view, row);
+
+		const native = (view as any)?.nativeViewProtected;
+		try { native.HorizontalAlignment = 3; } catch (_e) {}
+		try { native.MinHeight = (this._effectiveRowHeight && this._effectiveRowHeight > 0) ? this._effectiveRowHeight : 44; } catch (_e) {}
+		try { container.IsHitTestVisible = !row.header; } catch (_e) {}
+		// WinUI may have cleared a reused container's Content; re-attach if needed.
+		try { if (container.Content !== native) container.Content = native; } catch (_e) {}
+		try { args.Handled = true; } catch (_e) {}
+	}
+
+	// Host a view's native element inside a container, first detaching it from any previous
+	// container so one native element never has two parents.
+	private _attach(container: any, view: View): void {
+		const native = (view as any)?.nativeViewProtected;
+		const prev = (view as any).__ns_container;
+		if (prev && prev !== container) {
+			try { if (prev.Content === native) prev.Content = null; } catch (_e) {}
+			if (prev.__ns_view === view) prev.__ns_view = null;
+		}
+		container.__ns_view = view;
+		(view as any).__ns_container = container;
+		try { if (container.Content !== native) container.Content = native; } catch (_e) {}
+	}
+
+	// Detach the container's view, clear its Content, and return the view to the pool
+	// (unless it's stale from a previous data set, in which case just drop it).
+	private _detach(container: any): void {
+		const view = (container as any).__ns_view as View;
+		container.__ns_view = null;
+		if (!view) return;
+		const native = (view as any)?.nativeViewProtected;
+		try { if (container.Content === native) container.Content = null; } catch (_e) {}
+		if ((view as any).__ns_container === container) (view as any).__ns_container = null;
+		if ((view as any).__ns_gen === this._generation) {
+			this._recycle(view);
+		}
+	}
+
+	private _obtain(row: Row): View {
+		const key = row.templateKey;
+		const free = this._viewPool.get(key);
+		if (free && free.length) {
+			return free.pop() as View;
+		}
+
+		let view: View | null = null;
+		if (row.header) {
+			const tmpl = this.stickyHeaderTemplate as any;
+			try { view = typeof tmpl === 'function' ? tmpl() : Builder.parse(tmpl, this); } catch (_e) {}
+		} else {
+			const t = this._templateByKey(key);
+			try { view = t?.createView() ?? null; } catch (_e) {}
+			if (!view) view = this._getDefaultItemContent(row.globalIndex);
+		}
+		if (!view) view = this._getDefaultItemContent(row.globalIndex);
+
+		(view as any).__ns_templateKey = key;
+		(view as any).__ns_gen = this._generation;
+		(view as any).__ns_isNew = true;
+		if (!(view as any).nativeViewProtected) {
+			try { view._setupUI(this._context || ({} as any)); } catch (_e) {}
+		}
+		this._addView(view);
+		this._active.add(view);
+		return view;
+	}
+
+	private _bind(view: View, row: Row): void {
+		try { (view as any).bindingContext = row.data; } catch (_e) {}
+		if (!row.header && (view as any).__ns_isNew) {
+			const args: any = { eventName: ITEMLOADING, object: this, index: row.globalIndex, view, bindingContext: row.data, section: row.section };
+			this.notify(args);
+		}
+		(view as any).__ns_isNew = false;
+	}
+
+	private _recycle(view: View): void {
+		const key = (view as any).__ns_templateKey || 'default';
+		let arr = this._viewPool.get(key);
+		if (!arr) { arr = []; this._viewPool.set(key, arr); }
+		arr.push(view);
+	}
+
+	private _findActive(globalIndex: number): View | null {
+		const row = this._rows[globalIndex];
+		if (!row) return null;
+		for (const v of this._active) {
+			if ((v as any).bindingContext === row.data) return v;
+		}
+		return null;
+	}
+
+	private _teardown(): void {
+		// Invalidate any views still referenced by live containers — the generation guard in
+		// _onContainerContentChanging will discard them instead of reusing torn-down views.
+		this._generation++;
+		for (const v of this._active) {
+			try { this._removeView(v); } catch (_e) {}
+		}
+		this._active.clear();
+		this._viewPool.clear();
+		this._rows = [];
+		try { (this.nativeViewProtected as any).ItemsSource = null; } catch (_e) {}
+	}
+
+	public eachChildView(callback: (child: View) => boolean): void {
+		for (const v of this._active) {
+			if (!callback(v)) break;
+		}
+	}
+
+	public isItemAtIndexVisible(index: number): boolean {
+		try { return !!this.nativeViewProtected?.ContainerFromIndex(index); } catch (_e) { return false; }
+	}
+
+	public scrollToIndex(index: number): void {
+		try { this.nativeViewProtected?.ScrollIntoView((this.nativeViewProtected as any).Items.GetAt(index)); } catch (_e) {}
+	}
+
+	public scrollToIndexAnimated(index: number): void {
+		this.scrollToIndex(index);
+	}
+
+	public onLoaded(): void {
+		super.onLoaded();
+		this.refresh();
+	}
+
+	public _onItemsChanged(_data: ChangedData<any>): void {
+		this.refresh();
+	}
+
+	[itemTemplatesProperty.getDefault](): KeyedTemplate[] {
+		return null as unknown as KeyedTemplate[];
+	}
+	[itemTemplatesProperty.setNative](value: KeyedTemplate[]) {
+		this._itemTemplatesInternal = new Array<KeyedTemplate>(this._defaultTemplate);
+		if (value) {
+			this._itemTemplatesInternal = this._itemTemplatesInternal.concat(value);
+		}
+		if (this.nativeViewProtected) this.refresh();
+	}
+
+	[rowHeightProperty.getDefault]() {
+		return 'auto' as any;
+	}
+	[rowHeightProperty.setNative](_value: any) {}
+
+	[separatorColorProperty.getDefault](): Color {
+		return null as unknown as Color;
+	}
+	// @ts-ignore — setNative is a symbol index whose value type is widened across properties.
+	[separatorColorProperty.setNative](_value: Color) {}
+}
diff --git a/packages/core/ui/page/index.windows.ts b/packages/core/ui/page/index.windows.ts
new file mode 100644
index 0000000000..64699f4fda
--- /dev/null
+++ b/packages/core/ui/page/index.windows.ts
@@ -0,0 +1,52 @@
+export * from './page-common';
+
+import { PageBase } from './page-common';
+import type { View } from '../core/view';
+
+export class Page extends PageBase {
+	declare nativeViewProtected: Microsoft.UI.Xaml.Controls.Grid;
+	private _grid: Microsoft.UI.Xaml.Controls.Grid;
+
+	public createNativeView(): Microsoft.UI.Xaml.Controls.Grid {
+		this._grid = new Microsoft.UI.Xaml.Controls.Grid();
+		return this._grid;
+	}
+
+	public disposeNativeView(): void {
+		this._grid = null;
+		super.disposeNativeView();
+	}
+
+	get windows(): Microsoft.UI.Xaml.Controls.Grid {
+		return this._grid;
+	}
+
+	public _addViewToNativeVisualTree(child: View, _atIndex: number): boolean {
+		if (this.actionBar && child === (this.actionBar as unknown as View)) {
+			return true;
+		}
+
+		const nativeChild = child.nativeViewProtected as Microsoft.UI.Xaml.UIElement;
+		if (this._grid && nativeChild) {
+			this._grid.Children.Append(nativeChild);
+			return true;
+		}
+
+		return false;
+	}
+
+	public _removeViewFromNativeVisualTree(child: View): void {
+		if (this.actionBar && child === (this.actionBar as unknown as View)) {
+			return;
+		}
+
+		if (this._grid) {
+			const children = this._grid.Children;
+			for (let i = children.Size - 1; i >= 0; i--) {
+				try { children.RemoveAt(i); } catch (_e) {}
+			}
+		}
+
+		super._removeViewFromNativeVisualTree(child);
+	}
+}
diff --git a/packages/core/ui/progress/index.windows.ts b/packages/core/ui/progress/index.windows.ts
new file mode 100644
index 0000000000..842a290815
--- /dev/null
+++ b/packages/core/ui/progress/index.windows.ts
@@ -0,0 +1,73 @@
+import { maxValueProperty, ProgressBase, valueProperty } from './progress-common';
+import { Color } from '../../color';
+import { colorProperty, backgroundColorProperty, backgroundInternalProperty } from '../styling/style-properties';
+import { Background } from '../styling/background';
+
+export * from './progress-common';
+
+// ProgressBar is not WinRT-activatable in this WinAppSDK build: `new ProgressBar()` throws E_NOTIMPL (0x80004001).
+// Create via XamlReader instead; attempt `new` only until first failure, then go straight to XamlReader.
+let _progressBarActivatable: boolean | undefined;
+function createProgressBar(): Microsoft.UI.Xaml.Controls.ProgressBar {
+	if (_progressBarActivatable !== false) {
+		try {
+			const pb = new Microsoft.UI.Xaml.Controls.ProgressBar();
+			_progressBarActivatable = true;
+			return pb;
+		} catch (_e) {
+			_progressBarActivatable = false;
+		}
+	}
+	return Microsoft.UI.Xaml.Markup.XamlReader.Load('<ProgressBar xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" />') as Microsoft.UI.Xaml.Controls.ProgressBar;
+}
+
+export class Progress extends ProgressBase {
+	nativeViewProtected: Microsoft.UI.Xaml.Controls.ProgressBar;
+	private _windows: Microsoft.UI.Xaml.Controls.ProgressBar;
+
+	public createNativeView(): Microsoft.UI.Xaml.Controls.ProgressBar {
+		this._windows = createProgressBar();
+		return this._windows;
+	}
+
+	[valueProperty.getDefault](): number {
+		return 0;
+	}
+	[valueProperty.setNative](value: number) {
+		this.nativeViewProtected.Value = value;
+	}
+
+	[maxValueProperty.getDefault](): number {
+		return 100;
+	}
+	[maxValueProperty.setNative](value: number) {
+		this.nativeViewProtected.Maximum = value;
+	}
+
+	[colorProperty.getDefault](): number {
+		return -1;
+	}
+	[colorProperty.setNative](value: Color | number) {
+		if (value instanceof Color) {
+			this.nativeViewProtected.Foreground = new Microsoft.UI.Xaml.Media.SolidColorBrush(value.windows);
+		} else {
+			this.nativeViewProtected.Foreground = null;
+		}
+	}
+
+	[backgroundColorProperty.getDefault](): number {
+		return -1;
+	}
+	[backgroundColorProperty.setNative](value: Color | number) {
+		if (value instanceof Color) {
+			this.nativeViewProtected.Background = new Microsoft.UI.Xaml.Media.SolidColorBrush(value.windows);
+		} else {
+			this.nativeViewProtected.Background = null;
+		}
+	}
+
+	[backgroundInternalProperty.getDefault](): Background {
+		return null;
+	}
+	[backgroundInternalProperty.setNative](_value: Background) {}
+}
diff --git a/packages/core/ui/scroll-view/index.windows.ts b/packages/core/ui/scroll-view/index.windows.ts
new file mode 100644
index 0000000000..663815911e
--- /dev/null
+++ b/packages/core/ui/scroll-view/index.windows.ts
@@ -0,0 +1,233 @@
+export * from './scroll-view-common';
+
+import { ScrollViewBase, isScrollEnabledProperty, scrollBarIndicatorVisibleProperty } from './scroll-view-common';
+import type { ScrollEventData } from '.';
+import type { ViewCommon } from '../core/view/view-common';
+
+// Viewport sizing is the parent's responsibility: NativeScript.Widgets.StackLayout/Grid size a
+// Stretch/height:100% ScrollView to the bounded extent in MeasureOverride, giving the ScrollViewer
+// a proper scrollable viewport without any JS clamping.
+export class ScrollView extends ScrollViewBase {
+	declare nativeViewProtected: Microsoft.UI.Xaml.Controls.ScrollViewer;
+
+	private _scrollToken: any = null;
+	private _windows: Microsoft.UI.Xaml.Controls.ScrollViewer;
+
+	constructor() {
+		super();
+		// WinRT deferred to createNativeView() — keeps constructor pure-JS.
+	}
+
+	public createNativeView() {
+		this._windows = new Microsoft.UI.Xaml.Controls.ScrollViewer();
+		return this._windows;
+	}
+
+	get windows(): Microsoft.UI.Xaml.Controls.ScrollViewer {
+		return this._windows;
+	}
+
+	public initNativeView(): void {
+		super.initNativeView();
+		this._applyOrientation();
+	}
+
+	public disposeNativeView(): void {
+		this._scrollToken = null;
+		super.disposeNativeView();
+	}
+
+	private _applyOrientation(): void {
+		const viewer = this.windows;
+		if (!viewer) {
+			return;
+		}
+
+		const HorizontalAlignment = Microsoft.UI.Xaml.HorizontalAlignment;
+		const VerticalAlignment = Microsoft.UI.Xaml.VerticalAlignment;
+		const ScrollBarVisibility = Microsoft.UI.Xaml.Controls.ScrollBarVisibility;
+		const ScrollMode = Microsoft.UI.Xaml.Controls.ScrollMode;
+
+		if (this.orientation === 'horizontal') {
+			viewer.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto;
+			viewer.VerticalScrollBarVisibility = ScrollBarVisibility.Disabled;
+			viewer.HorizontalScrollMode = ScrollMode.Enabled;
+			viewer.VerticalScrollMode = ScrollMode.Disabled;
+			viewer.HorizontalContentAlignment = HorizontalAlignment.Left;
+			viewer.VerticalContentAlignment = VerticalAlignment.Stretch;
+		} else {
+			viewer.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
+			viewer.HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled;
+			viewer.VerticalScrollMode = ScrollMode.Enabled;
+			viewer.HorizontalScrollMode = ScrollMode.Disabled;
+			viewer.VerticalContentAlignment = VerticalAlignment.Top;
+			viewer.HorizontalContentAlignment = HorizontalAlignment.Stretch;
+		}
+	}
+
+	public _onOrientationChanged(): void {
+		this._applyOrientation();
+		const nativeChild = this.layoutView?.nativeViewProtected as Microsoft.UI.Xaml.FrameworkElement;
+		if (nativeChild) {
+			this._alignContent(nativeChild);
+		}
+	}
+
+	private _alignContent(nativeChild: Microsoft.UI.Xaml.FrameworkElement): void {
+		const HorizontalAlignment = Microsoft.UI.Xaml.HorizontalAlignment;
+		const VerticalAlignment = Microsoft.UI.Xaml.VerticalAlignment;
+		// Critically, the content must be aligned to the scroll-axis start (not Stretch on
+		// that axis) so the ScrollViewer measures it with infinite extent and lets it overflow.
+		if (this.orientation === 'horizontal') {
+			nativeChild.HorizontalAlignment = HorizontalAlignment.Left;
+			nativeChild.VerticalAlignment = VerticalAlignment.Stretch;
+		} else {
+			nativeChild.VerticalAlignment = VerticalAlignment.Top;
+			nativeChild.HorizontalAlignment = HorizontalAlignment.Stretch;
+		}
+	}
+
+	public _addViewToNativeVisualTree(child: ViewCommon, _atIndex?: number): boolean {
+		super._addViewToNativeVisualTree(child);
+
+		const nativeParent = this.nativeViewProtected;
+		const nativeChild = child.nativeViewProtected as Microsoft.UI.Xaml.FrameworkElement;
+
+		if (nativeParent && nativeChild) {
+			this._alignContent(nativeChild);
+			nativeParent.Content = nativeChild;
+			return true;
+		}
+
+		return false;
+	}
+
+	public _removeViewFromNativeVisualTree(child: ViewCommon): void {
+		if (this.nativeViewProtected) {
+			this.nativeViewProtected.Content = null as never;
+		}
+		super._removeViewFromNativeVisualTree(child);
+	}
+
+	private _changeViewSafe(viewer: Microsoft.UI.Xaml.Controls.ScrollViewer, horizontal?: number | null, vertical?: number | null, disableAnimation: boolean = true): void {
+		if (!viewer || typeof viewer.ChangeView !== 'function') {
+			return;
+		}
+
+		// ChangeView is a native call that can throw mid-layout; guard it.
+		try {
+			const currentH = typeof viewer.HorizontalOffset === 'number' ? viewer.HorizontalOffset : 0;
+			const currentV = typeof viewer.VerticalOffset === 'number' ? viewer.VerticalOffset : 0;
+			const zoom = typeof viewer.ZoomFactor === 'number' && viewer.ZoomFactor > 0 ? viewer.ZoomFactor : 1;
+
+			const h = typeof horizontal === 'number' ? horizontal : currentH;
+			const v = typeof vertical === 'number' ? vertical : currentV;
+
+			if (Math.abs(h - currentH) < 0.5 && Math.abs(v - currentV) < 0.5) {
+				return;
+			}
+
+			viewer.ChangeView(h, v, zoom, disableAnimation);
+		} catch (_err) {}
+	}
+
+	protected attachNative(): void {
+		const viewer = this.windows;
+		if (!viewer) {
+			return;
+		}
+
+		const that = new WeakRef(this);
+
+		this._scrollToken = NSWinRT.asDelegate((_sender: any, _args: any) => {
+			const owner = that.deref();
+			if (!owner) {
+				return;
+			}
+			owner.notify<ScrollEventData>({
+				eventName: ScrollViewBase.scrollEvent,
+				object: owner,
+				scrollX: owner.horizontalOffset,
+				scrollY: owner.verticalOffset,
+			});
+		});
+
+		viewer.ViewChanged = this._scrollToken;
+	}
+
+	protected detachNative(): void {
+		const viewer = this.windows;
+		if (!viewer) {
+			return;
+		}
+
+		viewer.ViewChanged = null as never;
+		this._scrollToken = null;
+	}
+
+	get horizontalOffset(): number {
+		return this.nativeViewProtected ? this.nativeViewProtected.HorizontalOffset : 0;
+	}
+
+	get verticalOffset(): number {
+		return this.nativeViewProtected ? this.nativeViewProtected.VerticalOffset : 0;
+	}
+
+	get scrollableWidth(): number {
+		if (!this.nativeViewProtected || this.orientation !== 'horizontal') {
+			return 0;
+		}
+
+		return Math.max(0, this.nativeViewProtected.ExtentWidth - this.nativeViewProtected.ViewportWidth);
+	}
+
+	get scrollableHeight(): number {
+		if (!this.nativeViewProtected || this.orientation !== 'vertical') {
+			return 0;
+		}
+
+		return Math.max(0, this.nativeViewProtected.ExtentHeight - this.nativeViewProtected.ViewportHeight);
+	}
+
+	public scrollToVerticalOffset(value: number, animated: boolean) {
+		if (this.nativeViewProtected && this.orientation === 'vertical' && this.isScrollEnabled) {
+			this._changeViewSafe(this.nativeViewProtected, undefined, value, !animated);
+		}
+	}
+
+	public scrollToHorizontalOffset(value: number, animated: boolean) {
+		if (this.nativeViewProtected && this.orientation === 'horizontal' && this.isScrollEnabled) {
+			this._changeViewSafe(this.nativeViewProtected, value, undefined, !animated);
+		}
+	}
+
+	[isScrollEnabledProperty.setNative](value: boolean): void {
+		const viewer = this.nativeViewProtected;
+		if (!viewer) {
+			return;
+		}
+
+		const ScrollMode = Microsoft.UI.Xaml.Controls.ScrollMode;
+
+		if (this.orientation === 'horizontal') {
+			viewer.HorizontalScrollMode = value ? ScrollMode.Enabled : ScrollMode.Disabled;
+		} else {
+			viewer.VerticalScrollMode = value ? ScrollMode.Enabled : ScrollMode.Disabled;
+		}
+	}
+
+	[scrollBarIndicatorVisibleProperty.setNative](value: boolean): void {
+		const viewer = this.nativeViewProtected;
+		if (!viewer) {
+			return;
+		}
+
+		const ScrollBarVisibility = Microsoft.UI.Xaml.Controls.ScrollBarVisibility;
+
+		if (this.orientation === 'horizontal') {
+			viewer.HorizontalScrollBarVisibility = value ? ScrollBarVisibility.Auto : ScrollBarVisibility.Hidden;
+		} else {
+			viewer.VerticalScrollBarVisibility = value ? ScrollBarVisibility.Auto : ScrollBarVisibility.Hidden;
+		}
+	}
+}
diff --git a/packages/core/ui/search-bar/index.windows.ts b/packages/core/ui/search-bar/index.windows.ts
new file mode 100644
index 0000000000..dd45d0fc4e
--- /dev/null
+++ b/packages/core/ui/search-bar/index.windows.ts
@@ -0,0 +1,88 @@
+export * from './search-bar-common';
+
+import { SearchBarBase, textProperty, hintProperty, textFieldBackgroundColorProperty, textFieldHintColorProperty, clearButtonColorProperty } from './search-bar-common';
+import { Color } from '../../color';
+
+export class SearchBar extends SearchBarBase {
+	nativeViewProtected: Microsoft.UI.Xaml.Controls.AutoSuggestBox;
+	private _textHandler: any = null;
+	private _queryHandler: any = null;
+	private _windows: Microsoft.UI.Xaml.Controls.AutoSuggestBox;
+
+	public createNativeView(): Microsoft.UI.Xaml.Controls.AutoSuggestBox {
+		this._windows = new Microsoft.UI.Xaml.Controls.AutoSuggestBox();
+		return this._windows;
+	}
+
+	get windows(): Microsoft.UI.Xaml.Controls.AutoSuggestBox {
+		return this._windows;
+	}
+
+	public initNativeView(): void {
+		super.initNativeView();
+		const that = new WeakRef(this);
+		const native = this.nativeViewProtected;
+
+		this._textHandler = NSWinRT.asDelegate(
+			'Windows.Foundation.TypedEventHandler`2<Microsoft.UI.Xaml.Controls.AutoSuggestBox,Microsoft.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs>',
+			() => {
+				const owner = that.deref();
+				if (owner) textProperty.nativeValueChange(owner, native.Text || '');
+			}
+		);
+		native.TextChanged = this._textHandler as never;
+
+		this._queryHandler = NSWinRT.asDelegate(
+			'Windows.Foundation.TypedEventHandler`2<Microsoft.UI.Xaml.Controls.AutoSuggestBox,Microsoft.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs>',
+			() => {
+				const owner = that.deref();
+				if (owner) owner.notify({ eventName: SearchBarBase.submitEvent, object: owner });
+			}
+		);
+		native.QuerySubmitted = this._queryHandler as never;
+	}
+
+	public disposeNativeView(): void {
+		if (this._textHandler) {
+			this.nativeViewProtected.TextChanged = null;
+			this._textHandler = null;
+		}
+		if (this._queryHandler) {
+			this.nativeViewProtected.QuerySubmitted = null;
+			this._queryHandler = null;
+		}
+		super.disposeNativeView();
+	}
+
+	public dismissSoftInput(): void {}
+
+	[textProperty.setNative](value: string) {
+		if (this.nativeViewProtected) {
+			this.nativeViewProtected.Text = value ?? '';
+		}
+	}
+
+	[hintProperty.setNative](value: string) {
+		if (this.nativeViewProtected) {
+			this.nativeViewProtected.PlaceholderText = value ?? '';
+		}
+	}
+
+	[textFieldBackgroundColorProperty.setNative](value: Color) {
+		if (!this.nativeViewProtected || !(value instanceof Color)) return;
+		this.nativeViewProtected.Background = new Microsoft.UI.Xaml.Media.SolidColorBrush(value.windows) as never;
+	}
+
+	[textFieldHintColorProperty.setNative](value: Color) {
+		const native = this.nativeViewProtected;
+		if (!native || !(value instanceof Color)) return;
+		// AutoSuggestBox has no PlaceholderForeground — override inner TextBox theme brushes via Resources.
+		const brush = new Microsoft.UI.Xaml.Media.SolidColorBrush(value.windows);
+		try { (native as any).Resources.Insert('TextControlPlaceholderForeground', brush); } catch (_e) {}
+		try { (native as any).Resources.Insert('TextControlPlaceholderForegroundPointerOver', brush); } catch (_e) {}
+		try { (native as any).Resources.Insert('TextControlPlaceholderForegroundFocused', brush); } catch (_e) {}
+		try { (native as any).Resources.Insert('TextControlPlaceholderForegroundDisabled', brush); } catch (_e) {}
+	}
+
+	[clearButtonColorProperty.setNative](_value: Color | string): void {}
+}
diff --git a/packages/core/ui/segmented-bar/index.windows.ts b/packages/core/ui/segmented-bar/index.windows.ts
new file mode 100644
index 0000000000..ddc19132fd
--- /dev/null
+++ b/packages/core/ui/segmented-bar/index.windows.ts
@@ -0,0 +1,111 @@
+export * from './segmented-bar-common';
+
+import { SegmentedBarBase, SegmentedBarItemBase, selectedIndexProperty, itemsProperty, selectedBackgroundColorProperty, selectedTextColorProperty } from './segmented-bar-common';
+import { Color } from '../../color';
+
+export class SegmentedBarItem extends SegmentedBarItemBase {
+	public _update(): void {
+		(this.parent as SegmentedBar)?._rebuildSegments?.();
+	}
+}
+
+// WinUI3 has no built-in segmented control — built as a horizontal row of ToggleButtons.
+export class SegmentedBar extends SegmentedBarBase {
+	nativeViewProtected: Microsoft.UI.Xaml.Controls.StackPanel;
+	private _buttons: Microsoft.UI.Xaml.Controls.Primitives.ToggleButton[] = [];
+	private _clickDelegates: any[] = [];
+	private _suppress = false;
+
+	private _windows: Microsoft.UI.Xaml.Controls.StackPanel;
+
+	public createNativeView(): Microsoft.UI.Xaml.Controls.StackPanel {
+		this._windows = new Microsoft.UI.Xaml.Controls.StackPanel();
+		this._windows.Orientation = Microsoft.UI.Xaml.Controls.Orientation.Horizontal;
+		return this._windows;
+	}
+
+	public _rebuildSegments(): void {
+		const panel = this._windows;
+		if (!panel || !panel.Children) return;
+		panel.Children.Clear();
+		this._buttons = [];
+		this._clickDelegates = [];
+		const items = this.items || [];
+		items.forEach((item, i) => {
+			let btn: Microsoft.UI.Xaml.Controls.Primitives.ToggleButton;
+			try {
+				btn = new Microsoft.UI.Xaml.Controls.Primitives.ToggleButton();
+			} catch (_e) {
+				return;
+			}
+			btn.Content = (item as SegmentedBarItemBase).title ?? '';
+			btn.MinWidth = 72;
+			// MUST wire via asDelegate — a raw RoutedEventHandler assignment doesn't reliably subscribe
+			// here; taps only toggle the native button without our handler running.
+			try {
+				const cb = () => {
+					if (this._suppress) return;
+					if (this.selectedIndex !== i) {
+						this.selectedIndex = i;
+					} else {
+						this._applySelection(i);
+					}
+				};
+				const del = NSWinRT.asDelegate('Microsoft.UI.Xaml.RoutedEventHandler', cb);
+				btn.Click = del;
+				this._clickDelegates.push(del);
+			} catch (_e) {}
+			this._buttons.push(btn);
+			panel.Children.Append(btn);
+		});
+		this._applySelection(this.selectedIndex);
+	}
+
+	private _applySelection(index: number): void {
+		this._suppress = true;
+		try {
+			this._buttons.forEach((btn, i) => {
+				btn.IsChecked = i === index;
+				this._styleButton(btn, i === index);
+			});
+		} finally {
+			this._suppress = false;
+		}
+	}
+
+	private _styleButton(btn: Microsoft.UI.Xaml.Controls.Primitives.ToggleButton, checked: boolean): void {
+		const Control = Microsoft.UI.Xaml.Controls.Control;
+		if (checked) {
+			const bg = this.selectedBackgroundColor;
+			const fg = this.selectedTextColor;
+			if (bg) btn.Background = new Microsoft.UI.Xaml.Media.SolidColorBrush(bg.windows);
+			if (fg) btn.Foreground = new Microsoft.UI.Xaml.Media.SolidColorBrush(fg.windows);
+		} else {
+			try { btn.ClearValue((Control as any).BackgroundProperty); } catch (_e) {}
+			try { btn.ClearValue((Control as any).ForegroundProperty); } catch (_e) {}
+		}
+	}
+
+	[selectedIndexProperty.getDefault](): number {
+		return -1;
+	}
+	[selectedIndexProperty.setNative](value: number) {
+		this._applySelection(value);
+	}
+
+	[itemsProperty.getDefault](): any {
+		return null;
+	}
+	[itemsProperty.setNative](_value: any) {
+		this._rebuildSegments();
+		selectedIndexProperty.coerce(this);
+	}
+
+	[selectedBackgroundColorProperty.setNative](_value: Color) {
+		this._applySelection(this.selectedIndex);
+	}
+
+	[selectedTextColorProperty.setNative](_value: Color) {
+		this._applySelection(this.selectedIndex);
+	}
+}
diff --git a/packages/core/ui/slider/index.windows.ts b/packages/core/ui/slider/index.windows.ts
new file mode 100644
index 0000000000..b7bde5e5a6
--- /dev/null
+++ b/packages/core/ui/slider/index.windows.ts
@@ -0,0 +1,144 @@
+export * from './slider-common';
+
+import { Background } from '../styling/background';
+import { SliderBase, valueProperty, minValueProperty, maxValueProperty } from './slider-common';
+import { colorProperty, backgroundColorProperty, backgroundInternalProperty } from '../styling/style-properties';
+import { Color } from '../../color';
+import { LinearGradient } from '../styling/linear-gradient';
+
+// Build a LinearGradientBrush from a NativeScript gradient, applying an optional alpha scale per stop.
+function buildGradientBrush(gradient: LinearGradient, startPt: any, endPt: any, alphaFactor: number): Microsoft.UI.Xaml.Media.LinearGradientBrush {
+	const brush = new Microsoft.UI.Xaml.Media.LinearGradientBrush();
+	brush.StartPoint = startPt;
+	brush.EndPoint = endPt;
+	for (let i = 0; i < gradient.colorStops.length; i++) {
+		const stop = gradient.colorStops[i];
+		const gs = new Microsoft.UI.Xaml.Media.GradientStop();
+
+		let winColor: Windows.UI.Color;
+		const src = stop.color as Color & { windows?: Windows.UI.Color };
+		if (src?.windows) {
+			const wc = src.windows;
+			winColor = { A: Math.max(0, Math.min(255, Math.round(wc.A * alphaFactor))), R: wc.R, G: wc.G, B: wc.B } as unknown as Windows.UI.Color;
+		} else {
+			const c = stop.color as { r?: number; g?: number; b?: number; a?: number } ?? {};
+			const norm = (v: number | undefined) => typeof v === 'number' ? (v <= 1 ? Math.round(v * 255) : Math.round(v)) : 0;
+			const a = Math.max(0, Math.min(255, Math.round(norm(c.a ?? 255) * alphaFactor)));
+			winColor = { A: a, R: norm(c.r), G: norm(c.g), B: norm(c.b) } as unknown as Windows.UI.Color;
+		}
+		gs.Color = winColor;
+
+		const offset = stop.offset as { unit?: string; value?: number } | undefined;
+		gs.Offset = offset?.unit === '%'
+			? Math.max(0, Math.min(1, (offset.value ?? 0) / 100))
+			: i / Math.max(1, gradient.colorStops.length - 1);
+
+		brush.GradientStops.Append(gs);
+	}
+	return brush;
+}
+
+export class Slider extends SliderBase {
+	nativeViewProtected: Microsoft.UI.Xaml.Controls.Slider;
+	private _windows: Microsoft.UI.Xaml.Controls.Slider;
+	private _pendingGradient: LinearGradient | null = null;
+	private _valueChangedDelegate: any = null;
+
+	public createNativeView(): Microsoft.UI.Xaml.Controls.Slider {
+		this._windows = new Microsoft.UI.Xaml.Controls.Slider();
+		if (this._pendingGradient) {
+			this._applyGradientToTrack(this._pendingGradient);
+			this._pendingGradient = null;
+		}
+		return this._windows;
+	}
+
+	public initNativeView(): void {
+		super.initNativeView();
+		const ref = new WeakRef(this);
+		this._valueChangedDelegate = NSWinRT.asDelegate('Microsoft.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler', (_sender: any, e: any) => {
+			const owner = ref.deref();
+			if (owner) valueProperty.nativeValueChange(owner, e.NewValue);
+		});
+		this.nativeViewProtected.ValueChanged = this._valueChangedDelegate;
+	}
+
+	public disposeNativeView(): void {
+		this._valueChangedDelegate = null;
+		super.disposeNativeView();
+	}
+
+	[valueProperty.setNative](value: number) {
+		this.nativeViewProtected.Value = value;
+	}
+
+	[minValueProperty.setNative](value: number) {
+		this.nativeViewProtected.Minimum = value;
+	}
+
+	[maxValueProperty.getDefault](): number {
+		return 100;
+	}
+	[maxValueProperty.setNative](value: number) {
+		this.nativeViewProtected.Maximum = value;
+	}
+
+	[colorProperty.getDefault](): number {
+		return -1;
+	}
+	[colorProperty.setNative](value: number | Color) {
+		if (!this.nativeViewProtected) return;
+		const resources = this.nativeViewProtected.Resources;
+		if (value instanceof Color) {
+			resources.Insert('SliderThumbBackground', new Microsoft.UI.Xaml.Media.SolidColorBrush(value.windows));
+		} else {
+			resources.Remove('SliderThumbBackground');
+		}
+	}
+
+	[backgroundColorProperty.getDefault](): number {
+		return -1;
+	}
+	[backgroundColorProperty.setNative](value: number | Color) {
+		if (!this.nativeViewProtected) return;
+		const resources = this.nativeViewProtected.Resources;
+		if (value instanceof Color) {
+			resources.Insert('SliderTrackValueFill', new Microsoft.UI.Xaml.Media.SolidColorBrush(value.windows));
+		} else {
+			resources.Remove('SliderTrackValueFill');
+		}
+	}
+
+	[backgroundInternalProperty.getDefault](): Background {
+		return null;
+	}
+	[backgroundInternalProperty.setNative](value: Background) {
+		if (!this.nativeViewProtected) {
+			this._pendingGradient = value && value.image instanceof LinearGradient ? value.image : null;
+			return;
+		}
+		const resources = this.nativeViewProtected.Resources;
+		if (value && value.image instanceof LinearGradient) {
+			this._applyGradientToTrack(value.image);
+			return;
+		}
+		resources.Remove('SliderTrackValueFill');
+		resources.Remove('SliderTrackBackgroundFill');
+	}
+
+	private _applyGradientToTrack(gradient: LinearGradient): void {
+		const nativeView = this.nativeViewProtected;
+		if (!nativeView || !gradient?.colorStops?.length) return;
+
+		const angle = typeof gradient.angle === 'number' ? gradient.angle : 0;
+		const rad = (angle * Math.PI) / 180;
+		const dx = Math.cos(rad);
+		const dy = Math.sin(rad);
+		const startPt = Microsoft.UI.Xaml.PointHelper.FromCoordinates(0.5 - dx / 2, 0.5 - dy / 2);
+		const endPt = Microsoft.UI.Xaml.PointHelper.FromCoordinates(0.5 + dx / 2, 0.5 + dy / 2);
+
+		const resources = nativeView.Resources;
+		resources.Insert('SliderTrackValueFill', buildGradientBrush(gradient, startPt, endPt, 1) as never);
+		resources.Insert('SliderTrackBackgroundFill', buildGradientBrush(gradient, startPt, endPt, 0.3) as never);
+	}
+}
diff --git a/packages/core/ui/split-view/index.windows.ts b/packages/core/ui/split-view/index.windows.ts
new file mode 100644
index 0000000000..71f729f251
--- /dev/null
+++ b/packages/core/ui/split-view/index.windows.ts
@@ -0,0 +1,516 @@
+export * from './split-view-common';
+
+import { SplitViewBase, displayModeProperty, splitBehaviorProperty, preferredPrimaryColumnWidthFractionProperty, preferredSupplementaryColumnWidthFractionProperty, preferredInspectorColumnWidthFractionProperty, navigationBarTintColorProperty } from './split-view-common';
+import { View } from '../core/view';
+import { layout } from '../../utils';
+import { FrameBase } from '../frame/frame-common';
+import { Color } from '../../color';
+import type { SplitRole } from '.';
+
+export class SplitView extends SplitViewBase {
+	static instance: SplitView;
+	static getInstance(): SplitViewBase | null {
+		return SplitView.instance;
+	}
+	primaryButtonAttached = false;
+	inspectorButtonAttached = false;
+	inspectorShowing = false;
+	primaryShowing = true;
+	nativeViewProtected: Microsoft.UI.Xaml.Controls.Grid;
+	private _grid: Microsoft.UI.Xaml.Controls.Grid;
+	private _containers = new Map<SplitRole, any>();
+	private _children = new Map<SplitRole, View>();
+	private _primaryDelegate: any = null;
+	private _inspectorDelegate: any = null;
+
+	get windows(): Microsoft.UI.Xaml.Controls.Grid {
+		return this._grid;
+	}
+
+	public createNativeView() {
+		this._grid = new Microsoft.UI.Xaml.Controls.Grid();
+		this._grid.HorizontalAlignment = Microsoft.UI.Xaml.HorizontalAlignment.Stretch;
+		this._grid.VerticalAlignment = Microsoft.UI.Xaml.VerticalAlignment.Stretch;
+		SplitView.instance = this;
+		this.nativeViewProtected = this._grid;
+		return this._grid;
+	}
+
+	public initNativeView(): void {
+		super.initNativeView && super.initNativeView();
+		this._applyPreferences();
+	}
+
+	public disposeNativeView(): void {
+		if (this._grid) {
+			this._grid.ColumnDefinitions.Clear();
+			this._grid.Children.Clear();
+		}
+
+		this._containers.clear();
+		this._children.clear();
+		this._primaryDelegate = null;
+		this._inspectorDelegate = null;
+		SplitView.instance = null;
+		this._grid = null;
+		super.disposeNativeView && super.disposeNativeView();
+	}
+
+	public _addViewToNativeVisualTree(child: View, atIndex: number = Number.MAX_SAFE_INTEGER): boolean {
+		// Call base so native/logic parent relationships and layout bookkeeping are set up correctly.
+		let res = true;
+		try { res = super._addViewToNativeVisualTree(child, atIndex); } catch (_e) { res = true; }
+
+		try {
+			const role = this._resolveRoleForChild(child as SplitViewBase, atIndex);
+			this._children.set(role, child);
+
+			const nativeChild = (child as any).nativeViewProtected as Microsoft.UI.Xaml.FrameworkElement;
+			let container = this._containers.get(role) as Microsoft.UI.Xaml.FrameworkElement;
+			if (!container && nativeChild) {
+				// nativeChild was appended to this._grid by super; keep it there and track it
+				nativeChild.HorizontalAlignment = Microsoft.UI.Xaml.HorizontalAlignment.Stretch;
+				nativeChild.VerticalAlignment = Microsoft.UI.Xaml.VerticalAlignment.Stretch;
+				this._containers.set(role, nativeChild);
+				container = nativeChild;
+			}
+
+			this._syncColumns();
+
+			// Ensure native layout pass occurs so children (ListView, Pages) can measure and render.
+			if (container) {
+				Microsoft.UI.Xaml.Controls.Grid.SetRow(container, 0);
+				container.InvalidateMeasure();
+				container.UpdateLayout();
+			}
+			this._grid.InvalidateMeasure();
+			this._grid.UpdateLayout();
+			this._invalidateAllChildLayouts();
+		} catch (_e) {}
+
+		return res;
+	}
+
+	public _removeViewFromNativeVisualTree(child: View): void {
+		try {
+			const role = this._findRoleByChild(child);
+			if (role) {
+				const container = this._containers.get(role);
+				if (container) {
+					(this._grid as any).Children.Remove(container);
+				}
+				try {
+					const childView: any = child as any;
+					const cmdBar = this._findCommandBarFor(childView);
+
+					if (childView._splitViewPrimaryNavigatedHandler) {
+						try { childView.off && childView.off(FrameBase.navigatedToEvent, childView._splitViewPrimaryNavigatedHandler); } catch (_e) {}
+						childView._splitViewPrimaryNavigatedHandler = null;
+					}
+					if (childView._splitViewPrimaryButton && cmdBar) {
+						try {
+							const cmds = (cmdBar as any).PrimaryCommands;
+							const size = cmds?.Size ?? 0;
+							for (let i = size - 1; i >= 0; i--) {
+								try { if (cmds.GetAt(i) === childView._splitViewPrimaryButton) { cmds.RemoveAt(i); break; } } catch (_e) {}
+							}
+						} catch (_e) {}
+						childView._splitViewPrimaryButton = null;
+						this.primaryButtonAttached = false;
+					}
+
+					if (childView._splitViewNavigatedHandler) {
+						try { childView.off && childView.off(FrameBase.navigatedToEvent, childView._splitViewNavigatedHandler); } catch (_e) {}
+						childView._splitViewNavigatedHandler = null;
+					}
+					if (childView._splitViewInspectorButton && cmdBar) {
+						try {
+							const cmds = (cmdBar as any).PrimaryCommands;
+							const size = cmds?.Size ?? 0;
+							for (let i = size - 1; i >= 0; i--) {
+								try { if (cmds.GetAt(i) === childView._splitViewInspectorButton) { cmds.RemoveAt(i); break; } } catch (_e) {}
+							}
+						} catch (_e) {}
+						childView._splitViewInspectorButton = null;
+						this.inspectorButtonAttached = false;
+					}
+				} catch (_e) {}
+
+				this._containers.delete(role);
+				this._children.delete(role);
+				this._syncColumns();
+			}
+		} catch (_e) {}
+
+		super._removeViewFromNativeVisualTree(child);
+	}
+
+	public onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void {
+		super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+
+		const width = layout.getMeasureSpecSize(widthMeasureSpec);
+		const widthMode = layout.getMeasureSpecMode(widthMeasureSpec);
+		const height = layout.getMeasureSpecSize(heightMeasureSpec);
+		const heightMode = layout.getMeasureSpecMode(heightMeasureSpec);
+
+		const horizontal = this.effectivePaddingLeft + this.effectivePaddingRight + this.effectiveBorderLeftWidth + this.effectiveBorderRightWidth;
+		const vertical = this.effectivePaddingTop + this.effectivePaddingBottom + this.effectiveBorderTopWidth + this.effectiveBorderBottomWidth;
+
+		const measuredWidth = Math.max(widthMode === layout.UNSPECIFIED ? 0 : width, this.effectiveMinWidth) + (widthMode === layout.UNSPECIFIED ? horizontal : 0);
+		const measuredHeight = Math.max(heightMode === layout.UNSPECIFIED ? 0 : height, this.effectiveMinHeight) + (heightMode === layout.UNSPECIFIED ? vertical : 0);
+
+		const widthAndState = View.resolveSizeAndState(measuredWidth, width, widthMode, 0);
+		const heightAndState = View.resolveSizeAndState(measuredHeight, height, heightMode, 0);
+		this.setMeasuredDimension(widthAndState, heightAndState);
+	}
+
+	public _invalidateAllChildLayouts(): void {
+		setTimeout(() => this.invalidateChildLayouts(), 0);
+	}
+
+	invalidateChildLayouts(delay: number = 0): void {
+		const refreshLayouts = () => {
+			for (const [role, child] of this._children.entries()) {
+				try { child.requestLayout && child.requestLayout(); } catch (_e) {}
+				const native = (child as any).nativeViewProtected as Microsoft.UI.Xaml.FrameworkElement;
+				if (native) {
+					native.InvalidateMeasure();
+					native.UpdateLayout();
+				}
+
+				if ((child as FrameBase)?.currentPage?.requestLayout) {
+					try { (child as FrameBase).currentPage.requestLayout(); } catch (_e) {}
+					const np = (child as FrameBase).currentPage.nativeViewProtected as Microsoft.UI.Xaml.FrameworkElement;
+					if (np) {
+						np.InvalidateMeasure();
+						np.UpdateLayout();
+					}
+				}
+			}
+
+			try { this.requestLayout(); } catch (_e) {}
+			if (this._grid) {
+				this._grid.InvalidateMeasure();
+				this._grid.UpdateLayout();
+			}
+		};
+
+		if (delay > 0) {
+			setTimeout(refreshLayouts, delay);
+		} else {
+			refreshLayouts();
+		}
+	}
+
+	private _resolveRoleForChild(child: SplitViewBase, atIndex: number): SplitRole {
+		const explicit = SplitViewBase.getRole(child);
+		if (explicit) return explicit;
+		return this._roleByIndex(atIndex) as SplitRole;
+	}
+
+	private _findRoleByChild(child: View): SplitRole | null {
+		for (const [role, c] of this._children.entries()) {
+			if (c === child) return role;
+		}
+		return null;
+	}
+
+	private _syncColumns(): void {
+		if (!this._grid) return;
+
+		try {
+			const ORDER: SplitRole[] = ['primary', 'secondary', 'supplementary', 'inspector'];
+			const activeRoles = ORDER.filter((r) => this._children.has(r));
+
+			const specified = new Map<SplitRole, number>();
+			let sumSpecified = 0;
+			if (activeRoles.indexOf('primary') >= 0 && typeof this.preferredPrimaryColumnWidthFraction === 'number' && this.preferredPrimaryColumnWidthFraction > 0) {
+				specified.set('primary', this.preferredPrimaryColumnWidthFraction);
+				sumSpecified += this.preferredPrimaryColumnWidthFraction;
+			}
+			if (activeRoles.indexOf('supplementary') >= 0 && typeof this.preferredSupplementaryColumnWidthFraction === 'number' && this.preferredSupplementaryColumnWidthFraction > 0) {
+				specified.set('supplementary', this.preferredSupplementaryColumnWidthFraction);
+				sumSpecified += this.preferredSupplementaryColumnWidthFraction;
+			}
+			if (activeRoles.indexOf('inspector') >= 0 && typeof this.preferredInspectorColumnWidthFraction === 'number' && this.preferredInspectorColumnWidthFraction > 0) {
+				specified.set('inspector', this.preferredInspectorColumnWidthFraction);
+				sumSpecified += this.preferredInspectorColumnWidthFraction;
+			}
+
+			const unspecifiedCount = activeRoles.length - specified.size;
+			const remaining = Math.max(0, 1 - sumSpecified);
+
+			const fractions: number[] = [];
+			for (const role of activeRoles) {
+				if (specified.has(role)) {
+					fractions.push(specified.get(role));
+				} else {
+					fractions.push(unspecifiedCount > 0 ? remaining / unspecifiedCount : 0);
+				}
+			}
+
+			const colDefs: Microsoft.UI.Xaml.Controls.ColumnDefinition[] = [];
+			for (let i = 0; i < fractions.length; i++) {
+				const cd = new Microsoft.UI.Xaml.Controls.ColumnDefinition();
+				const weight = fractions[i] > 0 ? fractions[i] : 1;
+				cd.Width = Microsoft.UI.Xaml.GridLengthHelper.FromValueAndType(weight, Microsoft.UI.Xaml.GridUnitType.Star);
+				colDefs.push(cd);
+			}
+
+			try { this._grid.ColumnDefinitions.ReplaceAll(colDefs); } catch (_e) {
+				try { this._grid.ColumnDefinitions.Clear(); } catch (_e2) {}
+				for (const cd of colDefs) {
+					try { this._grid.ColumnDefinitions.Append(cd); } catch (_e3) {}
+				}
+			}
+
+			for (let i = 0; i < activeRoles.length; i++) {
+				const role = activeRoles[i];
+				let container = this._containers.get(role) as Microsoft.UI.Xaml.FrameworkElement;
+				if (!container) {
+					const grid = new Microsoft.UI.Xaml.Controls.Grid();
+					grid.HorizontalAlignment = Microsoft.UI.Xaml.HorizontalAlignment.Stretch;
+					grid.VerticalAlignment = Microsoft.UI.Xaml.VerticalAlignment.Stretch;
+					this._containers.set(role, grid);
+					container = grid;
+					this._grid.Children.Append(grid);
+				}
+				Microsoft.UI.Xaml.Controls.Grid.SetColumn(container, i);
+			}
+
+			for (const [role, container] of Array.from(this._containers.entries())) {
+				if (activeRoles.indexOf(role) === -1) {
+					try { (this._grid.Children as any).Remove(container); } catch (_e) {}
+					this._containers.delete(role);
+				}
+			}
+
+			this._applyPreferences();
+		} catch (_e) {}
+	}
+
+	private _applyPreferences(): void {
+		if (!this._grid) return;
+
+		try {
+			const ORDER: SplitRole[] = ['primary', 'secondary', 'supplementary', 'inspector'];
+			const activeRoles = ORDER.filter((r) => this._children.has(r));
+
+			const cols = this._grid.ColumnDefinitions;
+			const colCount = cols?.Size ?? 0;
+			for (let i = 0; i < colCount; i++) {
+				try {
+					const cd = cols.GetAt(i);
+					// star sizing already set by _syncColumns; nothing to change per-column here
+				} catch (_e) {}
+			}
+
+			// Attach toggle buttons to Frame command bars (show/hide primary/inspector columns).
+			try {
+				const primary = this._children.get('primary');
+				if (primary) {
+					this.attachPrimaryButton();
+				}
+				const inspector = this._children.get('inspector');
+				if (inspector) {
+					this.attachInspectorButton();
+				}
+			} catch (_e) {}
+		} catch (_e) {}
+	}
+
+	showPrimary(): void {
+		const container = this._containers.get('primary') as Microsoft.UI.Xaml.UIElement;
+		if (!container) return;
+		container.Visibility = Microsoft.UI.Xaml.Visibility.Visible;
+		this.primaryShowing = true;
+		this._invalidateAllChildLayouts();
+	}
+
+	hidePrimary(): void {
+		const container = this._containers.get('primary') as Microsoft.UI.Xaml.UIElement;
+		if (!container) return;
+		container.Visibility = Microsoft.UI.Xaml.Visibility.Collapsed;
+		this.primaryShowing = false;
+		this._invalidateAllChildLayouts();
+	}
+
+	showSecondary(): void {
+		const container = this._containers.get('secondary') as Microsoft.UI.Xaml.UIElement;
+		if (!container) return;
+		container.Visibility = Microsoft.UI.Xaml.Visibility.Visible;
+		this._invalidateAllChildLayouts();
+	}
+
+	hideSecondary(): void {
+		const container = this._containers.get('secondary') as Microsoft.UI.Xaml.UIElement;
+		if (!container) return;
+		container.Visibility = Microsoft.UI.Xaml.Visibility.Collapsed;
+		this._invalidateAllChildLayouts();
+	}
+
+	showSupplementary(): void {
+		const container = this._containers.get('supplementary') as Microsoft.UI.Xaml.UIElement;
+		if (!container) return;
+		container.Visibility = Microsoft.UI.Xaml.Visibility.Visible;
+		this._invalidateAllChildLayouts();
+	}
+
+	hideSupplementary(): void {
+		const container = this._containers.get('supplementary') as Microsoft.UI.Xaml.UIElement;
+		if (!container) return;
+		container.Visibility = Microsoft.UI.Xaml.Visibility.Collapsed;
+		this._invalidateAllChildLayouts();
+	}
+
+	showInspector(): void {
+		const container = this._containers.get('inspector') as Microsoft.UI.Xaml.UIElement;
+		if (!container) return;
+		container.Visibility = Microsoft.UI.Xaml.Visibility.Visible;
+		this.notifyInspectorChange(true);
+		this._invalidateAllChildLayouts();
+	}
+
+	hideInspector(): void {
+		const container = this._containers.get('inspector') as Microsoft.UI.Xaml.UIElement;
+		if (!container) return;
+		container.Visibility = Microsoft.UI.Xaml.Visibility.Collapsed;
+		this.notifyInspectorChange(false);
+		this._invalidateAllChildLayouts();
+	}
+
+	notifyInspectorChange(showing: boolean): void {
+		this.inspectorShowing = showing;
+		this.notify({
+			eventName: 'inspectorChange',
+			object: this,
+			data: { showing },
+		});
+	}
+
+	private _findCommandBarFor(childView: any): any {
+		try {
+			const native = (childView && (childView.nativeViewProtected || childView.windows || childView)) as any;
+			if (!native) return null;
+			const visited = new Set<any>();
+			const walk = (node: any, depth = 0): any => {
+				if (!node || depth > 8 || visited.has(node)) return null;
+				visited.add(node);
+				try { if ((node as any).PrimaryCommands !== undefined) return node; } catch (_e) {}
+				try {
+					const children = node.Children as any;
+					if (children && typeof children.Size === 'number') {
+						for (let i = 0; i < (children.Size ?? 0); i++) {
+							try {
+								const el = children.GetAt(i);
+								const found = walk(el, depth + 1);
+								if (found) return found;
+							} catch (_e) {}
+						}
+					}
+				} catch (_e) {}
+				return null;
+			};
+			return walk(native, 0);
+		} catch (_e) {}
+		return null;
+	}
+
+	private attachPrimaryButton(): void {
+		if (this.primaryButtonAttached) return;
+
+		const primaryChild = this._children.get('primary') as any;
+		if (!primaryChild) return;
+
+		const cmdBar = this._findCommandBarFor(primaryChild);
+		if (!cmdBar) {
+			// Wait for frame navigation so the command bar exists
+			if (primaryChild && primaryChild.on && !primaryChild._splitViewPrimaryNavigatedHandler) {
+				primaryChild._splitViewPrimaryNavigatedHandler = () => {
+					setTimeout(() => this.attachPrimaryButton(), 0);
+				};
+				try { primaryChild.on(FrameBase.navigatedToEvent, primaryChild._splitViewPrimaryNavigatedHandler); } catch (_e) {}
+			}
+			return;
+		}
+
+		if (primaryChild._splitViewPrimaryButton) return;
+
+		const btn = new Microsoft.UI.Xaml.Controls.AppBarButton();
+		const fontIcon = new Microsoft.UI.Xaml.Controls.FontIcon();
+		fontIcon.Glyph = '\u2630';
+		btn.Icon = fontIcon;
+
+		const that = new WeakRef(this);
+		this._primaryDelegate = NSWinRT.asDelegate('Microsoft.UI.Xaml.RoutedEventHandler', () => {
+			const owner = that.deref();
+			if (!owner) return;
+			if (owner.primaryShowing) { owner.hidePrimary(); } else { owner.showPrimary(); }
+		});
+		btn.Click = this._primaryDelegate as never;
+		try { (cmdBar as any).PrimaryCommands.Append(btn); } catch (_e) {}
+		primaryChild._splitViewPrimaryButton = btn;
+		this.primaryButtonAttached = true;
+	}
+
+	private attachInspectorButton(): void {
+		if (this.inspectorButtonAttached) return;
+
+		const inspectorChild = this._children.get('inspector') as any;
+		if (!inspectorChild) return;
+
+		const cmdBar = this._findCommandBarFor(inspectorChild);
+		if (!cmdBar) {
+			if (inspectorChild && inspectorChild.on && !inspectorChild._splitViewNavigatedHandler) {
+				inspectorChild._splitViewNavigatedHandler = () => {
+					setTimeout(() => this.attachInspectorButton(), 100);
+				};
+				try { inspectorChild.on(FrameBase.navigatedToEvent, inspectorChild._splitViewNavigatedHandler); } catch (_e) {}
+			}
+			return;
+		}
+
+		if (inspectorChild._splitViewInspectorButton) return;
+
+		const btn = new Microsoft.UI.Xaml.Controls.AppBarButton();
+		const fontIcon = new Microsoft.UI.Xaml.Controls.FontIcon();
+		fontIcon.Glyph = '\u25A3';
+		btn.Icon = fontIcon;
+
+		const that = new WeakRef(this);
+		this._inspectorDelegate = NSWinRT.asDelegate('Microsoft.UI.Xaml.RoutedEventHandler', () => {
+			const owner = that.deref();
+			if (!owner) return;
+			if (owner.inspectorShowing) { owner.hideInspector(); } else { owner.showInspector(); }
+		});
+		btn.Click = this._inspectorDelegate as never;
+		try { (cmdBar as any).PrimaryCommands.Append(btn); } catch (_e) {}
+		inspectorChild._splitViewInspectorButton = btn;
+		this.inspectorButtonAttached = true;
+	}
+
+	[displayModeProperty.setNative](value: string) {
+		this._syncColumns();
+	}
+
+	[splitBehaviorProperty.setNative](value: string) {
+		this._syncColumns();
+	}
+
+	[preferredPrimaryColumnWidthFractionProperty.setNative](value: number) {
+		this._syncColumns();
+	}
+
+	[preferredSupplementaryColumnWidthFractionProperty.setNative](value: number) {
+		this._syncColumns();
+	}
+
+	[preferredInspectorColumnWidthFractionProperty.setNative](value: number) {
+		this._syncColumns();
+	}
+
+	[navigationBarTintColorProperty.setNative](value: Color) {
+		// iOS-only tint color; no-op on Windows.
+	}
+}
+
diff --git a/packages/core/ui/styling/background.windows.ts b/packages/core/ui/styling/background.windows.ts
new file mode 100644
index 0000000000..b4a5979fe5
--- /dev/null
+++ b/packages/core/ui/styling/background.windows.ts
@@ -0,0 +1,3 @@
+export * from './background-common';
+
+export namespace windows {}
\ No newline at end of file
diff --git a/packages/core/ui/styling/font.windows.ts b/packages/core/ui/styling/font.windows.ts
new file mode 100644
index 0000000000..3d1c2baac9
--- /dev/null
+++ b/packages/core/ui/styling/font.windows.ts
@@ -0,0 +1,188 @@
+import { Font as FontBase, parseFontFamily, genericFontFamilies, FontWeight, FontVariationSettings } from './font-common';
+import type { FontStyleType, FontWeightType, FontVariationSettingsType } from './font-interfaces';
+
+export * from './font-common';
+
+
+export const fontFamilyCache = new Map<string, Microsoft.UI.Xaml.Media.FontFamily | null>();
+
+// Maps lowercase font family name → ms-appx:///fonts/<file>#<face> URI for app-packaged fonts.
+const _fontNameToUri = new Map<string, string>();
+let _fontsScanDone = false;
+
+// Scans the app package's app/fonts/ directory once (blocking via .done()) and populates
+// _fontNameToUri so bare family names like "FontAwesome" resolve to their ms-appx URI.
+// NativeScript Windows packages bundle app assets under <InstallRoot>/app/, so fonts live at
+// <InstallRoot>/app/fonts/ → accessible as ms-appx:///app/fonts/<file>.
+function ensureFontsScan(): void {
+    if (_fontsScanDone) return;
+    _fontsScanDone = true;
+    try {
+        (Windows.ApplicationModel.Package.Current.InstalledLocation.GetFolderAsync('app') as any).done((appFolder: any) => {
+            if (!appFolder) return;
+            (appFolder.GetFolderAsync('fonts') as any).done((fontsFolder: any) => {
+                if (!fontsFolder) return;
+                (fontsFolder.GetFilesAsync() as any).done((files: any) => {
+                    if (!files) return;
+                    const count: number = files.Size ?? 0;
+                    for (let i = 0; i < count; i++) {
+                        const file = files.GetAt(i);
+                        const name: string = file.Name;
+                        if (/\.(ttf|otf|woff|woff2)$/i.test(name)) {
+                            const faceName = name.replace(/\.[^.]+$/, '');
+                            _fontNameToUri.set(faceName.toLowerCase(), `ms-appx:///app/fonts/${name}#${faceName}`);
+                        }
+                    }
+                });
+            });
+        });
+    } catch (_e) {}
+}
+
+function sanitizeFontFamily(raw: string): string {
+    if (!raw) return '';
+    let f = String(raw).trim();
+    if ((f.startsWith('"') && f.endsWith('"')) || (f.startsWith("'") && f.endsWith("'"))) {
+        f = f.substring(1, f.length - 1);
+    }
+    const commaIdx = f.indexOf(',');
+    if (commaIdx >= 0) f = f.substring(0, commaIdx).trim();
+    // Map NativeScript tilde path (~/) to Windows app directory (ms-appx:///app/).
+    // ~/fonts/Foo.ttf#Foo → app/fonts/Foo.ttf#Foo → handled as ms-appx path below.
+    if (f.startsWith('~/')) {
+        f = 'app/' + f.substring(2);
+    }
+    // Strip common URI scheme prefixes (e.g. font://, sys://)
+    f = f.replace(/^[a-zA-Z]+:\/\//, '');
+    return f;
+}
+
+function createFontFamilyCandidate(candidate: string): Microsoft.UI.Xaml.Media.FontFamily | null {
+    if (!candidate) return null;
+    try {
+        if (fontFamilyCache.has(candidate)) {
+            return fontFamilyCache.get(candidate) ?? null;
+        }
+
+        const ff = new Microsoft.UI.Xaml.Media.FontFamily(candidate);
+        fontFamilyCache.set(candidate, ff);
+        return ff;
+    } catch (err) {
+        fontFamilyCache.set(candidate, null);
+        return null;
+    }
+}
+
+export function getFontFamilyCached(family: string): Microsoft.UI.Xaml.Media.FontFamily | null {
+    ensureFontsScan();
+    const candidate = sanitizeFontFamily(String(family || ''));
+    if (!candidate) return null;
+
+    // Resolve bare name to app-packaged font URI before cache lookup.
+    let uri = candidate;
+    if (!candidate.includes('#') && !candidate.includes('/') && !candidate.includes('\\')) {
+        uri = _fontNameToUri.get(candidate.toLowerCase()) ?? candidate;
+    } else if (!candidate.includes('#') && (candidate.includes('/') || candidate.includes('\\'))) {
+        uri = candidate.startsWith('ms-appx') ? candidate
+            : 'ms-appx:///' + candidate.replace(/^\/+/, '');
+    }
+
+    if (fontFamilyCache.has(uri)) {
+        return fontFamilyCache.get(uri) ?? null;
+    }
+
+    return createFontFamilyCandidate(uri);
+}
+
+export function applyFontFamilyTo(target: any, fontFamilyValue: string): void {
+    if (!target || !fontFamilyValue) return;
+    ensureFontsScan();
+
+    const candidate = sanitizeFontFamily(String(fontFamilyValue || ''));
+    if (!candidate) return;
+
+    let uri: string;
+    if (candidate.includes('#')) {
+        // Already has face name (full URI or path#face) — normalise to ms-appx if it's a bare path.
+        uri = candidate.startsWith('ms-appx') ? candidate
+            : 'ms-appx:///' + candidate.replace(/^\/+/, '');
+    } else if (candidate.includes('/') || candidate.includes('\\')) {
+        // Path without face name — try ms-appx prefix.
+        uri = candidate.startsWith('ms-appx') ? candidate
+            : 'ms-appx:///' + candidate.replace(/^\/+/, '');
+    } else {
+        // Bare font family name. Check the scanned app font map first so "FontAwesome" resolves
+        // to "ms-appx:///fonts/FontAwesome.ttf#FontAwesome"; fall back to system font name.
+        uri = _fontNameToUri.get(candidate.toLowerCase()) ?? candidate;
+    }
+
+    const ff = createFontFamilyCandidate(uri);
+    if (ff) {
+        try {
+            target.FontFamily = ff;
+        } catch (_e) {}
+    }
+}
+
+export function clearFontFamilyCache(): void {
+    fontFamilyCache.clear();
+}
+
+export class Font extends FontBase {
+    static default = new Font('', 0);
+
+    constructor(family: string, size: number, style?: FontStyleType, weight?: FontWeightType, scale?: number, variationSettings?: Array<FontVariationSettingsType>) {
+        super(family, size, style, weight, scale, variationSettings ?? undefined);
+    }
+
+    public withFontFamily(family: string): Font {
+        return new Font(family, this.fontSize, this.fontStyle, this.fontWeight, 1, this.fontVariationSettings ?? undefined);
+    }
+
+    public withFontStyle(style: FontStyleType): Font {
+        return new Font(this.fontFamily, this.fontSize, style, this.fontWeight, this.fontScale, this.fontVariationSettings ?? undefined);
+    }
+
+    public withFontWeight(weight: FontWeightType): Font {
+        return new Font(this.fontFamily, this.fontSize, this.fontStyle, weight, this.fontScale, this.fontVariationSettings ?? undefined);
+    }
+
+    public withFontSize(size: number): Font {
+        return new Font(this.fontFamily, size, this.fontStyle, this.fontWeight, this.fontScale, this.fontVariationSettings ?? undefined);
+    }
+
+    public withFontScale(scale: number): Font {
+        return new Font(this.fontFamily, this.fontSize, this.fontStyle, this.fontWeight, scale, this.fontVariationSettings ?? undefined);
+    }
+
+    public withFontVariationSettings(variationSettings?: Array<FontVariationSettingsType>): Font {
+        return new Font(this.fontFamily, this.fontSize, this.fontStyle, this.fontWeight, this.fontScale, variationSettings ?? undefined);
+    }
+
+    public getAndroidTypeface(): any {
+        return undefined;
+    }
+
+    getWindowsFontDescriptor(defaultFont: any): any {
+        const families = parseFontFamily(this.fontFamily);
+        const fontSize = this.fontSize ? this.fontSize * (this.fontScale ?? 1) : (defaultFont?.pointSize ?? 0);
+
+        return {
+            fontFamily: families,
+            fontFamilyNative: getFontFamilyCached(this.fontFamily),
+            fontSize,
+            fontWeight: this.fontWeight ?? FontWeight.NORMAL,
+            fontVariationSettings: this.fontVariationSettings ?? undefined,
+            isBold: this.isBold,
+            isItalic: this.isItalic,
+        } as any;
+    }
+
+    applyWindowsFont(target: any) {
+        applyFontFamilyTo(target, this.fontFamily);
+    }
+
+    public getUIFont(defaultFont: any): any {
+        return undefined;
+    }
+}
diff --git a/packages/core/ui/styling/style-properties.ts b/packages/core/ui/styling/style-properties.ts
index bb65f7f602..b41f65b676 100644
--- a/packages/core/ui/styling/style-properties.ts
+++ b/packages/core/ui/styling/style-properties.ts
@@ -686,6 +686,8 @@ export const backgroundPositionProperty = new CssProperty<Style, string>({
 });
 backgroundPositionProperty.register(Style);
 
+
+
 // Border Color properties.
 const borderColorProperty = new ShorthandProperty<Style, string | Color>({
 	name: 'borderColor',
diff --git a/packages/core/ui/switch/index.windows.ts b/packages/core/ui/switch/index.windows.ts
new file mode 100644
index 0000000000..199776808c
--- /dev/null
+++ b/packages/core/ui/switch/index.windows.ts
@@ -0,0 +1,107 @@
+export * from './switch-common';
+
+import { SwitchBase, checkedProperty, offBackgroundColorProperty } from './switch-common';
+import { colorProperty, backgroundColorProperty, backgroundInternalProperty } from '../styling/style-properties';
+import { Color } from '../../color';
+
+export class Switch extends SwitchBase {
+	nativeViewProtected: Microsoft.UI.Xaml.Controls.ToggleSwitch;
+	private _toggledHandler: ((sender: Microsoft.UI.Xaml.Controls.ToggleSwitch) => void) | null = null;
+	private _windows: Microsoft.UI.Xaml.Controls.ToggleSwitch;
+
+	constructor() {
+		super();
+		// WinRT deferred to createNativeView() — keeps constructor pure-JS.
+	}
+
+	public createNativeView() {
+		this._windows = new Microsoft.UI.Xaml.Controls.ToggleSwitch();
+		return this._windows;
+	}
+
+	get windows(): Microsoft.UI.Xaml.Controls.ToggleSwitch {
+		return this._windows;
+	}
+
+	public initNativeView(): void {
+		super.initNativeView();
+
+		const that = new WeakRef(this);
+		const native = this.nativeViewProtected;
+
+		// Toggled is a generic TypedEventHandler<ToggleSwitch, RoutedEventArgs> — the runtime can't derive
+		// the parameterized GUID from a plain assignment, so build via asDelegate (can throw; keep guarded).
+		const handler = (s: Microsoft.UI.Xaml.Controls.ToggleSwitch) => {
+			const owner = that.deref();
+			if (!owner) return;
+			checkedProperty.nativeValueChange(owner, s.IsOn ?? false);
+		};
+		this._toggledHandler = handler;
+		try {
+			const typeName = 'Windows.Foundation.TypedEventHandler`2<Microsoft.UI.Xaml.Controls.ToggleSwitch,Microsoft.UI.Xaml.RoutedEventArgs>';
+			native.Toggled = NSWinRT.asDelegate(typeName, handler);
+		} catch (_e) {
+			native.Toggled = handler as unknown as Microsoft.UI.Xaml.RoutedEventHandler;
+		}
+	}
+
+	public disposeNativeView(): void {
+		const native = this.nativeViewProtected;
+		if (native && this._toggledHandler) {
+			native.Toggled = null;
+			this._toggledHandler = null;
+		}
+
+		super.disposeNativeView();
+	}
+
+	[checkedProperty.getDefault](): boolean {
+		return false;
+	}
+	[checkedProperty.setNative](value: boolean) {
+		if (this.nativeViewProtected) {
+			this.nativeViewProtected.IsOn = !!value;
+		}
+	}
+
+	[colorProperty.setNative](value: number | Color) {
+		if (!this.nativeViewProtected) return;
+		const resources = this.nativeViewProtected.Resources;
+
+		if (value instanceof Color) {
+			const color = new Microsoft.UI.Xaml.Media.SolidColorBrush(value.windows);
+			resources.Insert('ToggleSwitchKnobFillOn', color);
+			resources.Insert('ToggleSwitchKnobFillOff', color);
+		} else {
+			resources.Remove('ToggleSwitchKnobFillOn');
+			resources.Remove('ToggleSwitchKnobFillOff');
+		}
+	}
+
+	[backgroundColorProperty.setNative](value: number | Color) {
+		if (!this.nativeViewProtected) return;
+		if (!this.offBackgroundColor || this.checked) {
+			const resources = this.nativeViewProtected.Resources;
+			if (value instanceof Color) {
+				resources.Insert('ToggleSwitchFillOn', new Microsoft.UI.Xaml.Media.SolidColorBrush(value.windows));
+			} else {
+				resources.Remove('ToggleSwitchFillOn');
+			}
+		}
+	}
+
+	[backgroundInternalProperty.setNative](_value: any) {}
+
+
+	[offBackgroundColorProperty.setNative](value: number | Color) {
+		if (!this.nativeViewProtected) return;
+		if (!this.checked) {
+			const resources = this.nativeViewProtected.Resources;
+			if (value instanceof Color) {
+				resources.Insert('ToggleSwitchFillOff', new Microsoft.UI.Xaml.Media.SolidColorBrush(value.windows));
+			} else {
+				resources.Remove('ToggleSwitchFillOff');
+			}
+		}
+	}
+}
diff --git a/packages/core/ui/tab-view/index.windows.ts b/packages/core/ui/tab-view/index.windows.ts
new file mode 100644
index 0000000000..9a15bc5066
--- /dev/null
+++ b/packages/core/ui/tab-view/index.windows.ts
@@ -0,0 +1,264 @@
+export * from './tab-view-common';
+
+import { TabViewBase, TabViewItemBase } from './tab-view-common';
+import { ImageSource } from '../../image-source';
+import { knownFolders, path as fsPath } from '../../file-system';
+
+const TAB_HEIGHT = 48;
+
+// Resolves a tab `iconSource` (res://, ~/, file/abs path, http(s)) to a native bitmap and applies it.
+function resolveIconBitmap(src: string, apply: (bmp: any) => void): void {
+	if (!src) return;
+	try {
+		if (src.indexOf('res://') === 0) {
+			const imgSrc = ImageSource.fromResourceSync(src.substring('res://'.length)) as any;
+			if (imgSrc?.windows) apply(imgSrc.windows);
+		} else if (src.indexOf('~/') === 0) {
+			const filePath = fsPath.join(knownFolders.currentApp().path, src.replace('~/', ''));
+			const imgSrc = ImageSource.fromFileSync(filePath) as any;
+			if (imgSrc?.windows) apply(imgSrc.windows);
+		} else if (src.indexOf('http') === 0) {
+			ImageSource.fromUrl(src).then((imgSrc: any) => { if (imgSrc?.windows) apply(imgSrc.windows); }).catch(() => {});
+		} else {
+			const imgSrc = ImageSource.fromFileSync(src) as any;
+			if (imgSrc?.windows) apply(imgSrc.windows);
+		}
+	} catch (_e) {}
+}
+
+export class TabViewItem extends TabViewItemBase {
+	public _update(): void {
+		const parent = this.parent as TabView;
+		if (!parent) return;
+		parent._updateTabButton(this as any);
+	}
+}
+
+export class TabView extends TabViewBase {
+	declare nativeViewProtected: Microsoft.UI.Xaml.Controls.Grid;
+
+	private _outerGrid: Microsoft.UI.Xaml.Controls.Grid;
+	private _tabStrip: Microsoft.UI.Xaml.Controls.StackPanel;
+	private _contentArea: Microsoft.UI.Xaml.Controls.Grid;
+	private _tabButtons: Microsoft.UI.Xaml.Controls.Button[] = [];
+	// Held to prevent V8 from GC'ing the JS wrappers (a collected delegate goes dead on click).
+	private _tabButtonDelegates: any[] = [];
+
+	public createNativeView(): Microsoft.UI.Xaml.Controls.Grid {
+		this._outerGrid = new Microsoft.UI.Xaml.Controls.Grid();
+
+		const r0 = new Microsoft.UI.Xaml.Controls.RowDefinition();
+		r0.Height = new Microsoft.UI.Xaml.GridLength(1, Microsoft.UI.Xaml.GridUnitType.Auto);
+		const r1 = new Microsoft.UI.Xaml.Controls.RowDefinition();
+		r1.Height = new Microsoft.UI.Xaml.GridLength(1, Microsoft.UI.Xaml.GridUnitType.Star);
+		this._outerGrid.RowDefinitions.Append(r0);
+		this._outerGrid.RowDefinitions.Append(r1);
+
+		this._tabStrip = new Microsoft.UI.Xaml.Controls.StackPanel();
+		this._tabStrip.Orientation = Microsoft.UI.Xaml.Controls.Orientation.Horizontal;
+		Microsoft.UI.Xaml.Controls.Grid.SetRow(this._tabStrip, 0);
+		this._outerGrid.Children.Append(this._tabStrip);
+
+		this._contentArea = new Microsoft.UI.Xaml.Controls.Grid();
+		Microsoft.UI.Xaml.Controls.Grid.SetRow(this._contentArea, 1);
+		this._outerGrid.Children.Append(this._contentArea);
+
+		return this._outerGrid;
+	}
+
+	get windows(): Microsoft.UI.Xaml.Controls.Grid {
+		return this._outerGrid;
+	}
+
+	public _addChildFromBuilder(name: string, value: any): void {
+		if (value instanceof TabViewItemBase) {
+			(value as any).canBeLoaded = true;
+		}
+		super._addChildFromBuilder(name, value);
+		if (value instanceof TabViewItemBase) {
+			this._rebuildTabStrip();
+		}
+	}
+
+	public initNativeView(): void {
+		super.initNativeView();
+		this._rebuildTabStrip();
+	}
+
+	public onItemsChanged(oldItems: any[], newItems: any[]): void {
+		this._clearTabButtons();
+		if (this._tabStrip) this._tabStrip.Children.Clear();
+		this._clearContent();
+
+		if (newItems) {
+			for (const item of newItems) {
+				(item as any).canBeLoaded = true;
+			}
+		}
+
+		super.onItemsChanged(oldItems, newItems);
+
+		if (!newItems) return;
+
+		this._rebuildTabStrip();
+
+		if (this.isLoaded) {
+			this._showContent(Math.max(0, this.selectedIndex ?? 0));
+		}
+	}
+
+	public onLoaded(): void {
+		super.onLoaded();
+		this._clearContent();
+		const idx = Math.max(0, this.selectedIndex ?? 0);
+		this._showContent(idx);
+		this._highlightTab(idx);
+	}
+
+	public onSelectedIndexChanged(oldIndex: number, newIndex: number): void {
+		super.onSelectedIndexChanged(oldIndex, newIndex);
+		this._clearContent();
+		this._showContent(newIndex);
+		this._highlightTab(newIndex);
+	}
+
+	public disposeNativeView(): void {
+		this._clearTabButtons();
+		super.disposeNativeView();
+	}
+
+	public _updateTabButton(item: TabViewItemBase): void {
+		if (!this.items) return;
+		const idx = this.items.indexOf(item as any);
+		if (idx >= 0 && idx < this._tabButtons.length) {
+			this._tabButtons[idx].Content = this._buildButtonContent(item);
+		}
+	}
+
+	// WinUI Button shows only its string Content unless given a UIElement, so an icon-only tab
+	// needs an Image element; if both title and icon are present they are stacked vertically.
+	private _buildButtonContent(item: any): any {
+		const title: string = item?.title ?? '';
+		const iconSrc: string = item?.iconSource;
+		if (!iconSrc) {
+			return title;
+		}
+		const img = new Microsoft.UI.Xaml.Controls.Image();
+		img.Width = 24;
+		img.Height = 24;
+		img.Stretch = 2 as never; // Uniform
+		resolveIconBitmap(iconSrc, (bmp) => { try { img.Source = bmp; } catch (_e) {} });
+		if (!title) {
+			return img;
+		}
+		const stack = new Microsoft.UI.Xaml.Controls.StackPanel();
+		stack.Orientation = Microsoft.UI.Xaml.Controls.Orientation.Vertical;
+		stack.HorizontalAlignment = 1 as never; // Center
+		const tb = new Microsoft.UI.Xaml.Controls.TextBlock();
+		tb.Text = title;
+		tb.FontSize = 12;
+		tb.HorizontalAlignment = 1 as never; // Center
+		stack.Children.Append(img);
+		stack.Children.Append(tb);
+		return stack;
+	}
+
+	private _rebuildTabStrip(): void {
+		if (!this._tabStrip) return;
+		this._clearTabButtons();
+		this._tabStrip.Children.Clear();
+		const items = this.items;
+		if (!items) return;
+		for (let i = 0; i < items.length; i++) {
+			this._createTabButton(items[i], i);
+		}
+		this._highlightTab(Math.max(0, this.selectedIndex ?? 0));
+	}
+
+	private _createTabButton(item: any, index: number): void {
+		const btn = new Microsoft.UI.Xaml.Controls.Button();
+		btn.Content = this._buildButtonContent(item);
+		btn.MinWidth = 80;
+		btn.Height = TAB_HEIGHT;
+
+		const that = new WeakRef(this);
+		const fn = () => {
+			const owner = that.deref();
+			if (owner) owner.selectedIndex = index;
+		};
+		const del = NSWinRT.asDelegate('Microsoft.UI.Xaml.RoutedEventHandler', fn);
+		btn.Click = del as never;
+		this._tabButtonDelegates[index] = del;
+
+		this._tabButtons[index] = btn;
+		this._tabStrip.Children.Append(btn);
+	}
+
+	private _clearTabButtons(): void {
+		for (const btn of this._tabButtons) {
+			if (btn) btn.Click = null as never;
+		}
+		this._tabButtons = [];
+		this._tabButtonDelegates = [];
+	}
+
+	private _clearContent(): void {
+		if (!this._contentArea) return;
+		const children = this._contentArea.Children;
+		for (let i = children.Size - 1; i >= 0; i--) {
+			try { children.RemoveAt(i); } catch (_e) {}
+		}
+	}
+
+	private _showContent(index: number): void {
+		if (!this._contentArea) return;
+		const items = this.items;
+		if (!items || index < 0 || index >= items.length) return;
+		const item = items[index] as any;
+		const view = item?.view;
+		const native = view?.nativeViewProtected as Microsoft.UI.Xaml.FrameworkElement;
+		if (native) {
+			try {
+				native.HorizontalAlignment = 3 as never; // Stretch
+				native.VerticalAlignment = 3 as never; // Stretch
+				this._contentArea.Children.Append(native);
+			} catch (_e) {
+				console.error('[TabView] _showContent: failed to append native view for tab', index, _e);
+			}
+			// Ensure the NS view is marked loaded so Repeaters flush _isDirty and bindings
+			// propagate. super.onLoaded() loads all tabs, but if something races (e.g. items
+			// set after the first load), this guarantees the shown view is always live.
+			if (view && !view.isLoaded) {
+				try { view.callLoaded?.(); } catch (_e) {}
+			}
+		} else if (!native) {
+			// nativeViewProtected not yet created — defer until after the layout pass.
+			setTimeout(() => {
+				if (!this._contentArea) return;
+				const deferred = (this.items?.[index] as any)?.view;
+				const n = deferred?.nativeViewProtected as Microsoft.UI.Xaml.FrameworkElement;
+				if (n) {
+					try {
+						n.HorizontalAlignment = 3 as never;
+						n.VerticalAlignment = 3 as never;
+						this._clearContent();
+						this._contentArea.Children.Append(n);
+					} catch (_e) {}
+					if (deferred && !deferred.isLoaded) {
+						try { deferred.callLoaded?.(); } catch (_e) {}
+					}
+				}
+			}, 0);
+		}
+	}
+
+	private _highlightTab(selectedIndex: number): void {
+		for (let i = 0; i < this._tabButtons.length; i++) {
+			const btn = this._tabButtons[i];
+			if (!btn) continue;
+			(btn as any).FontWeight = i === selectedIndex
+				? Microsoft.UI.Text.FontWeights.Bold
+				: Microsoft.UI.Text.FontWeights.Normal;
+		}
+	}
+}
diff --git a/packages/core/ui/text-base/index.windows.ts b/packages/core/ui/text-base/index.windows.ts
new file mode 100644
index 0000000000..75c729e419
--- /dev/null
+++ b/packages/core/ui/text-base/index.windows.ts
@@ -0,0 +1,384 @@
+export * from './text-base-common';
+
+import { TextBaseCommon, textProperty, formattedTextProperty, textTransformProperty, textAlignmentProperty, whiteSpaceProperty, resetSymbol, textShadowProperty } from './text-base-common';
+import { CoreTypes } from '../../core-types';
+import { Color } from '../../color';
+import { colorProperty, fontInternalProperty, fontSizeProperty, paddingLeftProperty, paddingTopProperty, paddingRightProperty, paddingBottomProperty, fontWeightProperty, fontStyleProperty } from '../styling/style-properties';
+import { FontWeightType } from '../styling/font-interfaces';
+import type { ShadowCSSValues } from '../styling/css-shadow';
+import { layout } from '../../utils';
+
+// WinUI uses DIPs — do not multiply by density. Convert px→dip for 'px' unit values.
+function toDip(value: CoreTypes.LengthType, auto = 0): number {
+	if (typeof value === 'number') return value;
+	if (!value || typeof value === 'string') return auto;
+	const v = value as { value: number; unit: string };
+	if (v.unit === 'dip') return v.value;
+	if (v.unit === 'px') return v.value / (layout.getDisplayDensity?.() ?? 1);
+	return auto;
+}
+
+function makeThickness(options: { Left?: number; Top?: number; Right?: number; Bottom?: number }, def: Microsoft.UI.Xaml.Thickness): Microsoft.UI.Xaml.Thickness {
+	const { Left, Top, Right, Bottom } = options;
+	return Microsoft.UI.Xaml.ThicknessHelper.FromLengths(Left ?? def.Left, Top ?? def.Top, Right ?? def.Right, Bottom ?? def.Bottom);
+}
+
+// Microsoft.UI.Text.FontWeights resolves in WinUI3; guarded so a future projection gap degrades gracefully.
+function toFontWeight(value: FontWeightType): Microsoft.UI.Text.FontWeight | null {
+	try {
+		switch (value) {
+			case '700':
+			case 'bold':
+				return Microsoft.UI.Text.FontWeights.Bold;
+			case '400':
+			case 'normal':
+				return Microsoft.UI.Text.FontWeights.Normal;
+			case '100': return Microsoft.UI.Text.FontWeights.Thin;
+			case '200': return Microsoft.UI.Text.FontWeights.ExtraLight;
+			case '300': return Microsoft.UI.Text.FontWeights.Light;
+			case '500': return Microsoft.UI.Text.FontWeights.Medium;
+			case '600': return Microsoft.UI.Text.FontWeights.SemiBold;
+			case '800': return Microsoft.UI.Text.FontWeights.ExtraBold;
+			case '900': return Microsoft.UI.Text.FontWeights.Black;
+			default:
+				return null;
+		}
+	} catch {
+		return null;
+	}
+}
+
+function fromFontWeight(value: Microsoft.UI.Text.FontWeight): FontWeightType {
+	switch (value) {
+		case Microsoft.UI.Text.FontWeights.Bold:
+			return '700';
+		case Microsoft.UI.Text.FontWeights.Normal:
+			return '400';
+		case Microsoft.UI.Text.FontWeights.Thin:
+			return '100';
+		case Microsoft.UI.Text.FontWeights.ExtraLight:
+			return '200';
+		case Microsoft.UI.Text.FontWeights.Light:
+			return '300';
+		case Microsoft.UI.Text.FontWeights.Medium:
+			return '500';
+		case Microsoft.UI.Text.FontWeights.SemiBold:
+			return '600';
+		case Microsoft.UI.Text.FontWeights.ExtraBold:
+			return '800';
+		case Microsoft.UI.Text.FontWeights.Black:
+			return '900';
+		default:
+			return '400';
+	}
+}
+
+// FontStyle is `Windows.UI.Text.FontStyle` — NOT `Microsoft.UI.Text` (which was NOT migrated from
+// WinUI3; only FontWeights was). `Microsoft.UI.Text.FontStyle` is undefined, so `.Normal` throws.
+// Guard: a throw inside applyAllNativeSetters aborts loading every following sibling, blanking the page.
+function toFontStyle(value: 'normal' | 'italic' | 'oblique'): Windows.UI.Text.FontStyle | null {
+	try {
+		switch (value) {
+			case 'italic':
+				return Windows.UI.Text.FontStyle.Italic;
+			case 'normal':
+				return Windows.UI.Text.FontStyle.Normal;
+			case 'oblique':
+				return Windows.UI.Text.FontStyle.Oblique;
+			default:
+				return null;
+		}
+	} catch {
+		return null;
+	}
+}
+
+function fromFontStyle(value: Windows.UI.Text.FontStyle): 'normal' | 'italic' | 'oblique' {
+	try {
+		if (value === Windows.UI.Text.FontStyle.Italic) {
+			return 'italic';
+		} else if (value === Windows.UI.Text.FontStyle.Oblique) {
+			return 'oblique';
+		}
+	} catch {
+	}
+	return 'normal';
+}
+
+
+// Module-level foreground brush cache. Avoids creating a new SolidColorBrush COM object for
+// every text view that shares the same color. Foreground brushes are not mutated by animations
+// (NativeScript's color animation calls setNative per frame, re-assigning Foreground rather than
+// targeting the brush's Color property directly), so sharing is safe.
+const _fgBrushCache = new Map<number, any>(); // argb → SolidColorBrush
+const _FG_BRUSH_MAX = 32;
+
+export class TextBase extends TextBaseCommon {
+	nativeViewProtected: Microsoft.UI.Xaml.Controls.TextBox | Microsoft.UI.Xaml.Controls.TextBlock | Microsoft.UI.Xaml.Controls.PasswordBox | Microsoft.UI.Xaml.Controls.Button;
+
+	[textProperty.getDefault](): symbol {
+		return resetSymbol;
+	}
+
+	[textProperty.setNative](value: string | symbol): void {
+		const reset = value === resetSymbol;
+		if (!reset && this.formattedText) {
+			return;
+		}
+		this._setNativeText(reset);
+	}
+
+	private _textShadowVisual: Microsoft.UI.Composition.SpriteVisual | null = null;
+
+	// @ts-ignore — setNative is a symbol index whose value type is widened across properties.
+	[textShadowProperty.setNative](value: ShadowCSSValues) {
+		// Guarded: a throw here would abort page setup / navigation.
+		try {
+			const tv = this.nativeTextViewProtected as Microsoft.UI.Xaml.Controls.TextBlock;
+			if (!tv) {
+				return;
+			}
+			const host = Microsoft.UI.Xaml.Hosting.ElementCompositionPreview.GetElementVisual(tv);
+			const compositor = host.Compositor;
+
+			if (this._textShadowVisual) {
+				Microsoft.UI.Xaml.Hosting.ElementCompositionPreview.SetElementChildVisual(tv, null as never);
+				this._textShadowVisual = null;
+			}
+			if (!value || !value.color || typeof tv.GetAlphaMask !== 'function') {
+				return;
+			}
+
+			// GetAlphaMask gives the text's exact silhouette as a CompositionBrush — the correct
+			// mask for a text DropShadow (WinUI's canonical text-shadow technique).
+			const sprite = compositor.CreateSpriteVisual();
+			const sizeAnim = compositor.CreateExpressionAnimation('host.Size');
+			sizeAnim.SetReferenceParameter('host', host);
+			sprite.StartAnimation('Size', sizeAnim);
+
+			const drop = compositor.CreateDropShadow();
+			drop.Mask = tv.GetAlphaMask();
+			drop.Color = (value.color as Color & { windows: Windows.UI.Color }).windows;
+			drop.BlurRadius = toDip(value.blurRadius, 0);
+			drop.Offset = new Windows.Foundation.Numerics.Vector3(toDip(value.offsetX, 0), toDip(value.offsetY, 0), 0);
+			// Sprite has no fill brush, so only the shadow paints (the crisp text still renders
+			// from the TextBlock itself).
+			sprite.Shadow = drop;
+
+			Microsoft.UI.Xaml.Hosting.ElementCompositionPreview.SetElementChildVisual(tv, sprite);
+			this._textShadowVisual = sprite;
+		} catch (_e) {}
+	}
+
+	[colorProperty.getDefault](): Microsoft.UI.Xaml.Media.Brush | null {
+		const nativeView = this.nativeTextViewProtected;
+		return nativeView?.Foreground ?? null;
+	}
+
+	[colorProperty.setNative](value: Color | Windows.UI.Color | null | undefined) {
+		if (!this.formattedText || !(value instanceof Color)) {
+			try {
+				let brush: any = null;
+				if (value instanceof Color) {
+					// Reuse cached brush for the same ARGB — avoids a new SolidColorBrush COM object
+					// per text view when multiple views share the same color (e.g. theme text color).
+					const argb = (value as any).argb as number;
+					brush = _fgBrushCache.get(argb) ?? null;
+					if (!brush) {
+						brush = new Microsoft.UI.Xaml.Media.SolidColorBrush(value.windows);
+						if (_fgBrushCache.size >= _FG_BRUSH_MAX) {
+							_fgBrushCache.delete(_fgBrushCache.keys().next().value);
+						}
+						_fgBrushCache.set(argb, brush);
+					}
+				} else if (value != null) {
+					//@ts-ignore
+					if (value instanceof Windows.UI.Color) {
+						brush = new Microsoft.UI.Xaml.Media.SolidColorBrush(value as any);
+					} else {
+						brush = new Microsoft.UI.Xaml.Media.SolidColorBrush(new Color(value as never).windows);
+					}
+				}
+				if (brush) {
+					this.nativeTextViewProtected.Foreground = brush;
+					// Override ButtonForeground resource so the XAML template binding picks up
+					// our colour even when the Normal-state VSM animation replaces it.
+					try { (this.nativeTextViewProtected as any).Resources.Insert('ButtonForeground', brush); } catch (_re) {}
+					try { (this.nativeTextViewProtected as any).Resources.Insert('ButtonForegroundPointerOver', brush); } catch (_re) {}
+					try { (this.nativeTextViewProtected as any).Resources.Insert('ButtonForegroundPressed', brush); } catch (_re) {}
+				}
+			} catch (_e) { }
+		}
+	}
+
+	[fontSizeProperty.getDefault](): { nativeSize: number } {
+		// WinUI3 default FontSize = 14. Hardcoded to avoid a WinRT property read per text view
+		// during applyAllNativeSetters — saves 1 WinRT call per Label/Button/TextField created.
+		return { nativeSize: 14 };
+	}
+
+	[fontSizeProperty.setNative](value: number | { nativeSize: number }) {
+		if (!this.formattedText || typeof value !== 'number') {
+			const size = typeof value === 'number' ? value : value.nativeSize;
+			this.nativeTextViewProtected.FontSize = size;
+		}
+	}
+
+	[fontStyleProperty.getDefault]() {
+		// WinUI3 default FontStyle = Normal for all standard text controls.
+		// Hardcoded to avoid a WinRT read per text view.
+		return 'normal';
+	}
+
+	[fontStyleProperty.setNative](value: 'normal' | 'italic' | 'oblique') {
+		if (!this.formattedText) {
+			const style = toFontStyle(value);
+			if (!style) return;
+			this.nativeTextViewProtected.FontStyle = style;
+		}
+	}
+
+	[fontWeightProperty.getDefault](): FontWeightType {
+		// WinUI3 default FontWeight = Normal (400) for TextBlock, Button, TextBox, etc.
+		// Hardcoded to avoid a WinRT read per text view; saves 1 WinRT call during creation.
+		return '400' as FontWeightType;
+	}
+
+	[fontWeightProperty.setNative](value: FontWeightType) {
+		const weight = toFontWeight(value);
+		if (!weight) return;
+		this.nativeTextViewProtected.FontWeight = weight;
+	}
+
+	[fontInternalProperty.setNative](value: any) {
+		const nativeView = this.nativeTextViewProtected as any;
+		if (!nativeView) return;
+
+		if (value) {
+			value?.applyWindowsFont?.(nativeView);
+
+			if (value?.fontStyle) {
+				const style = toFontStyle(value.fontStyle);
+				if (style) {
+					nativeView.FontStyle = style;
+				}
+			}
+			if (value?.fontWeight) {
+				const weight = toFontWeight(value.fontWeight);
+				if (weight) {
+					nativeView.FontWeight = weight;
+				}
+			}
+
+			if (value?.fontSize) {
+				nativeView.FontSize = value.fontSize;
+			}
+			
+		}
+	}
+
+	[formattedTextProperty.setNative](value: any): void {
+		this._setNativeText();
+		textProperty.nativeValueChange(this, !value ? '' : value.toString());
+	}
+
+	[textTransformProperty.setNative](_value: CoreTypes.TextTransformType): void {
+		this._setNativeText();
+	}
+
+	[paddingTopProperty.getDefault](): CoreTypes.LengthType {
+		return { value: this._defaultPaddingTop, unit: 'px' };
+	}
+	[paddingTopProperty.setNative](value: CoreTypes.LengthType) {
+		const padding = this.nativeTextViewProtected.Padding;
+		if (!padding) return;
+		this.nativeTextViewProtected.Padding = makeThickness({
+			Top: toDip(value) + toDip(this.style.borderTopWidth),
+		}, padding);
+	}
+
+	[paddingRightProperty.getDefault](): CoreTypes.LengthType {
+		return { value: this._defaultPaddingRight, unit: 'px' };
+	}
+	[paddingRightProperty.setNative](value: CoreTypes.LengthType) {
+		const padding = this.nativeTextViewProtected.Padding;
+		if (!padding) return;
+		this.nativeTextViewProtected.Padding = makeThickness({
+			Right: toDip(value) + toDip(this.style.borderRightWidth),
+		}, padding);
+	}
+
+	[paddingBottomProperty.getDefault](): CoreTypes.LengthType {
+		return { value: this._defaultPaddingBottom, unit: 'px' };
+	}
+	[paddingBottomProperty.setNative](value: CoreTypes.LengthType) {
+		const padding = this.nativeTextViewProtected.Padding;
+		if (!padding) return;
+		this.nativeTextViewProtected.Padding = makeThickness({
+			Bottom: toDip(value) + toDip(this.style.borderBottomWidth),
+		}, padding);
+	}
+
+	[paddingLeftProperty.getDefault](): CoreTypes.LengthType {
+		return { value: this._defaultPaddingLeft, unit: 'px' };
+	}
+	[paddingLeftProperty.setNative](value: CoreTypes.LengthType) {
+		const padding = this.nativeTextViewProtected.Padding;
+		if (!padding) return;
+		this.nativeTextViewProtected.Padding = makeThickness({
+			Left: toDip(value) + toDip(this.style.borderLeftWidth),
+		}, padding);
+	}
+
+	// TextAlignment: Left=0, Center=1, Right=2, Justify=3
+	[textAlignmentProperty.setNative](value: CoreTypes.TextAlignmentType) {
+		const nativeView = this.nativeTextViewProtected as any;
+		if (!nativeView) return;
+		switch (value) {
+			case 'left': nativeView.TextAlignment = 0; break;
+			case 'center': nativeView.TextAlignment = 1; break;
+			case 'right': nativeView.TextAlignment = 2; break;
+			case 'justify': nativeView.TextAlignment = 3; break;
+		}
+	}
+
+	// TextWrapping: NoWrap=1, Wrap=2, WrapWholeWords=3
+	[whiteSpaceProperty.setNative](value: CoreTypes.WhiteSpaceType) {
+		const nativeView = this.nativeTextViewProtected as any;
+		if (!nativeView) return;
+		nativeView.TextWrapping = (value === 'nowrap') ? 1 : 3; // NoWrap or WrapWholeWords
+	}
+
+
+	_setNativeText(reset = false): void {
+		const nativeView = this.nativeTextViewProtected as any;
+		if (!nativeView) return;
+
+		const transformed = reset ? '' : getTransformedText(this.text ?? '', this.textTransform);
+		// Native Text/Content are HSTRING — a non-string value (e.g. a number bound straight from a
+		// ListView item) fails to marshal with 0x80004005. Coerce so any bound value renders as text.
+		const text = typeof transformed === 'string' ? transformed : String(transformed ?? '');
+
+		if (typeof nativeView.Text !== 'undefined') {
+			nativeView.Text = text;
+		} else if (typeof nativeView.Content !== 'undefined') {
+			nativeView.Content = text;
+		}
+	}
+}
+
+export function getTransformedText(text: string, textTransform: CoreTypes.TextTransformType): string {
+	if (!text || !textTransform || textTransform === 'none') {
+		return text;
+	}
+	switch (textTransform) {
+		case 'uppercase':
+			return text.toUpperCase();
+		case 'lowercase':
+			return text.toLowerCase();
+		case 'capitalize':
+			return text.replace(/\b\w/g, (c) => c.toUpperCase());
+		default:
+			return text;
+	}
+}
diff --git a/packages/core/ui/text-field/index.windows.ts b/packages/core/ui/text-field/index.windows.ts
new file mode 100644
index 0000000000..d7b8d4c895
--- /dev/null
+++ b/packages/core/ui/text-field/index.windows.ts
@@ -0,0 +1,176 @@
+export * from './text-field-common';
+
+import { TextFieldBase, secureProperty } from './text-field-common';
+import { hintProperty, editableProperty, maxLengthProperty, keyboardTypeProperty, autocapitalizationTypeProperty } from '../editable-text-base/editable-text-base-common';
+import { colorProperty } from '../styling/style-properties';
+import { Color } from '../../color';
+import type { CoreTypes } from '../../core-types';
+
+const KEYBOARD_SCOPE: Record<string, number> = {
+	number: 29,
+	datetime: 29,
+	phone: 3,
+	email: 7,
+	url: 14,
+	integer: 29,
+};
+
+function applyInputScope(nativeView: Microsoft.UI.Xaml.Controls.TextBox, kbType: string): void {
+	const scopeValue = KEYBOARD_SCOPE[kbType];
+	if (scopeValue === undefined) {
+		return;
+	}
+	const scope = new Microsoft.UI.Xaml.Input.InputScope();
+	const scopeName = new Microsoft.UI.Xaml.Input.InputScopeName(scopeValue);
+	// Names is typed as `IVector | array`; the runtime hands back the IVector, so building
+	// the collection can throw across the bridge — keep this guarded.
+	try {
+		(scope.Names as Windows.Foundation.Collections.IVector<Microsoft.UI.Xaml.Input.InputScopeName>).Append(scopeName);
+		nativeView.InputScope = scope;
+	} catch (_e) {}
+}
+
+export class TextField extends TextFieldBase {
+	declare nativeViewProtected: Microsoft.UI.Xaml.Controls.TextBox | Microsoft.UI.Xaml.Controls.PasswordBox;
+	private _isSecure = false;
+	private _keyDownDelegate: Microsoft.UI.Xaml.Input.KeyEventHandler | null = null;
+
+	// Declared so TS sees it through the common base; re-attached after the secure view swap.
+	declare _attachTextChangeListener: () => void;
+
+	public createNativeView(): Microsoft.UI.Xaml.Controls.TextBox | Microsoft.UI.Xaml.Controls.PasswordBox {
+		// `secure` is parsed before the native view is created; pick the correct control up-front.
+		if (this.secure != null) {
+			this._isSecure = !!this.secure;
+		}
+		return this._isSecure ? new Microsoft.UI.Xaml.Controls.PasswordBox() : new Microsoft.UI.Xaml.Controls.TextBox();
+	}
+
+	public initNativeView(): void {
+		super.initNativeView(); // wires TextChanged/PasswordChanged from editable-text-base
+		this._attachReturnKeyListener();
+	}
+
+	public _attachReturnKeyListener(): void {
+		const nv = this.nativeViewProtected;
+		if (!nv) {
+			return;
+		}
+		const ref = new WeakRef(this);
+		this._keyDownDelegate = NSWinRT.asDelegate('Microsoft.UI.Xaml.Input.KeyEventHandler', (_sender: any, e: Microsoft.UI.Xaml.Input.KeyRoutedEventArgs) => {
+			if (e.Key === Windows.System.VirtualKey.Enter) {
+				const owner = ref.deref();
+				if (owner) owner.notify({ eventName: TextFieldBase.returnPressEvent, object: owner });
+			}
+		});
+		// AddHandler(KeyDownEvent) throws E_INVALIDARG (0x80070057) in the runtime's RoutedEvent
+		// projection — an uncaught throw jams frame navigation. Fall back to instance KeyDown.
+		try {
+			nv.AddHandler(Microsoft.UI.Xaml.UIElement.KeyDownEvent, this._keyDownDelegate, true);
+		} catch (_e) {
+			try {
+				(nv as Microsoft.UI.Xaml.UIElement).KeyDown = this._keyDownDelegate;
+			} catch (_e2) {}
+		}
+	}
+
+	// @ts-ignore — setNative is a symbol index whose value type is widened across properties.
+	[secureProperty.setNative](value: boolean) {
+		if (this._isSecure === !!value) {
+			return;
+		}
+		this._isSecure = !!value;
+
+		const prev = this.nativeViewProtected;
+		const currentText = this._isSecure ? (prev as Microsoft.UI.Xaml.Controls.PasswordBox)?.Password ?? '' : (prev as Microsoft.UI.Xaml.Controls.TextBox)?.Text ?? '';
+
+		const newView = this._isSecure ? new Microsoft.UI.Xaml.Controls.PasswordBox() : new Microsoft.UI.Xaml.Controls.TextBox();
+
+		// Must swap in the ACTUAL visual parent (not the NS parent's nativeViewProtected) —
+		// using the NS parent's Border missed the real container and the swap silently no-op'd,
+		// leaving secure fields as cleartext TextBoxes.
+		const visualParent = prev?.Parent;
+		let swapped = false;
+		if (visualParent) {
+			const children = (visualParent as Microsoft.UI.Xaml.Controls.Panel).Children;
+			if (children && typeof children.Size === 'number') {
+				for (let i = 0; i < children.Size; i++) {
+					if (children.GetAt(i) === prev) {
+						children.RemoveAt(i);
+						children.InsertAt(i, newView); // preserve position
+						swapped = true;
+						break;
+					}
+				}
+			}
+			if (!swapped) {
+				const contentHost = visualParent as Microsoft.UI.Xaml.Controls.ContentControl;
+				if (contentHost.Content === prev) {
+					contentHost.Content = newView;
+					swapped = true;
+				}
+			}
+			if (!swapped) {
+				const borderHost = visualParent as Microsoft.UI.Xaml.Controls.Border;
+				if (borderHost.Child === prev) {
+					borderHost.Child = newView;
+					swapped = true;
+				}
+			}
+		}
+		this.nativeViewProtected = newView;
+		if (this._isSecure) {
+			(newView as Microsoft.UI.Xaml.Controls.PasswordBox).Password = currentText;
+		} else {
+			(newView as Microsoft.UI.Xaml.Controls.TextBox).Text = currentText;
+		}
+		this._attachTextChangeListener();
+		this._attachReturnKeyListener();
+	}
+
+	[hintProperty.setNative](value: string) {
+		const nativeView = this.nativeViewProtected as Microsoft.UI.Xaml.Controls.TextBox;
+		if (typeof nativeView.PlaceholderText !== 'undefined') {
+			nativeView.PlaceholderText = value ?? '';
+		}
+	}
+
+	// @ts-ignore — setNative is a symbol index whose value type is widened across properties.
+	[editableProperty.setNative](value: boolean) {
+		const nativeView = this.nativeViewProtected as Microsoft.UI.Xaml.Controls.TextBox;
+		if (typeof nativeView.IsReadOnly !== 'undefined') {
+			nativeView.IsReadOnly = !value;
+		}
+	}
+
+	// @ts-ignore — setNative is a symbol index whose value type is widened across properties.
+	[maxLengthProperty.setNative](value: number) {
+		const nativeView = this.nativeViewProtected as Microsoft.UI.Xaml.Controls.TextBox;
+		if (typeof nativeView.MaxLength !== 'undefined') {
+			nativeView.MaxLength = value ?? 0;
+		}
+	}
+
+	// @ts-ignore — setNative is a symbol index whose value type is widened across properties.
+	[keyboardTypeProperty.setNative](value: CoreTypes.KeyboardInputType) {
+		if (this.nativeViewProtected) {
+			applyInputScope(this.nativeViewProtected as Microsoft.UI.Xaml.Controls.TextBox, value);
+		}
+	}
+
+	// @ts-ignore — setNative is a symbol index whose value type is widened across properties.
+	[autocapitalizationTypeProperty.setNative](value: CoreTypes.AutocapitalizationInputType) {
+		const nativeView = this.nativeViewProtected as Microsoft.UI.Xaml.Controls.TextBox;
+		if (typeof nativeView.CharacterCasing !== 'undefined') {
+			nativeView.CharacterCasing = value === 'allcharacters' ? 1 : 0;
+		}
+	}
+
+	// @ts-ignore — setNative is a symbol index whose value type is widened across properties.
+	[colorProperty.setNative](value: Color | null) {
+		const nativeView = this.nativeViewProtected;
+		if (nativeView && value instanceof Color) {
+			nativeView.Foreground = new Microsoft.UI.Xaml.Media.SolidColorBrush(value.windows);
+		}
+	}
+}
diff --git a/packages/core/ui/text-view/index.windows.ts b/packages/core/ui/text-view/index.windows.ts
new file mode 100644
index 0000000000..13cfdeb3d1
--- /dev/null
+++ b/packages/core/ui/text-view/index.windows.ts
@@ -0,0 +1,51 @@
+export * from './text-view-common';
+
+import { TextViewBase } from './text-view-common';
+import { keyboardTypeProperty } from '../editable-text-base/editable-text-base-common';
+import { colorProperty } from '../styling/style-properties';
+import { Color } from '../../color';
+import type { CoreTypes } from '../../core-types';
+
+const KEYBOARD_SCOPE: Record<string, number> = {
+	number: 29,
+	datetime: 29,
+	phone: 3,
+	email: 7,
+	url: 14,
+	integer: 29,
+};
+
+export class TextView extends TextViewBase {
+	declare nativeViewProtected: Microsoft.UI.Xaml.Controls.TextBox;
+
+	createNativeView(): Microsoft.UI.Xaml.Controls.TextBox {
+		const textBox = new Microsoft.UI.Xaml.Controls.TextBox();
+		textBox.AcceptsReturn = true;
+		textBox.TextWrapping = 1 as never; // Wrap
+		textBox.VerticalScrollBarVisibility = 1 as never; // Auto
+		return textBox;
+	}
+
+	//@ts-ignore
+	[keyboardTypeProperty.setNative](value: CoreTypes.KeyboardInputType) {
+		const nativeView = this.nativeViewProtected;
+		if (!nativeView) return;
+		const scopeValue = KEYBOARD_SCOPE[value];
+		if (scopeValue === undefined) return;
+		const scope = new Microsoft.UI.Xaml.Input.InputScope();
+		const scopeName = new Microsoft.UI.Xaml.Input.InputScopeName(scopeValue);
+		// Names is typed as `IVector | array`; the runtime hands back the IVector, so
+		// building the collection can throw across the bridge — keep this guarded.
+		try {
+			(scope.Names as Windows.Foundation.Collections.IVector<Microsoft.UI.Xaml.Input.InputScopeName>).Append(scopeName);
+			nativeView.InputScope = scope;
+		} catch (_e) {}
+	}
+
+	//@ts-ignore
+	[colorProperty.setNative](value: Color | null) {
+		if (this.nativeViewProtected && value instanceof Color) {
+			this.nativeViewProtected.Foreground = new Microsoft.UI.Xaml.Media.SolidColorBrush(value.windows);
+		}
+	}
+}
diff --git a/packages/core/ui/time-picker/index.windows.ts b/packages/core/ui/time-picker/index.windows.ts
new file mode 100644
index 0000000000..cc1b16d51f
--- /dev/null
+++ b/packages/core/ui/time-picker/index.windows.ts
@@ -0,0 +1,80 @@
+export * from './time-picker-common';
+
+import { TimePickerBase, hourProperty, minuteProperty, timeProperty } from './time-picker-common';
+
+export class TimePicker extends TimePickerBase {
+	nativeViewProtected: Microsoft.UI.Xaml.Controls.TimePicker;
+	private _windows: Microsoft.UI.Xaml.Controls.TimePicker;
+	private _timeChangedHandler: any = null;
+
+	public createNativeView(): Microsoft.UI.Xaml.Controls.TimePicker {
+		this._windows = new Microsoft.UI.Xaml.Controls.TimePicker();
+		return this._windows;
+	}
+
+	get windows(): Microsoft.UI.Xaml.Controls.TimePicker {
+		return this._windows;
+	}
+
+	public initNativeView(): void {
+		super.initNativeView();
+		const that = new WeakRef(this);
+		const handler = (_sender: Microsoft.UI.Xaml.Controls.TimePicker, args: Microsoft.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs) => {
+			const owner = that.deref();
+			if (!owner) return;
+			const raw = args.NewTime as any; // System.Nullable<System.TimeSpan>
+			if (!raw) return;
+			// System.TimeSpan.Duration is 100-nanosecond ticks
+			const ticks = typeof raw.Duration === 'bigint' ? Number(raw.Duration) : (raw.Duration as number) ?? 0;
+			const totalSeconds = Math.round(ticks / 10_000_000);
+			const hour = Math.floor(totalSeconds / 3600);
+			const minute = Math.floor((totalSeconds % 3600) / 60);
+			hourProperty.nativeValueChange(owner, hour);
+			minuteProperty.nativeValueChange(owner, minute);
+			timeProperty.nativeValueChange(owner, new Date(0, 0, 0, hour, minute));
+			owner.notify({ eventName: TimePickerBase.timeChangeEvent, object: owner, value: { hour, minute } });
+		};
+		this._timeChangedHandler = NSWinRT.asDelegate(
+			'Windows.Foundation.TypedEventHandler`2<Microsoft.UI.Xaml.Controls.TimePicker,Microsoft.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs>',
+			handler
+		);
+		this._windows.SelectedTimeChanged = this._timeChangedHandler;
+	}
+
+	public disposeNativeView(): void {
+		if (this._windows && this._timeChangedHandler) {
+			this._windows.SelectedTimeChanged = null;
+			this._timeChangedHandler = null;
+		}
+		super.disposeNativeView();
+	}
+
+	private _setTime(ms: number): void {
+		const ts = NSWinRT.interop.timeSpan(ms);
+		this._windows.Time = ts;
+		// SelectedTime (IReference<TimeSpan>) makes the picker show the time as selected rather
+		// than showing placeholder dashes. Pass raw ms; the runtime handles boxing.
+		this._windows.SelectedTime = NSWinRT.interop.reference('Windows.Foundation.TimeSpan', ms);
+	}
+
+	[hourProperty.getDefault](): number {
+		return 0;
+	}
+	//@ts-ignore
+	[hourProperty.setNative](value: number) {
+		this._setTime((value * 3600 + (this.minute ?? 0) * 60) * 1000);
+	}
+
+	[minuteProperty.getDefault](): number {
+		return 0;
+	}
+	//@ts-ignore
+	[minuteProperty.setNative](value: number) {
+		this._setTime(((this.hour ?? 0) * 3600 + value * 60) * 1000);
+	}
+
+	//@ts-ignore
+	[timeProperty.setNative](value: Date) {
+		this._setTime((value.getHours() * 3600 + value.getMinutes() * 60) * 1000);
+	}
+}
diff --git a/packages/core/ui/transition/fade-transition.windows.ts b/packages/core/ui/transition/fade-transition.windows.ts
new file mode 100644
index 0000000000..41726706d6
--- /dev/null
+++ b/packages/core/ui/transition/fade-transition.windows.ts
@@ -0,0 +1,3 @@
+import { Transition } from '.';
+
+export class FadeTransition extends Transition {}
diff --git a/packages/core/ui/transition/index.windows.ts b/packages/core/ui/transition/index.windows.ts
new file mode 100644
index 0000000000..153ddb9ebf
--- /dev/null
+++ b/packages/core/ui/transition/index.windows.ts
@@ -0,0 +1,42 @@
+export * from './shared-transition';
+
+let transitionId = 0;
+
+export class Transition {
+	static AndroidTransitionType: { enter?: string; exit?: string; popEnter?: string; popExit?: string } = {};
+	id: number;
+	name?: string;
+	private _duration: number;
+	private _curve: any;
+
+	constructor(duration: number = 350, nativeCurve?: any) {
+		this._duration = duration ? duration / 1000 : 0.35;
+		this._curve = nativeCurve;
+		transitionId++;
+		this.id = transitionId;
+	}
+
+	getDuration(): number {
+		return this._duration;
+	}
+
+	setDuration(value: number): void {
+		this._duration = value;
+	}
+
+	getCurve(): any {
+		return this._curve;
+	}
+
+	animateIOSTransition(_transitionContext: any, _fromViewCtrl: any, _toViewCtrl: any, _operation: any): void {
+		throw new Error('Abstract method call');
+	}
+
+	createAndroidAnimator(_transitionType: string): any {
+		throw new Error('Abstract method call');
+	}
+
+	toString(): string {
+		return `Transition@${this.id}`;
+	}
+}
diff --git a/packages/core/ui/transition/modal-transition.windows.ts b/packages/core/ui/transition/modal-transition.windows.ts
new file mode 100644
index 0000000000..daf5025246
--- /dev/null
+++ b/packages/core/ui/transition/modal-transition.windows.ts
@@ -0,0 +1,3 @@
+import { Transition } from '.';
+
+export class ModalTransition extends Transition {}
diff --git a/packages/core/ui/transition/page-transition.windows.ts b/packages/core/ui/transition/page-transition.windows.ts
new file mode 100644
index 0000000000..b25e031ccb
--- /dev/null
+++ b/packages/core/ui/transition/page-transition.windows.ts
@@ -0,0 +1,3 @@
+import { Transition } from '.';
+
+export class PageTransition extends Transition {}
diff --git a/packages/core/ui/transition/shared-transition-helper.windows.ts b/packages/core/ui/transition/shared-transition-helper.windows.ts
new file mode 100644
index 0000000000..17fc74fbfa
--- /dev/null
+++ b/packages/core/ui/transition/shared-transition-helper.windows.ts
@@ -0,0 +1,144 @@
+import type { TransitionInteractiveState, TransitionNavigationType } from '.';
+import { SharedTransition, SharedTransitionAnimationType, SharedTransitionState } from './shared-transition';
+import { isNumber } from '../../utils/types';
+
+// Supplied by the Frame after it captures FROM-element rects and performs the normal page swap.
+// An earlier design kept both pages mounted + removed host children asynchronously — that froze
+// later navigation. We only animate the incoming elements' transforms; no host surgery.
+interface MorphPair {
+	toNative: any; // incoming shared element native
+	fromRect: { x: number; y: number; w: number; h: number }; // outgoing element's rect, in host coords
+	tag?: string;
+}
+interface WinTransitionContext {
+	host: any;
+	pairs: MorphPair[];
+	durationMs?: number;
+}
+
+// Duration as an ArrayBuffer: the nested TimeSpan field zeros out if passed as a plain object.
+function durationBuffer(ms: number): ArrayBuffer {
+	const buf = new ArrayBuffer(16);
+	const dv = new DataView(buf);
+	dv.setBigInt64(0, BigInt(Math.max(1, Math.round(ms)) * 10000), true);
+	dv.setInt32(8, 1, true);
+	return buf;
+}
+
+// GC guard: hold running storyboards until Completed fires.
+const _active = new Set<any>();
+
+function rectInHost(nativeEl: any, host: any): { x: number; y: number; w: number; h: number } | null {
+	try {
+		const gt = nativeEl.TransformToVisual(host);
+		const p = gt.TransformPoint(new Windows.Foundation.Point(0, 0));
+		return { x: p.X, y: p.Y, w: nativeEl.ActualWidth || 0, h: nativeEl.ActualHeight || 0 };
+	} catch (_e) {
+		return null;
+	}
+}
+
+/**
+ * Windows Shared Element Transition. iOS snapshots each element into a floated UIImageView; Windows has no
+ * such API, so we morph the REAL incoming element: a TransformGroup (scale + translate) places it over the
+ * outgoing element's captured rect, then animates to identity. No snapshots, no host-tree surgery.
+ */
+export class SharedTransitionHelper {
+	static animate(state: SharedTransitionState, context: WinTransitionContext, type: TransitionNavigationType): void {
+		const present = state?.activeType !== SharedTransitionAnimationType.dismiss;
+		const notify = (name: string) => {
+			try { SharedTransition.notifyEvent(name, { id: state.instance?.id, type, action: present ? 'present' : 'dismiss' }); } catch (_e) { }
+		};
+		try {
+			const A: any = Microsoft.UI.Xaml.Media.Animation;
+			const host = context?.host;
+			const pairs = (context && context.pairs) || [];
+			if (!host || !pairs.length) { return; }
+			const dur = isNumber(context.durationMs) ? context.durationMs : 350;
+			const pageEndTags = (state.pageEnd && state.pageEnd.sharedTransitionTags) || {};
+
+			try { host.UpdateLayout(); } catch (_e) { }
+
+			const sb = new A.Storyboard();
+			const addDouble = (targetObj: any, prop: string, from: number, to: number) => {
+				const da = new A.DoubleAnimation();
+				da.From = from;
+				da.To = to;
+				da.Duration = durationBuffer(dur) as never;
+				const ease = new A.CubicEase();
+				ease.EasingMode = A.EasingMode.EaseInOut;
+				da.EasingFunction = ease;
+				A.Storyboard.SetTarget(da, targetObj);
+				A.Storyboard.SetTargetProperty(da, prop);
+				sb.Children.Append(da);
+			};
+
+			const restores: Array<() => void> = [];
+			let morphed = 0;
+
+			for (const pair of pairs) {
+				const toNative = pair.toNative;
+				const fromRect = pair.fromRect;
+				if (!toNative || !fromRect) continue;
+				const toRect = rectInHost(toNative, host);
+				if (!toRect || toRect.w <= 0 || toRect.h <= 0 || fromRect.w <= 0 || fromRect.h <= 0) continue;
+
+				const tx = fromRect.x - toRect.x;
+				const ty = fromRect.y - toRect.y;
+				const sx = fromRect.w / toRect.w;
+				const sy = fromRect.h / toRect.h;
+
+				// TransformGroup(scale, translate); CompositeTransform.TranslateX/ScaleX do NOT animate in this host.
+				const st = new Microsoft.UI.Xaml.Media.ScaleTransform();
+				st.ScaleX = sx;
+				st.ScaleY = sy;
+				const tt = new Microsoft.UI.Xaml.Media.TranslateTransform();
+				tt.X = tx;
+				tt.Y = ty;
+				const tg = new Microsoft.UI.Xaml.Media.TransformGroup();
+				tg.Children.Append(st);
+				tg.Children.Append(tt);
+				try { toNative.RenderTransformOrigin = Microsoft.UI.Xaml.PointHelper.FromCoordinates(0, 0); } catch (_e) { }
+				toNative.RenderTransform = tg;
+
+				const z = pair.tag && pageEndTags[pair.tag] && isNumber(pageEndTags[pair.tag].zIndex) ? pageEndTags[pair.tag].zIndex : null;
+				if (z != null) { try { Microsoft.UI.Xaml.Controls.Panel.SetZIndex(toNative, z); } catch (_e) { } }
+
+				addDouble(tt, 'X', tx, 0);
+				addDouble(tt, 'Y', ty, 0);
+				addDouble(st, 'ScaleX', sx, 1);
+				addDouble(st, 'ScaleY', sy, 1);
+				restores.push(() => { try { toNative.RenderTransform = null; } catch (_e) { } });
+				morphed++;
+			}
+
+			if (morphed === 0) { return; }
+
+			let settled = false;
+			const finish = () => {
+				if (settled) return;
+				settled = true;
+				_active.delete(sb);
+				for (const r of restores) { try { r(); } catch (_e) { } }
+				try { SharedTransition.updateState(state.instance.id, { activeType: present ? SharedTransitionAnimationType.dismiss : SharedTransitionAnimationType.present }); } catch (_e) { }
+				if (!present) { try { SharedTransition.finishState(state.instance.id); } catch (_e) { } }
+				notify(SharedTransition.finishedEvent);
+			};
+
+			_active.add(sb);
+			try { sb.Completed = (() => finish()) as never; } catch (_e) { }
+			notify(SharedTransition.startedEvent);
+			// Defer Begin one frame: Storyboard.Begin() on a just-mounted element jumps to the end in this host.
+			setTimeout(() => { try { sb.Begin(); } catch (_e) { finish(); } }, 32);
+			setTimeout(finish, dur + 450); // safety: ensure finish lands if Completed never fires
+		} catch (_e) {
+			notify(SharedTransition.finishedEvent);
+		}
+	}
+
+	// Interactive (gesture-driven) dismissal is iOS-only; no-op on Windows.
+	static interactiveStart(_state: SharedTransitionState, _interactiveState: TransitionInteractiveState, _type: TransitionNavigationType): void { }
+	static interactiveUpdate(_state: SharedTransitionState, _interactiveState: TransitionInteractiveState, _type: TransitionNavigationType, _percent: number): void { }
+	static interactiveCancel(_state: SharedTransitionState, _interactiveState: TransitionInteractiveState, _type: TransitionNavigationType): void { }
+	static interactiveFinish(_state: SharedTransitionState, _interactiveState: TransitionInteractiveState, _type: TransitionNavigationType): void { }
+}
diff --git a/packages/core/ui/transition/slide-transition.windows.ts b/packages/core/ui/transition/slide-transition.windows.ts
new file mode 100644
index 0000000000..477ef6e37a
--- /dev/null
+++ b/packages/core/ui/transition/slide-transition.windows.ts
@@ -0,0 +1,3 @@
+import { Transition } from '.';
+
+export class SlideTransition extends Transition {}
diff --git a/packages/core/ui/utils.windows.ts b/packages/core/ui/utils.windows.ts
new file mode 100644
index 0000000000..98cd160453
--- /dev/null
+++ b/packages/core/ui/utils.windows.ts
@@ -0,0 +1,17 @@
+export namespace ios {
+	export function getActualHeight(_view: any): number {
+		return 0;
+	}
+	export function getStatusBarHeight(_viewController?: any): number {
+		return 0;
+	}
+	export function _layoutRootView(_rootView: any, _parentBounds: any) {}
+}
+
+export namespace windows {
+	export function getActualHeight(_view: any): number {
+		return 0;
+	}
+}
+
+export type NativeScriptUIView = any;
diff --git a/packages/core/ui/web-view/index.windows.ts b/packages/core/ui/web-view/index.windows.ts
new file mode 100644
index 0000000000..50be57356d
--- /dev/null
+++ b/packages/core/ui/web-view/index.windows.ts
@@ -0,0 +1,123 @@
+export * from './web-view-common';
+
+import { WebViewBase } from './web-view-common';
+
+// WebView2 is not WinRT-activatable in this WinAppSDK build: `new WebView2()` throws E_NOTIMPL.
+// Create via XamlReader instead; attempt `new` only until first failure, then go straight to XamlReader.
+let _webView2Activatable: boolean | undefined;
+function createWebView2(): Microsoft.UI.Xaml.Controls.WebView2 {
+	if (_webView2Activatable !== false) {
+		try {
+			const wv = new Microsoft.UI.Xaml.Controls.WebView2();
+			_webView2Activatable = true;
+			return wv;
+		} catch (_e) {
+			_webView2Activatable = false;
+		}
+	}
+	return Microsoft.UI.Xaml.Markup.XamlReader.Load('<WebView2 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" />') as Microsoft.UI.Xaml.Controls.WebView2;
+}
+
+export class WebView extends WebViewBase {
+	nativeViewProtected: Microsoft.UI.Xaml.Controls.WebView2;
+	private _windows: Microsoft.UI.Xaml.Controls.WebView2;
+
+	// Nav APIs are unusable until EnsureCoreWebView2Async() resolves; queue ops until then.
+	private _ready = false;
+	private _pending: Array<() => void> = [];
+	private _currentUrl = '';
+
+	constructor() {
+		super();
+		// WinRT deferred to createNativeView() — keeps constructor pure-JS.
+	}
+
+	public createNativeView() {
+		this._windows = createWebView2();
+		return this._windows;
+	}
+
+	initNativeView(): void {
+		super.initNativeView();
+
+		const nativeView = this.nativeViewProtected as any;
+
+		nativeView.NavigationStarting = NSWinRT.asDelegate(
+			'Windows.Foundation.TypedEventHandler`2<Microsoft.UI.Xaml.Controls.WebView2,Microsoft.Web.WebView2.Core.CoreWebView2NavigationStartingEventArgs>',
+			(_sender: any, args: any) => {
+				const url = args?.Uri ?? this._currentUrl;
+				this._currentUrl = url;
+				this._onLoadStarted(url, undefined);
+			}
+		);
+
+		nativeView.NavigationCompleted = NSWinRT.asDelegate(
+			'Windows.Foundation.TypedEventHandler`2<Microsoft.UI.Xaml.Controls.WebView2,Microsoft.Web.WebView2.Core.CoreWebView2NavigationCompletedEventArgs>',
+			(_sender: any, args: any) => {
+				const success = args?.IsSuccess !== false;
+				this._onLoadFinished(this._currentUrl, success ? undefined : String(args?.WebErrorStatus ?? 'navigation failed'));
+			}
+		);
+
+		NSWinRT.toPromise(this._windows.EnsureCoreWebView2Async())
+			.then(() => {
+				this._ready = true;
+				const pending = this._pending;
+				this._pending = [];
+				for (const op of pending) {
+					try {
+						op();
+					} catch (_e) {}
+				}
+			})
+			.catch(() => {});
+	}
+
+	disposeNativeView(): void {
+		this._pending = [];
+		this._ready = false;
+		super.disposeNativeView();
+	}
+
+	get windows(): Microsoft.UI.Xaml.Controls.WebView2 {
+		return this._windows;
+	}
+
+	private _run(op: () => void): void {
+		if (this._ready) {
+			op();
+		} else {
+			this._pending.push(op);
+		}
+	}
+
+	public _loadUrl(src: string): void {
+		this._currentUrl = src;
+		// Plain string avoids a System.Uri round-trip.
+		this._run(() => (this.nativeViewProtected as any).CoreWebView2.Navigate(src));
+	}
+
+	public _loadData(src: string): void {
+		this._run(() => this.nativeViewProtected.NavigateToString(src));
+	}
+
+	public stopLoading(): void {
+		this._run(() => (this.nativeViewProtected as any).CoreWebView2?.Stop());
+	}
+
+	get canGoBack(): boolean {
+		return this._ready ? this.nativeViewProtected.CanGoBack : false;
+	}
+	get canGoForward(): boolean {
+		return this._ready ? this.nativeViewProtected.CanGoForward : false;
+	}
+	goBack(): void {
+		this._run(() => this.nativeViewProtected.GoBack());
+	}
+	goForward(): void {
+		this._run(() => this.nativeViewProtected.GoForward());
+	}
+	reload(): void {
+		this._run(() => this.nativeViewProtected.Reload());
+	}
+}
diff --git a/packages/core/utils/constants.windows.ts b/packages/core/utils/constants.windows.ts
new file mode 100644
index 0000000000..ccb814e1c6
--- /dev/null
+++ b/packages/core/utils/constants.windows.ts
@@ -0,0 +1,5 @@
+export const SDK_VERSION = 0;
+
+export function supportsGlass(): boolean {
+	return false;
+}
diff --git a/packages/core/utils/debug-source.ts b/packages/core/utils/debug-source.ts
index 6ae704ee7f..a57b570d45 100644
--- a/packages/core/utils/debug-source.ts
+++ b/packages/core/utils/debug-source.ts
@@ -15,6 +15,8 @@ function getCurrentAppPath(): string {
 		}
 
 		return appPath;
+	} else if (__WINDOWS__) {
+		return global.__dirname || '';
 	} else {
 		const dir = getNativeApp<android.app.Application>().getApplicationContext().getFilesDir();
 
diff --git a/packages/core/utils/index.windows.ts b/packages/core/utils/index.windows.ts
new file mode 100644
index 0000000000..94684d7463
--- /dev/null
+++ b/packages/core/utils/index.windows.ts
@@ -0,0 +1,104 @@
+import { Trace } from '../trace';
+import { debounce, throttle } from './shared';
+
+export { clearInterval, clearTimeout, setInterval, setTimeout } from '../timer';
+export * from './animation-helpers';
+export * from './common';
+export * from './constants';
+export * from './debug';
+export * from './layout-helper';
+export * from './macrotask-scheduler';
+export * from './mainthread-helper';
+export * from './native-helper';
+export * from './shared';
+export * from './types';
+
+export function GC() {
+	if (typeof gc === 'function') {
+		(gc as any)();
+	}
+}
+
+let throttledGC: Map<number, () => void>;
+let debouncedGC: Map<number, () => void>;
+
+export function queueGC(delay = 900, useThrottle?: boolean) {
+	if (useThrottle) {
+		if (!throttledGC) {
+			throttledGC = new Map();
+		}
+		if (!throttledGC.get(delay)) {
+			throttledGC.set(
+				delay,
+				throttle(() => GC(), delay),
+			);
+		}
+		throttledGC.get(delay)();
+	} else {
+		if (!debouncedGC) {
+			debouncedGC = new Map();
+		}
+		if (!debouncedGC.get(delay)) {
+			debouncedGC.set(
+				delay,
+				debounce(() => GC(), delay),
+			);
+		}
+		debouncedGC.get(delay)();
+	}
+}
+
+export function releaseNativeObject(_object: any): void {}
+
+export function openUrl(location: string): boolean {
+	try {
+		Windows.System.Launcher.LaunchUriAsync(new Windows.Foundation.Uri(location.trim()));
+		return true;
+	} catch (e) {
+		Trace.write(`Failed to open URL: ${location}`, Trace.categories.Error, Trace.messageType.error);
+		return false;
+	}
+}
+
+export function openUrlAsync(location: string): Promise<boolean> {
+	return new Promise<boolean>((resolve) => {
+		try {
+			Windows.System.Launcher.LaunchUriAsync(new Windows.Foundation.Uri(location.trim())).then((result: boolean) => resolve(result));
+		} catch (e) {
+			Trace.write(`Failed to open URL: ${location}`, Trace.categories.Error, Trace.messageType.error);
+			resolve(false);
+		}
+	});
+}
+
+export function openFile(filePath: string, _title: string = 'Open File...'): boolean {
+	try {
+		Windows.System.StorageFile.GetFileFromPathAsync(filePath).then((file: any) => {
+			Windows.System.Launcher.LaunchFileAsync(file);
+		});
+		return true;
+	} catch (e) {
+		Trace.write(`Error in openFile: ${e.message}`, Trace.categories.Error, Trace.messageType.error);
+		return false;
+	}
+}
+
+export function dismissSoftInput(_nativeView?: any): void {
+	try {
+		Windows.UI.ViewManagement.InputPane.GetForCurrentView()?.TryHide();
+	} catch {}
+}
+
+export function dismissKeyboard(): void {
+	dismissSoftInput();
+}
+
+export function copyToClipboard(value: string): void {
+	try {
+		const dataPackage = new Windows.ApplicationModel.DataTransfer.DataPackage();
+		dataPackage.SetText(value);
+		Windows.ApplicationModel.DataTransfer.Clipboard.SetContent(dataPackage);
+	} catch (err) {
+		console.error(err);
+	}
+}
diff --git a/packages/core/utils/layout-helper/index.windows.ts b/packages/core/utils/layout-helper/index.windows.ts
new file mode 100644
index 0000000000..9bb8fdc5b1
--- /dev/null
+++ b/packages/core/utils/layout-helper/index.windows.ts
@@ -0,0 +1,83 @@
+import * as layoutCommon from './layout-helper-common';
+import { getCurrentWindowScale } from '../../application/window-helper.windows';
+
+export namespace layout {
+	export const MODE_SHIFT = 30;
+	export const MODE_MASK = 0x3 << MODE_SHIFT;
+
+	export const UNSPECIFIED = 0 << MODE_SHIFT;
+	export const EXACTLY = 1 << MODE_SHIFT;
+	export const AT_MOST = 2 << MODE_SHIFT;
+
+	export const MEASURED_HEIGHT_STATE_SHIFT = 0x00000010;
+	export const MEASURED_STATE_TOO_SMALL = 0x01000000;
+	export const MEASURED_STATE_MASK = 0xff000000;
+	export const MEASURED_SIZE_MASK = 0x00ffffff;
+
+	export function getMode(mode: number) {
+		return layoutCommon.getMode(mode);
+	}
+
+	export function getMeasureSpecMode(spec: number): number {
+		return layoutCommon.getMeasureSpecMode(spec);
+	}
+
+	export function getMeasureSpecSize(spec: number) {
+		return layoutCommon.getMeasureSpecSize(spec);
+	}
+
+	export function makeMeasureSpec(size: number, mode: number): number {
+		return (Math.round(Math.max(0, size)) & ~MODE_MASK) | (mode & MODE_MASK);
+	}
+
+	export function hasRtlSupport(): boolean {
+		return true;
+	}
+
+	export function getDisplayDensity(): number {
+		return getCurrentWindowScale();
+	}
+
+	export function toDevicePixels(value: number): number {
+		return value * getDisplayDensity();
+	}
+
+	export function toDeviceIndependentPixels(value: number): number {
+		return value / getDisplayDensity();
+	}
+
+	export function round(value: number) {
+		return layoutCommon.round(value);
+	}
+
+	function toXamlMeasureConstraint(size: number, mode: number): number {
+		if (mode === UNSPECIFIED) {
+			return Number.POSITIVE_INFINITY;
+		}
+		return toDeviceIndependentPixels(size);
+	}
+
+	export function measureNativeView(nativeView: any, width: number, widthMode: number, height: number, heightMode: number): { width: number; height: number } {
+		if (nativeView && nativeView.Measure) {
+			const size = Microsoft.UI.Xaml.SizeHelper.FromDimensions(
+				toXamlMeasureConstraint(width, widthMode),
+				toXamlMeasureConstraint(height, heightMode),
+			);
+
+			(nativeView as Microsoft.UI.Xaml.FrameworkElement).Measure(size);
+
+			const ret = (nativeView as Microsoft.UI.Xaml.FrameworkElement).DesiredSize;
+
+			return {
+				width: round(toDevicePixels(ret.Width)),
+				height: round(toDevicePixels(ret.Height)),
+			};
+		}
+
+		return { width: 0, height: 0 };
+	}
+
+	export function measureSpecToString(measureSpec: number) {
+		return layoutCommon.measureSpecToString(measureSpec);
+	}
+}
diff --git a/packages/core/utils/mainthread-helper.windows.ts b/packages/core/utils/mainthread-helper.windows.ts
new file mode 100644
index 0000000000..b0401e77c2
--- /dev/null
+++ b/packages/core/utils/mainthread-helper.windows.ts
@@ -0,0 +1,18 @@
+export function dispatchToMainThread(func: () => void): void {
+	(global as any).__nsRunOnUIThread(() => {
+		func();
+	})
+}
+
+export function isMainThread(): boolean {
+	try {
+		const queue = Microsoft?.UI?.Dispatching?.DispatcherQueue?.GetForCurrentThread?.();
+		return queue ? queue.HasThreadAccess : true;
+	} catch {
+		return true;
+	}
+}
+
+export function dispatchToUIThread(func: () => void): void {
+	dispatchToMainThread(func);
+}
diff --git a/packages/core/utils/native-helper.windows.ts b/packages/core/utils/native-helper.windows.ts
new file mode 100644
index 0000000000..5c437ed365
--- /dev/null
+++ b/packages/core/utils/native-helper.windows.ts
@@ -0,0 +1,124 @@
+import { platformCheck } from './platform-check';
+
+export function dataSerialize(data: any): any {
+	return data;
+}
+
+
+function tryDeserializeJsonValue(value: any): any {
+	if (value === null || value === undefined) return value;
+
+	//@ts-ignore
+	const JsonValueType = Windows.Data.Json.JsonValueType;
+
+	try {
+		switch (value.ValueType) {
+			case JsonValueType.Null:
+				return null;
+			case JsonValueType.Boolean:
+				return value.GetBoolean();
+			case JsonValueType.Number:
+				return value.GetNumber();
+			case JsonValueType.String:
+				return value.GetString();
+			case JsonValueType.Array:
+				return dataDeserialize(value.GetArray());
+			case JsonValueType.Object:
+				return dataDeserialize(value.GetObject());
+			default:
+				return value;
+		}
+	} catch {
+		try {
+			return JSON.parse(value.Stringify());
+		} catch {
+			return value;
+		}
+	}
+}
+
+export function dataDeserialize(data: any): any {
+	if (data === null || typeof data !== 'object') {
+		return data;
+	}
+
+
+	if (data instanceof Windows.Data.Json.JsonObject) {
+		const obj: Record<string, any> = {};
+		const iterator = data.First();
+		try {
+			while (iterator.HasCurrent) {
+				const current = iterator.Current;
+
+				obj[current.Key] = tryDeserializeJsonValue(current.Value)
+				iterator.MoveNext();
+			}
+		} catch { }
+		return obj;
+	}
+
+	if (data instanceof Windows.Data.Json.JsonArray) {
+		const result: any[] = [];
+		for (let i = 0; i < data.Size; i++) {
+			result.push(tryDeserializeJsonValue(data.GetObjectAt(i) ?? data.GetAt(i)));
+		}
+		return result;
+	}
+
+	//@ts-ignore
+	if (data instanceof Windows.Data.Json.JsonValue) {
+		return tryDeserializeJsonValue(data);
+	}
+
+
+
+	if (
+		//@ts-ignore
+		data instanceof Windows.Foundation.Collections.IVector ||
+		//@ts-ignore
+		data instanceof Windows.Foundation.Collections.IVectorView
+	) {
+		const result = [];
+
+		for (let i = 0; i < data.Size; i++) {
+			result.push(dataDeserialize(data.GetAt(i)));
+		}
+
+		return result;
+	}
+
+
+	if (
+		//@ts-ignore
+		data instanceof Windows.Foundation.Collections.IMap ||
+		//@ts-ignore
+		data instanceof Windows.Foundation.Collections.IMapView
+	) {
+		const obj: Record<any, any> = {};
+
+		const iterator = data.First();
+
+		while (iterator.HasCurrent) {
+			const current = iterator.Current;
+
+			obj[current.Key] = dataDeserialize(current.Value);
+
+			iterator.MoveNext();
+		}
+
+		return obj;
+	}
+	return data;
+}
+
+export function isRealDevice(): boolean {
+	return true;
+}
+
+export const windows = {};
+
+// These don't exist on Windows — stub them to warn in dev.
+export const ad = platformCheck('Utils.ad');
+export const android = platformCheck('Utils.android');
+export const ios = platformCheck('Utils.ios');
+export const iOSNativeHelper = platformCheck('Utils.iOSNativeHelper');
diff --git a/packages/types-minimal/src/lib/windows/NativeScript.Widgets.d.ts b/packages/types-minimal/src/lib/windows/NativeScript.Widgets.d.ts
new file mode 100644
index 0000000000..c58ffe5795
--- /dev/null
+++ b/packages/types-minimal/src/lib/windows/NativeScript.Widgets.d.ts
@@ -0,0 +1,55 @@
+// Auto-generated by typings-generator (dotnet mode).
+// Do not edit - re-run build.windows.ps1 to regenerate.
+
+declare namespace NativeScript.Widgets {
+    class FlexboxLayout extends Microsoft.UI.Xaml.Controls.Panel implements NativeScript.Widgets.IFlexboxLayout {
+      JustifyContent: number;
+      FlexWrap: number;
+      FlexDirection: number;
+      AlignItems: number;
+      AlignContent: number;
+      constructor();
+      static GetOrder(result: Microsoft.UI.Xaml.UIElement): number;
+      static SetOrder(element: Microsoft.UI.Xaml.UIElement, value: number): void;
+      static GetFlexGrow(result: Microsoft.UI.Xaml.UIElement): number;
+      static SetFlexGrow(element: Microsoft.UI.Xaml.UIElement, value: number): void;
+      static GetFlexShrink(result: Microsoft.UI.Xaml.UIElement): number;
+      static SetFlexShrink(element: Microsoft.UI.Xaml.UIElement, value: number): void;
+      static GetAlignSelf(result: Microsoft.UI.Xaml.UIElement): number;
+      static SetAlignSelf(element: Microsoft.UI.Xaml.UIElement, value: number): void;
+      static GetFlexBasisPercent(result: Microsoft.UI.Xaml.UIElement): number;
+      static SetFlexBasisPercent(element: Microsoft.UI.Xaml.UIElement, value: number): void;
+      static GetWrapBefore(result: Microsoft.UI.Xaml.UIElement): boolean;
+      static SetWrapBefore(element: Microsoft.UI.Xaml.UIElement, value: boolean): void;
+    }
+    class ImageHelper {
+      static LoadFromBufferAsync(operation: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<NativeScript.Widgets.ImageResult>;
+      static LoadFromUrlAsync(operation: string): Windows.Foundation.IAsyncOperation<NativeScript.Widgets.ImageResult>;
+      static LoadFromFileAsync(operation: string): Windows.Foundation.IAsyncOperation<NativeScript.Widgets.ImageResult>;
+      static ResizeAsync(operation: Windows.Storage.Streams.IBuffer, buffer: number): Windows.Foundation.IAsyncOperation<NativeScript.Widgets.ImageResult>;
+      static SaveToFileAsync(operation: Windows.Storage.Streams.IBuffer, buffer: string): Windows.Foundation.IAsyncOperation<boolean>;
+      static ReadFileAsync(operation: string): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+      static BufferToBase64(result: Windows.Storage.Streams.IBuffer): string;
+    }
+    class ImageResult implements NativeScript.Widgets.IImageResult {
+      readonly Bitmap: Microsoft.UI.Xaml.Media.Imaging.BitmapImage;
+      readonly Height: number;
+      readonly RawBuffer: Windows.Storage.Streams.IBuffer;
+      readonly Width: number;
+    }
+    class ShadowHelper {
+      static CreateShadow(result: number, width: number, height: number, blurRadius: number, spread: number, cornerRadius: number, offsetX: number, offsetY: number): NativeScript.Widgets.ShadowImageResult;
+      static CreateBorder(result: number, width: number, height: number, topW: number, rightW: number, bottomW: number, leftW: number, topArgb: number, rightArgb: number, bottomArgb: number, leftArgb: number): NativeScript.Widgets.ShadowImageResult;
+    }
+    class ShadowImageResult implements NativeScript.Widgets.IShadowImageResult {
+      readonly Height: number;
+      readonly Image: Microsoft.UI.Xaml.Controls.Image;
+      readonly Overhang: number;
+      readonly Width: number;
+    }
+    class StackLayout extends Microsoft.UI.Xaml.Controls.Panel implements NativeScript.Widgets.IStackLayout {
+      Orientation: number;
+      constructor();
+    }
+}
+
diff --git a/packages/types-minimal/src/lib/windows/microsoft.ui.d.ts b/packages/types-minimal/src/lib/windows/microsoft.ui.d.ts
new file mode 100644
index 0000000000..8006b9daa2
--- /dev/null
+++ b/packages/types-minimal/src/lib/windows/microsoft.ui.d.ts
@@ -0,0 +1,14806 @@
+// Auto-generated by typings-generator (dotnet mode).
+// Do not edit - re-run build.windows.ps1 to regenerate.
+
+declare namespace Microsoft.UI {
+    class ClosableNotifierHandler {
+      constructor(handler: () => void);
+      Invoke(): void;
+    }
+    class ColorHelper implements Microsoft.UI.IColorHelper {
+      static ToDisplayName(result: Windows.UI.Color): string;
+      static FromArgb(result: number, a: number, r: number, g: number): Windows.UI.Color;
+    }
+    class Colors implements Microsoft.UI.IColors {
+      static readonly AliceBlue: Windows.UI.Color;
+      static readonly AntiqueWhite: Windows.UI.Color;
+      static readonly Aqua: Windows.UI.Color;
+      static readonly Aquamarine: Windows.UI.Color;
+      static readonly Azure: Windows.UI.Color;
+      static readonly Beige: Windows.UI.Color;
+      static readonly Bisque: Windows.UI.Color;
+      static readonly Black: Windows.UI.Color;
+      static readonly BlanchedAlmond: Windows.UI.Color;
+      static readonly Blue: Windows.UI.Color;
+      static readonly BlueViolet: Windows.UI.Color;
+      static readonly Brown: Windows.UI.Color;
+      static readonly BurlyWood: Windows.UI.Color;
+      static readonly CadetBlue: Windows.UI.Color;
+      static readonly Chartreuse: Windows.UI.Color;
+      static readonly Chocolate: Windows.UI.Color;
+      static readonly Coral: Windows.UI.Color;
+      static readonly CornflowerBlue: Windows.UI.Color;
+      static readonly Cornsilk: Windows.UI.Color;
+      static readonly Crimson: Windows.UI.Color;
+      static readonly Cyan: Windows.UI.Color;
+      static readonly DarkBlue: Windows.UI.Color;
+      static readonly DarkCyan: Windows.UI.Color;
+      static readonly DarkGoldenrod: Windows.UI.Color;
+      static readonly DarkGray: Windows.UI.Color;
+      static readonly DarkGreen: Windows.UI.Color;
+      static readonly DarkKhaki: Windows.UI.Color;
+      static readonly DarkMagenta: Windows.UI.Color;
+      static readonly DarkOliveGreen: Windows.UI.Color;
+      static readonly DarkOrange: Windows.UI.Color;
+      static readonly DarkOrchid: Windows.UI.Color;
+      static readonly DarkRed: Windows.UI.Color;
+      static readonly DarkSalmon: Windows.UI.Color;
+      static readonly DarkSeaGreen: Windows.UI.Color;
+      static readonly DarkSlateBlue: Windows.UI.Color;
+      static readonly DarkSlateGray: Windows.UI.Color;
+      static readonly DarkTurquoise: Windows.UI.Color;
+      static readonly DarkViolet: Windows.UI.Color;
+      static readonly DeepPink: Windows.UI.Color;
+      static readonly DeepSkyBlue: Windows.UI.Color;
+      static readonly DimGray: Windows.UI.Color;
+      static readonly DodgerBlue: Windows.UI.Color;
+      static readonly Firebrick: Windows.UI.Color;
+      static readonly FloralWhite: Windows.UI.Color;
+      static readonly ForestGreen: Windows.UI.Color;
+      static readonly Fuchsia: Windows.UI.Color;
+      static readonly Gainsboro: Windows.UI.Color;
+      static readonly GhostWhite: Windows.UI.Color;
+      static readonly Gold: Windows.UI.Color;
+      static readonly Goldenrod: Windows.UI.Color;
+      static readonly Gray: Windows.UI.Color;
+      static readonly Green: Windows.UI.Color;
+      static readonly GreenYellow: Windows.UI.Color;
+      static readonly Honeydew: Windows.UI.Color;
+      static readonly HotPink: Windows.UI.Color;
+      static readonly IndianRed: Windows.UI.Color;
+      static readonly Indigo: Windows.UI.Color;
+      static readonly Ivory: Windows.UI.Color;
+      static readonly Khaki: Windows.UI.Color;
+      static readonly Lavender: Windows.UI.Color;
+      static readonly LavenderBlush: Windows.UI.Color;
+      static readonly LawnGreen: Windows.UI.Color;
+      static readonly LemonChiffon: Windows.UI.Color;
+      static readonly LightBlue: Windows.UI.Color;
+      static readonly LightCoral: Windows.UI.Color;
+      static readonly LightCyan: Windows.UI.Color;
+      static readonly LightGoldenrodYellow: Windows.UI.Color;
+      static readonly LightGray: Windows.UI.Color;
+      static readonly LightGreen: Windows.UI.Color;
+      static readonly LightPink: Windows.UI.Color;
+      static readonly LightSalmon: Windows.UI.Color;
+      static readonly LightSeaGreen: Windows.UI.Color;
+      static readonly LightSkyBlue: Windows.UI.Color;
+      static readonly LightSlateGray: Windows.UI.Color;
+      static readonly LightSteelBlue: Windows.UI.Color;
+      static readonly LightYellow: Windows.UI.Color;
+      static readonly Lime: Windows.UI.Color;
+      static readonly LimeGreen: Windows.UI.Color;
+      static readonly Linen: Windows.UI.Color;
+      static readonly Magenta: Windows.UI.Color;
+      static readonly Maroon: Windows.UI.Color;
+      static readonly MediumAquamarine: Windows.UI.Color;
+      static readonly MediumBlue: Windows.UI.Color;
+      static readonly MediumOrchid: Windows.UI.Color;
+      static readonly MediumPurple: Windows.UI.Color;
+      static readonly MediumSeaGreen: Windows.UI.Color;
+      static readonly MediumSlateBlue: Windows.UI.Color;
+      static readonly MediumSpringGreen: Windows.UI.Color;
+      static readonly MediumTurquoise: Windows.UI.Color;
+      static readonly MediumVioletRed: Windows.UI.Color;
+      static readonly MidnightBlue: Windows.UI.Color;
+      static readonly MintCream: Windows.UI.Color;
+      static readonly MistyRose: Windows.UI.Color;
+      static readonly Moccasin: Windows.UI.Color;
+      static readonly NavajoWhite: Windows.UI.Color;
+      static readonly Navy: Windows.UI.Color;
+      static readonly OldLace: Windows.UI.Color;
+      static readonly Olive: Windows.UI.Color;
+      static readonly OliveDrab: Windows.UI.Color;
+      static readonly Orange: Windows.UI.Color;
+      static readonly OrangeRed: Windows.UI.Color;
+      static readonly Orchid: Windows.UI.Color;
+      static readonly PaleGoldenrod: Windows.UI.Color;
+      static readonly PaleGreen: Windows.UI.Color;
+      static readonly PaleTurquoise: Windows.UI.Color;
+      static readonly PaleVioletRed: Windows.UI.Color;
+      static readonly PapayaWhip: Windows.UI.Color;
+      static readonly PeachPuff: Windows.UI.Color;
+      static readonly Peru: Windows.UI.Color;
+      static readonly Pink: Windows.UI.Color;
+      static readonly Plum: Windows.UI.Color;
+      static readonly PowderBlue: Windows.UI.Color;
+      static readonly Purple: Windows.UI.Color;
+      static readonly Red: Windows.UI.Color;
+      static readonly RosyBrown: Windows.UI.Color;
+      static readonly RoyalBlue: Windows.UI.Color;
+      static readonly SaddleBrown: Windows.UI.Color;
+      static readonly Salmon: Windows.UI.Color;
+      static readonly SandyBrown: Windows.UI.Color;
+      static readonly SeaGreen: Windows.UI.Color;
+      static readonly SeaShell: Windows.UI.Color;
+      static readonly Sienna: Windows.UI.Color;
+      static readonly Silver: Windows.UI.Color;
+      static readonly SkyBlue: Windows.UI.Color;
+      static readonly SlateBlue: Windows.UI.Color;
+      static readonly SlateGray: Windows.UI.Color;
+      static readonly Snow: Windows.UI.Color;
+      static readonly SpringGreen: Windows.UI.Color;
+      static readonly SteelBlue: Windows.UI.Color;
+      static readonly Tan: Windows.UI.Color;
+      static readonly Teal: Windows.UI.Color;
+      static readonly Thistle: Windows.UI.Color;
+      static readonly Tomato: Windows.UI.Color;
+      static readonly Transparent: Windows.UI.Color;
+      static readonly Turquoise: Windows.UI.Color;
+      static readonly Violet: Windows.UI.Color;
+      static readonly Wheat: Windows.UI.Color;
+      static readonly White: Windows.UI.Color;
+      static readonly WhiteSmoke: Windows.UI.Color;
+      static readonly Yellow: Windows.UI.Color;
+      static readonly YellowGreen: Windows.UI.Color;
+    }
+    class DisplayId extends System.ValueType {
+      Value: number;
+    }
+    interface IClosableNotifier {
+      Closed: Microsoft.UI.ClosableNotifierHandler | null;
+      FrameworkClosed: Microsoft.UI.ClosableNotifierHandler | null;
+      readonly IsClosed: boolean;
+    }
+    class IconId extends System.ValueType {
+      Value: number;
+    }
+    class WindowId extends System.ValueType {
+      Value: number;
+    }
+}
+
+declare namespace Microsoft.UI.Composition {
+    class CompositionObject implements Microsoft.UI.Composition.ICompositionObject, Microsoft.UI.Composition.ICompositionObject2, Microsoft.UI.Composition.ICompositionObject3, Microsoft.UI.Composition.ICompositionObject4, Microsoft.UI.Composition.ICompositionObject5, Microsoft.UI.Composition.IAnimationObject {
+      readonly Compositor: Microsoft.UI.Composition.Compositor;
+      readonly Properties: Microsoft.UI.Composition.CompositionPropertySet;
+      ImplicitAnimations: Microsoft.UI.Composition.ImplicitAnimationCollection;
+      Comment: string;
+      readonly DispatcherQueue: Microsoft.UI.Dispatching.DispatcherQueue;
+      Dispose(): void;
+      PopulatePropertyInfo(propertyName: string, propertyInfo: Microsoft.UI.Composition.AnimationPropertyInfo): void;
+      StartAnimation(propertyName: string, animation: Microsoft.UI.Composition.CompositionAnimation): void;
+      StopAnimation(propertyName: string): void;
+      StartAnimationGroup(value: Microsoft.UI.Composition.ICompositionAnimationBase): void;
+      StopAnimationGroup(value: Microsoft.UI.Composition.ICompositionAnimationBase): void;
+      TryGetAnimationController(result: string): Microsoft.UI.Composition.AnimationController;
+      StartAnimation(propertyName: string, animation: Microsoft.UI.Composition.CompositionAnimation, animationController: Microsoft.UI.Composition.AnimationController): void;
+      static StartAnimationWithIAnimationObject(target: Microsoft.UI.Composition.IAnimationObject, propertyName: string, animation: Microsoft.UI.Composition.CompositionAnimation): void;
+      static StartAnimationGroupWithIAnimationObject(target: Microsoft.UI.Composition.IAnimationObject, animation: Microsoft.UI.Composition.ICompositionAnimationBase): void;
+    }
+    class CompositionLight extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionLight, Microsoft.UI.Composition.ICompositionLight2, Microsoft.UI.Composition.ICompositionLight3 {
+      readonly Targets: Microsoft.UI.Composition.VisualUnorderedCollection;
+      readonly ExclusionsFromTargets: Microsoft.UI.Composition.VisualUnorderedCollection;
+      IsEnabled: boolean;
+    }
+    class AmbientLight extends Microsoft.UI.Composition.CompositionLight implements Microsoft.UI.Composition.IAmbientLight, Microsoft.UI.Composition.IAmbientLight2 {
+      Color: Windows.UI.Color;
+      Intensity: number;
+    }
+    class AnimationController extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.IAnimationController {
+      ProgressBehavior: number;
+      Progress: number;
+      PlaybackRate: number;
+      static readonly MaxPlaybackRate: number;
+      static readonly MinPlaybackRate: number;
+      Resume(): void;
+      Pause(): void;
+    }
+    class AnimationControllerProgressBehavior extends System.Enum {
+      value__: number;
+      static Default: number;
+      static IncludesDelayTime: number;
+    }
+    class AnimationDelayBehavior extends System.Enum {
+      value__: number;
+      static SetInitialValueAfterDelay: number;
+      static SetInitialValueBeforeDelay: number;
+    }
+    class AnimationDirection extends System.Enum {
+      value__: number;
+      static Normal: number;
+      static Reverse: number;
+      static Alternate: number;
+      static AlternateReverse: number;
+    }
+    class AnimationIterationBehavior extends System.Enum {
+      value__: number;
+      static Count: number;
+      static Forever: number;
+    }
+    class AnimationPropertyAccessMode extends System.Enum {
+      value__: number;
+      static None: number;
+      static ReadOnly: number;
+      static WriteOnly: number;
+      static ReadWrite: number;
+    }
+    class AnimationPropertyInfo extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.IAnimationPropertyInfo, Microsoft.UI.Composition.IAnimationPropertyInfo2 {
+      AccessMode: number;
+      GetResolvedCompositionObjectProperty(): string;
+      GetResolvedCompositionObject(): Microsoft.UI.Composition.CompositionObject;
+    }
+    class AnimationStopBehavior extends System.Enum {
+      value__: number;
+      static LeaveCurrentValue: number;
+      static SetToInitialValue: number;
+      static SetToFinalValue: number;
+    }
+    class CompositionEasingFunction extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionEasingFunction {
+      static CreateCubicBezierEasingFunction(result: Microsoft.UI.Composition.Compositor, owner: System.Numerics.Vector2, controlPoint1: System.Numerics.Vector2): Microsoft.UI.Composition.CubicBezierEasingFunction;
+      static CreateLinearEasingFunction(result: Microsoft.UI.Composition.Compositor): Microsoft.UI.Composition.LinearEasingFunction;
+      static CreateStepEasingFunction(result: Microsoft.UI.Composition.Compositor): Microsoft.UI.Composition.StepEasingFunction;
+      static CreateStepEasingFunction(result: Microsoft.UI.Composition.Compositor, owner: number): Microsoft.UI.Composition.StepEasingFunction;
+      static CreateBackEasingFunction(result: Microsoft.UI.Composition.Compositor, owner: number, mode: number): Microsoft.UI.Composition.BackEasingFunction;
+      static CreateBounceEasingFunction(result: Microsoft.UI.Composition.Compositor, owner: number, mode: number, bounces: number): Microsoft.UI.Composition.BounceEasingFunction;
+      static CreateCircleEasingFunction(result: Microsoft.UI.Composition.Compositor, owner: number): Microsoft.UI.Composition.CircleEasingFunction;
+      static CreateElasticEasingFunction(result: Microsoft.UI.Composition.Compositor, owner: number, mode: number, oscillations: number): Microsoft.UI.Composition.ElasticEasingFunction;
+      static CreateExponentialEasingFunction(result: Microsoft.UI.Composition.Compositor, owner: number, mode: number): Microsoft.UI.Composition.ExponentialEasingFunction;
+      static CreatePowerEasingFunction(result: Microsoft.UI.Composition.Compositor, owner: number, mode: number): Microsoft.UI.Composition.PowerEasingFunction;
+      static CreateSineEasingFunction(result: Microsoft.UI.Composition.Compositor, owner: number): Microsoft.UI.Composition.SineEasingFunction;
+    }
+    class BackEasingFunction extends Microsoft.UI.Composition.CompositionEasingFunction implements Microsoft.UI.Composition.IBackEasingFunction {
+      readonly Amplitude: number;
+      readonly Mode: number;
+    }
+    class CompositionAnimation extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionAnimation, Microsoft.UI.Composition.ICompositionAnimation2, Microsoft.UI.Composition.ICompositionAnimation3, Microsoft.UI.Composition.ICompositionAnimation4, Microsoft.UI.Composition.ICompositionAnimationBase {
+      Target: string;
+      readonly InitialValueExpressions: Microsoft.UI.Composition.InitialValueExpressionCollection;
+      SetVector4Parameter(key: string, value: System.Numerics.Vector4): void;
+      SetExpressionReferenceParameter(parameterName: string, source: Microsoft.UI.Composition.IAnimationObject): void;
+      SetScalarParameter(key: string, value: number): void;
+      SetReferenceParameter(key: string, compositionObject: Microsoft.UI.Composition.CompositionObject): void;
+      ClearParameter(key: string): void;
+      SetColorParameter(key: string, value: Windows.UI.Color): void;
+      SetBooleanParameter(key: string, value: boolean): void;
+      SetMatrix3x2Parameter(key: string, value: System.Numerics.Matrix3x2): void;
+      SetMatrix4x4Parameter(key: string, value: System.Numerics.Matrix4x4): void;
+      SetQuaternionParameter(key: string, value: System.Numerics.Quaternion): void;
+      SetVector2Parameter(key: string, value: System.Numerics.Vector2): void;
+      SetVector3Parameter(key: string, value: System.Numerics.Vector3): void;
+      ClearAllParameters(): void;
+    }
+    class KeyFrameAnimation extends Microsoft.UI.Composition.CompositionAnimation implements Microsoft.UI.Composition.IKeyFrameAnimation, Microsoft.UI.Composition.IKeyFrameAnimation2, Microsoft.UI.Composition.IKeyFrameAnimation3 {
+      StopBehavior: number;
+      IterationCount: number;
+      IterationBehavior: number;
+      Duration: System.TimeSpan;
+      DelayTime: System.TimeSpan;
+      readonly KeyFrameCount: number;
+      Direction: number;
+      DelayBehavior: number;
+      InsertExpressionKeyFrame(normalizedProgressKey: number, value: string): void;
+      InsertExpressionKeyFrame(normalizedProgressKey: number, value: string, easingFunction: Microsoft.UI.Composition.CompositionEasingFunction): void;
+    }
+    class BooleanKeyFrameAnimation extends Microsoft.UI.Composition.KeyFrameAnimation implements Microsoft.UI.Composition.IBooleanKeyFrameAnimation {
+      InsertKeyFrame(normalizedProgressKey: number, value: boolean): void;
+    }
+    class BounceEasingFunction extends Microsoft.UI.Composition.CompositionEasingFunction implements Microsoft.UI.Composition.IBounceEasingFunction {
+      readonly Bounces: number;
+      readonly Bounciness: number;
+      readonly Mode: number;
+    }
+    class NaturalMotionAnimation extends Microsoft.UI.Composition.CompositionAnimation implements Microsoft.UI.Composition.INaturalMotionAnimation {
+      StopBehavior: number;
+      DelayTime: System.TimeSpan;
+      DelayBehavior: number;
+    }
+    class ScalarNaturalMotionAnimation extends Microsoft.UI.Composition.NaturalMotionAnimation implements Microsoft.UI.Composition.IScalarNaturalMotionAnimation {
+      InitialVelocity: number;
+      InitialValue: System.Nullable<number>;
+      FinalValue: System.Nullable<number>;
+    }
+    class BounceScalarNaturalMotionAnimation extends Microsoft.UI.Composition.ScalarNaturalMotionAnimation implements Microsoft.UI.Composition.IBounceScalarNaturalMotionAnimation {
+      Restitution: number;
+      Acceleration: number;
+    }
+    class Vector2NaturalMotionAnimation extends Microsoft.UI.Composition.NaturalMotionAnimation implements Microsoft.UI.Composition.IVector2NaturalMotionAnimation {
+      InitialVelocity: System.Numerics.Vector2;
+      InitialValue: System.Nullable<System.Numerics.Vector2>;
+      FinalValue: System.Nullable<System.Numerics.Vector2>;
+    }
+    class BounceVector2NaturalMotionAnimation extends Microsoft.UI.Composition.Vector2NaturalMotionAnimation implements Microsoft.UI.Composition.IBounceVector2NaturalMotionAnimation {
+      Restitution: number;
+      Acceleration: number;
+    }
+    class Vector3NaturalMotionAnimation extends Microsoft.UI.Composition.NaturalMotionAnimation implements Microsoft.UI.Composition.IVector3NaturalMotionAnimation {
+      InitialVelocity: System.Numerics.Vector3;
+      InitialValue: System.Nullable<System.Numerics.Vector3>;
+      FinalValue: System.Nullable<System.Numerics.Vector3>;
+    }
+    class BounceVector3NaturalMotionAnimation extends Microsoft.UI.Composition.Vector3NaturalMotionAnimation implements Microsoft.UI.Composition.IBounceVector3NaturalMotionAnimation {
+      Restitution: number;
+      Acceleration: number;
+    }
+    class CircleEasingFunction extends Microsoft.UI.Composition.CompositionEasingFunction implements Microsoft.UI.Composition.ICircleEasingFunction {
+      readonly Mode: number;
+    }
+    class ColorKeyFrameAnimation extends Microsoft.UI.Composition.KeyFrameAnimation implements Microsoft.UI.Composition.IColorKeyFrameAnimation {
+      InterpolationColorSpace: number;
+      InsertKeyFrame(normalizedProgressKey: number, value: Windows.UI.Color, easingFunction: Microsoft.UI.Composition.CompositionEasingFunction): void;
+      InsertKeyFrame(normalizedProgressKey: number, value: Windows.UI.Color): void;
+    }
+    class CompositionAnimationGroup extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionAnimationGroup, Microsoft.UI.Composition.ICompositionAnimationBase {
+      readonly Count: number;
+      Remove(value: Microsoft.UI.Composition.CompositionAnimation): void;
+      Add(value: Microsoft.UI.Composition.CompositionAnimation): void;
+      RemoveAll(): void;
+    }
+    class CompositionApiInformation {
+      static readonly ApiVersion: number;
+    }
+    class CompositionBrush extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionBrush {
+    }
+    class CompositionBackdropBrush extends Microsoft.UI.Composition.CompositionBrush implements Microsoft.UI.Composition.ICompositionBackdropBrush {
+    }
+    class CompositionBackfaceVisibility extends System.Enum {
+      value__: number;
+      static Inherit: number;
+      static Visible: number;
+      static Hidden: number;
+    }
+    class CompositionBatchCompletedEventArgs extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionBatchCompletedEventArgs {
+    }
+    class CompositionBatchTypes extends System.Enum {
+      value__: number;
+      static None: number;
+      static Animation: number;
+      static Effect: number;
+      static InfiniteAnimation: number;
+      static AllAnimations: number;
+    }
+    class CompositionBitmapInterpolationMode extends System.Enum {
+      value__: number;
+      static NearestNeighbor: number;
+      static Linear: number;
+      static MagLinearMinLinearMipLinear: number;
+      static MagLinearMinLinearMipNearest: number;
+      static MagLinearMinNearestMipLinear: number;
+      static MagLinearMinNearestMipNearest: number;
+      static MagNearestMinLinearMipLinear: number;
+      static MagNearestMinLinearMipNearest: number;
+      static MagNearestMinNearestMipLinear: number;
+      static MagNearestMinNearestMipNearest: number;
+    }
+    class CompositionBorderMode extends System.Enum {
+      value__: number;
+      static Inherit: number;
+      static Soft: number;
+      static Hard: number;
+    }
+    class CompositionCapabilities implements Microsoft.UI.Composition.ICompositionCapabilities {
+      Changed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Composition.CompositionCapabilities, any> | null;
+      AreEffectsSupported(): boolean;
+      AreEffectsFast(): boolean;
+      constructor();
+    }
+    class CompositionClip extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionClip, Microsoft.UI.Composition.ICompositionClip2 {
+      TransformMatrix: System.Numerics.Matrix3x2;
+      Scale: System.Numerics.Vector2;
+      RotationAngleInDegrees: number;
+      RotationAngle: number;
+      Offset: System.Numerics.Vector2;
+      CenterPoint: System.Numerics.Vector2;
+      AnchorPoint: System.Numerics.Vector2;
+    }
+    class CompositionColorBrush extends Microsoft.UI.Composition.CompositionBrush implements Microsoft.UI.Composition.ICompositionColorBrush {
+      Color: Windows.UI.Color;
+    }
+    class CompositionColorGradientStop extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionColorGradientStop {
+      Offset: number;
+      Color: Windows.UI.Color;
+    }
+    class CompositionColorGradientStopCollection implements Microsoft.UI.Composition.ICompositionColorGradientStopCollection {
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class CompositionColorSpace extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Hsl: number;
+      static Rgb: number;
+      static HslLinear: number;
+      static RgbLinear: number;
+    }
+    class CompositionCommitBatch extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionCommitBatch {
+      Completed: Windows.Foundation.TypedEventHandler<any, Microsoft.UI.Composition.CompositionBatchCompletedEventArgs> | null;
+      readonly IsActive: boolean;
+      readonly IsEnded: boolean;
+    }
+    class CompositionCompositeMode extends System.Enum {
+      value__: number;
+      static Inherit: number;
+      static SourceOver: number;
+      static DestinationInvert: number;
+      static MinBlend: number;
+    }
+    class CompositionShape extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionShape {
+      TransformMatrix: System.Numerics.Matrix3x2;
+      Scale: System.Numerics.Vector2;
+      RotationAngleInDegrees: number;
+      RotationAngle: number;
+      Offset: System.Numerics.Vector2;
+      CenterPoint: System.Numerics.Vector2;
+    }
+    class CompositionContainerShape extends Microsoft.UI.Composition.CompositionShape implements Microsoft.UI.Composition.ICompositionContainerShape {
+      readonly Shapes: Microsoft.UI.Composition.CompositionShapeCollection;
+    }
+    class CompositionDrawingSurface extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionDrawingSurface, Microsoft.UI.Composition.ICompositionDrawingSurface2, Microsoft.UI.Composition.ICompositionSurface {
+      readonly AlphaMode: Microsoft.Graphics.DirectX.DirectXAlphaMode;
+      readonly PixelFormat: Microsoft.Graphics.DirectX.DirectXPixelFormat;
+      readonly Size: Windows.Foundation.Size;
+      readonly SizeInt32: Windows.Graphics.SizeInt32;
+      Resize(sizePixels: Windows.Graphics.SizeInt32): void;
+      Scroll(offset: Windows.Graphics.PointInt32): void;
+      Scroll(offset: Windows.Graphics.PointInt32, scrollRect: Windows.Graphics.RectInt32): void;
+      ScrollWithClip(offset: Windows.Graphics.PointInt32, clipRect: Windows.Graphics.RectInt32, scrollRect: Windows.Graphics.RectInt32): void;
+      ScrollWithClip(offset: Windows.Graphics.PointInt32, clipRect: Windows.Graphics.RectInt32): void;
+    }
+    class CompositionDropShadowSourcePolicy extends System.Enum {
+      value__: number;
+      static Default: number;
+      static InheritFromVisualContent: number;
+    }
+    class CompositionEasingFunctionMode extends System.Enum {
+      value__: number;
+      static In: number;
+      static Out: number;
+      static InOut: number;
+    }
+    class CompositionEffectBrush extends Microsoft.UI.Composition.CompositionBrush implements Microsoft.UI.Composition.ICompositionEffectBrush {
+      SetSourceParameter(name: string, source: Microsoft.UI.Composition.CompositionBrush): void;
+      GetSourceParameter(result: string): Microsoft.UI.Composition.CompositionBrush;
+    }
+    class CompositionEffectFactory extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionEffectFactory {
+      readonly ExtendedError: System.Exception;
+      readonly LoadStatus: number;
+      CreateBrush(): Microsoft.UI.Composition.CompositionEffectBrush;
+    }
+    class CompositionEffectFactoryLoadStatus extends System.Enum {
+      value__: number;
+      static Success: number;
+      static EffectTooComplex: number;
+      static Pending: number;
+      static Other: number;
+    }
+    class CompositionEffectSourceParameter implements Microsoft.UI.Composition.ICompositionEffectSourceParameter, Windows.Graphics.Effects.IGraphicsEffectSource {
+      readonly Name: string;
+      constructor(name: string);
+    }
+    class CompositionGeometry extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionGeometry {
+      TrimStart: number;
+      TrimOffset: number;
+      TrimEnd: number;
+    }
+    class CompositionEllipseGeometry extends Microsoft.UI.Composition.CompositionGeometry implements Microsoft.UI.Composition.ICompositionEllipseGeometry {
+      Radius: System.Numerics.Vector2;
+      Center: System.Numerics.Vector2;
+    }
+    class CompositionGeometricClip extends Microsoft.UI.Composition.CompositionClip implements Microsoft.UI.Composition.ICompositionGeometricClip {
+      ViewBox: Microsoft.UI.Composition.CompositionViewBox;
+      Geometry: Microsoft.UI.Composition.CompositionGeometry;
+    }
+    class CompositionGetValueStatus extends System.Enum {
+      value__: number;
+      static Succeeded: number;
+      static TypeMismatch: number;
+      static NotFound: number;
+    }
+    class CompositionGradientBrush extends Microsoft.UI.Composition.CompositionBrush implements Microsoft.UI.Composition.ICompositionGradientBrush, Microsoft.UI.Composition.ICompositionGradientBrush2 {
+      TransformMatrix: System.Numerics.Matrix3x2;
+      Scale: System.Numerics.Vector2;
+      RotationAngleInDegrees: number;
+      RotationAngle: number;
+      Offset: System.Numerics.Vector2;
+      InterpolationSpace: number;
+      ExtendMode: number;
+      CenterPoint: System.Numerics.Vector2;
+      AnchorPoint: System.Numerics.Vector2;
+      readonly ColorStops: Microsoft.UI.Composition.CompositionColorGradientStopCollection;
+      MappingMode: number;
+    }
+    class CompositionGradientExtendMode extends System.Enum {
+      value__: number;
+      static Clamp: number;
+      static Wrap: number;
+      static Mirror: number;
+    }
+    class CompositionGraphicsDevice extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionGraphicsDevice, Microsoft.UI.Composition.ICompositionGraphicsDevice2, Microsoft.UI.Composition.ICompositionGraphicsDevice3, Microsoft.UI.Composition.ICompositionGraphicsDevice4 {
+      RenderingDeviceReplaced: Windows.Foundation.TypedEventHandler<Microsoft.UI.Composition.CompositionGraphicsDevice, Microsoft.UI.Composition.RenderingDeviceReplacedEventArgs> | null;
+      Trim(): void;
+      CreateVirtualDrawingSurface(result: Windows.Graphics.SizeInt32, sizePixels: Microsoft.Graphics.DirectX.DirectXPixelFormat, pixelFormat: Microsoft.Graphics.DirectX.DirectXAlphaMode): Microsoft.UI.Composition.CompositionVirtualDrawingSurface;
+      CreateMipmapSurface(result: Windows.Graphics.SizeInt32, sizePixels: Microsoft.Graphics.DirectX.DirectXPixelFormat, pixelFormat: Microsoft.Graphics.DirectX.DirectXAlphaMode): Microsoft.UI.Composition.CompositionMipmapSurface;
+      CaptureAsync(operation: Microsoft.UI.Composition.Visual, captureVisual: Windows.Graphics.SizeInt32, size: Microsoft.Graphics.DirectX.DirectXPixelFormat, pixelFormat: Microsoft.Graphics.DirectX.DirectXAlphaMode, alphaMode: number): Windows.Foundation.IAsyncOperation<Microsoft.UI.Composition.ICompositionSurface>;
+      CreateDrawingSurface(result: Windows.Foundation.Size, sizePixels: Microsoft.Graphics.DirectX.DirectXPixelFormat, pixelFormat: Microsoft.Graphics.DirectX.DirectXAlphaMode): Microsoft.UI.Composition.CompositionDrawingSurface;
+      CreateDrawingSurface2(result: Windows.Graphics.SizeInt32, sizePixels: Microsoft.Graphics.DirectX.DirectXPixelFormat, pixelFormat: Microsoft.Graphics.DirectX.DirectXAlphaMode): Microsoft.UI.Composition.CompositionDrawingSurface;
+    }
+    class CompositionLineGeometry extends Microsoft.UI.Composition.CompositionGeometry implements Microsoft.UI.Composition.ICompositionLineGeometry {
+      Start: System.Numerics.Vector2;
+      End: System.Numerics.Vector2;
+    }
+    class CompositionLinearGradientBrush extends Microsoft.UI.Composition.CompositionGradientBrush implements Microsoft.UI.Composition.ICompositionLinearGradientBrush {
+      StartPoint: System.Numerics.Vector2;
+      EndPoint: System.Numerics.Vector2;
+    }
+    class CompositionMappingMode extends System.Enum {
+      value__: number;
+      static Absolute: number;
+      static Relative: number;
+    }
+    class CompositionMaskBrush extends Microsoft.UI.Composition.CompositionBrush implements Microsoft.UI.Composition.ICompositionMaskBrush {
+      Source: Microsoft.UI.Composition.CompositionBrush;
+      Mask: Microsoft.UI.Composition.CompositionBrush;
+    }
+    class CompositionMipmapSurface extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionMipmapSurface, Microsoft.UI.Composition.ICompositionSurface {
+      readonly AlphaMode: Microsoft.Graphics.DirectX.DirectXAlphaMode;
+      readonly LevelCount: number;
+      readonly PixelFormat: Microsoft.Graphics.DirectX.DirectXPixelFormat;
+      readonly SizeInt32: Windows.Graphics.SizeInt32;
+      GetDrawingSurfaceForLevel(result: number): Microsoft.UI.Composition.CompositionDrawingSurface;
+    }
+    class CompositionNineGridBrush extends Microsoft.UI.Composition.CompositionBrush implements Microsoft.UI.Composition.ICompositionNineGridBrush {
+      TopInsetScale: number;
+      TopInset: number;
+      Source: Microsoft.UI.Composition.CompositionBrush;
+      RightInsetScale: number;
+      RightInset: number;
+      LeftInsetScale: number;
+      LeftInset: number;
+      IsCenterHollow: boolean;
+      BottomInsetScale: number;
+      BottomInset: number;
+      SetInsets(left: number, top: number, right: number, bottom: number): void;
+      SetInsets(inset: number): void;
+      SetInsetScales(scale: number): void;
+      SetInsetScales(left: number, top: number, right: number, bottom: number): void;
+    }
+    class CompositionPath implements Microsoft.UI.Composition.ICompositionPath, Windows.Graphics.IGeometrySource2D {
+      constructor(source: Windows.Graphics.IGeometrySource2D);
+    }
+    class CompositionPathGeometry extends Microsoft.UI.Composition.CompositionGeometry implements Microsoft.UI.Composition.ICompositionPathGeometry {
+      Path: Microsoft.UI.Composition.CompositionPath;
+    }
+    class CompositionProjectedShadow extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionProjectedShadow {
+      MinBlurRadius: number;
+      MaxBlurRadius: number;
+      LightSource: Microsoft.UI.Composition.CompositionLight;
+      BlurRadiusMultiplier: number;
+      readonly Casters: Microsoft.UI.Composition.CompositionProjectedShadowCasterCollection;
+      readonly Receivers: Microsoft.UI.Composition.CompositionProjectedShadowReceiverUnorderedCollection;
+    }
+    class CompositionProjectedShadowCaster extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionProjectedShadowCaster {
+      CastingVisual: Microsoft.UI.Composition.Visual;
+      Brush: Microsoft.UI.Composition.CompositionBrush;
+    }
+    class CompositionProjectedShadowCasterCollection extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionProjectedShadowCasterCollection {
+      readonly Count: number;
+      static readonly MaxRespectedCasters: number;
+      InsertBelow(newCaster: Microsoft.UI.Composition.CompositionProjectedShadowCaster, reference: Microsoft.UI.Composition.CompositionProjectedShadowCaster): void;
+      InsertAbove(newCaster: Microsoft.UI.Composition.CompositionProjectedShadowCaster, reference: Microsoft.UI.Composition.CompositionProjectedShadowCaster): void;
+      InsertAtBottom(newCaster: Microsoft.UI.Composition.CompositionProjectedShadowCaster): void;
+      InsertAtTop(newCaster: Microsoft.UI.Composition.CompositionProjectedShadowCaster): void;
+      Remove(caster: Microsoft.UI.Composition.CompositionProjectedShadowCaster): void;
+      RemoveAll(): void;
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class CompositionProjectedShadowReceiver extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionProjectedShadowReceiver {
+      ReceivingVisual: Microsoft.UI.Composition.Visual;
+    }
+    class CompositionProjectedShadowReceiverUnorderedCollection extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionProjectedShadowReceiverUnorderedCollection {
+      readonly Count: number;
+      Add(value: Microsoft.UI.Composition.CompositionProjectedShadowReceiver): void;
+      Remove(value: Microsoft.UI.Composition.CompositionProjectedShadowReceiver): void;
+      RemoveAll(): void;
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class CompositionPropertySet extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionPropertySet, Microsoft.UI.Composition.ICompositionPropertySet2 {
+      TryGetBoolean(result: string, propertyName: boolean): number;
+      TryGetScalar(result: string, propertyName: number): number;
+      TryGetVector3(result: string, propertyName: System.Numerics.Vector3): number;
+      TryGetColor(result: string, propertyName: Windows.UI.Color): number;
+      TryGetVector2(result: string, propertyName: System.Numerics.Vector2): number;
+      TryGetVector4(result: string, propertyName: System.Numerics.Vector4): number;
+      InsertBoolean(propertyName: string, value: boolean): void;
+      InsertVector2(propertyName: string, value: System.Numerics.Vector2): void;
+      TryGetMatrix3x2(result: string, propertyName: System.Numerics.Matrix3x2): number;
+      TryGetMatrix4x4(result: string, propertyName: System.Numerics.Matrix4x4): number;
+      TryGetQuaternion(result: string, propertyName: System.Numerics.Quaternion): number;
+      InsertMatrix3x2(propertyName: string, value: System.Numerics.Matrix3x2): void;
+      InsertMatrix4x4(propertyName: string, value: System.Numerics.Matrix4x4): void;
+      InsertQuaternion(propertyName: string, value: System.Numerics.Quaternion): void;
+      InsertScalar(propertyName: string, value: number): void;
+      InsertColor(propertyName: string, value: Windows.UI.Color): void;
+      InsertVector3(propertyName: string, value: System.Numerics.Vector3): void;
+      InsertVector4(propertyName: string, value: System.Numerics.Vector4): void;
+    }
+    class CompositionRadialGradientBrush extends Microsoft.UI.Composition.CompositionGradientBrush implements Microsoft.UI.Composition.ICompositionRadialGradientBrush {
+      GradientOriginOffset: System.Numerics.Vector2;
+      EllipseRadius: System.Numerics.Vector2;
+      EllipseCenter: System.Numerics.Vector2;
+    }
+    class CompositionRectangleGeometry extends Microsoft.UI.Composition.CompositionGeometry implements Microsoft.UI.Composition.ICompositionRectangleGeometry {
+      Size: System.Numerics.Vector2;
+      Offset: System.Numerics.Vector2;
+    }
+    class CompositionRoundedRectangleGeometry extends Microsoft.UI.Composition.CompositionGeometry implements Microsoft.UI.Composition.ICompositionRoundedRectangleGeometry {
+      Size: System.Numerics.Vector2;
+      Offset: System.Numerics.Vector2;
+      CornerRadius: System.Numerics.Vector2;
+    }
+    class CompositionScopedBatch extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionScopedBatch {
+      Completed: Windows.Foundation.TypedEventHandler<any, Microsoft.UI.Composition.CompositionBatchCompletedEventArgs> | null;
+      readonly IsActive: boolean;
+      readonly IsEnded: boolean;
+      Resume(): void;
+      End(): void;
+      Suspend(): void;
+    }
+    class CompositionShadow extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionShadow {
+    }
+    class CompositionShapeCollection extends Microsoft.UI.Composition.CompositionObject {
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class CompositionSpriteShape extends Microsoft.UI.Composition.CompositionShape implements Microsoft.UI.Composition.ICompositionSpriteShape {
+      StrokeThickness: number;
+      StrokeStartCap: number;
+      StrokeMiterLimit: number;
+      StrokeLineJoin: number;
+      StrokeEndCap: number;
+      StrokeDashOffset: number;
+      StrokeDashCap: number;
+      StrokeBrush: Microsoft.UI.Composition.CompositionBrush;
+      IsStrokeNonScaling: boolean;
+      Geometry: Microsoft.UI.Composition.CompositionGeometry;
+      FillBrush: Microsoft.UI.Composition.CompositionBrush;
+      readonly StrokeDashArray: Microsoft.UI.Composition.CompositionStrokeDashArray;
+    }
+    class CompositionStretch extends System.Enum {
+      value__: number;
+      static None: number;
+      static Fill: number;
+      static Uniform: number;
+      static UniformToFill: number;
+    }
+    class CompositionStrokeCap extends System.Enum {
+      value__: number;
+      static Flat: number;
+      static Square: number;
+      static Round: number;
+      static Triangle: number;
+    }
+    class CompositionStrokeDashArray extends Microsoft.UI.Composition.CompositionObject {
+    }
+    class CompositionStrokeLineJoin extends System.Enum {
+      value__: number;
+      static Miter: number;
+      static Bevel: number;
+      static Round: number;
+      static MiterOrBevel: number;
+    }
+    class CompositionSurfaceBrush extends Microsoft.UI.Composition.CompositionBrush implements Microsoft.UI.Composition.ICompositionSurfaceBrush, Microsoft.UI.Composition.ICompositionSurfaceBrush2, Microsoft.UI.Composition.ICompositionSurfaceBrush3 {
+      VerticalAlignmentRatio: number;
+      Surface: Microsoft.UI.Composition.ICompositionSurface;
+      Stretch: number;
+      HorizontalAlignmentRatio: number;
+      BitmapInterpolationMode: number;
+      TransformMatrix: System.Numerics.Matrix3x2;
+      Scale: System.Numerics.Vector2;
+      RotationAngleInDegrees: number;
+      RotationAngle: number;
+      Offset: System.Numerics.Vector2;
+      CenterPoint: System.Numerics.Vector2;
+      AnchorPoint: System.Numerics.Vector2;
+      SnapToPixels: boolean;
+    }
+    class CompositionTransform extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionTransform {
+    }
+    class CompositionViewBox extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionViewBox {
+      VerticalAlignmentRatio: number;
+      Stretch: number;
+      Size: System.Numerics.Vector2;
+      Offset: System.Numerics.Vector2;
+      HorizontalAlignmentRatio: number;
+    }
+    class CompositionVirtualDrawingSurface extends Microsoft.UI.Composition.CompositionDrawingSurface implements Microsoft.UI.Composition.ICompositionVirtualDrawingSurface {
+      Trim(rects: Windows.Graphics.RectInt32[]): void;
+    }
+    class CompositionVisualSurface extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.ICompositionVisualSurface, Microsoft.UI.Composition.ICompositionSurface {
+      SourceVisual: Microsoft.UI.Composition.Visual;
+      SourceSize: System.Numerics.Vector2;
+      SourceOffset: System.Numerics.Vector2;
+    }
+    class Compositor implements Microsoft.UI.Composition.ICompositor, Microsoft.UI.Composition.ICompositor2, Microsoft.UI.Composition.ICompositor4, Microsoft.UI.Composition.ICompositor5, Microsoft.UI.Composition.ICompositor6, Microsoft.UI.Composition.ICompositor7, Microsoft.UI.Composition.ICompositorWithProjectedShadow, Microsoft.UI.Composition.ICompositorWithRadialGradient, Microsoft.UI.Composition.ICompositorWithVisualSurface, Microsoft.UI.Composition.ICompositor8 {
+      GlobalPlaybackRate: number;
+      Comment: string;
+      readonly DispatcherQueue: Microsoft.UI.Dispatching.DispatcherQueue;
+      static readonly MaxGlobalPlaybackRate: number;
+      static readonly MinGlobalPlaybackRate: number;
+      CreateBounceVector3Animation(): Microsoft.UI.Composition.BounceVector3NaturalMotionAnimation;
+      CreateSpringVector3Animation(): Microsoft.UI.Composition.SpringVector3NaturalMotionAnimation;
+      CreateBounceScalarAnimation(): Microsoft.UI.Composition.BounceScalarNaturalMotionAnimation;
+      CreateBounceVector2Animation(): Microsoft.UI.Composition.BounceVector2NaturalMotionAnimation;
+      CreateContainerShape(): Microsoft.UI.Composition.CompositionContainerShape;
+      CreateEllipseGeometry(): Microsoft.UI.Composition.CompositionEllipseGeometry;
+      CreateLineGeometry(): Microsoft.UI.Composition.CompositionLineGeometry;
+      CreatePathGeometry(): Microsoft.UI.Composition.CompositionPathGeometry;
+      CreatePathGeometry(result: Microsoft.UI.Composition.CompositionPath): Microsoft.UI.Composition.CompositionPathGeometry;
+      CreatePathKeyFrameAnimation(): Microsoft.UI.Composition.PathKeyFrameAnimation;
+      CreateRectangleGeometry(): Microsoft.UI.Composition.CompositionRectangleGeometry;
+      CreateRoundedRectangleGeometry(): Microsoft.UI.Composition.CompositionRoundedRectangleGeometry;
+      CreateShapeVisual(): Microsoft.UI.Composition.ShapeVisual;
+      CreateSpriteShape(): Microsoft.UI.Composition.CompositionSpriteShape;
+      CreateSpriteShape(result: Microsoft.UI.Composition.CompositionGeometry): Microsoft.UI.Composition.CompositionSpriteShape;
+      CreateViewBox(): Microsoft.UI.Composition.CompositionViewBox;
+      RequestCommitAsync(): Windows.Foundation.IAsyncAction;
+      CreateGeometricClip(): Microsoft.UI.Composition.CompositionGeometricClip;
+      CreateGeometricClip(result: Microsoft.UI.Composition.CompositionGeometry): Microsoft.UI.Composition.CompositionGeometricClip;
+      CreateRedirectVisual(): Microsoft.UI.Composition.RedirectVisual;
+      CreateRedirectVisual(result: Microsoft.UI.Composition.Visual): Microsoft.UI.Composition.RedirectVisual;
+      CreateBooleanKeyFrameAnimation(): Microsoft.UI.Composition.BooleanKeyFrameAnimation;
+      CreateAnimationPropertyInfo(): Microsoft.UI.Composition.AnimationPropertyInfo;
+      CreateRectangleClip(): Microsoft.UI.Composition.RectangleClip;
+      CreateRectangleClip(result: number, left: number, top: number, right: number): Microsoft.UI.Composition.RectangleClip;
+      CreateRectangleClip(result: number, left: number, top: number, right: number, bottom: System.Numerics.Vector2, topLeftRadius: System.Numerics.Vector2, topRightRadius: System.Numerics.Vector2, bottomRightRadius: System.Numerics.Vector2): Microsoft.UI.Composition.RectangleClip;
+      CreateProjectedShadowCaster(): Microsoft.UI.Composition.CompositionProjectedShadowCaster;
+      CreateProjectedShadow(): Microsoft.UI.Composition.CompositionProjectedShadow;
+      CreateProjectedShadowReceiver(): Microsoft.UI.Composition.CompositionProjectedShadowReceiver;
+      CreateRadialGradientBrush(): Microsoft.UI.Composition.CompositionRadialGradientBrush;
+      CreateVisualSurface(): Microsoft.UI.Composition.CompositionVisualSurface;
+      CreateAnimationController(): Microsoft.UI.Composition.AnimationController;
+      Dispose(): void;
+      CreateColorKeyFrameAnimation(): Microsoft.UI.Composition.ColorKeyFrameAnimation;
+      CreateColorBrush(): Microsoft.UI.Composition.CompositionColorBrush;
+      CreateColorBrush(result: Windows.UI.Color): Microsoft.UI.Composition.CompositionColorBrush;
+      CreateContainerVisual(): Microsoft.UI.Composition.ContainerVisual;
+      CreateCubicBezierEasingFunction(result: System.Numerics.Vector2, controlPoint1: System.Numerics.Vector2): Microsoft.UI.Composition.CubicBezierEasingFunction;
+      CreateEffectFactory(result: Windows.Graphics.Effects.IGraphicsEffect): Microsoft.UI.Composition.CompositionEffectFactory;
+      CreateEffectFactory(result: Windows.Graphics.Effects.IGraphicsEffect, graphicsEffect: System.Collections.Generic.IEnumerable<string>): Microsoft.UI.Composition.CompositionEffectFactory;
+      CreateExpressionAnimation(): Microsoft.UI.Composition.ExpressionAnimation;
+      CreateExpressionAnimation(result: string): Microsoft.UI.Composition.ExpressionAnimation;
+      CreateInsetClip(): Microsoft.UI.Composition.InsetClip;
+      CreateInsetClip(result: number, leftInset: number, topInset: number, rightInset: number): Microsoft.UI.Composition.InsetClip;
+      CreateLinearEasingFunction(): Microsoft.UI.Composition.LinearEasingFunction;
+      CreatePropertySet(): Microsoft.UI.Composition.CompositionPropertySet;
+      CreateQuaternionKeyFrameAnimation(): Microsoft.UI.Composition.QuaternionKeyFrameAnimation;
+      CreateScalarKeyFrameAnimation(): Microsoft.UI.Composition.ScalarKeyFrameAnimation;
+      CreateScopedBatch(result: number): Microsoft.UI.Composition.CompositionScopedBatch;
+      CreateSpriteVisual(): Microsoft.UI.Composition.SpriteVisual;
+      CreateSurfaceBrush(): Microsoft.UI.Composition.CompositionSurfaceBrush;
+      CreateSurfaceBrush(result: Microsoft.UI.Composition.ICompositionSurface): Microsoft.UI.Composition.CompositionSurfaceBrush;
+      CreateVector2KeyFrameAnimation(): Microsoft.UI.Composition.Vector2KeyFrameAnimation;
+      CreateVector3KeyFrameAnimation(): Microsoft.UI.Composition.Vector3KeyFrameAnimation;
+      CreateVector4KeyFrameAnimation(): Microsoft.UI.Composition.Vector4KeyFrameAnimation;
+      GetCommitBatch(result: number): Microsoft.UI.Composition.CompositionCommitBatch;
+      CreateAmbientLight(): Microsoft.UI.Composition.AmbientLight;
+      CreateAnimationGroup(): Microsoft.UI.Composition.CompositionAnimationGroup;
+      CreateBackdropBrush(): Microsoft.UI.Composition.CompositionBackdropBrush;
+      CreateDistantLight(): Microsoft.UI.Composition.DistantLight;
+      CreateDropShadow(): Microsoft.UI.Composition.DropShadow;
+      CreateImplicitAnimationCollection(): Microsoft.UI.Composition.ImplicitAnimationCollection;
+      CreateLayerVisual(): Microsoft.UI.Composition.LayerVisual;
+      CreateMaskBrush(): Microsoft.UI.Composition.CompositionMaskBrush;
+      CreateNineGridBrush(): Microsoft.UI.Composition.CompositionNineGridBrush;
+      CreatePointLight(): Microsoft.UI.Composition.PointLight;
+      CreateSpotLight(): Microsoft.UI.Composition.SpotLight;
+      CreateStepEasingFunction(): Microsoft.UI.Composition.StepEasingFunction;
+      CreateStepEasingFunction(result: number): Microsoft.UI.Composition.StepEasingFunction;
+      CreateColorGradientStop(): Microsoft.UI.Composition.CompositionColorGradientStop;
+      CreateColorGradientStop(result: number, offset: Windows.UI.Color): Microsoft.UI.Composition.CompositionColorGradientStop;
+      CreateLinearGradientBrush(): Microsoft.UI.Composition.CompositionLinearGradientBrush;
+      CreateSpringScalarAnimation(): Microsoft.UI.Composition.SpringScalarNaturalMotionAnimation;
+      CreateSpringVector2Animation(): Microsoft.UI.Composition.SpringVector2NaturalMotionAnimation;
+      constructor();
+    }
+    class Visual extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.IVisual, Microsoft.UI.Composition.IVisual2, Microsoft.UI.Composition.IVisual3, Microsoft.UI.Composition.IVisual4 {
+      TransformMatrix: System.Numerics.Matrix4x4;
+      Size: System.Numerics.Vector2;
+      Scale: System.Numerics.Vector3;
+      RotationAxis: System.Numerics.Vector3;
+      RotationAngleInDegrees: number;
+      RotationAngle: number;
+      Orientation: System.Numerics.Quaternion;
+      Opacity: number;
+      Offset: System.Numerics.Vector3;
+      IsVisible: boolean;
+      CompositeMode: number;
+      Clip: Microsoft.UI.Composition.CompositionClip;
+      CenterPoint: System.Numerics.Vector3;
+      BorderMode: number;
+      BackfaceVisibility: number;
+      AnchorPoint: System.Numerics.Vector2;
+      readonly Parent: Microsoft.UI.Composition.ContainerVisual;
+      RelativeSizeAdjustment: System.Numerics.Vector2;
+      RelativeOffsetAdjustment: System.Numerics.Vector3;
+      ParentForTransform: Microsoft.UI.Composition.Visual;
+      IsHitTestVisible: boolean;
+      IsPixelSnappingEnabled: boolean;
+    }
+    class ContainerVisual extends Microsoft.UI.Composition.Visual implements Microsoft.UI.Composition.IContainerVisual {
+      readonly Children: Microsoft.UI.Composition.VisualCollection;
+    }
+    class CubicBezierEasingFunction extends Microsoft.UI.Composition.CompositionEasingFunction implements Microsoft.UI.Composition.ICubicBezierEasingFunction {
+      readonly ControlPoint1: System.Numerics.Vector2;
+      readonly ControlPoint2: System.Numerics.Vector2;
+    }
+    class DistantLight extends Microsoft.UI.Composition.CompositionLight implements Microsoft.UI.Composition.IDistantLight, Microsoft.UI.Composition.IDistantLight2 {
+      Direction: System.Numerics.Vector3;
+      CoordinateSpace: Microsoft.UI.Composition.Visual;
+      Color: Windows.UI.Color;
+      Intensity: number;
+    }
+    class DropShadow extends Microsoft.UI.Composition.CompositionShadow implements Microsoft.UI.Composition.IDropShadow, Microsoft.UI.Composition.IDropShadow2 {
+      Opacity: number;
+      Offset: System.Numerics.Vector3;
+      Mask: Microsoft.UI.Composition.CompositionBrush;
+      Color: Windows.UI.Color;
+      BlurRadius: number;
+      SourcePolicy: number;
+    }
+    class ElasticEasingFunction extends Microsoft.UI.Composition.CompositionEasingFunction implements Microsoft.UI.Composition.IElasticEasingFunction {
+      readonly Mode: number;
+      readonly Oscillations: number;
+      readonly Springiness: number;
+    }
+    class ExponentialEasingFunction extends Microsoft.UI.Composition.CompositionEasingFunction implements Microsoft.UI.Composition.IExponentialEasingFunction {
+      readonly Exponent: number;
+      readonly Mode: number;
+    }
+    class ExpressionAnimation extends Microsoft.UI.Composition.CompositionAnimation implements Microsoft.UI.Composition.IExpressionAnimation {
+      Expression: string;
+    }
+    interface IAnimationObject {
+      PopulatePropertyInfo(propertyName: string, propertyInfo: Microsoft.UI.Composition.AnimationPropertyInfo): void;
+    }
+    interface ICompositionAnimationBase {
+    }
+    interface ICompositionSupportsSystemBackdrop {
+      SystemBackdrop: Windows.UI.Composition.CompositionBrush;
+    }
+    interface ICompositionSurface {
+    }
+    interface ICompositionSurfaceFacade {
+      GetRealSurface(): Microsoft.UI.Composition.ICompositionSurface;
+    }
+    interface IVisualElement {
+    }
+    interface IVisualElement2 {
+      GetVisualInternal(): Microsoft.UI.Composition.Visual;
+    }
+    class ImplicitAnimationCollection extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.IImplicitAnimationCollection {
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class InitialValueExpressionCollection extends Microsoft.UI.Composition.CompositionObject {
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class InsetClip extends Microsoft.UI.Composition.CompositionClip implements Microsoft.UI.Composition.IInsetClip {
+      TopInset: number;
+      RightInset: number;
+      LeftInset: number;
+      BottomInset: number;
+    }
+    class LayerVisual extends Microsoft.UI.Composition.ContainerVisual implements Microsoft.UI.Composition.ILayerVisual, Microsoft.UI.Composition.ILayerVisual2 {
+      Effect: Microsoft.UI.Composition.CompositionEffectBrush;
+      Shadow: Microsoft.UI.Composition.CompositionShadow;
+    }
+    class LinearEasingFunction extends Microsoft.UI.Composition.CompositionEasingFunction implements Microsoft.UI.Composition.ILinearEasingFunction {
+    }
+    class PathKeyFrameAnimation extends Microsoft.UI.Composition.KeyFrameAnimation implements Microsoft.UI.Composition.IPathKeyFrameAnimation {
+      InsertKeyFrame(normalizedProgressKey: number, path: Microsoft.UI.Composition.CompositionPath): void;
+      InsertKeyFrame(normalizedProgressKey: number, path: Microsoft.UI.Composition.CompositionPath, easingFunction: Microsoft.UI.Composition.CompositionEasingFunction): void;
+    }
+    class PointLight extends Microsoft.UI.Composition.CompositionLight implements Microsoft.UI.Composition.IPointLight, Microsoft.UI.Composition.IPointLight2, Microsoft.UI.Composition.IPointLight3 {
+      QuadraticAttenuation: number;
+      Offset: System.Numerics.Vector3;
+      LinearAttenuation: number;
+      CoordinateSpace: Microsoft.UI.Composition.Visual;
+      ConstantAttenuation: number;
+      Color: Windows.UI.Color;
+      Intensity: number;
+      MinAttenuationCutoff: number;
+      MaxAttenuationCutoff: number;
+    }
+    class PowerEasingFunction extends Microsoft.UI.Composition.CompositionEasingFunction implements Microsoft.UI.Composition.IPowerEasingFunction {
+      readonly Mode: number;
+      readonly Power: number;
+    }
+    class QuaternionKeyFrameAnimation extends Microsoft.UI.Composition.KeyFrameAnimation implements Microsoft.UI.Composition.IQuaternionKeyFrameAnimation {
+      InsertKeyFrame(normalizedProgressKey: number, value: System.Numerics.Quaternion, easingFunction: Microsoft.UI.Composition.CompositionEasingFunction): void;
+      InsertKeyFrame(normalizedProgressKey: number, value: System.Numerics.Quaternion): void;
+    }
+    class RectangleClip extends Microsoft.UI.Composition.CompositionClip implements Microsoft.UI.Composition.IRectangleClip {
+      TopRightRadius: System.Numerics.Vector2;
+      TopLeftRadius: System.Numerics.Vector2;
+      Top: number;
+      Right: number;
+      Left: number;
+      BottomRightRadius: System.Numerics.Vector2;
+      BottomLeftRadius: System.Numerics.Vector2;
+      Bottom: number;
+    }
+    class RedirectVisual extends Microsoft.UI.Composition.ContainerVisual implements Microsoft.UI.Composition.IRedirectVisual {
+      Source: Microsoft.UI.Composition.Visual;
+    }
+    class RenderingDeviceReplacedEventArgs extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.IRenderingDeviceReplacedEventArgs {
+      readonly GraphicsDevice: Microsoft.UI.Composition.CompositionGraphicsDevice;
+    }
+    class ScalarKeyFrameAnimation extends Microsoft.UI.Composition.KeyFrameAnimation implements Microsoft.UI.Composition.IScalarKeyFrameAnimation {
+      InsertKeyFrame(normalizedProgressKey: number, value: number, easingFunction: Microsoft.UI.Composition.CompositionEasingFunction): void;
+      InsertKeyFrame(normalizedProgressKey: number, value: number): void;
+    }
+    class ShapeVisual extends Microsoft.UI.Composition.ContainerVisual implements Microsoft.UI.Composition.IShapeVisual {
+      ViewBox: Microsoft.UI.Composition.CompositionViewBox;
+      readonly Shapes: Microsoft.UI.Composition.CompositionShapeCollection;
+    }
+    class SineEasingFunction extends Microsoft.UI.Composition.CompositionEasingFunction implements Microsoft.UI.Composition.ISineEasingFunction {
+      readonly Mode: number;
+    }
+    class SpotLight extends Microsoft.UI.Composition.CompositionLight implements Microsoft.UI.Composition.ISpotLight, Microsoft.UI.Composition.ISpotLight2, Microsoft.UI.Composition.ISpotLight3 {
+      QuadraticAttenuation: number;
+      OuterConeColor: Windows.UI.Color;
+      OuterConeAngleInDegrees: number;
+      OuterConeAngle: number;
+      Offset: System.Numerics.Vector3;
+      LinearAttenuation: number;
+      InnerConeColor: Windows.UI.Color;
+      InnerConeAngleInDegrees: number;
+      InnerConeAngle: number;
+      Direction: System.Numerics.Vector3;
+      CoordinateSpace: Microsoft.UI.Composition.Visual;
+      ConstantAttenuation: number;
+      OuterConeIntensity: number;
+      InnerConeIntensity: number;
+      MinAttenuationCutoff: number;
+      MaxAttenuationCutoff: number;
+    }
+    class SpringScalarNaturalMotionAnimation extends Microsoft.UI.Composition.ScalarNaturalMotionAnimation implements Microsoft.UI.Composition.ISpringScalarNaturalMotionAnimation {
+      Period: System.TimeSpan;
+      DampingRatio: number;
+    }
+    class SpringVector2NaturalMotionAnimation extends Microsoft.UI.Composition.Vector2NaturalMotionAnimation implements Microsoft.UI.Composition.ISpringVector2NaturalMotionAnimation {
+      Period: System.TimeSpan;
+      DampingRatio: number;
+    }
+    class SpringVector3NaturalMotionAnimation extends Microsoft.UI.Composition.Vector3NaturalMotionAnimation implements Microsoft.UI.Composition.ISpringVector3NaturalMotionAnimation {
+      Period: System.TimeSpan;
+      DampingRatio: number;
+    }
+    class SpriteVisual extends Microsoft.UI.Composition.ContainerVisual implements Microsoft.UI.Composition.ISpriteVisual, Microsoft.UI.Composition.ISpriteVisual2 {
+      Brush: Microsoft.UI.Composition.CompositionBrush;
+      Shadow: Microsoft.UI.Composition.CompositionShadow;
+    }
+    class StepEasingFunction extends Microsoft.UI.Composition.CompositionEasingFunction implements Microsoft.UI.Composition.IStepEasingFunction {
+      StepCount: number;
+      IsInitialStepSingleFrame: boolean;
+      IsFinalStepSingleFrame: boolean;
+      InitialStep: number;
+      FinalStep: number;
+    }
+    class Vector2KeyFrameAnimation extends Microsoft.UI.Composition.KeyFrameAnimation implements Microsoft.UI.Composition.IVector2KeyFrameAnimation {
+      InsertKeyFrame(normalizedProgressKey: number, value: System.Numerics.Vector2, easingFunction: Microsoft.UI.Composition.CompositionEasingFunction): void;
+      InsertKeyFrame(normalizedProgressKey: number, value: System.Numerics.Vector2): void;
+    }
+    class Vector3KeyFrameAnimation extends Microsoft.UI.Composition.KeyFrameAnimation implements Microsoft.UI.Composition.IVector3KeyFrameAnimation {
+      InsertKeyFrame(normalizedProgressKey: number, value: System.Numerics.Vector3): void;
+      InsertKeyFrame(normalizedProgressKey: number, value: System.Numerics.Vector3, easingFunction: Microsoft.UI.Composition.CompositionEasingFunction): void;
+    }
+    class Vector4KeyFrameAnimation extends Microsoft.UI.Composition.KeyFrameAnimation implements Microsoft.UI.Composition.IVector4KeyFrameAnimation {
+      InsertKeyFrame(normalizedProgressKey: number, value: System.Numerics.Vector4, easingFunction: Microsoft.UI.Composition.CompositionEasingFunction): void;
+      InsertKeyFrame(normalizedProgressKey: number, value: System.Numerics.Vector4): void;
+    }
+    class VisualCollection extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.IVisualCollection {
+      readonly Count: number;
+      Remove(child: Microsoft.UI.Composition.Visual): void;
+      InsertAbove(newChild: Microsoft.UI.Composition.Visual, sibling: Microsoft.UI.Composition.Visual): void;
+      InsertAtBottom(newChild: Microsoft.UI.Composition.Visual): void;
+      InsertAtTop(newChild: Microsoft.UI.Composition.Visual): void;
+      InsertBelow(newChild: Microsoft.UI.Composition.Visual, sibling: Microsoft.UI.Composition.Visual): void;
+      RemoveAll(): void;
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class VisualUnorderedCollection extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.IVisualUnorderedCollection {
+      readonly Count: number;
+      Add(newVisual: Microsoft.UI.Composition.Visual): void;
+      Remove(visual: Microsoft.UI.Composition.Visual): void;
+      RemoveAll(): void;
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+}
+
+declare namespace Microsoft.UI.Composition.Core {
+    class CompositorController implements Microsoft.UI.Composition.Core.ICompositorController {
+      CommitNeeded: Windows.Foundation.TypedEventHandler<Microsoft.UI.Composition.Core.CompositorController, any> | null;
+      readonly Compositor: Microsoft.UI.Composition.Compositor;
+      EnsurePreviousCommitCompletedAsync(): Windows.Foundation.IAsyncAction;
+      Dispose(): void;
+      Commit(): void;
+      constructor();
+    }
+}
+
+declare namespace Microsoft.UI.Composition.Diagnostics {
+    class CompositionDebugHeatMaps implements Microsoft.UI.Composition.Diagnostics.ICompositionDebugHeatMaps {
+      ShowOverdraw(subtree: Microsoft.UI.Composition.Visual, contentKinds: number): void;
+      ShowMemoryUsage(subtree: Microsoft.UI.Composition.Visual): void;
+      Hide(subtree: Microsoft.UI.Composition.Visual): void;
+      ShowRedraw(subtree: Microsoft.UI.Composition.Visual): void;
+    }
+    class CompositionDebugOverdrawContentKinds extends System.Enum {
+      value__: number;
+      static None: number;
+      static OffscreenRendered: number;
+      static Colors: number;
+      static Effects: number;
+      static Shadows: number;
+      static Lights: number;
+      static Surfaces: number;
+      static SwapChains: number;
+      static All: number;
+    }
+    class CompositionDebugSettings implements Microsoft.UI.Composition.Diagnostics.ICompositionDebugSettings {
+      readonly HeatMaps: Microsoft.UI.Composition.Diagnostics.CompositionDebugHeatMaps;
+      static TryGetSettings(result: Microsoft.UI.Composition.Compositor): Microsoft.UI.Composition.Diagnostics.CompositionDebugSettings;
+    }
+}
+
+declare namespace Microsoft.UI.Composition.Effects {
+    class SceneLightingEffect implements Microsoft.UI.Composition.Effects.ISceneLightingEffect, Microsoft.UI.Composition.Effects.ISceneLightingEffect2, Windows.Graphics.Effects.IGraphicsEffect, Windows.Graphics.Effects.IGraphicsEffectSource {
+      SpecularShine: number;
+      SpecularAmount: number;
+      NormalMapSource: Windows.Graphics.Effects.IGraphicsEffectSource;
+      DiffuseAmount: number;
+      AmbientAmount: number;
+      ReflectanceModel: number;
+      Name: string;
+      constructor();
+    }
+    class SceneLightingEffectReflectanceModel extends System.Enum {
+      value__: number;
+      static BlinnPhong: number;
+      static PhysicallyBasedBlinnPhong: number;
+    }
+}
+
+declare namespace Microsoft.UI.Composition.Interactions {
+    class CompositionConditionalValue extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.Interactions.ICompositionConditionalValue {
+      Value: Microsoft.UI.Composition.ExpressionAnimation;
+      Condition: Microsoft.UI.Composition.ExpressionAnimation;
+      static Create(result: Microsoft.UI.Composition.Compositor): Microsoft.UI.Composition.Interactions.CompositionConditionalValue;
+    }
+    class CompositionInteractionSourceCollection extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.Interactions.ICompositionInteractionSourceCollection {
+      readonly Count: number;
+      Add(value: Microsoft.UI.Composition.Interactions.ICompositionInteractionSource): void;
+      Remove(value: Microsoft.UI.Composition.Interactions.ICompositionInteractionSource): void;
+      RemoveAll(): void;
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    interface ICompositionInteractionSource {
+    }
+    interface IInteractionTrackerOwner {
+      CustomAnimationStateEntered(sender: Microsoft.UI.Composition.Interactions.InteractionTracker, args: Microsoft.UI.Composition.Interactions.InteractionTrackerCustomAnimationStateEnteredArgs): void;
+      IdleStateEntered(sender: Microsoft.UI.Composition.Interactions.InteractionTracker, args: Microsoft.UI.Composition.Interactions.InteractionTrackerIdleStateEnteredArgs): void;
+      InertiaStateEntered(sender: Microsoft.UI.Composition.Interactions.InteractionTracker, args: Microsoft.UI.Composition.Interactions.InteractionTrackerInertiaStateEnteredArgs): void;
+      InteractingStateEntered(sender: Microsoft.UI.Composition.Interactions.InteractionTracker, args: Microsoft.UI.Composition.Interactions.InteractionTrackerInteractingStateEnteredArgs): void;
+      RequestIgnored(sender: Microsoft.UI.Composition.Interactions.InteractionTracker, args: Microsoft.UI.Composition.Interactions.InteractionTrackerRequestIgnoredArgs): void;
+      ValuesChanged(sender: Microsoft.UI.Composition.Interactions.InteractionTracker, args: Microsoft.UI.Composition.Interactions.InteractionTrackerValuesChangedArgs): void;
+    }
+    class InteractionBindingAxisModes extends System.Enum {
+      value__: number;
+      static None: number;
+      static PositionX: number;
+      static PositionY: number;
+      static Scale: number;
+    }
+    class InteractionChainingMode extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Always: number;
+      static Never: number;
+    }
+    class InteractionSourceConfiguration extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.Interactions.IInteractionSourceConfiguration {
+      ScaleSourceMode: number;
+      PositionYSourceMode: number;
+      PositionXSourceMode: number;
+    }
+    class InteractionSourceMode extends System.Enum {
+      value__: number;
+      static Disabled: number;
+      static EnabledWithInertia: number;
+      static EnabledWithoutInertia: number;
+    }
+    class InteractionSourceRedirectionMode extends System.Enum {
+      value__: number;
+      static Disabled: number;
+      static Enabled: number;
+    }
+    class InteractionTracker extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.Interactions.IInteractionTracker, Microsoft.UI.Composition.Interactions.IInteractionTracker2, Microsoft.UI.Composition.Interactions.IInteractionTracker3, Microsoft.UI.Composition.Interactions.IInteractionTracker4, Microsoft.UI.Composition.Interactions.IInteractionTracker5 {
+      ScaleInertiaDecayRate: System.Nullable<number>;
+      PositionInertiaDecayRate: System.Nullable<System.Numerics.Vector3>;
+      MinScale: number;
+      MinPosition: System.Numerics.Vector3;
+      MaxScale: number;
+      MaxPosition: System.Numerics.Vector3;
+      readonly InteractionSources: Microsoft.UI.Composition.Interactions.CompositionInteractionSourceCollection;
+      readonly IsPositionRoundingSuggested: boolean;
+      readonly NaturalRestingPosition: System.Numerics.Vector3;
+      readonly NaturalRestingScale: number;
+      readonly Owner: Microsoft.UI.Composition.Interactions.IInteractionTrackerOwner;
+      readonly Position: System.Numerics.Vector3;
+      readonly PositionVelocityInPixelsPerSecond: System.Numerics.Vector3;
+      readonly Scale: number;
+      readonly ScaleVelocityInPercentPerSecond: number;
+      readonly IsInertiaFromImpulse: boolean;
+      AdjustPositionXIfGreaterThanThreshold(adjustment: number, positionThreshold: number): void;
+      AdjustPositionYIfGreaterThanThreshold(adjustment: number, positionThreshold: number): void;
+      ConfigurePositionXInertiaModifiers(modifiers: System.Collections.Generic.IEnumerable<Microsoft.UI.Composition.Interactions.InteractionTrackerInertiaModifier>): void;
+      ConfigurePositionYInertiaModifiers(modifiers: System.Collections.Generic.IEnumerable<Microsoft.UI.Composition.Interactions.InteractionTrackerInertiaModifier>): void;
+      ConfigureScaleInertiaModifiers(modifiers: System.Collections.Generic.IEnumerable<Microsoft.UI.Composition.Interactions.InteractionTrackerInertiaModifier>): void;
+      TryUpdatePosition(result: System.Numerics.Vector3): number;
+      TryUpdatePositionWithAnimation(result: Microsoft.UI.Composition.CompositionAnimation): number;
+      TryUpdatePositionWithAdditionalVelocity(result: System.Numerics.Vector3): number;
+      TryUpdateScale(result: number, value: System.Numerics.Vector3): number;
+      TryUpdateScaleWithAnimation(result: Microsoft.UI.Composition.CompositionAnimation, animation: System.Numerics.Vector3): number;
+      TryUpdateScaleWithAdditionalVelocity(result: number, velocityInPercentPerSecond: System.Numerics.Vector3): number;
+      ConfigureCenterPointXInertiaModifiers(conditionalValues: System.Collections.Generic.IEnumerable<Microsoft.UI.Composition.Interactions.CompositionConditionalValue>): void;
+      ConfigureCenterPointYInertiaModifiers(conditionalValues: System.Collections.Generic.IEnumerable<Microsoft.UI.Composition.Interactions.CompositionConditionalValue>): void;
+      ConfigureVector2PositionInertiaModifiers(modifiers: System.Collections.Generic.IEnumerable<Microsoft.UI.Composition.Interactions.InteractionTrackerVector2InertiaModifier>): void;
+      TryUpdatePosition(result: System.Numerics.Vector3, value: number): number;
+      TryUpdatePositionBy(result: System.Numerics.Vector3, amount: number): number;
+      TryUpdatePosition(result: System.Numerics.Vector3, value: number, option: number): number;
+      TryUpdatePositionBy(result: System.Numerics.Vector3): number;
+      static SetBindingMode(boundTracker1: Microsoft.UI.Composition.Interactions.InteractionTracker, boundTracker2: Microsoft.UI.Composition.Interactions.InteractionTracker, axisMode: number): void;
+      static GetBindingMode(result: Microsoft.UI.Composition.Interactions.InteractionTracker, boundTracker1: Microsoft.UI.Composition.Interactions.InteractionTracker): number;
+      static Create(result: Microsoft.UI.Composition.Compositor): Microsoft.UI.Composition.Interactions.InteractionTracker;
+      static CreateWithOwner(result: Microsoft.UI.Composition.Compositor, compositor: Microsoft.UI.Composition.Interactions.IInteractionTrackerOwner): Microsoft.UI.Composition.Interactions.InteractionTracker;
+    }
+    class InteractionTrackerClampingOption extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Disabled: number;
+    }
+    class InteractionTrackerCustomAnimationStateEnteredArgs implements Microsoft.UI.Composition.Interactions.IInteractionTrackerCustomAnimationStateEnteredArgs, Microsoft.UI.Composition.Interactions.IInteractionTrackerCustomAnimationStateEnteredArgs2 {
+      readonly RequestId: number;
+      readonly IsFromBinding: boolean;
+    }
+    class InteractionTrackerIdleStateEnteredArgs implements Microsoft.UI.Composition.Interactions.IInteractionTrackerIdleStateEnteredArgs, Microsoft.UI.Composition.Interactions.IInteractionTrackerIdleStateEnteredArgs2 {
+      readonly RequestId: number;
+      readonly IsFromBinding: boolean;
+    }
+    class InteractionTrackerInertiaModifier extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.Interactions.IInteractionTrackerInertiaModifier {
+    }
+    class InteractionTrackerInertiaMotion extends Microsoft.UI.Composition.Interactions.InteractionTrackerInertiaModifier implements Microsoft.UI.Composition.Interactions.IInteractionTrackerInertiaMotion {
+      Motion: Microsoft.UI.Composition.ExpressionAnimation;
+      Condition: Microsoft.UI.Composition.ExpressionAnimation;
+      static Create(result: Microsoft.UI.Composition.Compositor): Microsoft.UI.Composition.Interactions.InteractionTrackerInertiaMotion;
+    }
+    class InteractionTrackerInertiaNaturalMotion extends Microsoft.UI.Composition.Interactions.InteractionTrackerInertiaModifier implements Microsoft.UI.Composition.Interactions.IInteractionTrackerInertiaNaturalMotion {
+      NaturalMotion: Microsoft.UI.Composition.ScalarNaturalMotionAnimation;
+      Condition: Microsoft.UI.Composition.ExpressionAnimation;
+      static Create(result: Microsoft.UI.Composition.Compositor): Microsoft.UI.Composition.Interactions.InteractionTrackerInertiaNaturalMotion;
+    }
+    class InteractionTrackerInertiaRestingValue extends Microsoft.UI.Composition.Interactions.InteractionTrackerInertiaModifier implements Microsoft.UI.Composition.Interactions.IInteractionTrackerInertiaRestingValue {
+      RestingValue: Microsoft.UI.Composition.ExpressionAnimation;
+      Condition: Microsoft.UI.Composition.ExpressionAnimation;
+      static Create(result: Microsoft.UI.Composition.Compositor): Microsoft.UI.Composition.Interactions.InteractionTrackerInertiaRestingValue;
+    }
+    class InteractionTrackerInertiaStateEnteredArgs implements Microsoft.UI.Composition.Interactions.IInteractionTrackerInertiaStateEnteredArgs, Microsoft.UI.Composition.Interactions.IInteractionTrackerInertiaStateEnteredArgs2, Microsoft.UI.Composition.Interactions.IInteractionTrackerInertiaStateEnteredArgs3 {
+      readonly ModifiedRestingPosition: System.Nullable<System.Numerics.Vector3>;
+      readonly ModifiedRestingScale: System.Nullable<number>;
+      readonly NaturalRestingPosition: System.Numerics.Vector3;
+      readonly NaturalRestingScale: number;
+      readonly PositionVelocityInPixelsPerSecond: System.Numerics.Vector3;
+      readonly RequestId: number;
+      readonly ScaleVelocityInPercentPerSecond: number;
+      readonly IsInertiaFromImpulse: boolean;
+      readonly IsFromBinding: boolean;
+    }
+    class InteractionTrackerInteractingStateEnteredArgs implements Microsoft.UI.Composition.Interactions.IInteractionTrackerInteractingStateEnteredArgs, Microsoft.UI.Composition.Interactions.IInteractionTrackerInteractingStateEnteredArgs2 {
+      readonly RequestId: number;
+      readonly IsFromBinding: boolean;
+    }
+    class InteractionTrackerPositionUpdateOption extends System.Enum {
+      value__: number;
+      static Default: number;
+      static AllowActiveCustomScaleAnimation: number;
+    }
+    class InteractionTrackerRequestIgnoredArgs implements Microsoft.UI.Composition.Interactions.IInteractionTrackerRequestIgnoredArgs {
+      readonly RequestId: number;
+    }
+    class InteractionTrackerValuesChangedArgs implements Microsoft.UI.Composition.Interactions.IInteractionTrackerValuesChangedArgs {
+      readonly Position: System.Numerics.Vector3;
+      readonly RequestId: number;
+      readonly Scale: number;
+    }
+    class InteractionTrackerVector2InertiaModifier extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.Interactions.IInteractionTrackerVector2InertiaModifier {
+    }
+    class InteractionTrackerVector2InertiaNaturalMotion extends Microsoft.UI.Composition.Interactions.InteractionTrackerVector2InertiaModifier implements Microsoft.UI.Composition.Interactions.IInteractionTrackerVector2InertiaNaturalMotion {
+      NaturalMotion: Microsoft.UI.Composition.Vector2NaturalMotionAnimation;
+      Condition: Microsoft.UI.Composition.ExpressionAnimation;
+      static Create(result: Microsoft.UI.Composition.Compositor): Microsoft.UI.Composition.Interactions.InteractionTrackerVector2InertiaNaturalMotion;
+    }
+    class VisualInteractionSource extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.Interactions.IVisualInteractionSource, Microsoft.UI.Composition.Interactions.IVisualInteractionSource2, Microsoft.UI.Composition.Interactions.IVisualInteractionSource3, Microsoft.UI.Composition.Interactions.ICompositionInteractionSource {
+      ScaleSourceMode: number;
+      ScaleChainingMode: number;
+      PositionYSourceMode: number;
+      PositionYChainingMode: number;
+      PositionXSourceMode: number;
+      PositionXChainingMode: number;
+      ManipulationRedirectionMode: number;
+      IsPositionYRailsEnabled: boolean;
+      IsPositionXRailsEnabled: boolean;
+      readonly Source: Microsoft.UI.Composition.Visual;
+      readonly DeltaPosition: System.Numerics.Vector3;
+      readonly DeltaScale: number;
+      readonly Position: System.Numerics.Vector3;
+      readonly PositionVelocity: System.Numerics.Vector3;
+      readonly Scale: number;
+      readonly ScaleVelocity: number;
+      readonly PointerWheelConfig: Microsoft.UI.Composition.Interactions.InteractionSourceConfiguration;
+      TryRedirectForManipulation(pointerPoint: Microsoft.UI.Input.PointerPoint): void;
+      ConfigureCenterPointXModifiers(conditionalValues: System.Collections.Generic.IEnumerable<Microsoft.UI.Composition.Interactions.CompositionConditionalValue>): void;
+      ConfigureCenterPointYModifiers(conditionalValues: System.Collections.Generic.IEnumerable<Microsoft.UI.Composition.Interactions.CompositionConditionalValue>): void;
+      ConfigureDeltaPositionXModifiers(conditionalValues: System.Collections.Generic.IEnumerable<Microsoft.UI.Composition.Interactions.CompositionConditionalValue>): void;
+      ConfigureDeltaPositionYModifiers(conditionalValues: System.Collections.Generic.IEnumerable<Microsoft.UI.Composition.Interactions.CompositionConditionalValue>): void;
+      ConfigureDeltaScaleModifiers(conditionalValues: System.Collections.Generic.IEnumerable<Microsoft.UI.Composition.Interactions.CompositionConditionalValue>): void;
+      static CreateFromIVisualElement(result: Microsoft.UI.Composition.IVisualElement): Microsoft.UI.Composition.Interactions.VisualInteractionSource;
+      static Create(result: Microsoft.UI.Composition.Visual): Microsoft.UI.Composition.Interactions.VisualInteractionSource;
+    }
+    class VisualInteractionSourceRedirectionMode extends System.Enum {
+      value__: number;
+      static Off: number;
+      static CapableTouchpadOnly: number;
+      static PointerWheelOnly: number;
+      static CapableTouchpadAndPointerWheel: number;
+    }
+}
+
+declare namespace Microsoft.UI.Composition.Scenes {
+    class SceneAlphaMode extends System.Enum {
+      value__: number;
+      static Opaque: number;
+      static AlphaTest: number;
+      static Blend: number;
+    }
+    class SceneAttributeSemantic extends System.Enum {
+      value__: number;
+      static Index: number;
+      static Vertex: number;
+      static Normal: number;
+      static TexCoord0: number;
+      static TexCoord1: number;
+      static Color: number;
+      static Tangent: number;
+    }
+    class SceneObject extends Microsoft.UI.Composition.CompositionObject implements Microsoft.UI.Composition.Scenes.ISceneObject {
+    }
+    class SceneBoundingBox extends Microsoft.UI.Composition.Scenes.SceneObject implements Microsoft.UI.Composition.Scenes.ISceneBoundingBox {
+      readonly Center: System.Numerics.Vector3;
+      readonly Extents: System.Numerics.Vector3;
+      readonly Max: System.Numerics.Vector3;
+      readonly Min: System.Numerics.Vector3;
+      readonly Size: System.Numerics.Vector3;
+    }
+    class SceneComponent extends Microsoft.UI.Composition.Scenes.SceneObject implements Microsoft.UI.Composition.Scenes.ISceneComponent {
+      readonly ComponentType: number;
+    }
+    class SceneComponentCollection extends Microsoft.UI.Composition.Scenes.SceneObject implements Microsoft.UI.Composition.Scenes.ISceneComponentCollection {
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class SceneComponentType extends System.Enum {
+      value__: number;
+      static MeshRendererComponent: number;
+    }
+    class SceneMaterial extends Microsoft.UI.Composition.Scenes.SceneObject implements Microsoft.UI.Composition.Scenes.ISceneMaterial {
+    }
+    class SceneMaterialInput extends Microsoft.UI.Composition.Scenes.SceneObject implements Microsoft.UI.Composition.Scenes.ISceneMaterialInput {
+    }
+    class SceneMesh extends Microsoft.UI.Composition.Scenes.SceneObject implements Microsoft.UI.Composition.Scenes.ISceneMesh {
+      PrimitiveTopology: Microsoft.Graphics.DirectX.DirectXPrimitiveTopology;
+      readonly Bounds: Microsoft.UI.Composition.Scenes.SceneBoundingBox;
+      FillMeshAttribute(semantic: number, format: Microsoft.Graphics.DirectX.DirectXPixelFormat, memory: Windows.Foundation.MemoryBuffer): void;
+      static Create(result: Microsoft.UI.Composition.Compositor): Microsoft.UI.Composition.Scenes.SceneMesh;
+    }
+    class SceneMeshMaterialAttributeMap extends Microsoft.UI.Composition.Scenes.SceneObject implements Microsoft.UI.Composition.Scenes.ISceneMeshMaterialAttributeMap {
+    }
+    class SceneRendererComponent extends Microsoft.UI.Composition.Scenes.SceneComponent implements Microsoft.UI.Composition.Scenes.ISceneRendererComponent {
+    }
+    class SceneMeshRendererComponent extends Microsoft.UI.Composition.Scenes.SceneRendererComponent implements Microsoft.UI.Composition.Scenes.ISceneMeshRendererComponent {
+      Mesh: Microsoft.UI.Composition.Scenes.SceneMesh;
+      Material: Microsoft.UI.Composition.Scenes.SceneMaterial;
+      readonly UVMappings: Microsoft.UI.Composition.Scenes.SceneMeshMaterialAttributeMap;
+      static Create(result: Microsoft.UI.Composition.Compositor): Microsoft.UI.Composition.Scenes.SceneMeshRendererComponent;
+    }
+    class ScenePbrMaterial extends Microsoft.UI.Composition.Scenes.SceneMaterial implements Microsoft.UI.Composition.Scenes.IScenePbrMaterial {
+      OcclusionStrength: number;
+      OcclusionInput: Microsoft.UI.Composition.Scenes.SceneMaterialInput;
+      NormalScale: number;
+      NormalInput: Microsoft.UI.Composition.Scenes.SceneMaterialInput;
+      IsDoubleSided: boolean;
+      EmissiveInput: Microsoft.UI.Composition.Scenes.SceneMaterialInput;
+      EmissiveFactor: System.Numerics.Vector3;
+      AlphaMode: number;
+      AlphaCutoff: number;
+    }
+    class SceneMetallicRoughnessMaterial extends Microsoft.UI.Composition.Scenes.ScenePbrMaterial implements Microsoft.UI.Composition.Scenes.ISceneMetallicRoughnessMaterial {
+      RoughnessFactor: number;
+      MetallicRoughnessInput: Microsoft.UI.Composition.Scenes.SceneMaterialInput;
+      MetallicFactor: number;
+      BaseColorInput: Microsoft.UI.Composition.Scenes.SceneMaterialInput;
+      BaseColorFactor: System.Numerics.Vector4;
+      static Create(result: Microsoft.UI.Composition.Compositor): Microsoft.UI.Composition.Scenes.SceneMetallicRoughnessMaterial;
+    }
+    class SceneModelTransform extends Microsoft.UI.Composition.CompositionTransform implements Microsoft.UI.Composition.Scenes.ISceneModelTransform {
+      Translation: System.Numerics.Vector3;
+      Scale: System.Numerics.Vector3;
+      RotationAxis: System.Numerics.Vector3;
+      RotationAngleInDegrees: number;
+      RotationAngle: number;
+      Orientation: System.Numerics.Quaternion;
+    }
+    class SceneNode extends Microsoft.UI.Composition.Scenes.SceneObject implements Microsoft.UI.Composition.Scenes.ISceneNode {
+      readonly Children: Microsoft.UI.Composition.Scenes.SceneNodeCollection;
+      readonly Components: Microsoft.UI.Composition.Scenes.SceneComponentCollection;
+      readonly Parent: Microsoft.UI.Composition.Scenes.SceneNode;
+      readonly Transform: Microsoft.UI.Composition.Scenes.SceneModelTransform;
+      FindFirstComponentOfType(result: number): Microsoft.UI.Composition.Scenes.SceneComponent;
+      static Create(result: Microsoft.UI.Composition.Compositor): Microsoft.UI.Composition.Scenes.SceneNode;
+    }
+    class SceneNodeCollection extends Microsoft.UI.Composition.Scenes.SceneObject implements Microsoft.UI.Composition.Scenes.ISceneNodeCollection {
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class SceneSurfaceMaterialInput extends Microsoft.UI.Composition.Scenes.SceneMaterialInput implements Microsoft.UI.Composition.Scenes.ISceneSurfaceMaterialInput {
+      WrappingVMode: number;
+      WrappingUMode: number;
+      Surface: Microsoft.UI.Composition.ICompositionSurface;
+      BitmapInterpolationMode: number;
+      static Create(result: Microsoft.UI.Composition.Compositor): Microsoft.UI.Composition.Scenes.SceneSurfaceMaterialInput;
+    }
+    class SceneVisual extends Microsoft.UI.Composition.ContainerVisual implements Microsoft.UI.Composition.Scenes.ISceneVisual {
+      Root: Microsoft.UI.Composition.Scenes.SceneNode;
+      static Create(result: Microsoft.UI.Composition.Compositor): Microsoft.UI.Composition.Scenes.SceneVisual;
+    }
+    class SceneWrappingMode extends System.Enum {
+      value__: number;
+      static ClampToEdge: number;
+      static MirroredRepeat: number;
+      static Repeat: number;
+    }
+}
+
+declare namespace Microsoft.UI.Composition.SystemBackdrops {
+    class DesktopAcrylicController implements Microsoft.UI.Composition.SystemBackdrops.IDesktopAcrylicController, Microsoft.UI.Composition.SystemBackdrops.IDesktopAcrylicController2, Microsoft.UI.Composition.SystemBackdrops.IDesktopAcrylicController3, Microsoft.UI.Composition.SystemBackdrops.ISystemBackdropController, Microsoft.UI.Composition.SystemBackdrops.ISystemBackdropControllerWithTargets, Microsoft.UI.IClosableNotifier {
+      StateChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Composition.SystemBackdrops.ISystemBackdropControllerWithTargets, any> | null;
+      Closed: Microsoft.UI.ClosableNotifierHandler | null;
+      FrameworkClosed: Microsoft.UI.ClosableNotifierHandler | null;
+      TintOpacity: number;
+      TintColor: Windows.UI.Color;
+      LuminosityOpacity: number;
+      FallbackColor: Windows.UI.Color;
+      Kind: number;
+      readonly State: number;
+      readonly IsClosed: boolean;
+      ResetProperties(): void;
+      SetTarget(result: Microsoft.UI.WindowId, windowId: Windows.UI.Composition.CompositionTarget): boolean;
+      SetTarget(result: Windows.UI.Core.CoreWindow, coreWindow: Windows.UI.Composition.CompositionTarget): boolean;
+      Dispose(): void;
+      AddSystemBackdropTarget(result: Microsoft.UI.Composition.ICompositionSupportsSystemBackdrop): boolean;
+      RemoveAllSystemBackdropTargets(): void;
+      RemoveSystemBackdropTarget(result: Microsoft.UI.Composition.ICompositionSupportsSystemBackdrop): boolean;
+      SetSystemBackdropConfiguration(configuration: Microsoft.UI.Composition.SystemBackdrops.SystemBackdropConfiguration): void;
+      constructor();
+      static IsSupported(): boolean;
+    }
+    class DesktopAcrylicKind extends System.Enum {
+      value__: number;
+      static Default: number;
+      static Base: number;
+      static Thin: number;
+    }
+    interface ISystemBackdropController {
+      SetTarget(result: Microsoft.UI.WindowId, windowId: Windows.UI.Composition.CompositionTarget): boolean;
+      SetTarget(result: Windows.UI.Core.CoreWindow, coreWindow: Windows.UI.Composition.CompositionTarget): boolean;
+    }
+    interface ISystemBackdropControllerWithTargets extends Microsoft.UI.Composition.SystemBackdrops.ISystemBackdropController {
+      StateChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Composition.SystemBackdrops.ISystemBackdropControllerWithTargets, any> | null;
+      readonly State: number;
+      AddSystemBackdropTarget(result: Microsoft.UI.Composition.ICompositionSupportsSystemBackdrop): boolean;
+      RemoveAllSystemBackdropTargets(): void;
+      RemoveSystemBackdropTarget(result: Microsoft.UI.Composition.ICompositionSupportsSystemBackdrop): boolean;
+      SetSystemBackdropConfiguration(configuration: Microsoft.UI.Composition.SystemBackdrops.SystemBackdropConfiguration): void;
+    }
+    class MicaController implements Microsoft.UI.Composition.SystemBackdrops.IMicaController, Microsoft.UI.Composition.SystemBackdrops.IMicaController2, Microsoft.UI.Composition.SystemBackdrops.ISystemBackdropController, Microsoft.UI.Composition.SystemBackdrops.ISystemBackdropControllerWithTargets, Microsoft.UI.IClosableNotifier {
+      StateChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Composition.SystemBackdrops.ISystemBackdropControllerWithTargets, any> | null;
+      Closed: Microsoft.UI.ClosableNotifierHandler | null;
+      FrameworkClosed: Microsoft.UI.ClosableNotifierHandler | null;
+      TintOpacity: number;
+      TintColor: Windows.UI.Color;
+      LuminosityOpacity: number;
+      FallbackColor: Windows.UI.Color;
+      Kind: number;
+      readonly State: number;
+      readonly IsClosed: boolean;
+      SetTarget(result: Windows.UI.Core.CoreWindow, coreWindow: Windows.UI.Composition.CompositionTarget): boolean;
+      ResetProperties(): void;
+      SetTarget(result: Microsoft.UI.WindowId, windowId: Windows.UI.Composition.CompositionTarget): boolean;
+      Dispose(): void;
+      AddSystemBackdropTarget(result: Microsoft.UI.Composition.ICompositionSupportsSystemBackdrop): boolean;
+      RemoveAllSystemBackdropTargets(): void;
+      RemoveSystemBackdropTarget(result: Microsoft.UI.Composition.ICompositionSupportsSystemBackdrop): boolean;
+      SetSystemBackdropConfiguration(configuration: Microsoft.UI.Composition.SystemBackdrops.SystemBackdropConfiguration): void;
+      constructor();
+      static IsSupported(): boolean;
+    }
+    class MicaKind extends System.Enum {
+      value__: number;
+      static Base: number;
+      static BaseAlt: number;
+    }
+    class SystemBackdropConfiguration implements Microsoft.UI.Composition.SystemBackdrops.ISystemBackdropConfiguration {
+      Theme: number;
+      IsInputActive: boolean;
+      IsHighContrast: boolean;
+      HighContrastBackgroundColor: System.Nullable<Windows.UI.Color>;
+      constructor();
+    }
+    class SystemBackdropState extends System.Enum {
+      value__: number;
+      static Active: number;
+      static Fallback: number;
+      static HighContrast: number;
+    }
+    class SystemBackdropTheme extends System.Enum {
+      value__: number;
+      static Default: number;
+      static Light: number;
+      static Dark: number;
+    }
+}
+
+declare namespace Microsoft.UI.Content {
+    class ContentCoordinateConverter implements Microsoft.UI.Content.IContentCoordinateConverter {
+      ConvertLocalToScreen(result: Windows.Foundation.Rect): Windows.Graphics.RectInt32;
+      ConvertLocalToScreen(result: Windows.Foundation.Point[]): Windows.Graphics.PointInt32[];
+      ConvertLocalToScreen(result: Windows.Foundation.Point[], localPoints: number): Windows.Graphics.PointInt32[];
+      ConvertLocalToScreen(result: Windows.Foundation.Point): Windows.Graphics.PointInt32;
+      ConvertScreenToLocal(result: Windows.Graphics.PointInt32): Windows.Foundation.Point;
+      ConvertScreenToLocal(result: Windows.Graphics.PointInt32[]): Windows.Foundation.Point[];
+      ConvertScreenToLocal(result: Windows.Graphics.RectInt32): Windows.Foundation.Rect;
+      static CreateForWindowId(result: Microsoft.UI.WindowId): Microsoft.UI.Content.ContentCoordinateConverter;
+    }
+    class ContentCoordinateRoundingMode extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Floor: number;
+      static Round: number;
+      static Ceiling: number;
+    }
+    class ContentDeferral implements Microsoft.UI.Content.IContentDeferral {
+      Complete(): void;
+    }
+    class ContentEnvironmentSettingChangedEventArgs implements Microsoft.UI.Content.IContentEnvironmentSettingChangedEventArgs {
+      readonly SettingName: string;
+    }
+    class ContentEnvironmentStateChangedEventArgs implements Microsoft.UI.Content.IContentEnvironmentStateChangedEventArgs {
+      readonly DidAppWindowIdChange: boolean;
+      readonly DidDisplayIdChange: boolean;
+    }
+    class ContentIsland implements Microsoft.UI.Content.IContentIsland, Microsoft.UI.IClosableNotifier, Microsoft.UI.Composition.ICompositionSupportsSystemBackdrop {
+      AutomationProviderRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Content.ContentIsland, Microsoft.UI.Content.ContentIslandAutomationProviderRequestedEventArgs> | null;
+      StateChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Content.ContentIsland, Microsoft.UI.Content.ContentIslandStateChangedEventArgs> | null;
+      Closed: Microsoft.UI.ClosableNotifierHandler | null;
+      FrameworkClosed: Microsoft.UI.ClosableNotifierHandler | null;
+      SystemBackdrop: Windows.UI.Composition.CompositionBrush;
+      IsIslandVisible: boolean;
+      IsIslandEnabled: boolean;
+      IsHitTestVisibleWhenTransparent: boolean;
+      AppData: any;
+      readonly ActualSize: System.Numerics.Vector2;
+      readonly CoordinateConverter: Microsoft.UI.Content.ContentCoordinateConverter;
+      readonly CustomProperties: Windows.Foundation.Collections.IPropertySet;
+      readonly DispatcherQueue: Microsoft.UI.Dispatching.DispatcherQueue;
+      readonly Environment: Microsoft.UI.Content.ContentIslandEnvironment;
+      readonly Id: number;
+      readonly IsConnected: boolean;
+      readonly IsSiteEnabled: boolean;
+      readonly IsSiteVisible: boolean;
+      readonly LayoutDirection: number;
+      readonly RasterizationScale: number;
+      readonly IsClosed: boolean;
+      GetAutomationHostProvider(): any;
+      GetStateChangeDeferral(): Microsoft.UI.Content.ContentDeferral;
+      RequestSize(size: System.Numerics.Vector2): void;
+      Dispose(): void;
+      static Create(result: Microsoft.UI.Composition.Visual): Microsoft.UI.Content.ContentIsland;
+      static FindAllForCompositor(result: Microsoft.UI.Composition.Compositor): Microsoft.UI.Content.ContentIsland[];
+      static FindAllForCurrentThread(): Microsoft.UI.Content.ContentIsland[];
+      static GetByVisual(result: Microsoft.UI.Composition.Visual): Microsoft.UI.Content.ContentIsland;
+      static GetFromId(result: number): Microsoft.UI.Content.ContentIsland;
+    }
+    class ContentIslandAutomationProviderRequestedEventArgs implements Microsoft.UI.Content.IContentIslandAutomationProviderRequestedEventArgs {
+      Handled: boolean;
+      AutomationProvider: any;
+    }
+    class ContentIslandEnvironment implements Microsoft.UI.Content.IContentIslandEnvironment {
+      SettingChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Content.ContentIslandEnvironment, Microsoft.UI.Content.ContentEnvironmentSettingChangedEventArgs> | null;
+      StateChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Content.ContentIslandEnvironment, Microsoft.UI.Content.ContentEnvironmentStateChangedEventArgs> | null;
+      readonly AppWindowId: Microsoft.UI.WindowId;
+      readonly DisplayId: Microsoft.UI.DisplayId;
+    }
+    class ContentIslandStateChangedEventArgs implements Microsoft.UI.Content.IContentIslandStateChangedEventArgs {
+      readonly DidActualSizeChange: boolean;
+      readonly DidLayoutDirectionChange: boolean;
+      readonly DidRasterizationScaleChange: boolean;
+      readonly DidSiteEnabledChange: boolean;
+      readonly DidSiteVisibleChange: boolean;
+    }
+    class ContentLayoutDirection extends System.Enum {
+      value__: number;
+      static LeftToRight: number;
+      static RightToLeft: number;
+    }
+    class ContentSite implements Microsoft.UI.Content.IContentSite, Microsoft.UI.IClosableNotifier {
+      RequestedStateChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Content.ContentSite, Microsoft.UI.Content.ContentSiteRequestedStateChangedEventArgs> | null;
+      Closed: Microsoft.UI.ClosableNotifierHandler | null;
+      FrameworkClosed: Microsoft.UI.ClosableNotifierHandler | null;
+      ShouldApplyRasterizationScale: boolean;
+      ParentScale: number;
+      OverrideScale: number;
+      LayoutDirection: number;
+      IsSiteVisible: boolean;
+      IsSiteEnabled: boolean;
+      ClientSize: Windows.Graphics.SizeInt32;
+      ActualSize: System.Numerics.Vector2;
+      readonly CoordinateConverter: Microsoft.UI.Content.ContentCoordinateConverter;
+      readonly DispatcherQueue: Microsoft.UI.Dispatching.DispatcherQueue;
+      readonly Environment: Microsoft.UI.Content.ContentSiteEnvironment;
+      readonly IsConnected: boolean;
+      readonly RasterizationScale: number;
+      readonly RequestedSize: System.Numerics.Vector2;
+      readonly View: Microsoft.UI.Content.ContentSiteView;
+      readonly IsClosed: boolean;
+      GetIslandStateChangeDeferral(): Microsoft.UI.Content.ContentDeferral;
+      Dispose(): void;
+    }
+    class ContentSiteEnvironment implements Microsoft.UI.Content.IContentSiteEnvironment {
+      DisplayId: Microsoft.UI.DisplayId;
+      AppWindowId: Microsoft.UI.WindowId;
+      readonly View: Microsoft.UI.Content.ContentSiteEnvironmentView;
+      NotifySettingChanged(setting: string): void;
+    }
+    class ContentSiteEnvironmentView implements Microsoft.UI.Content.IContentSiteEnvironmentView {
+      readonly AppWindowId: Microsoft.UI.WindowId;
+      readonly DisplayId: Microsoft.UI.DisplayId;
+    }
+    class ContentSiteRequestedStateChangedEventArgs implements Microsoft.UI.Content.IContentSiteRequestedStateChangedEventArgs {
+      readonly DidRequestedSizeChange: boolean;
+    }
+    class ContentSiteView implements Microsoft.UI.Content.IContentSiteView {
+      readonly ActualSize: System.Numerics.Vector2;
+      readonly ClientSize: Windows.Graphics.SizeInt32;
+      readonly CoordinateConverter: Microsoft.UI.Content.ContentCoordinateConverter;
+      readonly DispatcherQueue: Microsoft.UI.Dispatching.DispatcherQueue;
+      readonly EnvironmentView: Microsoft.UI.Content.ContentSiteEnvironmentView;
+      readonly IsConnected: boolean;
+      readonly IsSiteEnabled: boolean;
+      readonly IsSiteVisible: boolean;
+      readonly LayoutDirection: number;
+      readonly OverrideScale: number;
+      readonly ParentScale: number;
+      readonly RasterizationScale: number;
+      readonly RequestedSize: System.Numerics.Vector2;
+      readonly ShouldApplyRasterizationScale: boolean;
+    }
+    class ContentSizePolicy extends System.Enum {
+      value__: number;
+      static None: number;
+      static ResizeContentToParentWindow: number;
+      static ResizeParentWindowToContent: number;
+    }
+    class DesktopSiteBridge implements Microsoft.UI.Content.IDesktopSiteBridge, Microsoft.UI.IClosableNotifier, Microsoft.UI.Content.IContentSiteBridge {
+      Closed: Microsoft.UI.ClosableNotifierHandler | null;
+      FrameworkClosed: Microsoft.UI.ClosableNotifierHandler | null;
+      OverrideScale: number;
+      LayoutDirectionOverride: System.Nullable<number>;
+      readonly DispatcherQueue: Microsoft.UI.Dispatching.DispatcherQueue;
+      readonly IsEnabled: boolean;
+      readonly IsVisible: boolean;
+      readonly WindowId: Microsoft.UI.WindowId;
+      readonly IsClosed: boolean;
+      Show(): void;
+      Dispose(): void;
+      Connect(content: Microsoft.UI.Content.ContentIsland): void;
+      Disable(): void;
+      Enable(): void;
+      Hide(): void;
+      MoveAndResize(rect: Windows.Graphics.RectInt32): void;
+      MoveInZOrderAtBottom(): void;
+      MoveInZOrderAtTop(): void;
+      MoveInZOrderBelow(windowId: Microsoft.UI.WindowId): void;
+      static IsSupported(): boolean;
+    }
+    class DesktopChildSiteBridge extends Microsoft.UI.Content.DesktopSiteBridge implements Microsoft.UI.Content.IDesktopChildSiteBridge {
+      ResizePolicy: number;
+      readonly SiteView: Microsoft.UI.Content.ContentSiteView;
+      static Create(result: Microsoft.UI.Composition.Compositor, compositor: Microsoft.UI.WindowId): Microsoft.UI.Content.DesktopChildSiteBridge;
+    }
+    interface IContentSiteBridge {
+      readonly DispatcherQueue: Microsoft.UI.Dispatching.DispatcherQueue;
+      LayoutDirectionOverride: System.Nullable<number>;
+      OverrideScale: number;
+    }
+}
+
+declare namespace Microsoft.UI.Dispatching {
+    class DispatcherExitDeferral implements Microsoft.UI.Dispatching.IDispatcherExitDeferral {
+      Complete(): void;
+      constructor();
+    }
+    class DispatcherQueue implements Microsoft.UI.Dispatching.IDispatcherQueue, Microsoft.UI.Dispatching.IDispatcherQueue2, Microsoft.UI.Dispatching.IDispatcherQueue3 {
+      ShutdownCompleted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Dispatching.DispatcherQueue, any> | null;
+      ShutdownStarting: Windows.Foundation.TypedEventHandler<Microsoft.UI.Dispatching.DispatcherQueue, Microsoft.UI.Dispatching.DispatcherQueueShutdownStartingEventArgs> | null;
+      FrameworkShutdownCompleted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Dispatching.DispatcherQueue, any> | null;
+      FrameworkShutdownStarting: Windows.Foundation.TypedEventHandler<Microsoft.UI.Dispatching.DispatcherQueue, Microsoft.UI.Dispatching.DispatcherQueueShutdownStartingEventArgs> | null;
+      readonly HasThreadAccess: boolean;
+      TryEnqueue(result: Microsoft.UI.Dispatching.DispatcherQueueHandler): boolean;
+      TryEnqueue(result: number, priority: Microsoft.UI.Dispatching.DispatcherQueueHandler): boolean;
+      CreateTimer(): Microsoft.UI.Dispatching.DispatcherQueueTimer;
+      EnqueueEventLoopExit(): void;
+      EnsureSystemDispatcherQueue(): void;
+      RunEventLoop(): void;
+      RunEventLoop(options: number, deferral: Microsoft.UI.Dispatching.DispatcherExitDeferral): void;
+      static GetForCurrentThread(): Microsoft.UI.Dispatching.DispatcherQueue;
+    }
+    class DispatcherQueueController implements Microsoft.UI.Dispatching.IDispatcherQueueController, Microsoft.UI.Dispatching.IDispatcherQueueController2 {
+      readonly DispatcherQueue: Microsoft.UI.Dispatching.DispatcherQueue;
+      ShutdownQueueAsync(): Windows.Foundation.IAsyncAction;
+      ShutdownQueue(): void;
+      static CreateOnDedicatedThread(): Microsoft.UI.Dispatching.DispatcherQueueController;
+      static CreateOnCurrentThread(): Microsoft.UI.Dispatching.DispatcherQueueController;
+    }
+    class DispatcherQueueHandler {
+      constructor(handler: () => void);
+      Invoke(): void;
+    }
+    class DispatcherQueuePriority extends System.Enum {
+      value__: number;
+      static Low: number;
+      static Normal: number;
+      static High: number;
+    }
+    class DispatcherQueueShutdownStartingEventArgs implements Microsoft.UI.Dispatching.IDispatcherQueueShutdownStartingEventArgs {
+      GetDeferral(): Windows.Foundation.Deferral;
+    }
+    class DispatcherQueueTimer implements Microsoft.UI.Dispatching.IDispatcherQueueTimer {
+      Tick: Windows.Foundation.TypedEventHandler<Microsoft.UI.Dispatching.DispatcherQueueTimer, any> | null;
+      IsRepeating: boolean;
+      Interval: System.TimeSpan;
+      readonly IsRunning: boolean;
+      Start(): void;
+      Stop(): void;
+    }
+    class DispatcherRunOptions extends System.Enum {
+      value__: number;
+      static None: number;
+      static ContinueOnQuit: number;
+      static QuitOnlyLocalLoop: number;
+    }
+}
+
+declare namespace Microsoft.UI.Input {
+    class CharacterReceivedEventArgs implements Microsoft.UI.Input.ICharacterReceivedEventArgs {
+      Handled: boolean;
+      readonly KeyCode: number;
+      readonly KeyStatus: Microsoft.UI.Input.PhysicalKeyStatus;
+    }
+    class ContextMenuKeyEventArgs implements Microsoft.UI.Input.IContextMenuKeyEventArgs {
+      Handled: boolean;
+    }
+    class CrossSlideThresholds extends System.ValueType {
+      SelectionStart: number;
+      SpeedBumpStart: number;
+      SpeedBumpEnd: number;
+      RearrangeStart: number;
+    }
+    class CrossSlidingEventArgs implements Microsoft.UI.Input.ICrossSlidingEventArgs {
+      readonly CrossSlidingState: number;
+      readonly PointerDeviceType: number;
+      readonly Position: Windows.Foundation.Point;
+    }
+    class CrossSlidingState extends System.Enum {
+      value__: number;
+      static Started: number;
+      static Dragging: number;
+      static Selecting: number;
+      static SelectSpeedBumping: number;
+      static SpeedBumping: number;
+      static Rearranging: number;
+      static Completed: number;
+    }
+    class DraggingEventArgs implements Microsoft.UI.Input.IDraggingEventArgs {
+      readonly DraggingState: number;
+      readonly PointerDeviceType: number;
+      readonly Position: Windows.Foundation.Point;
+    }
+    class DraggingState extends System.Enum {
+      value__: number;
+      static Started: number;
+      static Continuing: number;
+      static Completed: number;
+    }
+    class EnteredMoveSizeEventArgs implements Microsoft.UI.Input.IEnteredMoveSizeEventArgs {
+      readonly MoveSizeOperation: number;
+      readonly PointerScreenPoint: Windows.Graphics.PointInt32;
+    }
+    class EnteringMoveSizeEventArgs implements Microsoft.UI.Input.IEnteringMoveSizeEventArgs {
+      MoveSizeWindowId: Microsoft.UI.WindowId;
+      readonly MoveSizeOperation: number;
+      readonly PointerScreenPoint: Windows.Graphics.PointInt32;
+    }
+    class ExitedMoveSizeEventArgs implements Microsoft.UI.Input.IExitedMoveSizeEventArgs {
+      readonly MoveSizeOperation: number;
+      readonly PointerScreenPoint: Windows.Graphics.PointInt32;
+    }
+    class FocusChangedEventArgs implements Microsoft.UI.Input.IFocusChangedEventArgs {
+      Handled: boolean;
+    }
+    class FocusNavigationReason extends System.Enum {
+      value__: number;
+      static Programmatic: number;
+      static Restore: number;
+      static First: number;
+      static Last: number;
+      static Left: number;
+      static Up: number;
+      static Right: number;
+      static Down: number;
+    }
+    class FocusNavigationRequest implements Microsoft.UI.Input.IFocusNavigationRequest {
+      readonly CorrelationId: System.Guid;
+      readonly HintRect: System.Nullable<Windows.Foundation.Rect>;
+      readonly Reason: number;
+      static Create(result: number): Microsoft.UI.Input.FocusNavigationRequest;
+      static Create(result: number, reason: Windows.Foundation.Rect): Microsoft.UI.Input.FocusNavigationRequest;
+      static Create(result: number, reason: Windows.Foundation.Rect, hintRect: System.Guid): Microsoft.UI.Input.FocusNavigationRequest;
+    }
+    class FocusNavigationRequestEventArgs implements Microsoft.UI.Input.IFocusNavigationRequestEventArgs {
+      Result: number;
+      readonly Request: Microsoft.UI.Input.FocusNavigationRequest;
+    }
+    class FocusNavigationResult extends System.Enum {
+      value__: number;
+      static NotMoved: number;
+      static Moved: number;
+      static NoFocusableElements: number;
+    }
+    class GestureRecognizer implements Microsoft.UI.Input.IGestureRecognizer {
+      CrossSliding: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.GestureRecognizer, Microsoft.UI.Input.CrossSlidingEventArgs> | null;
+      Dragging: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.GestureRecognizer, Microsoft.UI.Input.DraggingEventArgs> | null;
+      Holding: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.GestureRecognizer, Microsoft.UI.Input.HoldingEventArgs> | null;
+      ManipulationCompleted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.GestureRecognizer, Microsoft.UI.Input.ManipulationCompletedEventArgs> | null;
+      ManipulationInertiaStarting: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.GestureRecognizer, Microsoft.UI.Input.ManipulationInertiaStartingEventArgs> | null;
+      ManipulationStarted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.GestureRecognizer, Microsoft.UI.Input.ManipulationStartedEventArgs> | null;
+      ManipulationUpdated: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.GestureRecognizer, Microsoft.UI.Input.ManipulationUpdatedEventArgs> | null;
+      RightTapped: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.GestureRecognizer, Microsoft.UI.Input.RightTappedEventArgs> | null;
+      Tapped: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.GestureRecognizer, Microsoft.UI.Input.TappedEventArgs> | null;
+      ShowGestureFeedback: boolean;
+      PivotRadius: number;
+      PivotCenter: Windows.Foundation.Point;
+      ManipulationExact: boolean;
+      InertiaTranslationDisplacement: number;
+      InertiaTranslationDeceleration: number;
+      InertiaRotationDeceleration: number;
+      InertiaRotationAngle: number;
+      InertiaExpansionDeceleration: number;
+      InertiaExpansion: number;
+      GestureSettings: number;
+      CrossSlideThresholds: Microsoft.UI.Input.CrossSlideThresholds;
+      CrossSlideHorizontally: boolean;
+      CrossSlideExact: boolean;
+      AutoProcessInertia: boolean;
+      readonly IsActive: boolean;
+      readonly IsInertial: boolean;
+      readonly MouseWheelParameters: Microsoft.UI.Input.MouseWheelParameters;
+      CompleteGesture(): void;
+      ProcessDownEvent(value: Microsoft.UI.Input.PointerPoint): void;
+      ProcessMoveEvents(value: System.Collections.Generic.IList<Microsoft.UI.Input.PointerPoint>): void;
+      ProcessMouseWheelEvent(value: Microsoft.UI.Input.PointerPoint, isShiftKeyDown: boolean, isControlKeyDown: boolean): void;
+      ProcessInertia(): void;
+      ProcessUpEvent(value: Microsoft.UI.Input.PointerPoint): void;
+      CanBeDoubleTap(result: Microsoft.UI.Input.PointerPoint): boolean;
+      constructor();
+    }
+    class GestureSettings extends System.Enum {
+      value__: number;
+      static None: number;
+      static Tap: number;
+      static DoubleTap: number;
+      static Hold: number;
+      static HoldWithMouse: number;
+      static RightTap: number;
+      static Drag: number;
+      static ManipulationTranslateX: number;
+      static ManipulationTranslateY: number;
+      static ManipulationTranslateRailsX: number;
+      static ManipulationTranslateRailsY: number;
+      static ManipulationRotate: number;
+      static ManipulationScale: number;
+      static ManipulationTranslateInertia: number;
+      static ManipulationRotateInertia: number;
+      static ManipulationScaleInertia: number;
+      static CrossSlide: number;
+      static ManipulationMultipleFingerPanning: number;
+    }
+    class HoldingEventArgs implements Microsoft.UI.Input.IHoldingEventArgs {
+      readonly HoldingState: number;
+      readonly PointerDeviceType: number;
+      readonly Position: Windows.Foundation.Point;
+    }
+    class HoldingState extends System.Enum {
+      value__: number;
+      static Started: number;
+      static Completed: number;
+      static Canceled: number;
+    }
+    interface IPointerPointTransform {
+      readonly Inverse: Microsoft.UI.Input.IPointerPointTransform;
+      TryTransform(result: Windows.Foundation.Point, inPoint: Windows.Foundation.Point): boolean;
+      TryTransformBounds(result: Windows.Foundation.Rect, inRect: Windows.Foundation.Rect): boolean;
+    }
+    class InputObject implements Microsoft.UI.Input.IInputObject {
+      readonly DispatcherQueue: Microsoft.UI.Dispatching.DispatcherQueue;
+    }
+    class InputActivationListener extends Microsoft.UI.Input.InputObject implements Microsoft.UI.Input.IInputActivationListener {
+      InputActivationChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputActivationListener, Microsoft.UI.Input.InputActivationListenerActivationChangedEventArgs> | null;
+      readonly State: number;
+      static GetForIsland(result: Microsoft.UI.Content.ContentIsland): Microsoft.UI.Input.InputActivationListener;
+      static GetForWindowId(result: Microsoft.UI.WindowId): Microsoft.UI.Input.InputActivationListener;
+    }
+    class InputActivationListenerActivationChangedEventArgs implements Microsoft.UI.Input.IInputActivationListenerActivationChangedEventArgs {
+    }
+    class InputActivationState extends System.Enum {
+      value__: number;
+      static None: number;
+      static Deactivated: number;
+      static Activated: number;
+    }
+    class InputCursor implements Microsoft.UI.Input.IInputCursor {
+      Dispose(): void;
+      static CreateFromCoreCursor(result: Windows.UI.Core.CoreCursor): Microsoft.UI.Input.InputCursor;
+    }
+    class InputCustomCursor extends Microsoft.UI.Input.InputCursor implements Microsoft.UI.Input.IInputCustomCursor {
+    }
+    class InputDesktopNamedResourceCursor extends Microsoft.UI.Input.InputCursor implements Microsoft.UI.Input.IInputDesktopNamedResourceCursor {
+      readonly ModuleName: string;
+      readonly ResourceName: string;
+      static Create(result: string): Microsoft.UI.Input.InputDesktopNamedResourceCursor;
+      static CreateFromModule(result: string, moduleName: string): Microsoft.UI.Input.InputDesktopNamedResourceCursor;
+    }
+    class InputDesktopResourceCursor extends Microsoft.UI.Input.InputCursor implements Microsoft.UI.Input.IInputDesktopResourceCursor {
+      readonly ModuleName: string;
+      readonly ResourceId: number;
+      static Create(result: number): Microsoft.UI.Input.InputDesktopResourceCursor;
+      static CreateFromModule(result: string, moduleName: number): Microsoft.UI.Input.InputDesktopResourceCursor;
+    }
+    class InputFocusController extends Microsoft.UI.Input.InputObject implements Microsoft.UI.Input.IInputFocusController, Microsoft.UI.Input.IInputFocusController2 {
+      GotFocus: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputFocusController, Microsoft.UI.Input.FocusChangedEventArgs> | null;
+      LostFocus: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputFocusController, Microsoft.UI.Input.FocusChangedEventArgs> | null;
+      NavigateFocusRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputFocusController, Microsoft.UI.Input.FocusNavigationRequestEventArgs> | null;
+      readonly HasFocus: boolean;
+      DepartFocus(result: Microsoft.UI.Input.FocusNavigationRequest): number;
+      TrySetFocus(): boolean;
+      static GetForIsland(result: Microsoft.UI.Content.ContentIsland): Microsoft.UI.Input.InputFocusController;
+    }
+    class InputFocusNavigationHost extends Microsoft.UI.Input.InputObject implements Microsoft.UI.Input.IInputFocusNavigationHost {
+      DepartFocusRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputFocusNavigationHost, Microsoft.UI.Input.FocusNavigationRequestEventArgs> | null;
+      readonly ContainsFocus: boolean;
+      NavigateFocus(result: Microsoft.UI.Input.FocusNavigationRequest): number;
+      static GetForSiteBridge(result: Microsoft.UI.Content.IContentSiteBridge): Microsoft.UI.Input.InputFocusNavigationHost;
+    }
+    class InputKeyboardSource extends Microsoft.UI.Input.InputObject implements Microsoft.UI.Input.IInputKeyboardSource, Microsoft.UI.Input.IInputKeyboardSource2 {
+      CharacterReceived: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputKeyboardSource, Microsoft.UI.Input.CharacterReceivedEventArgs> | null;
+      ContextMenuKey: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputKeyboardSource, Microsoft.UI.Input.ContextMenuKeyEventArgs> | null;
+      KeyDown: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputKeyboardSource, Microsoft.UI.Input.KeyEventArgs> | null;
+      KeyUp: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputKeyboardSource, Microsoft.UI.Input.KeyEventArgs> | null;
+      SystemKeyDown: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputKeyboardSource, Microsoft.UI.Input.KeyEventArgs> | null;
+      SystemKeyUp: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputKeyboardSource, Microsoft.UI.Input.KeyEventArgs> | null;
+      GetCurrentKeyState(result: Windows.System.VirtualKey): number;
+      GetKeyState(result: Windows.System.VirtualKey): number;
+      static GetForIsland(result: Microsoft.UI.Content.ContentIsland): Microsoft.UI.Input.InputKeyboardSource;
+      static GetKeyStateForCurrentThread(result: Windows.System.VirtualKey): Windows.UI.Core.CoreVirtualKeyStates;
+    }
+    class InputLightDismissAction extends Microsoft.UI.Input.InputObject implements Microsoft.UI.Input.IInputLightDismissAction {
+      Dismissed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputLightDismissAction, Microsoft.UI.Input.InputLightDismissEventArgs> | null;
+      static GetForWindowId(result: Microsoft.UI.WindowId): Microsoft.UI.Input.InputLightDismissAction;
+    }
+    class InputLightDismissEventArgs implements Microsoft.UI.Input.IInputLightDismissEventArgs {
+    }
+    class InputNonClientPointerSource implements Microsoft.UI.Input.IInputNonClientPointerSource, Microsoft.UI.Input.IInputNonClientPointerSource2 {
+      CaptionTapped: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputNonClientPointerSource, Microsoft.UI.Input.NonClientCaptionTappedEventArgs> | null;
+      PointerEntered: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputNonClientPointerSource, Microsoft.UI.Input.NonClientPointerEventArgs> | null;
+      PointerExited: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputNonClientPointerSource, Microsoft.UI.Input.NonClientPointerEventArgs> | null;
+      PointerMoved: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputNonClientPointerSource, Microsoft.UI.Input.NonClientPointerEventArgs> | null;
+      PointerPressed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputNonClientPointerSource, Microsoft.UI.Input.NonClientPointerEventArgs> | null;
+      PointerReleased: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputNonClientPointerSource, Microsoft.UI.Input.NonClientPointerEventArgs> | null;
+      RegionsChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputNonClientPointerSource, Microsoft.UI.Input.NonClientRegionsChangedEventArgs> | null;
+      EnteredMoveSize: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputNonClientPointerSource, Microsoft.UI.Input.EnteredMoveSizeEventArgs> | null;
+      EnteringMoveSize: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputNonClientPointerSource, Microsoft.UI.Input.EnteringMoveSizeEventArgs> | null;
+      ExitedMoveSize: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputNonClientPointerSource, Microsoft.UI.Input.ExitedMoveSizeEventArgs> | null;
+      WindowRectChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputNonClientPointerSource, Microsoft.UI.Input.WindowRectChangedEventArgs> | null;
+      WindowRectChanging: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputNonClientPointerSource, Microsoft.UI.Input.WindowRectChangingEventArgs> | null;
+      readonly DispatcherQueue: Microsoft.UI.Dispatching.DispatcherQueue;
+      ClearRegionRects(region: number): void;
+      GetRegionRects(result: number): Windows.Graphics.RectInt32[];
+      SetRegionRects(region: number, rects: Windows.Graphics.RectInt32[]): void;
+      ClearAllRegionRects(): void;
+      static GetForWindowId(result: Microsoft.UI.WindowId): Microsoft.UI.Input.InputNonClientPointerSource;
+    }
+    class InputPointerSource extends Microsoft.UI.Input.InputObject implements Microsoft.UI.Input.IInputPointerSource {
+      PointerCaptureLost: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputPointerSource, Microsoft.UI.Input.PointerEventArgs> | null;
+      PointerEntered: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputPointerSource, Microsoft.UI.Input.PointerEventArgs> | null;
+      PointerExited: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputPointerSource, Microsoft.UI.Input.PointerEventArgs> | null;
+      PointerMoved: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputPointerSource, Microsoft.UI.Input.PointerEventArgs> | null;
+      PointerPressed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputPointerSource, Microsoft.UI.Input.PointerEventArgs> | null;
+      PointerReleased: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputPointerSource, Microsoft.UI.Input.PointerEventArgs> | null;
+      PointerRoutedAway: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputPointerSource, Microsoft.UI.Input.PointerEventArgs> | null;
+      PointerRoutedReleased: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputPointerSource, Microsoft.UI.Input.PointerEventArgs> | null;
+      PointerRoutedTo: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputPointerSource, Microsoft.UI.Input.PointerEventArgs> | null;
+      PointerWheelChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.InputPointerSource, Microsoft.UI.Input.PointerEventArgs> | null;
+      Cursor: Microsoft.UI.Input.InputCursor;
+      readonly DeviceKinds: number;
+      static GetForIsland(result: Microsoft.UI.Content.ContentIsland): Microsoft.UI.Input.InputPointerSource;
+    }
+    class InputPointerSourceDeviceKinds extends System.Enum {
+      value__: number;
+      static None: number;
+      static Touch: number;
+      static Pen: number;
+      static Mouse: number;
+    }
+    class InputPreTranslateKeyboardSource extends Microsoft.UI.Input.InputObject implements Microsoft.UI.Input.IInputPreTranslateKeyboardSource {
+      static GetForIsland(result: Microsoft.UI.Content.ContentIsland): Microsoft.UI.Input.InputPreTranslateKeyboardSource;
+    }
+    class InputSystemCursor extends Microsoft.UI.Input.InputCursor implements Microsoft.UI.Input.IInputSystemCursor {
+      readonly CursorShape: number;
+      static Create(result: number): Microsoft.UI.Input.InputSystemCursor;
+    }
+    class InputSystemCursorShape extends System.Enum {
+      value__: number;
+      static Arrow: number;
+      static Cross: number;
+      static Hand: number;
+      static Help: number;
+      static IBeam: number;
+      static SizeAll: number;
+      static SizeNortheastSouthwest: number;
+      static SizeNorthSouth: number;
+      static SizeNorthwestSoutheast: number;
+      static SizeWestEast: number;
+      static UniversalNo: number;
+      static UpArrow: number;
+      static Wait: number;
+      static Pin: number;
+      static Person: number;
+      static AppStarting: number;
+    }
+    class KeyEventArgs implements Microsoft.UI.Input.IKeyEventArgs {
+      Handled: boolean;
+      readonly KeyStatus: Microsoft.UI.Input.PhysicalKeyStatus;
+      readonly Timestamp: number;
+      readonly VirtualKey: Windows.System.VirtualKey;
+    }
+    class ManipulationCompletedEventArgs implements Microsoft.UI.Input.IManipulationCompletedEventArgs {
+      readonly Cumulative: Microsoft.UI.Input.ManipulationDelta;
+      readonly PointerDeviceType: number;
+      readonly Position: Windows.Foundation.Point;
+      readonly Velocities: Microsoft.UI.Input.ManipulationVelocities;
+    }
+    class ManipulationDelta extends System.ValueType {
+      Translation: Windows.Foundation.Point;
+      Scale: number;
+      Rotation: number;
+      Expansion: number;
+    }
+    class ManipulationInertiaStartingEventArgs implements Microsoft.UI.Input.IManipulationInertiaStartingEventArgs {
+      readonly Cumulative: Microsoft.UI.Input.ManipulationDelta;
+      readonly Delta: Microsoft.UI.Input.ManipulationDelta;
+      readonly PointerDeviceType: number;
+      readonly Position: Windows.Foundation.Point;
+      readonly Velocities: Microsoft.UI.Input.ManipulationVelocities;
+    }
+    class ManipulationStartedEventArgs implements Microsoft.UI.Input.IManipulationStartedEventArgs {
+      readonly Cumulative: Microsoft.UI.Input.ManipulationDelta;
+      readonly PointerDeviceType: number;
+      readonly Position: Windows.Foundation.Point;
+    }
+    class ManipulationUpdatedEventArgs implements Microsoft.UI.Input.IManipulationUpdatedEventArgs {
+      readonly Cumulative: Microsoft.UI.Input.ManipulationDelta;
+      readonly Delta: Microsoft.UI.Input.ManipulationDelta;
+      readonly PointerDeviceType: number;
+      readonly Position: Windows.Foundation.Point;
+      readonly Velocities: Microsoft.UI.Input.ManipulationVelocities;
+    }
+    class ManipulationVelocities extends System.ValueType {
+      Linear: Windows.Foundation.Point;
+      Angular: number;
+      Expansion: number;
+    }
+    class MouseWheelParameters implements Microsoft.UI.Input.IMouseWheelParameters {
+      PageTranslation: Windows.Foundation.Point;
+      DeltaScale: number;
+      DeltaRotationAngle: number;
+      CharTranslation: Windows.Foundation.Point;
+    }
+    class MoveSizeOperation extends System.Enum {
+      value__: number;
+      static Move: number;
+      static SizeBottom: number;
+      static SizeBottomLeft: number;
+      static SizeBottomRight: number;
+      static SizeLeft: number;
+      static SizeRight: number;
+      static SizeTop: number;
+      static SizeTopLeft: number;
+      static SizeTopRight: number;
+    }
+    class NonClientCaptionTappedEventArgs implements Microsoft.UI.Input.INonClientCaptionTappedEventArgs {
+      readonly Point: Windows.Foundation.Point;
+      readonly PointerDeviceType: number;
+    }
+    class NonClientPointerEventArgs implements Microsoft.UI.Input.INonClientPointerEventArgs {
+      readonly IsPointInRegion: boolean;
+      readonly Point: Windows.Foundation.Point;
+      readonly PointerDeviceType: number;
+      readonly RegionKind: number;
+    }
+    class NonClientRegionKind extends System.Enum {
+      value__: number;
+      static Close: number;
+      static Maximize: number;
+      static Minimize: number;
+      static Icon: number;
+      static Caption: number;
+      static TopBorder: number;
+      static LeftBorder: number;
+      static BottomBorder: number;
+      static RightBorder: number;
+      static Passthrough: number;
+    }
+    class NonClientRegionsChangedEventArgs implements Microsoft.UI.Input.INonClientRegionsChangedEventArgs {
+      readonly ChangedRegions: number[];
+    }
+    class PhysicalKeyStatus extends System.ValueType {
+      RepeatCount: number;
+      ScanCode: number;
+      IsExtendedKey: boolean;
+      IsMenuKeyDown: boolean;
+      WasKeyDown: boolean;
+      IsKeyReleased: boolean;
+    }
+    class PointerDeviceType extends System.Enum {
+      value__: number;
+      static Touch: number;
+      static Pen: number;
+      static Mouse: number;
+      static Touchpad: number;
+    }
+    class PointerEventArgs implements Microsoft.UI.Input.IPointerEventArgs {
+      Handled: boolean;
+      readonly CurrentPoint: Microsoft.UI.Input.PointerPoint;
+      readonly KeyModifiers: Windows.System.VirtualKeyModifiers;
+      GetIntermediateTransformedPoints(result: Microsoft.UI.Input.IPointerPointTransform): System.Collections.Generic.IList<Microsoft.UI.Input.PointerPoint>;
+      GetIntermediatePoints(): System.Collections.Generic.IList<Microsoft.UI.Input.PointerPoint>;
+    }
+    class PointerPoint implements Microsoft.UI.Input.IPointerPoint {
+      readonly FrameId: number;
+      readonly IsInContact: boolean;
+      readonly PointerDeviceType: number;
+      readonly PointerId: number;
+      readonly Position: Windows.Foundation.Point;
+      readonly Properties: Microsoft.UI.Input.PointerPointProperties;
+      readonly Timestamp: number;
+      GetTransformedPoint(result: Microsoft.UI.Input.IPointerPointTransform): Microsoft.UI.Input.PointerPoint;
+    }
+    class PointerPointProperties implements Microsoft.UI.Input.IPointerPointProperties {
+      readonly ContactRect: Windows.Foundation.Rect;
+      readonly IsBarrelButtonPressed: boolean;
+      readonly IsCanceled: boolean;
+      readonly IsEraser: boolean;
+      readonly IsHorizontalMouseWheel: boolean;
+      readonly IsInRange: boolean;
+      readonly IsInverted: boolean;
+      readonly IsLeftButtonPressed: boolean;
+      readonly IsMiddleButtonPressed: boolean;
+      readonly IsPrimary: boolean;
+      readonly IsRightButtonPressed: boolean;
+      readonly IsXButton1Pressed: boolean;
+      readonly IsXButton2Pressed: boolean;
+      readonly MouseWheelDelta: number;
+      readonly Orientation: number;
+      readonly PointerUpdateKind: number;
+      readonly Pressure: number;
+      readonly TouchConfidence: boolean;
+      readonly Twist: number;
+      readonly XTilt: number;
+      readonly YTilt: number;
+    }
+    class PointerPredictor implements Microsoft.UI.Input.IPointerPredictor {
+      PredictionTime: System.TimeSpan;
+      GetPredictedPoints(result: Microsoft.UI.Input.PointerPoint): Microsoft.UI.Input.PointerPoint[];
+      Dispose(): void;
+      static CreateForInputPointerSource(result: Microsoft.UI.Input.InputPointerSource): Microsoft.UI.Input.PointerPredictor;
+    }
+    class PointerUpdateKind extends System.Enum {
+      value__: number;
+      static Other: number;
+      static LeftButtonPressed: number;
+      static LeftButtonReleased: number;
+      static RightButtonPressed: number;
+      static RightButtonReleased: number;
+      static MiddleButtonPressed: number;
+      static MiddleButtonReleased: number;
+      static XButton1Pressed: number;
+      static XButton1Released: number;
+      static XButton2Pressed: number;
+      static XButton2Released: number;
+    }
+    class RightTappedEventArgs implements Microsoft.UI.Input.IRightTappedEventArgs {
+      readonly PointerDeviceType: number;
+      readonly Position: Windows.Foundation.Point;
+    }
+    class TappedEventArgs implements Microsoft.UI.Input.ITappedEventArgs {
+      readonly PointerDeviceType: number;
+      readonly Position: Windows.Foundation.Point;
+      readonly TapCount: number;
+    }
+    class VirtualKeyStates extends System.Enum {
+      value__: number;
+      static None: number;
+      static Down: number;
+      static Locked: number;
+    }
+    class WindowRectChangedEventArgs implements Microsoft.UI.Input.IWindowRectChangedEventArgs {
+      readonly MoveSizeOperation: number;
+      readonly NewWindowRect: Windows.Graphics.RectInt32;
+      readonly OldWindowRect: Windows.Graphics.RectInt32;
+      readonly PointerScreenPoint: Windows.Graphics.PointInt32;
+    }
+    class WindowRectChangingEventArgs implements Microsoft.UI.Input.IWindowRectChangingEventArgs {
+      ShowWindow: boolean;
+      NewWindowRect: Windows.Graphics.RectInt32;
+      AllowRectChange: boolean;
+      readonly MoveSizeOperation: number;
+      readonly OldWindowRect: Windows.Graphics.RectInt32;
+      readonly PointerScreenPoint: Windows.Graphics.PointInt32;
+    }
+}
+
+declare namespace Microsoft.UI.Input.DragDrop {
+    class DragDropManager implements Microsoft.UI.Input.DragDrop.IDragDropManager {
+      TargetRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Input.DragDrop.DragDropManager, Microsoft.UI.Input.DragDrop.DropOperationTargetRequestedEventArgs> | null;
+      AreConcurrentOperationsEnabled: boolean;
+      Dispose(): void;
+      static GetForIsland(result: Microsoft.UI.Content.ContentIsland): Microsoft.UI.Input.DragDrop.DragDropManager;
+    }
+    class DragDropModifiers extends System.Enum {
+      value__: number;
+      static None: number;
+      static Shift: number;
+      static Control: number;
+      static Alt: number;
+      static LeftButton: number;
+      static MiddleButton: number;
+      static RightButton: number;
+    }
+    class DragInfo implements Microsoft.UI.Input.DragDrop.IDragInfo {
+      readonly AllowedOperations: Windows.ApplicationModel.DataTransfer.DataPackageOperation;
+      readonly Data: Windows.ApplicationModel.DataTransfer.DataPackageView;
+      readonly Modifiers: number;
+      readonly Position: Windows.Foundation.Point;
+    }
+    class DragOperation implements Microsoft.UI.Input.DragDrop.IDragOperation {
+      DragUIContentMode: number;
+      AllowedOperations: Windows.ApplicationModel.DataTransfer.DataPackageOperation;
+      readonly Data: Windows.ApplicationModel.DataTransfer.DataPackage;
+      SetDragUIContentFromSoftwareBitmap(bitmap: Windows.Graphics.Imaging.SoftwareBitmap): void;
+      SetDragUIContentFromSoftwareBitmap(bitmap: Windows.Graphics.Imaging.SoftwareBitmap, anchorPoint: Windows.Foundation.Point): void;
+      StartAsync(operation: Microsoft.UI.Input.DragDrop.DragDropManager, initialTarget: Microsoft.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.DataTransfer.DataPackageOperation>;
+      Dispose(): void;
+      constructor();
+    }
+    class DragUIContentMode extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Deferred: number;
+    }
+    class DragUIOverride implements Microsoft.UI.Input.DragDrop.IDragUIOverride {
+      IsGlyphVisible: boolean;
+      IsContentVisible: boolean;
+      IsCaptionVisible: boolean;
+      Caption: string;
+      Clear(): void;
+      SetContentFromSoftwareBitmap(bitmap: Windows.Graphics.Imaging.SoftwareBitmap): void;
+      SetContentFromSoftwareBitmap(bitmap: Windows.Graphics.Imaging.SoftwareBitmap, anchorPoint: Windows.Foundation.Point): void;
+    }
+    class DropOperationTargetRequestedEventArgs implements Microsoft.UI.Input.DragDrop.IDropOperationTargetRequestedEventArgs {
+      SetTarget(target: Microsoft.UI.Input.DragDrop.IDropOperationTarget): void;
+    }
+    interface IDropOperationTarget {
+      DropAsync(operation: Microsoft.UI.Input.DragDrop.DragInfo): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.DataTransfer.DataPackageOperation>;
+      EnterAsync(operation: Microsoft.UI.Input.DragDrop.DragInfo, dragInfo: Microsoft.UI.Input.DragDrop.DragUIOverride): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.DataTransfer.DataPackageOperation>;
+      LeaveAsync(operation: Microsoft.UI.Input.DragDrop.DragInfo): Windows.Foundation.IAsyncAction;
+      OverAsync(operation: Microsoft.UI.Input.DragDrop.DragInfo, dragInfo: Microsoft.UI.Input.DragDrop.DragUIOverride): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.DataTransfer.DataPackageOperation>;
+    }
+}
+
+declare namespace Microsoft.UI.Input.Interop {
+    class PenDeviceInterop {
+      static FromPointerPoint(result: Microsoft.UI.Input.PointerPoint): Windows.Devices.Input.PenDevice;
+    }
+}
+
+declare namespace Microsoft.UI.System {
+    class ThemeSettings implements Microsoft.UI.System.IThemeSettings {
+      Changed: Windows.Foundation.TypedEventHandler<Microsoft.UI.System.ThemeSettings, any> | null;
+      readonly HighContrast: boolean;
+      readonly HighContrastScheme: string;
+      static CreateForWindowId(result: Microsoft.UI.WindowId): Microsoft.UI.System.ThemeSettings;
+    }
+}
+
+declare namespace Microsoft.UI.Text {
+    class CaretType extends System.Enum {
+      value__: number;
+      static Normal: number;
+      static Null: number;
+    }
+    class FindOptions extends System.Enum {
+      value__: number;
+      static None: number;
+      static Word: number;
+      static Case: number;
+    }
+    class FontWeights implements Microsoft.UI.Text.IFontWeights {
+      static readonly Black: Windows.UI.Text.FontWeight;
+      static readonly Bold: Windows.UI.Text.FontWeight;
+      static readonly ExtraBlack: Windows.UI.Text.FontWeight;
+      static readonly ExtraBold: Windows.UI.Text.FontWeight;
+      static readonly ExtraLight: Windows.UI.Text.FontWeight;
+      static readonly Light: Windows.UI.Text.FontWeight;
+      static readonly Medium: Windows.UI.Text.FontWeight;
+      static readonly Normal: Windows.UI.Text.FontWeight;
+      static readonly SemiBold: Windows.UI.Text.FontWeight;
+      static readonly SemiLight: Windows.UI.Text.FontWeight;
+      static readonly Thin: Windows.UI.Text.FontWeight;
+    }
+    class FormatEffect extends System.Enum {
+      value__: number;
+      static Off: number;
+      static On: number;
+      static Toggle: number;
+      static Undefined: number;
+    }
+    class HorizontalCharacterAlignment extends System.Enum {
+      value__: number;
+      static Left: number;
+      static Right: number;
+      static Center: number;
+    }
+    interface ITextCharacterFormat {
+      AllCaps: number;
+      BackgroundColor: Windows.UI.Color;
+      Bold: number;
+      FontStretch: Windows.UI.Text.FontStretch;
+      FontStyle: Windows.UI.Text.FontStyle;
+      ForegroundColor: Windows.UI.Color;
+      Hidden: number;
+      Italic: number;
+      Kerning: number;
+      LanguageTag: string;
+      readonly LinkType: number;
+      Name: string;
+      Outline: number;
+      Position: number;
+      ProtectedText: number;
+      Size: number;
+      SmallCaps: number;
+      Spacing: number;
+      Strikethrough: number;
+      Subscript: number;
+      Superscript: number;
+      TextScript: number;
+      Underline: number;
+      Weight: number;
+      SetClone(value: Microsoft.UI.Text.ITextCharacterFormat): void;
+      GetClone(): Microsoft.UI.Text.ITextCharacterFormat;
+      IsEqual(result: Microsoft.UI.Text.ITextCharacterFormat): boolean;
+    }
+    interface ITextParagraphFormat {
+      Alignment: number;
+      readonly FirstLineIndent: number;
+      KeepTogether: number;
+      KeepWithNext: number;
+      readonly LeftIndent: number;
+      readonly LineSpacing: number;
+      readonly LineSpacingRule: number;
+      ListAlignment: number;
+      ListLevelIndex: number;
+      ListStart: number;
+      ListStyle: number;
+      ListTab: number;
+      ListType: number;
+      NoLineNumber: number;
+      PageBreakBefore: number;
+      RightIndent: number;
+      RightToLeft: number;
+      SpaceAfter: number;
+      SpaceBefore: number;
+      Style: number;
+      readonly TabCount: number;
+      WidowControl: number;
+      AddTab(position: number, align: number, leader: number): void;
+      ClearAllTabs(): void;
+      DeleteTab(position: number): void;
+      GetClone(): Microsoft.UI.Text.ITextParagraphFormat;
+      GetTab(index: number, position: number, align: number, leader: number): void;
+      IsEqual(result: Microsoft.UI.Text.ITextParagraphFormat): boolean;
+      SetClone(format: Microsoft.UI.Text.ITextParagraphFormat): void;
+      SetIndents(start: number, left: number, right: number): void;
+      SetLineSpacing(rule: number, spacing: number): void;
+    }
+    interface ITextRange {
+      Character: string;
+      CharacterFormat: Microsoft.UI.Text.ITextCharacterFormat;
+      EndPosition: number;
+      FormattedText: Microsoft.UI.Text.ITextRange;
+      Gravity: number;
+      readonly Length: number;
+      Link: string;
+      ParagraphFormat: Microsoft.UI.Text.ITextParagraphFormat;
+      StartPosition: number;
+      readonly StoryLength: number;
+      Text: string;
+      CanPaste(result: number): boolean;
+      ChangeCase(value: number): void;
+      Collapse(value: boolean): void;
+      Copy(): void;
+      Cut(): void;
+      Delete(result: number, unit: number): number;
+      EndOf(result: number, unit: boolean): number;
+      Expand(result: number): number;
+      FindText(result: string, value: number, scanLength: number): number;
+      GetCharacterUtf32(value: number, offset: number): void;
+      GetClone(): Microsoft.UI.Text.ITextRange;
+      GetIndex(result: number): number;
+      GetPoint(horizontalAlign: number, verticalAlign: number, options: number, point: Windows.Foundation.Point): void;
+      GetRect(options: number, rect: Windows.Foundation.Rect, hit: number): void;
+      GetText(options: number, value: string): void;
+      GetTextViaStream(options: number, value: Windows.Storage.Streams.IRandomAccessStream): void;
+      InRange(result: Microsoft.UI.Text.ITextRange): boolean;
+      InsertImage(width: number, height: number, ascent: number, verticalAlign: number, alternateText: string, value: Windows.Storage.Streams.IRandomAccessStream): void;
+      InStory(result: Microsoft.UI.Text.ITextRange): boolean;
+      IsEqual(result: Microsoft.UI.Text.ITextRange): boolean;
+      Move(result: number, unit: number): number;
+      MoveEnd(result: number, unit: number): number;
+      MoveStart(result: number, unit: number): number;
+      Paste(format: number): void;
+      ScrollIntoView(value: number): void;
+      MatchSelection(): void;
+      SetIndex(unit: number, index: number, extend: boolean): void;
+      SetPoint(point: Windows.Foundation.Point, options: number, extend: boolean): void;
+      SetRange(startPosition: number, endPosition: number): void;
+      SetText(options: number, value: string): void;
+      SetTextViaStream(options: number, value: Windows.Storage.Streams.IRandomAccessStream): void;
+      StartOf(result: number, unit: boolean): number;
+    }
+    interface ITextSelection extends Microsoft.UI.Text.ITextRange {
+      Options: number;
+      readonly Type: number;
+      EndKey(result: number, unit: boolean): number;
+      HomeKey(result: number, unit: boolean): number;
+      MoveDown(result: number, unit: number, count: boolean): number;
+      MoveLeft(result: number, unit: number, count: boolean): number;
+      MoveRight(result: number, unit: number, count: boolean): number;
+      MoveUp(result: number, unit: number, count: boolean): number;
+      TypeText(value: string): void;
+    }
+    class LetterCase extends System.Enum {
+      value__: number;
+      static Lower: number;
+      static Upper: number;
+    }
+    class LineSpacingRule extends System.Enum {
+      value__: number;
+      static Undefined: number;
+      static Single: number;
+      static OneAndHalf: number;
+      static Double: number;
+      static AtLeast: number;
+      static Exactly: number;
+      static Multiple: number;
+      static Percent: number;
+    }
+    class LinkType extends System.Enum {
+      value__: number;
+      static Undefined: number;
+      static NotALink: number;
+      static ClientLink: number;
+      static FriendlyLinkName: number;
+      static FriendlyLinkAddress: number;
+      static AutoLink: number;
+      static AutoLinkEmail: number;
+      static AutoLinkPhone: number;
+      static AutoLinkPath: number;
+    }
+    class MarkerAlignment extends System.Enum {
+      value__: number;
+      static Undefined: number;
+      static Left: number;
+      static Center: number;
+      static Right: number;
+    }
+    class MarkerStyle extends System.Enum {
+      value__: number;
+      static Undefined: number;
+      static Parenthesis: number;
+      static Parentheses: number;
+      static Period: number;
+      static Plain: number;
+      static Minus: number;
+      static NoNumber: number;
+    }
+    class MarkerType extends System.Enum {
+      value__: number;
+      static Undefined: number;
+      static None: number;
+      static Bullet: number;
+      static Arabic: number;
+      static LowercaseEnglishLetter: number;
+      static UppercaseEnglishLetter: number;
+      static LowercaseRoman: number;
+      static UppercaseRoman: number;
+      static UnicodeSequence: number;
+      static CircledNumber: number;
+      static BlackCircleWingding: number;
+      static WhiteCircleWingding: number;
+      static ArabicWide: number;
+      static SimplifiedChinese: number;
+      static TraditionalChinese: number;
+      static JapanSimplifiedChinese: number;
+      static JapanKorea: number;
+      static ArabicDictionary: number;
+      static ArabicAbjad: number;
+      static Hebrew: number;
+      static ThaiAlphabetic: number;
+      static ThaiNumeric: number;
+      static DevanagariVowel: number;
+      static DevanagariConsonant: number;
+      static DevanagariNumeric: number;
+    }
+    class ParagraphAlignment extends System.Enum {
+      value__: number;
+      static Undefined: number;
+      static Left: number;
+      static Center: number;
+      static Right: number;
+      static Justify: number;
+    }
+    class ParagraphStyle extends System.Enum {
+      value__: number;
+      static Undefined: number;
+      static None: number;
+      static Normal: number;
+      static Heading1: number;
+      static Heading2: number;
+      static Heading3: number;
+      static Heading4: number;
+      static Heading5: number;
+      static Heading6: number;
+      static Heading7: number;
+      static Heading8: number;
+      static Heading9: number;
+    }
+    class PointOptions extends System.Enum {
+      value__: number;
+      static None: number;
+      static IncludeInset: number;
+      static Start: number;
+      static ClientCoordinates: number;
+      static AllowOffClient: number;
+      static Transform: number;
+      static NoHorizontalScroll: number;
+      static NoVerticalScroll: number;
+    }
+    class RangeGravity extends System.Enum {
+      value__: number;
+      static UIBehavior: number;
+      static Backward: number;
+      static Forward: number;
+      static Inward: number;
+      static Outward: number;
+    }
+    class RichEditMathMode extends System.Enum {
+      value__: number;
+      static NoMath: number;
+      static MathOnly: number;
+    }
+    class RichEditTextDocument implements Microsoft.UI.Text.ITextDocument {
+      UndoLimit: number;
+      IgnoreTrailingCharacterSpacing: boolean;
+      DefaultTabStop: number;
+      CaretType: number;
+      AlignmentIncludesTrailingWhitespace: boolean;
+      readonly Selection: Microsoft.UI.Text.ITextSelection;
+      CanCopy(): boolean;
+      CanPaste(): boolean;
+      CanRedo(): boolean;
+      CanUndo(): boolean;
+      ApplyDisplayUpdates(): number;
+      BatchDisplayUpdates(): number;
+      BeginUndoGroup(): void;
+      EndUndoGroup(): void;
+      GetDefaultCharacterFormat(): Microsoft.UI.Text.ITextCharacterFormat;
+      GetDefaultParagraphFormat(): Microsoft.UI.Text.ITextParagraphFormat;
+      GetRange(result: number, startPosition: number): Microsoft.UI.Text.ITextRange;
+      GetRangeFromPoint(result: Windows.Foundation.Point, point: number): Microsoft.UI.Text.ITextRange;
+      GetText(options: number, value: string): void;
+      LoadFromStream(options: number, value: Windows.Storage.Streams.IRandomAccessStream): void;
+      Redo(): void;
+      SaveToStream(options: number, value: Windows.Storage.Streams.IRandomAccessStream): void;
+      SetDefaultCharacterFormat(value: Microsoft.UI.Text.ITextCharacterFormat): void;
+      SetDefaultParagraphFormat(value: Microsoft.UI.Text.ITextParagraphFormat): void;
+      SetText(options: number, value: string): void;
+      Undo(): void;
+      ClearUndoRedoHistory(): void;
+    }
+    class RichEditTextRange implements Microsoft.UI.Text.ITextRange {
+      Text: string;
+      StartPosition: number;
+      ParagraphFormat: Microsoft.UI.Text.ITextParagraphFormat;
+      Link: string;
+      Gravity: number;
+      FormattedText: Microsoft.UI.Text.ITextRange;
+      EndPosition: number;
+      CharacterFormat: Microsoft.UI.Text.ITextCharacterFormat;
+      Character: string;
+      readonly Length: number;
+      readonly StoryLength: number;
+      CanPaste(result: number): boolean;
+      ChangeCase(value: number): void;
+      Collapse(value: boolean): void;
+      Copy(): void;
+      Cut(): void;
+      Delete(result: number, unit: number): number;
+      EndOf(result: number, unit: boolean): number;
+      Expand(result: number): number;
+      FindText(result: string, value: number, scanLength: number): number;
+      GetCharacterUtf32(value: number, offset: number): void;
+      GetClone(): Microsoft.UI.Text.ITextRange;
+      GetIndex(result: number): number;
+      GetPoint(horizontalAlign: number, verticalAlign: number, options: number, point: Windows.Foundation.Point): void;
+      GetRect(options: number, rect: Windows.Foundation.Rect, hit: number): void;
+      GetText(options: number, value: string): void;
+      GetTextViaStream(options: number, value: Windows.Storage.Streams.IRandomAccessStream): void;
+      InRange(result: Microsoft.UI.Text.ITextRange): boolean;
+      InsertImage(width: number, height: number, ascent: number, verticalAlign: number, alternateText: string, value: Windows.Storage.Streams.IRandomAccessStream): void;
+      InStory(result: Microsoft.UI.Text.ITextRange): boolean;
+      IsEqual(result: Microsoft.UI.Text.ITextRange): boolean;
+      Move(result: number, unit: number): number;
+      MoveEnd(result: number, unit: number): number;
+      MoveStart(result: number, unit: number): number;
+      Paste(format: number): void;
+      ScrollIntoView(value: number): void;
+      MatchSelection(): void;
+      SetIndex(unit: number, index: number, extend: boolean): void;
+      SetPoint(point: Windows.Foundation.Point, options: number, extend: boolean): void;
+      SetRange(startPosition: number, endPosition: number): void;
+      SetText(options: number, value: string): void;
+      SetTextViaStream(options: number, value: Windows.Storage.Streams.IRandomAccessStream): void;
+      StartOf(result: number, unit: boolean): number;
+    }
+    class SelectionOptions extends System.Enum {
+      value__: number;
+      static StartActive: number;
+      static AtEndOfLine: number;
+      static Overtype: number;
+      static Active: number;
+      static Replace: number;
+    }
+    class SelectionType extends System.Enum {
+      value__: number;
+      static None: number;
+      static InsertionPoint: number;
+      static Normal: number;
+      static InlineShape: number;
+      static Shape: number;
+    }
+    class TabAlignment extends System.Enum {
+      value__: number;
+      static Left: number;
+      static Center: number;
+      static Right: number;
+      static Decimal: number;
+      static Bar: number;
+    }
+    class TabLeader extends System.Enum {
+      value__: number;
+      static Spaces: number;
+      static Dots: number;
+      static Dashes: number;
+      static Lines: number;
+      static ThickLines: number;
+      static Equals: number;
+    }
+    class TextConstants {
+      static readonly AutoColor: Windows.UI.Color;
+      static readonly MaxUnitCount: number;
+      static readonly MinUnitCount: number;
+      static readonly UndefinedColor: Windows.UI.Color;
+      static readonly UndefinedFloatValue: number;
+      static readonly UndefinedFontStretch: Windows.UI.Text.FontStretch;
+      static readonly UndefinedFontStyle: Windows.UI.Text.FontStyle;
+      static readonly UndefinedInt32Value: number;
+    }
+    class TextGetOptions extends System.Enum {
+      value__: number;
+      static None: number;
+      static AdjustCrlf: number;
+      static UseCrlf: number;
+      static UseObjectText: number;
+      static AllowFinalEop: number;
+      static NoHidden: number;
+      static IncludeNumbering: number;
+      static FormatRtf: number;
+      static UseLf: number;
+    }
+    class TextRangeUnit extends System.Enum {
+      value__: number;
+      static Character: number;
+      static Word: number;
+      static Sentence: number;
+      static Paragraph: number;
+      static Line: number;
+      static Story: number;
+      static Screen: number;
+      static Section: number;
+      static Window: number;
+      static CharacterFormat: number;
+      static ParagraphFormat: number;
+      static Object: number;
+      static HardParagraph: number;
+      static Cluster: number;
+      static Bold: number;
+      static Italic: number;
+      static Underline: number;
+      static Strikethrough: number;
+      static ProtectedText: number;
+      static Link: number;
+      static SmallCaps: number;
+      static AllCaps: number;
+      static Hidden: number;
+      static Outline: number;
+      static Shadow: number;
+      static Imprint: number;
+      static Disabled: number;
+      static Revised: number;
+      static Subscript: number;
+      static Superscript: number;
+      static FontBound: number;
+      static LinkProtected: number;
+      static ContentLink: number;
+    }
+    class TextScript extends System.Enum {
+      value__: number;
+      static Undefined: number;
+      static Ansi: number;
+      static EastEurope: number;
+      static Cyrillic: number;
+      static Greek: number;
+      static Turkish: number;
+      static Hebrew: number;
+      static Arabic: number;
+      static Baltic: number;
+      static Vietnamese: number;
+      static Default: number;
+      static Symbol: number;
+      static Thai: number;
+      static ShiftJis: number;
+      static GB2312: number;
+      static Hangul: number;
+      static Big5: number;
+      static PC437: number;
+      static Oem: number;
+      static Mac: number;
+      static Armenian: number;
+      static Syriac: number;
+      static Thaana: number;
+      static Devanagari: number;
+      static Bengali: number;
+      static Gurmukhi: number;
+      static Gujarati: number;
+      static Oriya: number;
+      static Tamil: number;
+      static Telugu: number;
+      static Kannada: number;
+      static Malayalam: number;
+      static Sinhala: number;
+      static Lao: number;
+      static Tibetan: number;
+      static Myanmar: number;
+      static Georgian: number;
+      static Jamo: number;
+      static Ethiopic: number;
+      static Cherokee: number;
+      static Aboriginal: number;
+      static Ogham: number;
+      static Runic: number;
+      static Khmer: number;
+      static Mongolian: number;
+      static Braille: number;
+      static Yi: number;
+      static Limbu: number;
+      static TaiLe: number;
+      static NewTaiLue: number;
+      static SylotiNagri: number;
+      static Kharoshthi: number;
+      static Kayahli: number;
+      static UnicodeSymbol: number;
+      static Emoji: number;
+      static Glagolitic: number;
+      static Lisu: number;
+      static Vai: number;
+      static NKo: number;
+      static Osmanya: number;
+      static PhagsPa: number;
+      static Gothic: number;
+      static Deseret: number;
+      static Tifinagh: number;
+    }
+    class TextSetOptions extends System.Enum {
+      value__: number;
+      static None: number;
+      static UnicodeBidi: number;
+      static Unlink: number;
+      static Unhide: number;
+      static CheckTextLimit: number;
+      static FormatRtf: number;
+      static ApplyRtfDocumentDefaults: number;
+    }
+    class UnderlineType extends System.Enum {
+      value__: number;
+      static Undefined: number;
+      static None: number;
+      static Single: number;
+      static Words: number;
+      static Double: number;
+      static Dotted: number;
+      static Dash: number;
+      static DashDot: number;
+      static DashDotDot: number;
+      static Wave: number;
+      static Thick: number;
+      static Thin: number;
+      static DoubleWave: number;
+      static HeavyWave: number;
+      static LongDash: number;
+      static ThickDash: number;
+      static ThickDashDot: number;
+      static ThickDashDotDot: number;
+      static ThickDotted: number;
+      static ThickLongDash: number;
+    }
+    class VerticalCharacterAlignment extends System.Enum {
+      value__: number;
+      static Top: number;
+      static Baseline: number;
+      static Bottom: number;
+    }
+}
+
+declare namespace Microsoft.UI.Windowing {
+    class AppWindow implements Microsoft.UI.Windowing.IAppWindow, Microsoft.UI.Windowing.IAppWindow2, Microsoft.UI.Windowing.IAppWindow3 {
+      Changed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Windowing.AppWindow, Microsoft.UI.Windowing.AppWindowChangedEventArgs> | null;
+      Closing: Windows.Foundation.TypedEventHandler<Microsoft.UI.Windowing.AppWindow, Microsoft.UI.Windowing.AppWindowClosingEventArgs> | null;
+      Destroying: Windows.Foundation.TypedEventHandler<Microsoft.UI.Windowing.AppWindow, any> | null;
+      Title: string;
+      IsShownInSwitchers: boolean;
+      readonly Id: Microsoft.UI.WindowId;
+      readonly IsVisible: boolean;
+      readonly OwnerWindowId: Microsoft.UI.WindowId;
+      readonly Position: Windows.Graphics.PointInt32;
+      readonly Presenter: Microsoft.UI.Windowing.AppWindowPresenter;
+      readonly Size: Windows.Graphics.SizeInt32;
+      readonly TitleBar: Microsoft.UI.Windowing.AppWindowTitleBar;
+      readonly ClientSize: Windows.Graphics.SizeInt32;
+      readonly DispatcherQueue: Microsoft.UI.Dispatching.DispatcherQueue;
+      Show(activateWindow: boolean): void;
+      Hide(): void;
+      Move(position: Windows.Graphics.PointInt32): void;
+      MoveAndResize(rect: Windows.Graphics.RectInt32): void;
+      MoveAndResize(rect: Windows.Graphics.RectInt32, displayarea: Microsoft.UI.Windowing.DisplayArea): void;
+      Resize(size: Windows.Graphics.SizeInt32): void;
+      SetIcon(iconPath: string): void;
+      SetIcon(iconId: Microsoft.UI.IconId): void;
+      SetPresenter(appWindowPresenter: Microsoft.UI.Windowing.AppWindowPresenter): void;
+      SetPresenter(appWindowPresenterKind: number): void;
+      Show(): void;
+      Destroy(): void;
+      MoveInZOrderAtBottom(): void;
+      MoveInZOrderAtTop(): void;
+      MoveInZOrderBelow(windowId: Microsoft.UI.WindowId): void;
+      ResizeClient(size: Windows.Graphics.SizeInt32): void;
+      ShowOnceWithRequestedStartupState(): void;
+      AssociateWithDispatcherQueue(dispatcherQueue: Microsoft.UI.Dispatching.DispatcherQueue): void;
+      static Create(result: Microsoft.UI.Windowing.AppWindowPresenter, appWindowPresenter: Microsoft.UI.WindowId, ownerWindowId: Microsoft.UI.Dispatching.DispatcherQueue): Microsoft.UI.Windowing.AppWindow;
+      static Create(): Microsoft.UI.Windowing.AppWindow;
+      static Create(result: Microsoft.UI.Windowing.AppWindowPresenter): Microsoft.UI.Windowing.AppWindow;
+      static Create(result: Microsoft.UI.Windowing.AppWindowPresenter, appWindowPresenter: Microsoft.UI.WindowId): Microsoft.UI.Windowing.AppWindow;
+      static GetFromWindowId(result: Microsoft.UI.WindowId): Microsoft.UI.Windowing.AppWindow;
+    }
+    class AppWindowChangedEventArgs implements Microsoft.UI.Windowing.IAppWindowChangedEventArgs, Microsoft.UI.Windowing.IAppWindowChangedEventArgs2 {
+      readonly DidPositionChange: boolean;
+      readonly DidPresenterChange: boolean;
+      readonly DidSizeChange: boolean;
+      readonly DidVisibilityChange: boolean;
+      readonly DidZOrderChange: boolean;
+      readonly IsZOrderAtBottom: boolean;
+      readonly IsZOrderAtTop: boolean;
+      readonly ZOrderBelowWindowId: Microsoft.UI.WindowId;
+    }
+    class AppWindowClosingEventArgs implements Microsoft.UI.Windowing.IAppWindowClosingEventArgs {
+      Cancel: boolean;
+    }
+    class AppWindowPresenter implements Microsoft.UI.Windowing.IAppWindowPresenter {
+      readonly Kind: number;
+    }
+    class AppWindowPresenterKind extends System.Enum {
+      value__: number;
+      static Default: number;
+      static CompactOverlay: number;
+      static FullScreen: number;
+      static Overlapped: number;
+    }
+    class AppWindowTitleBar implements Microsoft.UI.Windowing.IAppWindowTitleBar, Microsoft.UI.Windowing.IAppWindowTitleBar2 {
+      InactiveForegroundColor: System.Nullable<Windows.UI.Color>;
+      InactiveBackgroundColor: System.Nullable<Windows.UI.Color>;
+      IconShowOptions: number;
+      ForegroundColor: System.Nullable<Windows.UI.Color>;
+      ExtendsContentIntoTitleBar: boolean;
+      ButtonPressedForegroundColor: System.Nullable<Windows.UI.Color>;
+      ButtonPressedBackgroundColor: System.Nullable<Windows.UI.Color>;
+      ButtonInactiveForegroundColor: System.Nullable<Windows.UI.Color>;
+      ButtonInactiveBackgroundColor: System.Nullable<Windows.UI.Color>;
+      ButtonHoverForegroundColor: System.Nullable<Windows.UI.Color>;
+      ButtonHoverBackgroundColor: System.Nullable<Windows.UI.Color>;
+      ButtonForegroundColor: System.Nullable<Windows.UI.Color>;
+      ButtonBackgroundColor: System.Nullable<Windows.UI.Color>;
+      BackgroundColor: System.Nullable<Windows.UI.Color>;
+      readonly Height: number;
+      readonly LeftInset: number;
+      readonly RightInset: number;
+      PreferredHeightOption: number;
+      ResetToDefault(): void;
+      SetDragRectangles(value: Windows.Graphics.RectInt32[]): void;
+      static IsCustomizationSupported(): boolean;
+    }
+    class CompactOverlayPresenter extends Microsoft.UI.Windowing.AppWindowPresenter implements Microsoft.UI.Windowing.ICompactOverlayPresenter {
+      InitialSize: number;
+      static Create(): Microsoft.UI.Windowing.CompactOverlayPresenter;
+    }
+    class CompactOverlaySize extends System.Enum {
+      value__: number;
+      static Small: number;
+      static Medium: number;
+      static Large: number;
+    }
+    class DisplayArea implements Microsoft.UI.Windowing.IDisplayArea {
+      readonly DisplayId: Microsoft.UI.DisplayId;
+      readonly IsPrimary: boolean;
+      readonly OuterBounds: Windows.Graphics.RectInt32;
+      readonly WorkArea: Windows.Graphics.RectInt32;
+      static readonly Primary: Microsoft.UI.Windowing.DisplayArea;
+      static GetFromDisplayId(result: Microsoft.UI.DisplayId): Microsoft.UI.Windowing.DisplayArea;
+      static CreateWatcher(): Microsoft.UI.Windowing.DisplayAreaWatcher;
+      static FindAll(): System.Collections.Generic.IReadOnlyList<Microsoft.UI.Windowing.DisplayArea>;
+      static GetFromWindowId(result: Microsoft.UI.WindowId, windowId: number): Microsoft.UI.Windowing.DisplayArea;
+      static GetFromPoint(result: Windows.Graphics.PointInt32, point: number): Microsoft.UI.Windowing.DisplayArea;
+      static GetFromRect(result: Windows.Graphics.RectInt32, rect: number): Microsoft.UI.Windowing.DisplayArea;
+    }
+    class DisplayAreaFallback extends System.Enum {
+      value__: number;
+      static None: number;
+      static Primary: number;
+      static Nearest: number;
+    }
+    class DisplayAreaWatcher implements Microsoft.UI.Windowing.IDisplayAreaWatcher {
+      Added: Windows.Foundation.TypedEventHandler<Microsoft.UI.Windowing.DisplayAreaWatcher, Microsoft.UI.Windowing.DisplayArea> | null;
+      EnumerationCompleted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Windowing.DisplayAreaWatcher, any> | null;
+      Removed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Windowing.DisplayAreaWatcher, Microsoft.UI.Windowing.DisplayArea> | null;
+      Stopped: Windows.Foundation.TypedEventHandler<Microsoft.UI.Windowing.DisplayAreaWatcher, any> | null;
+      Updated: Windows.Foundation.TypedEventHandler<Microsoft.UI.Windowing.DisplayAreaWatcher, Microsoft.UI.Windowing.DisplayArea> | null;
+      readonly Status: number;
+      Start(): void;
+      Stop(): void;
+    }
+    class DisplayAreaWatcherStatus extends System.Enum {
+      value__: number;
+      static Created: number;
+      static Started: number;
+      static EnumerationCompleted: number;
+      static Stopping: number;
+      static Stopped: number;
+      static Aborted: number;
+    }
+    class FullScreenPresenter extends Microsoft.UI.Windowing.AppWindowPresenter implements Microsoft.UI.Windowing.IFullScreenPresenter {
+      static Create(): Microsoft.UI.Windowing.FullScreenPresenter;
+    }
+    class IconShowOptions extends System.Enum {
+      value__: number;
+      static ShowIconAndSystemMenu: number;
+      static HideIconAndSystemMenu: number;
+    }
+    class OverlappedPresenter extends Microsoft.UI.Windowing.AppWindowPresenter implements Microsoft.UI.Windowing.IOverlappedPresenter, Microsoft.UI.Windowing.IOverlappedPresenter2 {
+      IsResizable: boolean;
+      IsModal: boolean;
+      IsMinimizable: boolean;
+      IsMaximizable: boolean;
+      IsAlwaysOnTop: boolean;
+      readonly HasBorder: boolean;
+      readonly HasTitleBar: boolean;
+      readonly State: number;
+      static readonly RequestedStartupState: number;
+      Restore(): void;
+      Maximize(): void;
+      Minimize(): void;
+      SetBorderAndTitleBar(hasBorder: boolean, hasTitleBar: boolean): void;
+      Minimize(activateWindow: boolean): void;
+      Restore(activateWindow: boolean): void;
+      static Create(): Microsoft.UI.Windowing.OverlappedPresenter;
+      static CreateForContextMenu(): Microsoft.UI.Windowing.OverlappedPresenter;
+      static CreateForDialog(): Microsoft.UI.Windowing.OverlappedPresenter;
+      static CreateForToolWindow(): Microsoft.UI.Windowing.OverlappedPresenter;
+    }
+    class OverlappedPresenterState extends System.Enum {
+      value__: number;
+      static Maximized: number;
+      static Minimized: number;
+      static Restored: number;
+    }
+    class TitleBarHeightOption extends System.Enum {
+      value__: number;
+      static Standard: number;
+      static Tall: number;
+      static Collapsed: number;
+    }
+}
+
+declare namespace Microsoft.UI.Xaml {
+    class DependencyObject implements Microsoft.UI.Xaml.IDependencyObject {
+      readonly Dispatcher: Windows.UI.Core.CoreDispatcher;
+      readonly DispatcherQueue: Microsoft.UI.Dispatching.DispatcherQueue;
+      GetValue(result: Microsoft.UI.Xaml.DependencyProperty): any;
+      SetValue(dp: Microsoft.UI.Xaml.DependencyProperty, value: any): void;
+      ClearValue(dp: Microsoft.UI.Xaml.DependencyProperty): void;
+      ReadLocalValue(result: Microsoft.UI.Xaml.DependencyProperty): any;
+      GetAnimationBaseValue(result: Microsoft.UI.Xaml.DependencyProperty): any;
+      RegisterPropertyChangedCallback(result: Microsoft.UI.Xaml.DependencyProperty, dp: Microsoft.UI.Xaml.DependencyPropertyChangedCallback): number;
+      UnregisterPropertyChangedCallback(dp: Microsoft.UI.Xaml.DependencyProperty, token: number): void;
+    }
+    class StateTriggerBase extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.IStateTriggerBase, Microsoft.UI.Xaml.IStateTriggerBaseProtected {
+    }
+    class AdaptiveTrigger extends Microsoft.UI.Xaml.StateTriggerBase implements Microsoft.UI.Xaml.IAdaptiveTrigger {
+      MinWindowWidth: number;
+      MinWindowHeight: number;
+      static readonly MinWindowHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinWindowWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class Application implements Microsoft.UI.Xaml.IApplication, Microsoft.UI.Xaml.IApplication2, Microsoft.UI.Xaml.IApplication3, Microsoft.UI.Xaml.IApplicationOverrides {
+      UnhandledException: Microsoft.UI.Xaml.UnhandledExceptionEventHandler | null;
+      ResourceManagerRequested: Windows.Foundation.TypedEventHandler<any, Microsoft.UI.Xaml.ResourceManagerRequestedEventArgs> | null;
+      Resources: Microsoft.UI.Xaml.ResourceDictionary;
+      RequestedTheme: number;
+      HighContrastAdjustment: number;
+      FocusVisualKind: number;
+      readonly DebugSettings: Microsoft.UI.Xaml.DebugSettings;
+      DispatcherShutdownMode: number;
+      static readonly Current: Microsoft.UI.Xaml.Application;
+      constructor();
+      Exit(): void;
+      static Start(callback: Microsoft.UI.Xaml.ApplicationInitializationCallback): void;
+      static LoadComponent(component: any, resourceLocator: System.Uri): void;
+      static LoadComponent(component: any, resourceLocator: System.Uri, componentResourceLocation: number): void;
+    }
+    class ApplicationHighContrastAdjustment extends System.Enum {
+      value__: number;
+      static None: number;
+      static Auto: number;
+    }
+    class ApplicationInitializationCallback {
+      constructor(handler: (p: Microsoft.UI.Xaml.ApplicationInitializationCallbackParams) => void);
+      Invoke(p: Microsoft.UI.Xaml.ApplicationInitializationCallbackParams): void;
+    }
+    class ApplicationInitializationCallbackParams implements Microsoft.UI.Xaml.IApplicationInitializationCallbackParams {
+    }
+    class ApplicationRequiresPointerMode extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static WhenRequested: number;
+    }
+    class ApplicationTheme extends System.Enum {
+      value__: number;
+      static Light: number;
+      static Dark: number;
+    }
+    class AutomationTextAttributesEnum extends System.Enum {
+      value__: number;
+      static AnimationStyleAttribute: number;
+      static BackgroundColorAttribute: number;
+      static BulletStyleAttribute: number;
+      static CapStyleAttribute: number;
+      static CultureAttribute: number;
+      static FontNameAttribute: number;
+      static FontSizeAttribute: number;
+      static FontWeightAttribute: number;
+      static ForegroundColorAttribute: number;
+      static HorizontalTextAlignmentAttribute: number;
+      static IndentationFirstLineAttribute: number;
+      static IndentationLeadingAttribute: number;
+      static IndentationTrailingAttribute: number;
+      static IsHiddenAttribute: number;
+      static IsItalicAttribute: number;
+      static IsReadOnlyAttribute: number;
+      static IsSubscriptAttribute: number;
+      static IsSuperscriptAttribute: number;
+      static MarginBottomAttribute: number;
+      static MarginLeadingAttribute: number;
+      static MarginTopAttribute: number;
+      static MarginTrailingAttribute: number;
+      static OutlineStylesAttribute: number;
+      static OverlineColorAttribute: number;
+      static OverlineStyleAttribute: number;
+      static StrikethroughColorAttribute: number;
+      static StrikethroughStyleAttribute: number;
+      static TabsAttribute: number;
+      static TextFlowDirectionsAttribute: number;
+      static UnderlineColorAttribute: number;
+      static UnderlineStyleAttribute: number;
+      static AnnotationTypesAttribute: number;
+      static AnnotationObjectsAttribute: number;
+      static StyleNameAttribute: number;
+      static StyleIdAttribute: number;
+      static LinkAttribute: number;
+      static IsActiveAttribute: number;
+      static SelectionActiveEndAttribute: number;
+      static CaretPositionAttribute: number;
+      static CaretBidiModeAttribute: number;
+    }
+    class BindingFailedEventArgs implements Microsoft.UI.Xaml.IBindingFailedEventArgs {
+      readonly Message: string;
+    }
+    class BindingFailedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.BindingFailedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.BindingFailedEventArgs): void;
+    }
+    class BringIntoViewOptions implements Microsoft.UI.Xaml.IBringIntoViewOptions {
+      VerticalOffset: number;
+      VerticalAlignmentRatio: number;
+      TargetRect: System.Nullable<Windows.Foundation.Rect>;
+      HorizontalOffset: number;
+      HorizontalAlignmentRatio: number;
+      AnimationDesired: boolean;
+      constructor();
+    }
+    class RoutedEventArgs implements Microsoft.UI.Xaml.IRoutedEventArgs {
+      readonly OriginalSource: any;
+      constructor();
+    }
+    class BringIntoViewRequestedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.IBringIntoViewRequestedEventArgs {
+      VerticalOffset: number;
+      TargetRect: Windows.Foundation.Rect;
+      TargetElement: Microsoft.UI.Xaml.UIElement;
+      HorizontalOffset: number;
+      Handled: boolean;
+      AnimationDesired: boolean;
+      readonly HorizontalAlignmentRatio: number;
+      readonly VerticalAlignmentRatio: number;
+    }
+    class BrushTransition implements Microsoft.UI.Xaml.IBrushTransition {
+      Duration: System.TimeSpan;
+      constructor();
+    }
+    class ResourceDictionary extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.IResourceDictionary {
+      Source: System.Uri;
+      readonly MergedDictionaries: System.Collections.Generic.IList<Microsoft.UI.Xaml.ResourceDictionary>;
+      readonly ThemeDictionaries: System.Collections.Generic.IDictionary<any, any>;
+      constructor();
+      Lookup(key: any): any;
+      readonly Size: number;
+      HasKey(key: any): boolean;
+      Insert(key: any, value: any): boolean;
+      Remove(key: any): void;
+      Clear(): void;
+      GetView(): any;
+      First(): any;
+    }
+    class ColorPaletteResources extends Microsoft.UI.Xaml.ResourceDictionary implements Microsoft.UI.Xaml.IColorPaletteResources {
+      ListMedium: System.Nullable<Windows.UI.Color>;
+      ListLow: System.Nullable<Windows.UI.Color>;
+      ErrorText: System.Nullable<Windows.UI.Color>;
+      ChromeWhite: System.Nullable<Windows.UI.Color>;
+      ChromeMediumLow: System.Nullable<Windows.UI.Color>;
+      ChromeMedium: System.Nullable<Windows.UI.Color>;
+      ChromeLow: System.Nullable<Windows.UI.Color>;
+      ChromeHigh: System.Nullable<Windows.UI.Color>;
+      ChromeGray: System.Nullable<Windows.UI.Color>;
+      ChromeDisabledLow: System.Nullable<Windows.UI.Color>;
+      ChromeDisabledHigh: System.Nullable<Windows.UI.Color>;
+      ChromeBlackMediumLow: System.Nullable<Windows.UI.Color>;
+      ChromeBlackMedium: System.Nullable<Windows.UI.Color>;
+      ChromeBlackLow: System.Nullable<Windows.UI.Color>;
+      ChromeBlackHigh: System.Nullable<Windows.UI.Color>;
+      ChromeAltLow: System.Nullable<Windows.UI.Color>;
+      BaseMediumLow: System.Nullable<Windows.UI.Color>;
+      BaseMediumHigh: System.Nullable<Windows.UI.Color>;
+      BaseMedium: System.Nullable<Windows.UI.Color>;
+      BaseLow: System.Nullable<Windows.UI.Color>;
+      BaseHigh: System.Nullable<Windows.UI.Color>;
+      AltMediumLow: System.Nullable<Windows.UI.Color>;
+      AltMediumHigh: System.Nullable<Windows.UI.Color>;
+      AltMedium: System.Nullable<Windows.UI.Color>;
+      AltLow: System.Nullable<Windows.UI.Color>;
+      AltHigh: System.Nullable<Windows.UI.Color>;
+      Accent: System.Nullable<Windows.UI.Color>;
+      constructor();
+    }
+    class UIElement extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.IUIElement, Microsoft.UI.Xaml.IUIElementProtected, Microsoft.UI.Xaml.IUIElementOverrides, Microsoft.UI.Composition.IAnimationObject, Microsoft.UI.Composition.IVisualElement, Microsoft.UI.Composition.IVisualElement2 {
+      AccessKeyDisplayDismissed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.UIElement, Microsoft.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs> | null;
+      AccessKeyDisplayRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.UIElement, Microsoft.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs> | null;
+      AccessKeyInvoked: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.UIElement, Microsoft.UI.Xaml.Input.AccessKeyInvokedEventArgs> | null;
+      BringIntoViewRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.UIElement, Microsoft.UI.Xaml.BringIntoViewRequestedEventArgs> | null;
+      CharacterReceived: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.UIElement, Microsoft.UI.Xaml.Input.CharacterReceivedRoutedEventArgs> | null;
+      ContextCanceled: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.UIElement, Microsoft.UI.Xaml.RoutedEventArgs> | null;
+      ContextRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.UIElement, Microsoft.UI.Xaml.Input.ContextRequestedEventArgs> | null;
+      DoubleTapped: Microsoft.UI.Xaml.Input.DoubleTappedEventHandler | null;
+      DragEnter: Microsoft.UI.Xaml.DragEventHandler | null;
+      DragLeave: Microsoft.UI.Xaml.DragEventHandler | null;
+      DragOver: Microsoft.UI.Xaml.DragEventHandler | null;
+      DragStarting: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.UIElement, Microsoft.UI.Xaml.DragStartingEventArgs> | null;
+      Drop: Microsoft.UI.Xaml.DragEventHandler | null;
+      DropCompleted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.UIElement, Microsoft.UI.Xaml.DropCompletedEventArgs> | null;
+      GettingFocus: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.UIElement, Microsoft.UI.Xaml.Input.GettingFocusEventArgs> | null;
+      GotFocus: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      Holding: Microsoft.UI.Xaml.Input.HoldingEventHandler | null;
+      KeyDown: Microsoft.UI.Xaml.Input.KeyEventHandler | null;
+      KeyUp: Microsoft.UI.Xaml.Input.KeyEventHandler | null;
+      LosingFocus: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.UIElement, Microsoft.UI.Xaml.Input.LosingFocusEventArgs> | null;
+      LostFocus: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      ManipulationCompleted: Microsoft.UI.Xaml.Input.ManipulationCompletedEventHandler | null;
+      ManipulationDelta: Microsoft.UI.Xaml.Input.ManipulationDeltaEventHandler | null;
+      ManipulationInertiaStarting: Microsoft.UI.Xaml.Input.ManipulationInertiaStartingEventHandler | null;
+      ManipulationStarted: Microsoft.UI.Xaml.Input.ManipulationStartedEventHandler | null;
+      ManipulationStarting: Microsoft.UI.Xaml.Input.ManipulationStartingEventHandler | null;
+      NoFocusCandidateFound: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.UIElement, Microsoft.UI.Xaml.Input.NoFocusCandidateFoundEventArgs> | null;
+      PointerCanceled: Microsoft.UI.Xaml.Input.PointerEventHandler | null;
+      PointerCaptureLost: Microsoft.UI.Xaml.Input.PointerEventHandler | null;
+      PointerEntered: Microsoft.UI.Xaml.Input.PointerEventHandler | null;
+      PointerExited: Microsoft.UI.Xaml.Input.PointerEventHandler | null;
+      PointerMoved: Microsoft.UI.Xaml.Input.PointerEventHandler | null;
+      PointerPressed: Microsoft.UI.Xaml.Input.PointerEventHandler | null;
+      PointerReleased: Microsoft.UI.Xaml.Input.PointerEventHandler | null;
+      PointerWheelChanged: Microsoft.UI.Xaml.Input.PointerEventHandler | null;
+      PreviewKeyDown: Microsoft.UI.Xaml.Input.KeyEventHandler | null;
+      PreviewKeyUp: Microsoft.UI.Xaml.Input.KeyEventHandler | null;
+      ProcessKeyboardAccelerators: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.UIElement, Microsoft.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs> | null;
+      RightTapped: Microsoft.UI.Xaml.Input.RightTappedEventHandler | null;
+      Tapped: Microsoft.UI.Xaml.Input.TappedEventHandler | null;
+      KeyboardAcceleratorPlacementMode: number;
+      RotationTransition: Microsoft.UI.Xaml.ScalarTransition;
+      KeyTipTarget: Microsoft.UI.Xaml.DependencyObject;
+      KeyTipPlacementMode: number;
+      KeyTipHorizontalOffset: number;
+      IsTapEnabled: boolean;
+      IsTabStop: boolean;
+      IsRightTapEnabled: boolean;
+      IsHoldingEnabled: boolean;
+      IsHitTestVisible: boolean;
+      IsDoubleTapEnabled: boolean;
+      AccessKey: string;
+      HighContrastAdjustment: number;
+      ManipulationMode: number;
+      ExitDisplayModeOnAccessKeyInvoked: boolean;
+      OpacityTransition: Microsoft.UI.Xaml.ScalarTransition;
+      ContextFlyout: Microsoft.UI.Xaml.Controls.Primitives.FlyoutBase;
+      CompositeMode: number;
+      Clip: Microsoft.UI.Xaml.Media.RectangleGeometry;
+      Translation: System.Numerics.Vector3;
+      CanDrag: boolean;
+      CanBeScrollAnchor: boolean;
+      CacheMode: Microsoft.UI.Xaml.Media.CacheMode;
+      AllowDrop: boolean;
+      Opacity: number;
+      KeyboardAcceleratorPlacementTarget: Microsoft.UI.Xaml.DependencyObject;
+      AccessKeyScopeOwner: Microsoft.UI.Xaml.DependencyObject;
+      IsAccessKeyScope: boolean;
+      KeyTipVerticalOffset: number;
+      XamlRoot: Microsoft.UI.Xaml.XamlRoot;
+      XYFocusUpNavigationStrategy: number;
+      XYFocusUp: Microsoft.UI.Xaml.DependencyObject;
+      XYFocusRightNavigationStrategy: number;
+      XYFocusRight: Microsoft.UI.Xaml.DependencyObject;
+      XYFocusLeftNavigationStrategy: number;
+      CenterPoint: System.Numerics.Vector3;
+      XYFocusKeyboardNavigation: number;
+      XYFocusDownNavigationStrategy: number;
+      XYFocusDown: Microsoft.UI.Xaml.DependencyObject;
+      Visibility: number;
+      UseSystemFocusVisuals: boolean;
+      UseLayoutRounding: boolean;
+      TranslationTransition: Microsoft.UI.Xaml.Vector3Transition;
+      XYFocusLeft: Microsoft.UI.Xaml.DependencyObject;
+      Transitions: Microsoft.UI.Xaml.Media.Animation.TransitionCollection;
+      TransformMatrix: System.Numerics.Matrix4x4;
+      Rotation: number;
+      RenderTransformOrigin: Windows.Foundation.Point;
+      RenderTransform: Microsoft.UI.Xaml.Media.Transform;
+      TabFocusNavigation: number;
+      RasterizationScale: number;
+      Projection: Microsoft.UI.Xaml.Media.Projection;
+      Shadow: Microsoft.UI.Xaml.Media.Shadow;
+      ScaleTransition: Microsoft.UI.Xaml.Vector3Transition;
+      Scale: System.Numerics.Vector3;
+      TabIndex: number;
+      RotationAxis: System.Numerics.Vector3;
+      Transform3D: Microsoft.UI.Xaml.Media.Media3D.Transform3D;
+      readonly DesiredSize: Windows.Foundation.Size;
+      readonly FocusState: number;
+      readonly KeyboardAccelerators: System.Collections.Generic.IList<Microsoft.UI.Xaml.Input.KeyboardAccelerator>;
+      readonly Lights: System.Collections.Generic.IList<Microsoft.UI.Xaml.Media.XamlLight>;
+      readonly RenderSize: Windows.Foundation.Size;
+      readonly PointerCaptures: System.Collections.Generic.IReadOnlyList<Microsoft.UI.Xaml.Input.Pointer>;
+      readonly ActualOffset: System.Numerics.Vector3;
+      readonly ActualSize: System.Numerics.Vector2;
+      static readonly AccessKeyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AccessKeyScopeOwnerProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AllowDropProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BringIntoViewRequestedEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly CacheModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CanBeScrollAnchorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CanDragProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CharacterReceivedEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly ClipProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CompositeModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContextFlyoutProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContextRequestedEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly DoubleTappedEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly DragEnterEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly DragLeaveEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly DragOverEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly DropEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly ExitDisplayModeOnAccessKeyInvokedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FocusStateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GettingFocusEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly HighContrastAdjustmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HoldingEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly IsAccessKeyScopeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsDoubleTapEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsHitTestVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsHoldingEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsRightTapEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTabStopProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTapEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly KeyDownEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly KeyTipHorizontalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly KeyTipPlacementModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly KeyTipTargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly KeyTipVerticalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly KeyUpEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly KeyboardAcceleratorPlacementModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly KeyboardAcceleratorPlacementTargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LightsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LosingFocusEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly ManipulationCompletedEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly ManipulationDeltaEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly ManipulationInertiaStartingEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly ManipulationModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ManipulationStartedEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly ManipulationStartingEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly NoFocusCandidateFoundEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly OpacityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PointerCanceledEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly PointerCaptureLostEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly PointerCapturesProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PointerEnteredEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly PointerExitedEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly PointerMovedEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly PointerPressedEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly PointerReleasedEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly PointerWheelChangedEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly PreviewKeyDownEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly PreviewKeyUpEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly ProjectionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RenderTransformOriginProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RenderTransformProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RightTappedEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly ShadowProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TabFocusNavigationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TabIndexProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TappedEvent: Microsoft.UI.Xaml.RoutedEvent;
+      static readonly Transform3DProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TransitionsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly UseLayoutRoundingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly UseSystemFocusVisualsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly XYFocusDownNavigationStrategyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly XYFocusDownProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly XYFocusKeyboardNavigationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly XYFocusLeftNavigationStrategyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly XYFocusLeftProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly XYFocusRightNavigationStrategyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly XYFocusRightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly XYFocusUpNavigationStrategyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly XYFocusUpProperty: Microsoft.UI.Xaml.DependencyProperty;
+      Measure(availableSize: Windows.Foundation.Size): void;
+      Arrange(finalRect: Windows.Foundation.Rect): void;
+      CapturePointer(result: Microsoft.UI.Xaml.Input.Pointer): boolean;
+      ReleasePointerCapture(value: Microsoft.UI.Xaml.Input.Pointer): void;
+      ReleasePointerCaptures(): void;
+      AddHandler(routedEvent: Microsoft.UI.Xaml.RoutedEvent, handler: any, handledEventsToo: boolean): void;
+      RemoveHandler(routedEvent: Microsoft.UI.Xaml.RoutedEvent, handler: any): void;
+      TransformToVisual(result: Microsoft.UI.Xaml.UIElement): Microsoft.UI.Xaml.Media.GeneralTransform;
+      InvalidateMeasure(): void;
+      InvalidateArrange(): void;
+      UpdateLayout(): void;
+      CancelDirectManipulations(): boolean;
+      StartDragAsync(operation: Microsoft.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.DataTransfer.DataPackageOperation>;
+      StartBringIntoView(): void;
+      StartBringIntoView(options: Microsoft.UI.Xaml.BringIntoViewOptions): void;
+      TryInvokeKeyboardAccelerator(args: Microsoft.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+      Focus(result: number): boolean;
+      StartAnimation(animation: Microsoft.UI.Composition.ICompositionAnimationBase): void;
+      StopAnimation(animation: Microsoft.UI.Composition.ICompositionAnimationBase): void;
+      PopulatePropertyInfo(propertyName: string, propertyInfo: Microsoft.UI.Composition.AnimationPropertyInfo): void;
+      GetVisualInternal(): Microsoft.UI.Composition.Visual;
+      static TryStartDirectManipulation(result: Microsoft.UI.Xaml.Input.Pointer): boolean;
+      static RegisterAsScrollPort(element: Microsoft.UI.Xaml.UIElement): void;
+    }
+    class FrameworkElement extends Microsoft.UI.Xaml.UIElement implements Microsoft.UI.Xaml.IFrameworkElement, Microsoft.UI.Xaml.IFrameworkElementProtected, Microsoft.UI.Xaml.IFrameworkElementOverrides {
+      ActualThemeChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.FrameworkElement, any> | null;
+      DataContextChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.FrameworkElement, Microsoft.UI.Xaml.DataContextChangedEventArgs> | null;
+      EffectiveViewportChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.FrameworkElement, Microsoft.UI.Xaml.EffectiveViewportChangedEventArgs> | null;
+      LayoutUpdated: System.EventHandler<any> | null;
+      Loaded: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      Loading: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.FrameworkElement, any> | null;
+      SizeChanged: Microsoft.UI.Xaml.SizeChangedEventHandler | null;
+      Unloaded: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      Width: number;
+      VerticalAlignment: number;
+      Tag: any;
+      Style: Microsoft.UI.Xaml.Style;
+      Resources: Microsoft.UI.Xaml.ResourceDictionary;
+      RequestedTheme: number;
+      Name: string;
+      MinWidth: number;
+      MinHeight: number;
+      MaxWidth: number;
+      MaxHeight: number;
+      Margin: Microsoft.UI.Xaml.Thickness;
+      Language: string;
+      HorizontalAlignment: number;
+      Height: number;
+      FocusVisualSecondaryThickness: Microsoft.UI.Xaml.Thickness;
+      FocusVisualSecondaryBrush: Microsoft.UI.Xaml.Media.Brush;
+      FocusVisualPrimaryThickness: Microsoft.UI.Xaml.Thickness;
+      FocusVisualPrimaryBrush: Microsoft.UI.Xaml.Media.Brush;
+      FocusVisualMargin: Microsoft.UI.Xaml.Thickness;
+      FlowDirection: number;
+      DataContext: any;
+      AllowFocusWhenDisabled: boolean;
+      AllowFocusOnInteraction: boolean;
+      readonly ActualHeight: number;
+      readonly ActualTheme: number;
+      readonly ActualWidth: number;
+      readonly BaseUri: System.Uri;
+      readonly IsLoaded: boolean;
+      readonly Parent: Microsoft.UI.Xaml.DependencyObject;
+      readonly Triggers: Microsoft.UI.Xaml.TriggerCollection;
+      static readonly ActualHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ActualThemeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ActualWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AllowFocusOnInteractionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AllowFocusWhenDisabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DataContextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FlowDirectionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FocusVisualMarginProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FocusVisualPrimaryBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FocusVisualPrimaryThicknessProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FocusVisualSecondaryBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FocusVisualSecondaryThicknessProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LanguageProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MarginProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly NameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RequestedThemeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TagProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly WidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      FindName(result: string): any;
+      SetBinding(dp: Microsoft.UI.Xaml.DependencyProperty, binding: Microsoft.UI.Xaml.Data.BindingBase): void;
+      GetBindingExpression(result: Microsoft.UI.Xaml.DependencyProperty): Microsoft.UI.Xaml.Data.BindingExpression;
+      static DeferTree(element: Microsoft.UI.Xaml.DependencyObject): void;
+    }
+    class FrameworkTemplate extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.IFrameworkTemplate {
+    }
+    class CornerRadius extends System.ValueType {
+      TopLeft: number;
+      TopRight: number;
+      BottomRight: number;
+      BottomLeft: number;
+    }
+    class CornerRadiusHelper implements Microsoft.UI.Xaml.ICornerRadiusHelper {
+      static FromRadii(result: number, topLeft: number, topRight: number, bottomRight: number): Microsoft.UI.Xaml.CornerRadius;
+      static FromUniformRadius(result: number): Microsoft.UI.Xaml.CornerRadius;
+    }
+    class CreateDefaultValueCallback {
+      constructor(handler: () => any);
+      Invoke(): any;
+    }
+    class DataContextChangedEventArgs implements Microsoft.UI.Xaml.IDataContextChangedEventArgs {
+      Handled: boolean;
+      readonly NewValue: any;
+    }
+    class DataTemplate extends Microsoft.UI.Xaml.FrameworkTemplate implements Microsoft.UI.Xaml.IDataTemplate, Microsoft.UI.Xaml.IElementFactory {
+      static readonly ExtensionInstanceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      LoadContent(): Microsoft.UI.Xaml.DependencyObject;
+      GetElement(result: Microsoft.UI.Xaml.ElementFactoryGetArgs): Microsoft.UI.Xaml.UIElement;
+      RecycleElement(args: Microsoft.UI.Xaml.ElementFactoryRecycleArgs): void;
+      static GetExtensionInstance(result: Microsoft.UI.Xaml.FrameworkElement): Microsoft.UI.Xaml.IDataTemplateExtension;
+      static SetExtensionInstance(element: Microsoft.UI.Xaml.FrameworkElement, value: Microsoft.UI.Xaml.IDataTemplateExtension): void;
+    }
+    class DataTemplateKey implements Microsoft.UI.Xaml.IDataTemplateKey {
+      DataType: any;
+      constructor();
+      constructor(dataType: any);
+    }
+    class DebugSettings implements Microsoft.UI.Xaml.IDebugSettings, Microsoft.UI.Xaml.IDebugSettings2, Microsoft.UI.Xaml.IDebugSettings3 {
+      BindingFailed: Microsoft.UI.Xaml.BindingFailedEventHandler | null;
+      XamlResourceReferenceFailed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.DebugSettings, Microsoft.UI.Xaml.XamlResourceReferenceFailedEventArgs> | null;
+      IsTextPerformanceVisualizationEnabled: boolean;
+      IsBindingTracingEnabled: boolean;
+      FailFastOnErrors: boolean;
+      EnableFrameRateCounter: boolean;
+      IsXamlResourceReferenceTracingEnabled: boolean;
+      LayoutCycleTracingLevel: number;
+      LayoutCycleDebugBreakLevel: number;
+    }
+    class DependencyObjectCollection extends Microsoft.UI.Xaml.DependencyObject implements Windows.Foundation.Collections.IObservableVector<Microsoft.UI.Xaml.DependencyObject> {
+      VectorChanged: Windows.Foundation.Collections.VectorChangedEventHandler<Microsoft.UI.Xaml.DependencyObject> | null;
+      constructor();
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class DependencyProperty implements Microsoft.UI.Xaml.IDependencyProperty {
+      static readonly UnsetValue: any;
+      GetMetadata(result: System.Type): Microsoft.UI.Xaml.PropertyMetadata;
+      static Register(result: string, name: System.Type, propertyType: System.Type, ownerType: Microsoft.UI.Xaml.PropertyMetadata): Microsoft.UI.Xaml.DependencyProperty;
+      static RegisterAttached(result: string, name: System.Type, propertyType: System.Type, ownerType: Microsoft.UI.Xaml.PropertyMetadata): Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class DependencyPropertyChangedCallback {
+      constructor(handler: (sender: Microsoft.UI.Xaml.DependencyObject, dp: Microsoft.UI.Xaml.DependencyProperty) => void);
+      Invoke(sender: Microsoft.UI.Xaml.DependencyObject, dp: Microsoft.UI.Xaml.DependencyProperty): void;
+    }
+    class DependencyPropertyChangedEventArgs implements Microsoft.UI.Xaml.IDependencyPropertyChangedEventArgs {
+      readonly NewValue: any;
+      readonly OldValue: any;
+      readonly Property: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class DependencyPropertyChangedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.DependencyPropertyChangedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.DependencyPropertyChangedEventArgs): void;
+    }
+    class DispatcherShutdownMode extends System.Enum {
+      value__: number;
+      static OnLastWindowClose: number;
+      static OnExplicitShutdown: number;
+    }
+    class DispatcherTimer implements Microsoft.UI.Xaml.IDispatcherTimer {
+      Tick: System.EventHandler<any> | null;
+      Interval: System.TimeSpan;
+      readonly IsEnabled: boolean;
+      constructor();
+      Start(): void;
+      Stop(): void;
+    }
+    class DragEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.IDragEventArgs {
+      Handled: boolean;
+      Data: Windows.ApplicationModel.DataTransfer.DataPackage;
+      AcceptedOperation: Windows.ApplicationModel.DataTransfer.DataPackageOperation;
+      readonly AllowedOperations: Windows.ApplicationModel.DataTransfer.DataPackageOperation;
+      readonly DataView: Windows.ApplicationModel.DataTransfer.DataPackageView;
+      readonly DragUIOverride: Microsoft.UI.Xaml.DragUIOverride;
+      readonly Modifiers: Windows.ApplicationModel.DataTransfer.DragDrop.DragDropModifiers;
+      GetDeferral(): Microsoft.UI.Xaml.DragOperationDeferral;
+      GetPosition(result: Microsoft.UI.Xaml.UIElement): Windows.Foundation.Point;
+    }
+    class DragEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.DragEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.DragEventArgs): void;
+    }
+    class DragOperationDeferral implements Microsoft.UI.Xaml.IDragOperationDeferral {
+      Complete(): void;
+    }
+    class DragStartingEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.IDragStartingEventArgs {
+      Cancel: boolean;
+      AllowedOperations: Windows.ApplicationModel.DataTransfer.DataPackageOperation;
+      readonly Data: Windows.ApplicationModel.DataTransfer.DataPackage;
+      readonly DragUI: Microsoft.UI.Xaml.DragUI;
+      GetDeferral(): Microsoft.UI.Xaml.DragOperationDeferral;
+      GetPosition(result: Microsoft.UI.Xaml.UIElement): Windows.Foundation.Point;
+    }
+    class DragUI implements Microsoft.UI.Xaml.IDragUI {
+      SetContentFromBitmapImage(bitmapImage: Microsoft.UI.Xaml.Media.Imaging.BitmapImage): void;
+      SetContentFromBitmapImage(bitmapImage: Microsoft.UI.Xaml.Media.Imaging.BitmapImage, anchorPoint: Windows.Foundation.Point): void;
+      SetContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap): void;
+      SetContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap, anchorPoint: Windows.Foundation.Point): void;
+      SetContentFromDataPackage(): void;
+    }
+    class DragUIOverride implements Microsoft.UI.Xaml.IDragUIOverride {
+      IsGlyphVisible: boolean;
+      IsContentVisible: boolean;
+      IsCaptionVisible: boolean;
+      Caption: string;
+      Clear(): void;
+      SetContentFromBitmapImage(bitmapImage: Microsoft.UI.Xaml.Media.Imaging.BitmapImage): void;
+      SetContentFromBitmapImage(bitmapImage: Microsoft.UI.Xaml.Media.Imaging.BitmapImage, anchorPoint: Windows.Foundation.Point): void;
+      SetContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap): void;
+      SetContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap, anchorPoint: Windows.Foundation.Point): void;
+    }
+    class DropCompletedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.IDropCompletedEventArgs {
+      readonly DropResult: Windows.ApplicationModel.DataTransfer.DataPackageOperation;
+    }
+    class Duration extends System.ValueType {
+      TimeSpan: System.TimeSpan;
+      Type: number;
+    }
+    class DurationHelper implements Microsoft.UI.Xaml.IDurationHelper {
+      static readonly Automatic: Microsoft.UI.Xaml.Duration;
+      static readonly Forever: Microsoft.UI.Xaml.Duration;
+      static Compare(result: Microsoft.UI.Xaml.Duration, duration1: Microsoft.UI.Xaml.Duration): number;
+      static FromTimeSpan(result: System.TimeSpan): Microsoft.UI.Xaml.Duration;
+      static GetHasTimeSpan(result: Microsoft.UI.Xaml.Duration): boolean;
+      static Add(result: Microsoft.UI.Xaml.Duration, target: Microsoft.UI.Xaml.Duration): Microsoft.UI.Xaml.Duration;
+      static Equals(result: Microsoft.UI.Xaml.Duration, target: Microsoft.UI.Xaml.Duration): boolean;
+      static Subtract(result: Microsoft.UI.Xaml.Duration, target: Microsoft.UI.Xaml.Duration): Microsoft.UI.Xaml.Duration;
+    }
+    class DurationType extends System.Enum {
+      value__: number;
+      static Automatic: number;
+      static TimeSpan: number;
+      static Forever: number;
+    }
+    class EffectiveViewportChangedEventArgs implements Microsoft.UI.Xaml.IEffectiveViewportChangedEventArgs {
+      readonly BringIntoViewDistanceX: number;
+      readonly BringIntoViewDistanceY: number;
+      readonly EffectiveViewport: Windows.Foundation.Rect;
+      readonly MaxViewport: Windows.Foundation.Rect;
+    }
+    class ElementFactoryGetArgs implements Microsoft.UI.Xaml.IElementFactoryGetArgs {
+      Parent: Microsoft.UI.Xaml.UIElement;
+      Data: any;
+      constructor();
+    }
+    class ElementFactoryRecycleArgs implements Microsoft.UI.Xaml.IElementFactoryRecycleArgs {
+      Parent: Microsoft.UI.Xaml.UIElement;
+      Element: Microsoft.UI.Xaml.UIElement;
+      constructor();
+    }
+    class ElementHighContrastAdjustment extends System.Enum {
+      value__: number;
+      static None: number;
+      static Application: number;
+      static Auto: number;
+    }
+    class ElementSoundKind extends System.Enum {
+      value__: number;
+      static Focus: number;
+      static Invoke: number;
+      static Show: number;
+      static Hide: number;
+      static MovePrevious: number;
+      static MoveNext: number;
+      static GoBack: number;
+    }
+    class ElementSoundMode extends System.Enum {
+      value__: number;
+      static Default: number;
+      static FocusOnly: number;
+      static Off: number;
+    }
+    class ElementSoundPlayer implements Microsoft.UI.Xaml.IElementSoundPlayer {
+      static Volume: number;
+      static State: number;
+      static SpatialAudioMode: number;
+      static Play(sound: number): void;
+    }
+    class ElementSoundPlayerState extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Off: number;
+      static On: number;
+    }
+    class ElementSpatialAudioMode extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Off: number;
+      static On: number;
+    }
+    class ElementTheme extends System.Enum {
+      value__: number;
+      static Default: number;
+      static Light: number;
+      static Dark: number;
+    }
+    class EnteredBackgroundEventHandler {
+      constructor(handler: (sender: any, e: Windows.ApplicationModel.EnteredBackgroundEventArgs) => void);
+      Invoke(sender: any, e: Windows.ApplicationModel.EnteredBackgroundEventArgs): void;
+    }
+    class TriggerBase extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.ITriggerBase {
+    }
+    class EventTrigger extends Microsoft.UI.Xaml.TriggerBase implements Microsoft.UI.Xaml.IEventTrigger {
+      RoutedEvent: Microsoft.UI.Xaml.RoutedEvent;
+      readonly Actions: Microsoft.UI.Xaml.TriggerActionCollection;
+      constructor();
+    }
+    class ExceptionRoutedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.IExceptionRoutedEventArgs {
+      readonly ErrorMessage: string;
+    }
+    class ExceptionRoutedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.ExceptionRoutedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.ExceptionRoutedEventArgs): void;
+    }
+    class FlowDirection extends System.Enum {
+      value__: number;
+      static LeftToRight: number;
+      static RightToLeft: number;
+    }
+    class FocusState extends System.Enum {
+      value__: number;
+      static Unfocused: number;
+      static Pointer: number;
+      static Keyboard: number;
+      static Programmatic: number;
+    }
+    class FocusVisualKind extends System.Enum {
+      value__: number;
+      static DottedLine: number;
+      static HighVisibility: number;
+      static Reveal: number;
+    }
+    class FontCapitals extends System.Enum {
+      value__: number;
+      static Normal: number;
+      static AllSmallCaps: number;
+      static SmallCaps: number;
+      static AllPetiteCaps: number;
+      static PetiteCaps: number;
+      static Unicase: number;
+      static Titling: number;
+    }
+    class FontEastAsianLanguage extends System.Enum {
+      value__: number;
+      static Normal: number;
+      static HojoKanji: number;
+      static Jis04: number;
+      static Jis78: number;
+      static Jis83: number;
+      static Jis90: number;
+      static NlcKanji: number;
+      static Simplified: number;
+      static Traditional: number;
+      static TraditionalNames: number;
+    }
+    class FontEastAsianWidths extends System.Enum {
+      value__: number;
+      static Normal: number;
+      static Full: number;
+      static Half: number;
+      static Proportional: number;
+      static Quarter: number;
+      static Third: number;
+    }
+    class FontFraction extends System.Enum {
+      value__: number;
+      static Normal: number;
+      static Stacked: number;
+      static Slashed: number;
+    }
+    class FontNumeralAlignment extends System.Enum {
+      value__: number;
+      static Normal: number;
+      static Proportional: number;
+      static Tabular: number;
+    }
+    class FontNumeralStyle extends System.Enum {
+      value__: number;
+      static Normal: number;
+      static Lining: number;
+      static OldStyle: number;
+    }
+    class FontVariants extends System.Enum {
+      value__: number;
+      static Normal: number;
+      static Superscript: number;
+      static Subscript: number;
+      static Ordinal: number;
+      static Inferior: number;
+      static Ruby: number;
+    }
+    class FrameworkView implements Microsoft.UI.Xaml.IFrameworkView, Windows.ApplicationModel.Core.IFrameworkView {
+      constructor();
+      Initialize(applicationView: Windows.ApplicationModel.Core.CoreApplicationView): void;
+      SetWindow(window: Windows.UI.Core.CoreWindow): void;
+      Load(entryPoint: string): void;
+      Run(): void;
+      Uninitialize(): void;
+    }
+    class FrameworkViewSource implements Microsoft.UI.Xaml.IFrameworkViewSource, Windows.ApplicationModel.Core.IFrameworkViewSource {
+      constructor();
+      CreateView(): Windows.ApplicationModel.Core.IFrameworkView;
+    }
+    class GridLength extends System.ValueType {
+      Value: number;
+      GridUnitType: number;
+    }
+    class GridLengthHelper implements Microsoft.UI.Xaml.IGridLengthHelper {
+      static readonly Auto: Microsoft.UI.Xaml.GridLength;
+      static FromPixels(result: number): Microsoft.UI.Xaml.GridLength;
+      static FromValueAndType(result: number, value: number): Microsoft.UI.Xaml.GridLength;
+      static GetIsAbsolute(result: Microsoft.UI.Xaml.GridLength): boolean;
+      static GetIsAuto(result: Microsoft.UI.Xaml.GridLength): boolean;
+      static GetIsStar(result: Microsoft.UI.Xaml.GridLength): boolean;
+      static Equals(result: Microsoft.UI.Xaml.GridLength, target: Microsoft.UI.Xaml.GridLength): boolean;
+    }
+    class GridUnitType extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Pixel: number;
+      static Star: number;
+    }
+    class HorizontalAlignment extends System.Enum {
+      value__: number;
+      static Left: number;
+      static Center: number;
+      static Right: number;
+      static Stretch: number;
+    }
+    interface IDataTemplateExtension {
+      ResetTemplate(): void;
+      ProcessBinding(result: number): boolean;
+      ProcessBindings(result: Microsoft.UI.Xaml.Controls.ContainerContentChangingEventArgs): number;
+    }
+    interface IElementFactory {
+      GetElement(result: Microsoft.UI.Xaml.ElementFactoryGetArgs): Microsoft.UI.Xaml.UIElement;
+      RecycleElement(args: Microsoft.UI.Xaml.ElementFactoryRecycleArgs): void;
+    }
+    interface IXamlServiceProvider {
+      GetService(result: System.Type): any;
+    }
+    class LaunchActivatedEventArgs implements Microsoft.UI.Xaml.ILaunchActivatedEventArgs {
+      readonly Arguments: string;
+      readonly UWPLaunchActivatedEventArgs: Windows.ApplicationModel.Activation.LaunchActivatedEventArgs;
+    }
+    class LayoutCycleDebugBreakLevel extends System.Enum {
+      value__: number;
+      static None: number;
+      static Low: number;
+      static High: number;
+    }
+    class LayoutCycleTracingLevel extends System.Enum {
+      value__: number;
+      static None: number;
+      static Low: number;
+      static High: number;
+    }
+    class LeavingBackgroundEventHandler {
+      constructor(handler: (sender: any, e: Windows.ApplicationModel.LeavingBackgroundEventArgs) => void);
+      Invoke(sender: any, e: Windows.ApplicationModel.LeavingBackgroundEventArgs): void;
+    }
+    class LineStackingStrategy extends System.Enum {
+      value__: number;
+      static MaxHeight: number;
+      static BlockLineHeight: number;
+      static BaselineToBaseline: number;
+    }
+    class TriggerAction extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.ITriggerAction {
+    }
+    class MediaFailedRoutedEventArgs extends Microsoft.UI.Xaml.ExceptionRoutedEventArgs implements Microsoft.UI.Xaml.IMediaFailedRoutedEventArgs {
+      readonly ErrorTrace: string;
+    }
+    class OpticalMarginAlignment extends System.Enum {
+      value__: number;
+      static None: number;
+      static TrimSideBearings: number;
+    }
+    class PointHelper implements Microsoft.UI.Xaml.IPointHelper {
+      static FromCoordinates(result: number, x: number): Windows.Foundation.Point;
+    }
+    class PropertyChangedCallback {
+      constructor(handler: (d: Microsoft.UI.Xaml.DependencyObject, e: Microsoft.UI.Xaml.DependencyPropertyChangedEventArgs) => void);
+      Invoke(d: Microsoft.UI.Xaml.DependencyObject, e: Microsoft.UI.Xaml.DependencyPropertyChangedEventArgs): void;
+    }
+    class PropertyMetadata implements Microsoft.UI.Xaml.IPropertyMetadata {
+      readonly CreateDefaultValueCallback: Microsoft.UI.Xaml.CreateDefaultValueCallback;
+      readonly DefaultValue: any;
+      constructor(defaultValue: any);
+      constructor(defaultValue: any, propertyChangedCallback: Microsoft.UI.Xaml.PropertyChangedCallback);
+      static Create(result: any): Microsoft.UI.Xaml.PropertyMetadata;
+      static Create(result: any, defaultValue: Microsoft.UI.Xaml.PropertyChangedCallback): Microsoft.UI.Xaml.PropertyMetadata;
+      static Create(result: Microsoft.UI.Xaml.CreateDefaultValueCallback): Microsoft.UI.Xaml.PropertyMetadata;
+      static Create(result: Microsoft.UI.Xaml.CreateDefaultValueCallback, createDefaultValueCallback: Microsoft.UI.Xaml.PropertyChangedCallback): Microsoft.UI.Xaml.PropertyMetadata;
+    }
+    class PropertyPath extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.IPropertyPath {
+      readonly Path: string;
+      constructor(path: string);
+    }
+    class RectHelper implements Microsoft.UI.Xaml.IRectHelper {
+      static readonly Empty: Windows.Foundation.Rect;
+      static FromCoordinatesAndDimensions(result: number, x: number, y: number, width: number): Windows.Foundation.Rect;
+      static FromPoints(result: Windows.Foundation.Point, point1: Windows.Foundation.Point): Windows.Foundation.Rect;
+      static FromLocationAndSize(result: Windows.Foundation.Point, location: Windows.Foundation.Size): Windows.Foundation.Rect;
+      static GetIsEmpty(result: Windows.Foundation.Rect): boolean;
+      static GetBottom(result: Windows.Foundation.Rect): number;
+      static GetLeft(result: Windows.Foundation.Rect): number;
+      static GetRight(result: Windows.Foundation.Rect): number;
+      static GetTop(result: Windows.Foundation.Rect): number;
+      static Contains(result: Windows.Foundation.Rect, target: Windows.Foundation.Point): boolean;
+      static Equals(result: Windows.Foundation.Rect, target: Windows.Foundation.Rect): boolean;
+      static Intersect(result: Windows.Foundation.Rect, target: Windows.Foundation.Rect): Windows.Foundation.Rect;
+      static Union(result: Windows.Foundation.Rect, target: Windows.Foundation.Point): Windows.Foundation.Rect;
+      static Union(result: Windows.Foundation.Rect, target: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    }
+    class ResourceManagerRequestedEventArgs implements Microsoft.UI.Xaml.IResourceManagerRequestedEventArgs {
+      CustomResourceManager: Microsoft.Windows.ApplicationModel.Resources.IResourceManager;
+    }
+    class RoutedEvent implements Microsoft.UI.Xaml.IRoutedEvent {
+    }
+    class RoutedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.RoutedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.RoutedEventArgs): void;
+    }
+    class ScalarTransition implements Microsoft.UI.Xaml.IScalarTransition {
+      Duration: System.TimeSpan;
+      constructor();
+    }
+    class SetterBase extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.ISetterBase {
+      readonly IsSealed: boolean;
+    }
+    class Setter extends Microsoft.UI.Xaml.SetterBase implements Microsoft.UI.Xaml.ISetter {
+      Value: any;
+      Target: Microsoft.UI.Xaml.TargetPropertyPath;
+      Property: Microsoft.UI.Xaml.DependencyProperty;
+      constructor(targetProperty: Microsoft.UI.Xaml.DependencyProperty, value: any);
+      constructor();
+    }
+    class SetterBaseCollection implements Microsoft.UI.Xaml.ISetterBaseCollection {
+      readonly IsSealed: boolean;
+      constructor();
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class SizeChangedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.ISizeChangedEventArgs {
+      readonly NewSize: Windows.Foundation.Size;
+      readonly PreviousSize: Windows.Foundation.Size;
+    }
+    class SizeChangedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.SizeChangedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.SizeChangedEventArgs): void;
+    }
+    class SizeHelper implements Microsoft.UI.Xaml.ISizeHelper {
+      static readonly Empty: Windows.Foundation.Size;
+      static FromDimensions(result: number, width: number): Windows.Foundation.Size;
+      static GetIsEmpty(result: Windows.Foundation.Size): boolean;
+      static Equals(result: Windows.Foundation.Size, target: Windows.Foundation.Size): boolean;
+    }
+    class StateTrigger extends Microsoft.UI.Xaml.StateTriggerBase implements Microsoft.UI.Xaml.IStateTrigger {
+      IsActive: boolean;
+      static readonly IsActiveProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class Style extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.IStyle {
+      TargetType: System.Type;
+      BasedOn: Microsoft.UI.Xaml.Style;
+      readonly IsSealed: boolean;
+      readonly Setters: Microsoft.UI.Xaml.SetterBaseCollection;
+      constructor(targetType: System.Type);
+      constructor();
+      Seal(): void;
+    }
+    class StyleTypedPropertyAttribute extends System.Attribute {
+      Property: string;
+      StyleTargetType: System.Type;
+      constructor();
+    }
+    class SuspendingEventHandler {
+      constructor(handler: (sender: any, e: Windows.ApplicationModel.SuspendingEventArgs) => void);
+      Invoke(sender: any, e: Windows.ApplicationModel.SuspendingEventArgs): void;
+    }
+    class TargetPropertyPath implements Microsoft.UI.Xaml.ITargetPropertyPath {
+      Target: any;
+      Path: Microsoft.UI.Xaml.PropertyPath;
+      constructor(targetProperty: Microsoft.UI.Xaml.DependencyProperty);
+      constructor();
+    }
+    class TemplatePartAttribute extends System.Attribute {
+      Name: string;
+      Type: System.Type;
+      constructor();
+    }
+    class TemplateVisualStateAttribute extends System.Attribute {
+      Name: string;
+      GroupName: string;
+      constructor();
+    }
+    class TextAlignment extends System.Enum {
+      value__: number;
+      static Center: number;
+      static Left: number;
+      static Start: number;
+      static Right: number;
+      static End: number;
+      static Justify: number;
+      static DetectFromContent: number;
+    }
+    class TextLineBounds extends System.Enum {
+      value__: number;
+      static Full: number;
+      static TrimToCapHeight: number;
+      static TrimToBaseline: number;
+      static Tight: number;
+    }
+    class TextReadingOrder extends System.Enum {
+      value__: number;
+      static Default: number;
+      static UseFlowDirection: number;
+      static DetectFromContent: number;
+    }
+    class TextTrimming extends System.Enum {
+      value__: number;
+      static None: number;
+      static CharacterEllipsis: number;
+      static WordEllipsis: number;
+      static Clip: number;
+    }
+    class TextWrapping extends System.Enum {
+      value__: number;
+      static NoWrap: number;
+      static Wrap: number;
+      static WrapWholeWords: number;
+    }
+    class Thickness extends System.ValueType {
+      Left: number;
+      Top: number;
+      Right: number;
+      Bottom: number;
+    }
+    class ThicknessHelper implements Microsoft.UI.Xaml.IThicknessHelper {
+      static FromLengths(result: number, left: number, top: number, right: number): Microsoft.UI.Xaml.Thickness;
+      static FromUniformLength(result: number): Microsoft.UI.Xaml.Thickness;
+    }
+    class TriggerActionCollection {
+      constructor();
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class TriggerCollection {
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class UIElementWeakCollection {
+      constructor();
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class UnhandledExceptionEventArgs implements Microsoft.UI.Xaml.IUnhandledExceptionEventArgs {
+      Handled: boolean;
+      readonly Exception: System.Exception;
+      readonly Message: string;
+    }
+    class UnhandledExceptionEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.UnhandledExceptionEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.UnhandledExceptionEventArgs): void;
+    }
+    class Vector3Transition implements Microsoft.UI.Xaml.IVector3Transition {
+      Duration: System.TimeSpan;
+      Components: number;
+      constructor();
+    }
+    class Vector3TransitionComponents extends System.Enum {
+      value__: number;
+      static X: number;
+      static Y: number;
+      static Z: number;
+    }
+    class VerticalAlignment extends System.Enum {
+      value__: number;
+      static Top: number;
+      static Center: number;
+      static Bottom: number;
+      static Stretch: number;
+    }
+    class Visibility extends System.Enum {
+      value__: number;
+      static Visible: number;
+      static Collapsed: number;
+    }
+    class VisualState extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.IVisualState {
+      Storyboard: Microsoft.UI.Xaml.Media.Animation.Storyboard;
+      readonly Name: string;
+      readonly Setters: Microsoft.UI.Xaml.SetterBaseCollection;
+      readonly StateTriggers: System.Collections.Generic.IList<Microsoft.UI.Xaml.StateTriggerBase>;
+      constructor();
+    }
+    class VisualStateChangedEventArgs implements Microsoft.UI.Xaml.IVisualStateChangedEventArgs {
+      OldState: Microsoft.UI.Xaml.VisualState;
+      NewState: Microsoft.UI.Xaml.VisualState;
+      Control: Microsoft.UI.Xaml.Controls.Control;
+      constructor();
+    }
+    class VisualStateChangedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.VisualStateChangedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.VisualStateChangedEventArgs): void;
+    }
+    class VisualStateGroup extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.IVisualStateGroup {
+      CurrentStateChanged: Microsoft.UI.Xaml.VisualStateChangedEventHandler | null;
+      CurrentStateChanging: Microsoft.UI.Xaml.VisualStateChangedEventHandler | null;
+      readonly CurrentState: Microsoft.UI.Xaml.VisualState;
+      readonly Name: string;
+      readonly States: System.Collections.Generic.IList<Microsoft.UI.Xaml.VisualState>;
+      readonly Transitions: System.Collections.Generic.IList<Microsoft.UI.Xaml.VisualTransition>;
+      constructor();
+    }
+    class VisualStateManager extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.IVisualStateManager, Microsoft.UI.Xaml.IVisualStateManagerProtected, Microsoft.UI.Xaml.IVisualStateManagerOverrides {
+      static readonly CustomVisualStateManagerProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      static GetVisualStateGroups(result: Microsoft.UI.Xaml.FrameworkElement): System.Collections.Generic.IList<Microsoft.UI.Xaml.VisualStateGroup>;
+      static GetCustomVisualStateManager(result: Microsoft.UI.Xaml.FrameworkElement): Microsoft.UI.Xaml.VisualStateManager;
+      static SetCustomVisualStateManager(obj: Microsoft.UI.Xaml.FrameworkElement, value: Microsoft.UI.Xaml.VisualStateManager): void;
+      static GoToState(result: Microsoft.UI.Xaml.Controls.Control, control: string, stateName: boolean): boolean;
+    }
+    class VisualTransition extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.IVisualTransition {
+      To: string;
+      Storyboard: Microsoft.UI.Xaml.Media.Animation.Storyboard;
+      GeneratedEasingFunction: Microsoft.UI.Xaml.Media.Animation.EasingFunctionBase;
+      GeneratedDuration: Microsoft.UI.Xaml.Duration;
+      From: string;
+      constructor();
+    }
+    class WinUIContract extends System.ValueType {
+    }
+    class Window implements Microsoft.UI.Xaml.IWindow, Microsoft.UI.Xaml.IWindow2 {
+      Activated: Windows.Foundation.TypedEventHandler<any, Microsoft.UI.Xaml.WindowActivatedEventArgs> | null;
+      Closed: Windows.Foundation.TypedEventHandler<any, Microsoft.UI.Xaml.WindowEventArgs> | null;
+      SizeChanged: Windows.Foundation.TypedEventHandler<any, Microsoft.UI.Xaml.WindowSizeChangedEventArgs> | null;
+      VisibilityChanged: Windows.Foundation.TypedEventHandler<any, Microsoft.UI.Xaml.WindowVisibilityChangedEventArgs> | null;
+      Title: string;
+      ExtendsContentIntoTitleBar: boolean;
+      Content: Microsoft.UI.Xaml.UIElement;
+      readonly Bounds: Windows.Foundation.Rect;
+      readonly Compositor: Microsoft.UI.Composition.Compositor;
+      readonly CoreWindow: Windows.UI.Core.CoreWindow;
+      readonly Dispatcher: Windows.UI.Core.CoreDispatcher;
+      readonly DispatcherQueue: Microsoft.UI.Dispatching.DispatcherQueue;
+      readonly Visible: boolean;
+      SystemBackdrop: Microsoft.UI.Xaml.Media.SystemBackdrop;
+      readonly AppWindow: Microsoft.UI.Windowing.AppWindow;
+      static readonly Current: Microsoft.UI.Xaml.Window;
+      constructor();
+      Activate(): void;
+      Close(): void;
+      SetTitleBar(titleBar: Microsoft.UI.Xaml.UIElement): void;
+    }
+    class WindowActivatedEventArgs implements Microsoft.UI.Xaml.IWindowActivatedEventArgs {
+      Handled: boolean;
+      readonly WindowActivationState: number;
+    }
+    class WindowActivationState extends System.Enum {
+      value__: number;
+      static CodeActivated: number;
+      static Deactivated: number;
+      static PointerActivated: number;
+    }
+    class WindowEventArgs implements Microsoft.UI.Xaml.IWindowEventArgs {
+      Handled: boolean;
+    }
+    class WindowSizeChangedEventArgs implements Microsoft.UI.Xaml.IWindowSizeChangedEventArgs {
+      Handled: boolean;
+      readonly Size: Windows.Foundation.Size;
+    }
+    class WindowVisibilityChangedEventArgs implements Microsoft.UI.Xaml.IWindowVisibilityChangedEventArgs {
+      Handled: boolean;
+      readonly Visible: boolean;
+    }
+    class XamlContract extends System.ValueType {
+    }
+    class XamlResourceReferenceFailedEventArgs implements Microsoft.UI.Xaml.IXamlResourceReferenceFailedEventArgs {
+      readonly Message: string;
+    }
+    class XamlRoot implements Microsoft.UI.Xaml.IXamlRoot, Microsoft.UI.Xaml.IXamlRoot2, Microsoft.UI.Xaml.IXamlRoot3 {
+      Changed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.XamlRoot, Microsoft.UI.Xaml.XamlRootChangedEventArgs> | null;
+      readonly Content: Microsoft.UI.Xaml.UIElement;
+      readonly IsHostVisible: boolean;
+      readonly RasterizationScale: number;
+      readonly Size: Windows.Foundation.Size;
+      readonly ContentIslandEnvironment: Microsoft.UI.Content.ContentIslandEnvironment;
+      readonly CoordinateConverter: Microsoft.UI.Content.ContentCoordinateConverter;
+    }
+    class XamlRootChangedEventArgs implements Microsoft.UI.Xaml.IXamlRootChangedEventArgs {
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Automation {
+    class AnnotationPatternIdentifiers implements Microsoft.UI.Xaml.Automation.IAnnotationPatternIdentifiers {
+      static readonly AnnotationTypeIdProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly AnnotationTypeNameProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly AuthorProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly DateTimeProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly TargetProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class AnnotationType extends System.Enum {
+      value__: number;
+      static Unknown: number;
+      static SpellingError: number;
+      static GrammarError: number;
+      static Comment: number;
+      static FormulaError: number;
+      static TrackChanges: number;
+      static Header: number;
+      static Footer: number;
+      static Highlighted: number;
+      static Endnote: number;
+      static Footnote: number;
+      static InsertionChange: number;
+      static DeletionChange: number;
+      static MoveChange: number;
+      static FormatChange: number;
+      static UnsyncedChange: number;
+      static EditingLockedChange: number;
+      static ExternalChange: number;
+      static ConflictingChange: number;
+      static Author: number;
+      static AdvancedProofingIssue: number;
+      static DataValidationError: number;
+      static CircularReferenceError: number;
+    }
+    class AutomationActiveEnd extends System.Enum {
+      value__: number;
+      static None: number;
+      static Start: number;
+      static End: number;
+    }
+    class AutomationAnimationStyle extends System.Enum {
+      value__: number;
+      static None: number;
+      static LasVegasLights: number;
+      static BlinkingBackground: number;
+      static SparkleText: number;
+      static MarchingBlackAnts: number;
+      static MarchingRedAnts: number;
+      static Shimmer: number;
+      static Other: number;
+    }
+    class AutomationAnnotation extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Automation.IAutomationAnnotation {
+      Type: number;
+      Element: Microsoft.UI.Xaml.UIElement;
+      static readonly ElementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TypeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor(type: number);
+      constructor(type: number, element: Microsoft.UI.Xaml.UIElement);
+      constructor();
+    }
+    class AutomationBulletStyle extends System.Enum {
+      value__: number;
+      static None: number;
+      static HollowRoundBullet: number;
+      static FilledRoundBullet: number;
+      static HollowSquareBullet: number;
+      static FilledSquareBullet: number;
+      static DashBullet: number;
+      static Other: number;
+    }
+    class AutomationCaretBidiMode extends System.Enum {
+      value__: number;
+      static LTR: number;
+      static RTL: number;
+    }
+    class AutomationCaretPosition extends System.Enum {
+      value__: number;
+      static Unknown: number;
+      static EndOfLine: number;
+      static BeginningOfLine: number;
+    }
+    class AutomationElementIdentifiers implements Microsoft.UI.Xaml.Automation.IAutomationElementIdentifiers {
+      static readonly AcceleratorKeyProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly AccessKeyProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly AnnotationsProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly AutomationIdProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly BoundingRectangleProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly ClassNameProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly ClickablePointProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly ControlTypeProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly ControlledPeersProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly CultureProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly DescribedByProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly FlowsFromProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly FlowsToProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly FullDescriptionProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly HasKeyboardFocusProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly HeadingLevelProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly HelpTextProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly IsContentElementProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly IsControlElementProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly IsDataValidForFormProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly IsDialogProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly IsEnabledProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly IsKeyboardFocusableProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly IsOffscreenProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly IsPasswordProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly IsPeripheralProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly IsRequiredForFormProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly ItemStatusProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly ItemTypeProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly LabeledByProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly LandmarkTypeProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly LevelProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly LiveSettingProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly LocalizedControlTypeProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly LocalizedLandmarkTypeProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly NameProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly OrientationProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly PositionInSetProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly SizeOfSetProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class AutomationFlowDirections extends System.Enum {
+      value__: number;
+      static Default: number;
+      static RightToLeft: number;
+      static BottomToTop: number;
+      static Vertical: number;
+    }
+    class AutomationOutlineStyles extends System.Enum {
+      value__: number;
+      static None: number;
+      static Outline: number;
+      static Shadow: number;
+      static Engraved: number;
+      static Embossed: number;
+    }
+    class AutomationProperties implements Microsoft.UI.Xaml.Automation.IAutomationProperties {
+      static readonly AcceleratorKeyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AccessKeyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AccessibilityViewProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AnnotationsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AutomationIdProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ControlledPeersProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CultureProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DescribedByProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FlowsFromProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FlowsToProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FullDescriptionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeadingLevelProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HelpTextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsDataValidForFormProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsDialogProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsPeripheralProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsRequiredForFormProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemStatusProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemTypeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LabeledByProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LandmarkTypeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LevelProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LiveSettingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LocalizedControlTypeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LocalizedLandmarkTypeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly NameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PositionInSetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SizeOfSetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AutomationControlTypeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static GetAutomationControlType(result: Microsoft.UI.Xaml.UIElement): number;
+      static SetAutomationControlType(element: Microsoft.UI.Xaml.UIElement, value: number): void;
+      static GetAcceleratorKey(result: Microsoft.UI.Xaml.DependencyObject): string;
+      static SetAcceleratorKey(element: Microsoft.UI.Xaml.DependencyObject, value: string): void;
+      static GetAccessKey(result: Microsoft.UI.Xaml.DependencyObject): string;
+      static SetAccessKey(element: Microsoft.UI.Xaml.DependencyObject, value: string): void;
+      static GetAutomationId(result: Microsoft.UI.Xaml.DependencyObject): string;
+      static SetAutomationId(element: Microsoft.UI.Xaml.DependencyObject, value: string): void;
+      static GetHelpText(result: Microsoft.UI.Xaml.DependencyObject): string;
+      static SetHelpText(element: Microsoft.UI.Xaml.DependencyObject, value: string): void;
+      static GetIsRequiredForForm(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetIsRequiredForForm(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetItemStatus(result: Microsoft.UI.Xaml.DependencyObject): string;
+      static SetItemStatus(element: Microsoft.UI.Xaml.DependencyObject, value: string): void;
+      static GetItemType(result: Microsoft.UI.Xaml.DependencyObject): string;
+      static SetItemType(element: Microsoft.UI.Xaml.DependencyObject, value: string): void;
+      static GetLabeledBy(result: Microsoft.UI.Xaml.DependencyObject): Microsoft.UI.Xaml.UIElement;
+      static SetLabeledBy(element: Microsoft.UI.Xaml.DependencyObject, value: Microsoft.UI.Xaml.UIElement): void;
+      static GetName(result: Microsoft.UI.Xaml.DependencyObject): string;
+      static SetName(element: Microsoft.UI.Xaml.DependencyObject, value: string): void;
+      static GetLiveSetting(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetLiveSetting(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetAccessibilityView(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetAccessibilityView(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetControlledPeers(result: Microsoft.UI.Xaml.DependencyObject): System.Collections.Generic.IList<Microsoft.UI.Xaml.UIElement>;
+      static GetPositionInSet(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetPositionInSet(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetSizeOfSet(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetSizeOfSet(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetLevel(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetLevel(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetAnnotations(result: Microsoft.UI.Xaml.DependencyObject): System.Collections.Generic.IList<Microsoft.UI.Xaml.Automation.AutomationAnnotation>;
+      static GetLandmarkType(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetLandmarkType(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetLocalizedLandmarkType(result: Microsoft.UI.Xaml.DependencyObject): string;
+      static SetLocalizedLandmarkType(element: Microsoft.UI.Xaml.DependencyObject, value: string): void;
+      static GetIsPeripheral(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetIsPeripheral(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetIsDataValidForForm(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetIsDataValidForForm(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetFullDescription(result: Microsoft.UI.Xaml.DependencyObject): string;
+      static SetFullDescription(element: Microsoft.UI.Xaml.DependencyObject, value: string): void;
+      static GetLocalizedControlType(result: Microsoft.UI.Xaml.DependencyObject): string;
+      static SetLocalizedControlType(element: Microsoft.UI.Xaml.DependencyObject, value: string): void;
+      static GetDescribedBy(result: Microsoft.UI.Xaml.DependencyObject): System.Collections.Generic.IList<Microsoft.UI.Xaml.DependencyObject>;
+      static GetFlowsTo(result: Microsoft.UI.Xaml.DependencyObject): System.Collections.Generic.IList<Microsoft.UI.Xaml.DependencyObject>;
+      static GetFlowsFrom(result: Microsoft.UI.Xaml.DependencyObject): System.Collections.Generic.IList<Microsoft.UI.Xaml.DependencyObject>;
+      static GetCulture(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetCulture(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetHeadingLevel(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetHeadingLevel(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetIsDialog(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetIsDialog(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+    }
+    class AutomationProperty implements Microsoft.UI.Xaml.Automation.IAutomationProperty {
+    }
+    class AutomationStyleId extends System.Enum {
+      value__: number;
+      static Heading1: number;
+      static Heading2: number;
+      static Heading3: number;
+      static Heading4: number;
+      static Heading5: number;
+      static Heading6: number;
+      static Heading7: number;
+      static Heading8: number;
+      static Heading9: number;
+      static Title: number;
+      static Subtitle: number;
+      static Normal: number;
+      static Emphasis: number;
+      static Quote: number;
+      static BulletedList: number;
+    }
+    class AutomationTextDecorationLineStyle extends System.Enum {
+      value__: number;
+      static None: number;
+      static Single: number;
+      static WordsOnly: number;
+      static Double: number;
+      static Dot: number;
+      static Dash: number;
+      static DashDot: number;
+      static DashDotDot: number;
+      static Wavy: number;
+      static ThickSingle: number;
+      static DoubleWavy: number;
+      static ThickWavy: number;
+      static LongDash: number;
+      static ThickDash: number;
+      static ThickDashDot: number;
+      static ThickDashDotDot: number;
+      static ThickDot: number;
+      static ThickLongDash: number;
+      static Other: number;
+    }
+    class AutomationTextEditChangeType extends System.Enum {
+      value__: number;
+      static None: number;
+      static AutoCorrect: number;
+      static Composition: number;
+      static CompositionFinalized: number;
+    }
+    class DockPatternIdentifiers implements Microsoft.UI.Xaml.Automation.IDockPatternIdentifiers {
+      static readonly DockPositionProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class DockPosition extends System.Enum {
+      value__: number;
+      static Top: number;
+      static Left: number;
+      static Bottom: number;
+      static Right: number;
+      static Fill: number;
+      static None: number;
+    }
+    class DragPatternIdentifiers implements Microsoft.UI.Xaml.Automation.IDragPatternIdentifiers {
+      static readonly DropEffectProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly DropEffectsProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly GrabbedItemsProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly IsGrabbedProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class DropTargetPatternIdentifiers implements Microsoft.UI.Xaml.Automation.IDropTargetPatternIdentifiers {
+      static readonly DropTargetEffectProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly DropTargetEffectsProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class ExpandCollapsePatternIdentifiers implements Microsoft.UI.Xaml.Automation.IExpandCollapsePatternIdentifiers {
+      static readonly ExpandCollapseStateProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class ExpandCollapseState extends System.Enum {
+      value__: number;
+      static Collapsed: number;
+      static Expanded: number;
+      static PartiallyExpanded: number;
+      static LeafNode: number;
+    }
+    class GridItemPatternIdentifiers implements Microsoft.UI.Xaml.Automation.IGridItemPatternIdentifiers {
+      static readonly ColumnProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly ColumnSpanProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly ContainingGridProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly RowProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly RowSpanProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class GridPatternIdentifiers implements Microsoft.UI.Xaml.Automation.IGridPatternIdentifiers {
+      static readonly ColumnCountProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly RowCountProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class MultipleViewPatternIdentifiers implements Microsoft.UI.Xaml.Automation.IMultipleViewPatternIdentifiers {
+      static readonly CurrentViewProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly SupportedViewsProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class RangeValuePatternIdentifiers implements Microsoft.UI.Xaml.Automation.IRangeValuePatternIdentifiers {
+      static readonly IsReadOnlyProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly LargeChangeProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly MaximumProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly MinimumProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly SmallChangeProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly ValueProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class RowOrColumnMajor extends System.Enum {
+      value__: number;
+      static RowMajor: number;
+      static ColumnMajor: number;
+      static Indeterminate: number;
+    }
+    class ScrollAmount extends System.Enum {
+      value__: number;
+      static LargeDecrement: number;
+      static SmallDecrement: number;
+      static NoAmount: number;
+      static LargeIncrement: number;
+      static SmallIncrement: number;
+    }
+    class ScrollPatternIdentifiers implements Microsoft.UI.Xaml.Automation.IScrollPatternIdentifiers {
+      static readonly HorizontalScrollPercentProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly HorizontalViewSizeProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly HorizontallyScrollableProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly NoScroll: number;
+      static readonly VerticalScrollPercentProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly VerticalViewSizeProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly VerticallyScrollableProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class SelectionItemPatternIdentifiers implements Microsoft.UI.Xaml.Automation.ISelectionItemPatternIdentifiers {
+      static readonly IsSelectedProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly SelectionContainerProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class SelectionPatternIdentifiers implements Microsoft.UI.Xaml.Automation.ISelectionPatternIdentifiers {
+      static readonly CanSelectMultipleProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly IsSelectionRequiredProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly SelectionProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class SpreadsheetItemPatternIdentifiers implements Microsoft.UI.Xaml.Automation.ISpreadsheetItemPatternIdentifiers {
+      static readonly FormulaProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class StylesPatternIdentifiers implements Microsoft.UI.Xaml.Automation.IStylesPatternIdentifiers {
+      static readonly ExtendedPropertiesProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly FillColorProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly FillPatternColorProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly FillPatternStyleProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly ShapeProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly StyleIdProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly StyleNameProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class SupportedTextSelection extends System.Enum {
+      value__: number;
+      static None: number;
+      static Single: number;
+      static Multiple: number;
+    }
+    class SynchronizedInputType extends System.Enum {
+      value__: number;
+      static KeyUp: number;
+      static KeyDown: number;
+      static LeftMouseUp: number;
+      static LeftMouseDown: number;
+      static RightMouseUp: number;
+      static RightMouseDown: number;
+    }
+    class TableItemPatternIdentifiers implements Microsoft.UI.Xaml.Automation.ITableItemPatternIdentifiers {
+      static readonly ColumnHeaderItemsProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly RowHeaderItemsProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class TablePatternIdentifiers implements Microsoft.UI.Xaml.Automation.ITablePatternIdentifiers {
+      static readonly ColumnHeadersProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly RowHeadersProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly RowOrColumnMajorProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class TogglePatternIdentifiers implements Microsoft.UI.Xaml.Automation.ITogglePatternIdentifiers {
+      static readonly ToggleStateProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class ToggleState extends System.Enum {
+      value__: number;
+      static Off: number;
+      static On: number;
+      static Indeterminate: number;
+    }
+    class TransformPattern2Identifiers implements Microsoft.UI.Xaml.Automation.ITransformPattern2Identifiers {
+      static readonly CanZoomProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly MaxZoomProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly MinZoomProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly ZoomLevelProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class TransformPatternIdentifiers implements Microsoft.UI.Xaml.Automation.ITransformPatternIdentifiers {
+      static readonly CanMoveProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly CanResizeProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly CanRotateProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class ValuePatternIdentifiers implements Microsoft.UI.Xaml.Automation.IValuePatternIdentifiers {
+      static readonly IsReadOnlyProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly ValueProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class WindowInteractionState extends System.Enum {
+      value__: number;
+      static Running: number;
+      static Closing: number;
+      static ReadyForUserInteraction: number;
+      static BlockedByModalWindow: number;
+      static NotResponding: number;
+    }
+    class WindowPatternIdentifiers implements Microsoft.UI.Xaml.Automation.IWindowPatternIdentifiers {
+      static readonly CanMaximizeProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly CanMinimizeProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly IsModalProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly IsTopmostProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly WindowInteractionStateProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+      static readonly WindowVisualStateProperty: Microsoft.UI.Xaml.Automation.AutomationProperty;
+    }
+    class WindowVisualState extends System.Enum {
+      value__: number;
+      static Normal: number;
+      static Maximized: number;
+      static Minimized: number;
+    }
+    class ZoomUnit extends System.Enum {
+      value__: number;
+      static NoAmount: number;
+      static LargeDecrement: number;
+      static SmallDecrement: number;
+      static LargeIncrement: number;
+      static SmallIncrement: number;
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Automation.Peers {
+    class AccessibilityView extends System.Enum {
+      value__: number;
+      static Raw: number;
+      static Control: number;
+      static Content: number;
+    }
+    class AutomationPeer extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Automation.Peers.IAutomationPeer, Microsoft.UI.Xaml.Automation.Peers.IAutomationPeerProtected, Microsoft.UI.Xaml.Automation.Peers.IAutomationPeerOverrides {
+      EventsSource: Microsoft.UI.Xaml.Automation.Peers.AutomationPeer;
+      GetPattern(result: number): any;
+      RaiseAutomationEvent(eventId: number): void;
+      RaisePropertyChangedEvent(automationProperty: Microsoft.UI.Xaml.Automation.AutomationProperty, oldValue: any, newValue: any): void;
+      GetAcceleratorKey(): string;
+      GetAccessKey(): string;
+      GetAutomationControlType(): number;
+      GetAutomationId(): string;
+      GetBoundingRectangle(): Windows.Foundation.Rect;
+      GetChildren(): System.Collections.Generic.IList<Microsoft.UI.Xaml.Automation.Peers.AutomationPeer>;
+      Navigate(result: number): any;
+      GetClassName(): string;
+      GetClickablePoint(): Windows.Foundation.Point;
+      GetHelpText(): string;
+      GetItemStatus(): string;
+      GetItemType(): string;
+      GetLabeledBy(): Microsoft.UI.Xaml.Automation.Peers.AutomationPeer;
+      GetLocalizedControlType(): string;
+      GetName(): string;
+      GetOrientation(): number;
+      HasKeyboardFocus(): boolean;
+      IsContentElement(): boolean;
+      IsControlElement(): boolean;
+      IsEnabled(): boolean;
+      IsKeyboardFocusable(): boolean;
+      IsOffscreen(): boolean;
+      IsPassword(): boolean;
+      IsRequiredForForm(): boolean;
+      SetFocus(): void;
+      GetParent(): Microsoft.UI.Xaml.Automation.Peers.AutomationPeer;
+      InvalidatePeer(): void;
+      GetPeerFromPoint(result: Windows.Foundation.Point): Microsoft.UI.Xaml.Automation.Peers.AutomationPeer;
+      GetElementFromPoint(result: Windows.Foundation.Point): any;
+      GetFocusedElement(): any;
+      GetLiveSetting(): number;
+      ShowContextMenu(): void;
+      GetControlledPeers(): System.Collections.Generic.IReadOnlyList<Microsoft.UI.Xaml.Automation.Peers.AutomationPeer>;
+      GetAnnotations(): System.Collections.Generic.IList<Microsoft.UI.Xaml.Automation.Peers.AutomationPeerAnnotation>;
+      SetParent(peer: Microsoft.UI.Xaml.Automation.Peers.AutomationPeer): void;
+      RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: System.Collections.Generic.IReadOnlyList<string>): void;
+      GetPositionInSet(): number;
+      GetSizeOfSet(): number;
+      GetLevel(): number;
+      RaiseStructureChangedEvent(structureChangeType: number, child: Microsoft.UI.Xaml.Automation.Peers.AutomationPeer): void;
+      GetLandmarkType(): number;
+      GetLocalizedLandmarkType(): string;
+      IsPeripheral(): boolean;
+      IsDataValidForForm(): boolean;
+      GetFullDescription(): string;
+      GetCulture(): number;
+      RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+      GetHeadingLevel(): number;
+      IsDialog(): boolean;
+      static ListenerExists(result: number): boolean;
+      static GenerateRawElementProviderRuntimeId(): Microsoft.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    }
+    class FrameworkElementAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.AutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IFrameworkElementAutomationPeer {
+      readonly Owner: Microsoft.UI.Xaml.UIElement;
+      constructor(owner: Microsoft.UI.Xaml.FrameworkElement);
+      static FromElement(result: Microsoft.UI.Xaml.UIElement): Microsoft.UI.Xaml.Automation.Peers.AutomationPeer;
+      static CreatePeerForElement(result: Microsoft.UI.Xaml.UIElement): Microsoft.UI.Xaml.Automation.Peers.AutomationPeer;
+    }
+    class AnimatedVisualPlayerAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IAnimatedVisualPlayerAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer);
+    }
+    class AppBarAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IAppBarAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IExpandCollapseProvider, Microsoft.UI.Xaml.Automation.Provider.IToggleProvider, Microsoft.UI.Xaml.Automation.Provider.IWindowProvider {
+      readonly ExpandCollapseState: number;
+      readonly ToggleState: number;
+      readonly InteractionState: number;
+      readonly IsModal: boolean;
+      readonly IsTopmost: boolean;
+      readonly Maximizable: boolean;
+      readonly Minimizable: boolean;
+      readonly VisualState: number;
+      constructor(owner: Microsoft.UI.Xaml.Controls.AppBar);
+      Collapse(): void;
+      Expand(): void;
+      Toggle(): void;
+      Close(): void;
+      SetVisualState(state: number): void;
+      WaitForInputIdle(result: number): boolean;
+    }
+    class ButtonBaseAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IButtonBaseAutomationPeer {
+    }
+    class ButtonAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ButtonBaseAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IButtonAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IInvokeProvider {
+      constructor(owner: Microsoft.UI.Xaml.Controls.Button);
+      Invoke(): void;
+    }
+    class AppBarButtonAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ButtonAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IAppBarButtonAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IExpandCollapseProvider {
+      readonly ExpandCollapseState: number;
+      constructor(owner: Microsoft.UI.Xaml.Controls.AppBarButton);
+      Collapse(): void;
+      Expand(): void;
+    }
+    class ToggleButtonAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ButtonBaseAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IToggleButtonAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IToggleProvider {
+      readonly ToggleState: number;
+      constructor(owner: Microsoft.UI.Xaml.Controls.Primitives.ToggleButton);
+      Toggle(): void;
+    }
+    class AppBarToggleButtonAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ToggleButtonAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IAppBarToggleButtonAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.AppBarToggleButton);
+    }
+    class AutoSuggestBoxAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IAutoSuggestBoxAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IInvokeProvider {
+      constructor(owner: Microsoft.UI.Xaml.Controls.AutoSuggestBox);
+      Invoke(): void;
+    }
+    class AutomationControlType extends System.Enum {
+      value__: number;
+      static Button: number;
+      static Calendar: number;
+      static CheckBox: number;
+      static ComboBox: number;
+      static Edit: number;
+      static Hyperlink: number;
+      static Image: number;
+      static ListItem: number;
+      static List: number;
+      static Menu: number;
+      static MenuBar: number;
+      static MenuItem: number;
+      static ProgressBar: number;
+      static RadioButton: number;
+      static ScrollBar: number;
+      static Slider: number;
+      static Spinner: number;
+      static StatusBar: number;
+      static Tab: number;
+      static TabItem: number;
+      static Text: number;
+      static ToolBar: number;
+      static ToolTip: number;
+      static Tree: number;
+      static TreeItem: number;
+      static Custom: number;
+      static Group: number;
+      static Thumb: number;
+      static DataGrid: number;
+      static DataItem: number;
+      static Document: number;
+      static SplitButton: number;
+      static Window: number;
+      static Pane: number;
+      static Header: number;
+      static HeaderItem: number;
+      static Table: number;
+      static TitleBar: number;
+      static Separator: number;
+      static SemanticZoom: number;
+      static AppBar: number;
+      static FlipView: number;
+    }
+    class AutomationEvents extends System.Enum {
+      value__: number;
+      static ToolTipOpened: number;
+      static ToolTipClosed: number;
+      static MenuOpened: number;
+      static MenuClosed: number;
+      static AutomationFocusChanged: number;
+      static InvokePatternOnInvoked: number;
+      static SelectionItemPatternOnElementAddedToSelection: number;
+      static SelectionItemPatternOnElementRemovedFromSelection: number;
+      static SelectionItemPatternOnElementSelected: number;
+      static SelectionPatternOnInvalidated: number;
+      static TextPatternOnTextSelectionChanged: number;
+      static TextPatternOnTextChanged: number;
+      static AsyncContentLoaded: number;
+      static PropertyChanged: number;
+      static StructureChanged: number;
+      static DragStart: number;
+      static DragCancel: number;
+      static DragComplete: number;
+      static DragEnter: number;
+      static DragLeave: number;
+      static Dropped: number;
+      static LiveRegionChanged: number;
+      static InputReachedTarget: number;
+      static InputReachedOtherElement: number;
+      static InputDiscarded: number;
+      static WindowClosed: number;
+      static WindowOpened: number;
+      static ConversionTargetChanged: number;
+      static TextEditTextChanged: number;
+      static LayoutInvalidated: number;
+    }
+    class AutomationHeadingLevel extends System.Enum {
+      value__: number;
+      static None: number;
+      static Level1: number;
+      static Level2: number;
+      static Level3: number;
+      static Level4: number;
+      static Level5: number;
+      static Level6: number;
+      static Level7: number;
+      static Level8: number;
+      static Level9: number;
+    }
+    class AutomationLandmarkType extends System.Enum {
+      value__: number;
+      static None: number;
+      static Custom: number;
+      static Form: number;
+      static Main: number;
+      static Navigation: number;
+      static Search: number;
+    }
+    class AutomationLiveSetting extends System.Enum {
+      value__: number;
+      static Off: number;
+      static Polite: number;
+      static Assertive: number;
+    }
+    class AutomationNavigationDirection extends System.Enum {
+      value__: number;
+      static Parent: number;
+      static NextSibling: number;
+      static PreviousSibling: number;
+      static FirstChild: number;
+      static LastChild: number;
+    }
+    class AutomationNotificationKind extends System.Enum {
+      value__: number;
+      static ItemAdded: number;
+      static ItemRemoved: number;
+      static ActionCompleted: number;
+      static ActionAborted: number;
+      static Other: number;
+    }
+    class AutomationNotificationProcessing extends System.Enum {
+      value__: number;
+      static ImportantAll: number;
+      static ImportantMostRecent: number;
+      static All: number;
+      static MostRecent: number;
+      static CurrentThenMostRecent: number;
+    }
+    class AutomationOrientation extends System.Enum {
+      value__: number;
+      static None: number;
+      static Horizontal: number;
+      static Vertical: number;
+    }
+    class AutomationPeerAnnotation extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation {
+      Type: number;
+      Peer: Microsoft.UI.Xaml.Automation.Peers.AutomationPeer;
+      static readonly PeerProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TypeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor(type: number);
+      constructor(type: number, peer: Microsoft.UI.Xaml.Automation.Peers.AutomationPeer);
+      constructor();
+    }
+    class AutomationStructureChangeType extends System.Enum {
+      value__: number;
+      static ChildAdded: number;
+      static ChildRemoved: number;
+      static ChildrenInvalidated: number;
+      static ChildrenBulkAdded: number;
+      static ChildrenBulkRemoved: number;
+      static ChildrenReordered: number;
+    }
+    class BreadcrumbBarItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IBreadcrumbBarItemAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IInvokeProvider {
+      constructor(owner: Microsoft.UI.Xaml.Controls.BreadcrumbBarItem);
+      Invoke(): void;
+    }
+    class CalendarDatePickerAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ICalendarDatePickerAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IInvokeProvider, Microsoft.UI.Xaml.Automation.Provider.IValueProvider {
+      readonly IsReadOnly: boolean;
+      readonly Value: string;
+      constructor(owner: Microsoft.UI.Xaml.Controls.CalendarDatePicker);
+      Invoke(): void;
+      SetValue(value: string): void;
+    }
+    class CheckBoxAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ToggleButtonAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ICheckBoxAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.CheckBox);
+    }
+    class RangeBaseAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IRangeBaseAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IRangeValueProvider {
+      readonly IsReadOnly: boolean;
+      readonly LargeChange: number;
+      readonly Maximum: number;
+      readonly Minimum: number;
+      readonly SmallChange: number;
+      readonly Value: number;
+      constructor(owner: Microsoft.UI.Xaml.Controls.Primitives.RangeBase);
+      SetValue(value: number): void;
+    }
+    class SliderAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.RangeBaseAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ISliderAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.Slider);
+    }
+    class ColorPickerSliderAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.SliderAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IColorPickerSliderAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.Primitives.ColorPickerSlider);
+    }
+    class ColorSpectrumAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IColorSpectrumAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.Primitives.ColorSpectrum);
+    }
+    class ItemsControlAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IItemsControlAutomationPeer, Microsoft.UI.Xaml.Automation.Peers.IItemsControlAutomationPeerOverrides, Microsoft.UI.Xaml.Automation.Provider.IItemContainerProvider {
+      constructor(owner: Microsoft.UI.Xaml.Controls.ItemsControl);
+      CreateItemAutomationPeer(result: any): Microsoft.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+      FindItemByProperty(result: Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple, startAfter: Microsoft.UI.Xaml.Automation.AutomationProperty, automationProperty: any): Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    }
+    class SelectorAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ItemsControlAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ISelectorAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.ISelectionProvider {
+      readonly CanSelectMultiple: boolean;
+      readonly IsSelectionRequired: boolean;
+      constructor(owner: Microsoft.UI.Xaml.Controls.Primitives.Selector);
+      GetSelection(): Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    }
+    class ComboBoxAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.SelectorAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IComboBoxAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IValueProvider, Microsoft.UI.Xaml.Automation.Provider.IExpandCollapseProvider, Microsoft.UI.Xaml.Automation.Provider.IWindowProvider {
+      readonly ExpandCollapseState: number;
+      readonly IsReadOnly: boolean;
+      readonly Value: string;
+      readonly InteractionState: number;
+      readonly IsModal: boolean;
+      readonly IsTopmost: boolean;
+      readonly Maximizable: boolean;
+      readonly Minimizable: boolean;
+      readonly VisualState: number;
+      constructor(owner: Microsoft.UI.Xaml.Controls.ComboBox);
+      SetValue(value: string): void;
+      Collapse(): void;
+      Expand(): void;
+      Close(): void;
+      SetVisualState(state: number): void;
+      WaitForInputIdle(result: number): boolean;
+    }
+    class ComboBoxItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IComboBoxItemAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.ComboBoxItem);
+    }
+    class ItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.AutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IItemAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IVirtualizedItemProvider {
+      readonly Item: any;
+      readonly ItemsControlAutomationPeer: Microsoft.UI.Xaml.Automation.Peers.ItemsControlAutomationPeer;
+      constructor(item: any, parent: Microsoft.UI.Xaml.Automation.Peers.ItemsControlAutomationPeer);
+      Realize(): void;
+    }
+    class SelectorItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ItemAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ISelectorItemAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.ISelectionItemProvider {
+      readonly IsSelected: boolean;
+      readonly SelectionContainer: Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+      constructor(item: any, parent: Microsoft.UI.Xaml.Automation.Peers.SelectorAutomationPeer);
+      AddToSelection(): void;
+      RemoveFromSelection(): void;
+      Select(): void;
+    }
+    class ComboBoxItemDataAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.SelectorItemAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IComboBoxItemDataAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IScrollItemProvider {
+      constructor(item: any, parent: Microsoft.UI.Xaml.Automation.Peers.ComboBoxAutomationPeer);
+      ScrollIntoView(): void;
+    }
+    class DatePickerAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IDatePickerAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.DatePicker);
+    }
+    class DatePickerFlyoutPresenterAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IDatePickerFlyoutPresenterAutomationPeer {
+    }
+    class DropDownButtonAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ButtonAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IDropDownButtonAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IExpandCollapseProvider {
+      readonly ExpandCollapseState: number;
+      constructor(owner: Microsoft.UI.Xaml.Controls.DropDownButton);
+      Collapse(): void;
+      Expand(): void;
+    }
+    class ExpanderAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IExpanderAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IExpandCollapseProvider {
+      readonly ExpandCollapseState: number;
+      constructor(owner: Microsoft.UI.Xaml.Controls.Expander);
+      Collapse(): void;
+      Expand(): void;
+    }
+    class FlipViewAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.SelectorAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IFlipViewAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.FlipView);
+    }
+    class FlipViewItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IFlipViewItemAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.FlipViewItem);
+    }
+    class FlipViewItemDataAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.SelectorItemAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IFlipViewItemDataAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IScrollItemProvider {
+      constructor(item: any, parent: Microsoft.UI.Xaml.Automation.Peers.FlipViewAutomationPeer);
+      ScrollIntoView(): void;
+    }
+    class FlyoutPresenterAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IFlyoutPresenterAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.FlyoutPresenter);
+    }
+    class ListViewBaseAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.SelectorAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IListViewBaseAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IDropTargetProvider {
+      readonly DropEffect: string;
+      readonly DropEffects: string[];
+      constructor(owner: Microsoft.UI.Xaml.Controls.ListViewBase);
+    }
+    class GridViewAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ListViewBaseAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IGridViewAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.GridView);
+    }
+    class ListViewBaseHeaderItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IListViewBaseHeaderItemAutomationPeer {
+    }
+    class GridViewHeaderItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ListViewBaseHeaderItemAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IGridViewHeaderItemAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.GridViewHeaderItem);
+    }
+    class GridViewItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IGridViewItemAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.GridViewItem);
+    }
+    class GridViewItemDataAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.SelectorItemAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IGridViewItemDataAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IScrollItemProvider {
+      constructor(item: any, parent: Microsoft.UI.Xaml.Automation.Peers.GridViewAutomationPeer);
+      ScrollIntoView(): void;
+    }
+    class GroupItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IGroupItemAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.GroupItem);
+    }
+    class HubAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IHubAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.Hub);
+    }
+    class HubSectionAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IHubSectionAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IScrollItemProvider {
+      constructor(owner: Microsoft.UI.Xaml.Controls.HubSection);
+      ScrollIntoView(): void;
+    }
+    class HyperlinkButtonAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ButtonBaseAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IHyperlinkButtonAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IInvokeProvider {
+      constructor(owner: Microsoft.UI.Xaml.Controls.HyperlinkButton);
+      Invoke(): void;
+    }
+    class ImageAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IImageAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.Image);
+    }
+    class InfoBarAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IInfoBarAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.InfoBar);
+    }
+    class ItemContainerAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IItemContainerAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.ISelectionItemProvider, Microsoft.UI.Xaml.Automation.Provider.IInvokeProvider {
+      readonly IsSelected: boolean;
+      readonly SelectionContainer: Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+      constructor(owner: Microsoft.UI.Xaml.Controls.ItemContainer);
+      AddToSelection(): void;
+      RemoveFromSelection(): void;
+      Select(): void;
+      Invoke(): void;
+    }
+    class ItemsViewAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IItemsViewAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.ISelectionProvider {
+      readonly CanSelectMultiple: boolean;
+      readonly IsSelectionRequired: boolean;
+      constructor(owner: Microsoft.UI.Xaml.Controls.ItemsView);
+      GetSelection(): Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    }
+    class ListBoxAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.SelectorAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IListBoxAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.ListBox);
+    }
+    class ListBoxItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IListBoxItemAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.ListBoxItem);
+    }
+    class ListBoxItemDataAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.SelectorItemAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IListBoxItemDataAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IScrollItemProvider {
+      constructor(item: any, parent: Microsoft.UI.Xaml.Automation.Peers.ListBoxAutomationPeer);
+      ScrollIntoView(): void;
+    }
+    class ListPickerFlyoutPresenterAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IListPickerFlyoutPresenterAutomationPeer {
+    }
+    class ListViewAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ListViewBaseAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IListViewAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.ListView);
+    }
+    class ListViewHeaderItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ListViewBaseHeaderItemAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IListViewHeaderItemAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.ListViewHeaderItem);
+    }
+    class ListViewItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IListViewItemAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.ListViewItem);
+    }
+    class ListViewItemDataAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.SelectorItemAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IListViewItemDataAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IScrollItemProvider {
+      constructor(item: any, parent: Microsoft.UI.Xaml.Automation.Peers.ListViewBaseAutomationPeer);
+      ScrollIntoView(): void;
+    }
+    class LoopingSelectorAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ILoopingSelectorAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.ISelectionProvider, Microsoft.UI.Xaml.Automation.Provider.IItemContainerProvider, Microsoft.UI.Xaml.Automation.Provider.IScrollProvider {
+      readonly HorizontalScrollPercent: number;
+      readonly HorizontalViewSize: number;
+      readonly HorizontallyScrollable: boolean;
+      readonly VerticalScrollPercent: number;
+      readonly VerticalViewSize: number;
+      readonly VerticallyScrollable: boolean;
+      readonly CanSelectMultiple: boolean;
+      readonly IsSelectionRequired: boolean;
+      GetSelection(): Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+      FindItemByProperty(result: Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple, startAfter: Microsoft.UI.Xaml.Automation.AutomationProperty, automationProperty: any): Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+      Scroll(horizontalAmount: number, verticalAmount: number): void;
+      SetScrollPercent(horizontalPercent: number, verticalPercent: number): void;
+    }
+    class LoopingSelectorItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ILoopingSelectorItemAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IScrollItemProvider, Microsoft.UI.Xaml.Automation.Provider.ISelectionItemProvider {
+      readonly IsSelected: boolean;
+      readonly SelectionContainer: Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+      ScrollIntoView(): void;
+      AddToSelection(): void;
+      RemoveFromSelection(): void;
+      Select(): void;
+    }
+    class LoopingSelectorItemDataAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.AutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ILoopingSelectorItemDataAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IVirtualizedItemProvider {
+      Realize(): void;
+    }
+    class MediaPlayerElementAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IMediaPlayerElementAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.MediaPlayerElement);
+    }
+    class MediaTransportControlsAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IMediaTransportControlsAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.MediaTransportControls);
+    }
+    class MenuBarAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IMenuBarAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.MenuBar);
+    }
+    class MenuBarItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IMenuBarItemAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IExpandCollapseProvider, Microsoft.UI.Xaml.Automation.Provider.IInvokeProvider {
+      readonly ExpandCollapseState: number;
+      constructor(owner: Microsoft.UI.Xaml.Controls.MenuBarItem);
+      Collapse(): void;
+      Expand(): void;
+      Invoke(): void;
+    }
+    class MenuFlyoutItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IMenuFlyoutItemAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IInvokeProvider {
+      constructor(owner: Microsoft.UI.Xaml.Controls.MenuFlyoutItem);
+      Invoke(): void;
+    }
+    class MenuFlyoutPresenterAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ItemsControlAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IMenuFlyoutPresenterAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.MenuFlyoutPresenter);
+    }
+    class NavigationViewAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.INavigationViewAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.NavigationView);
+    }
+    class NavigationViewItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.INavigationViewItemAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IExpandCollapseProvider {
+      readonly ExpandCollapseState: number;
+      constructor(owner: Microsoft.UI.Xaml.Controls.NavigationViewItem);
+      Collapse(): void;
+      Expand(): void;
+    }
+    class NumberBoxAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.INumberBoxAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.NumberBox);
+    }
+    class PasswordBoxAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IPasswordBoxAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.PasswordBox);
+    }
+    class PatternInterface extends System.Enum {
+      value__: number;
+      static Invoke: number;
+      static Selection: number;
+      static Value: number;
+      static RangeValue: number;
+      static Scroll: number;
+      static ScrollItem: number;
+      static ExpandCollapse: number;
+      static Grid: number;
+      static GridItem: number;
+      static MultipleView: number;
+      static Window: number;
+      static SelectionItem: number;
+      static Dock: number;
+      static Table: number;
+      static TableItem: number;
+      static Toggle: number;
+      static Transform: number;
+      static Text: number;
+      static ItemContainer: number;
+      static VirtualizedItem: number;
+      static Text2: number;
+      static TextChild: number;
+      static TextRange: number;
+      static Annotation: number;
+      static Drag: number;
+      static DropTarget: number;
+      static ObjectModel: number;
+      static Spreadsheet: number;
+      static SpreadsheetItem: number;
+      static Styles: number;
+      static Transform2: number;
+      static SynchronizedInput: number;
+      static TextEdit: number;
+      static CustomNavigation: number;
+    }
+    class PersonPictureAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IPersonPictureAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.PersonPicture);
+    }
+    class PickerFlyoutPresenterAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IPickerFlyoutPresenterAutomationPeer {
+    }
+    class PipsPagerAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IPipsPagerAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.PipsPager);
+    }
+    class PivotAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ItemsControlAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IPivotAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.ISelectionProvider, Microsoft.UI.Xaml.Automation.Provider.IScrollProvider {
+      readonly HorizontalScrollPercent: number;
+      readonly HorizontalViewSize: number;
+      readonly HorizontallyScrollable: boolean;
+      readonly VerticalScrollPercent: number;
+      readonly VerticalViewSize: number;
+      readonly VerticallyScrollable: boolean;
+      readonly CanSelectMultiple: boolean;
+      readonly IsSelectionRequired: boolean;
+      constructor(owner: Microsoft.UI.Xaml.Controls.Pivot);
+      GetSelection(): Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+      Scroll(horizontalAmount: number, verticalAmount: number): void;
+      SetScrollPercent(horizontalPercent: number, verticalPercent: number): void;
+    }
+    class PivotItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IPivotItemAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.PivotItem);
+    }
+    class PivotItemDataAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ItemAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IPivotItemDataAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IScrollItemProvider, Microsoft.UI.Xaml.Automation.Provider.ISelectionItemProvider, Microsoft.UI.Xaml.Automation.Provider.IVirtualizedItemProvider {
+      readonly IsSelected: boolean;
+      readonly SelectionContainer: Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+      constructor(item: any, parent: Microsoft.UI.Xaml.Automation.Peers.PivotAutomationPeer);
+      ScrollIntoView(): void;
+      AddToSelection(): void;
+      RemoveFromSelection(): void;
+      Select(): void;
+      Realize(): void;
+    }
+    class ProgressBarAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.RangeBaseAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IProgressBarAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.ProgressBar);
+    }
+    class ProgressRingAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IProgressRingAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IRangeValueProvider {
+      readonly IsReadOnly: boolean;
+      readonly LargeChange: number;
+      readonly Maximum: number;
+      readonly Minimum: number;
+      readonly SmallChange: number;
+      readonly Value: number;
+      constructor(owner: Microsoft.UI.Xaml.Controls.ProgressRing);
+      SetValue(value: number): void;
+    }
+    class RadioButtonAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ToggleButtonAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IRadioButtonAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.ISelectionItemProvider {
+      readonly IsSelected: boolean;
+      readonly SelectionContainer: Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+      constructor(owner: Microsoft.UI.Xaml.Controls.RadioButton);
+      AddToSelection(): void;
+      RemoveFromSelection(): void;
+      Select(): void;
+    }
+    class RadioButtonsAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IRadioButtonsAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.RadioButtons);
+    }
+    class RatingControlAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IRatingControlAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.RatingControl);
+    }
+    class RawElementProviderRuntimeId extends System.ValueType {
+      Part1: number;
+      Part2: number;
+    }
+    class RepeatButtonAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ButtonBaseAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IRepeatButtonAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IInvokeProvider {
+      constructor(owner: Microsoft.UI.Xaml.Controls.Primitives.RepeatButton);
+      Invoke(): void;
+    }
+    class RepeaterAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IRepeaterAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.ItemsRepeater);
+    }
+    class RichEditBoxAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IRichEditBoxAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.RichEditBox);
+    }
+    class RichTextBlockAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IRichTextBlockAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.RichTextBlock);
+    }
+    class RichTextBlockOverflowAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IRichTextBlockOverflowAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.RichTextBlockOverflow);
+    }
+    class ScrollBarAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.RangeBaseAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IScrollBarAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.Primitives.ScrollBar);
+    }
+    class ScrollPresenterAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IScrollPresenterAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.Primitives.ScrollPresenter);
+    }
+    class ScrollViewerAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IScrollViewerAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IScrollProvider {
+      readonly HorizontalScrollPercent: number;
+      readonly HorizontalViewSize: number;
+      readonly HorizontallyScrollable: boolean;
+      readonly VerticalScrollPercent: number;
+      readonly VerticalViewSize: number;
+      readonly VerticallyScrollable: boolean;
+      constructor(owner: Microsoft.UI.Xaml.Controls.ScrollViewer);
+      Scroll(horizontalAmount: number, verticalAmount: number): void;
+      SetScrollPercent(horizontalPercent: number, verticalPercent: number): void;
+    }
+    class SelectorBarItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ItemContainerAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ISelectorBarItemAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.SelectorBarItem);
+    }
+    class SemanticZoomAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ISemanticZoomAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IToggleProvider {
+      readonly ToggleState: number;
+      constructor(owner: Microsoft.UI.Xaml.Controls.SemanticZoom);
+      Toggle(): void;
+    }
+    class SplitButtonAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ISplitButtonAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IExpandCollapseProvider, Microsoft.UI.Xaml.Automation.Provider.IInvokeProvider {
+      readonly ExpandCollapseState: number;
+      constructor(owner: Microsoft.UI.Xaml.Controls.SplitButton);
+      Collapse(): void;
+      Expand(): void;
+      Invoke(): void;
+    }
+    class TabViewAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ITabViewAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.TabView);
+    }
+    class TabViewItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ListViewItemAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ITabViewItemAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.TabViewItem);
+    }
+    class TeachingTipAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ITeachingTipAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.TeachingTip);
+    }
+    class TextBlockAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ITextBlockAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.TextBlock);
+    }
+    class TextBoxAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ITextBoxAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.TextBox);
+    }
+    class ThumbAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IThumbAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.Primitives.Thumb);
+    }
+    class TimePickerAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ITimePickerAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.TimePicker);
+    }
+    class TimePickerFlyoutPresenterAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ITimePickerFlyoutPresenterAutomationPeer {
+    }
+    class ToggleMenuFlyoutItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IToggleMenuFlyoutItemAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IToggleProvider {
+      readonly ToggleState: number;
+      constructor(owner: Microsoft.UI.Xaml.Controls.ToggleMenuFlyoutItem);
+      Toggle(): void;
+    }
+    class ToggleSplitButtonAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IToggleSplitButtonAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IExpandCollapseProvider, Microsoft.UI.Xaml.Automation.Provider.IToggleProvider {
+      readonly ExpandCollapseState: number;
+      readonly ToggleState: number;
+      constructor(owner: Microsoft.UI.Xaml.Controls.ToggleSplitButton);
+      Collapse(): void;
+      Expand(): void;
+      Toggle(): void;
+    }
+    class ToggleSwitchAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IToggleSwitchAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IToggleProvider {
+      readonly ToggleState: number;
+      constructor(owner: Microsoft.UI.Xaml.Controls.ToggleSwitch);
+      Toggle(): void;
+    }
+    class TreeViewItemAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ListViewItemAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ITreeViewItemAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IExpandCollapseProvider {
+      readonly ExpandCollapseState: number;
+      constructor(owner: Microsoft.UI.Xaml.Controls.TreeViewItem);
+      Collapse(): void;
+      Expand(): void;
+    }
+    class TreeViewItemDataAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ItemAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ITreeViewItemDataAutomationPeer, Microsoft.UI.Xaml.Automation.Provider.IExpandCollapseProvider {
+      readonly ExpandCollapseState: number;
+      constructor(item: any, parent: Microsoft.UI.Xaml.Automation.Peers.TreeViewListAutomationPeer);
+      Collapse(): void;
+      Expand(): void;
+    }
+    class TreeViewListAutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.ListViewAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.ITreeViewListAutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.TreeViewList);
+    }
+    class WebView2AutomationPeer extends Microsoft.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Microsoft.UI.Xaml.Automation.Peers.IWebView2AutomationPeer {
+      constructor(owner: Microsoft.UI.Xaml.Controls.WebView2);
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Automation.Provider {
+    interface IAnnotationProvider {
+      readonly AnnotationTypeId: number;
+      readonly AnnotationTypeName: string;
+      readonly Author: string;
+      readonly DateTime: string;
+      readonly Target: Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    }
+    interface ICustomNavigationProvider {
+      NavigateCustom(result: number): any;
+    }
+    interface IDockProvider {
+      readonly DockPosition: number;
+      SetDockPosition(dockPosition: number): void;
+    }
+    interface IDragProvider {
+      readonly DropEffect: string;
+      readonly DropEffects: string[];
+      readonly IsGrabbed: boolean;
+      GetGrabbedItems(): Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    }
+    interface IDropTargetProvider {
+      readonly DropEffect: string;
+      readonly DropEffects: string[];
+    }
+    interface IExpandCollapseProvider {
+      readonly ExpandCollapseState: number;
+      Collapse(): void;
+      Expand(): void;
+    }
+    interface IGridItemProvider {
+      readonly Column: number;
+      readonly ColumnSpan: number;
+      readonly ContainingGrid: Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+      readonly Row: number;
+      readonly RowSpan: number;
+    }
+    interface IGridProvider {
+      readonly ColumnCount: number;
+      readonly RowCount: number;
+      GetItem(result: number, row: number): Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    }
+    interface IInvokeProvider {
+      Invoke(): void;
+    }
+    interface IItemContainerProvider {
+      FindItemByProperty(result: Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple, startAfter: Microsoft.UI.Xaml.Automation.AutomationProperty, automationProperty: any): Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    }
+    interface IMultipleViewProvider {
+      readonly CurrentView: number;
+      GetSupportedViews(): number[];
+      GetViewName(result: number): string;
+      SetCurrentView(viewId: number): void;
+    }
+    interface IObjectModelProvider {
+      GetUnderlyingObjectModel(): any;
+    }
+    interface IRangeValueProvider {
+      readonly IsReadOnly: boolean;
+      readonly LargeChange: number;
+      readonly Maximum: number;
+      readonly Minimum: number;
+      readonly SmallChange: number;
+      readonly Value: number;
+      SetValue(value: number): void;
+    }
+    class IRawElementProviderSimple extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Automation.Provider.IIRawElementProviderSimple {
+    }
+    interface IScrollItemProvider {
+      ScrollIntoView(): void;
+    }
+    interface IScrollProvider {
+      readonly HorizontalScrollPercent: number;
+      readonly HorizontalViewSize: number;
+      readonly HorizontallyScrollable: boolean;
+      readonly VerticalScrollPercent: number;
+      readonly VerticalViewSize: number;
+      readonly VerticallyScrollable: boolean;
+      Scroll(horizontalAmount: number, verticalAmount: number): void;
+      SetScrollPercent(horizontalPercent: number, verticalPercent: number): void;
+    }
+    interface ISelectionItemProvider {
+      readonly IsSelected: boolean;
+      readonly SelectionContainer: Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+      AddToSelection(): void;
+      RemoveFromSelection(): void;
+      Select(): void;
+    }
+    interface ISelectionProvider {
+      readonly CanSelectMultiple: boolean;
+      readonly IsSelectionRequired: boolean;
+      GetSelection(): Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    }
+    interface ISpreadsheetItemProvider {
+      readonly Formula: string;
+      GetAnnotationObjects(): Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+      GetAnnotationTypes(): number[];
+    }
+    interface ISpreadsheetProvider {
+      GetItemByName(result: string): Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    }
+    interface IStylesProvider {
+      readonly ExtendedProperties: string;
+      readonly FillColor: Windows.UI.Color;
+      readonly FillPatternColor: Windows.UI.Color;
+      readonly FillPatternStyle: string;
+      readonly Shape: string;
+      readonly StyleId: number;
+      readonly StyleName: string;
+    }
+    interface ISynchronizedInputProvider {
+      Cancel(): void;
+      StartListening(inputType: number): void;
+    }
+    interface ITableItemProvider {
+      GetColumnHeaderItems(): Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+      GetRowHeaderItems(): Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    }
+    interface ITableProvider {
+      readonly RowOrColumnMajor: number;
+      GetColumnHeaders(): Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+      GetRowHeaders(): Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    }
+    interface ITextChildProvider {
+      readonly TextContainer: Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+      readonly TextRange: Microsoft.UI.Xaml.Automation.Provider.ITextRangeProvider;
+    }
+    interface ITextEditProvider extends Microsoft.UI.Xaml.Automation.Provider.ITextProvider {
+      GetActiveComposition(): Microsoft.UI.Xaml.Automation.Provider.ITextRangeProvider;
+      GetConversionTarget(): Microsoft.UI.Xaml.Automation.Provider.ITextRangeProvider;
+    }
+    interface ITextProvider {
+      readonly DocumentRange: Microsoft.UI.Xaml.Automation.Provider.ITextRangeProvider;
+      readonly SupportedTextSelection: number;
+      GetSelection(): Microsoft.UI.Xaml.Automation.Provider.ITextRangeProvider[];
+      GetVisibleRanges(): Microsoft.UI.Xaml.Automation.Provider.ITextRangeProvider[];
+      RangeFromChild(result: Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Microsoft.UI.Xaml.Automation.Provider.ITextRangeProvider;
+      RangeFromPoint(result: Windows.Foundation.Point): Microsoft.UI.Xaml.Automation.Provider.ITextRangeProvider;
+    }
+    interface ITextProvider2 extends Microsoft.UI.Xaml.Automation.Provider.ITextProvider {
+      RangeFromAnnotation(result: Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Microsoft.UI.Xaml.Automation.Provider.ITextRangeProvider;
+      GetCaretRange(returnValue: boolean): Microsoft.UI.Xaml.Automation.Provider.ITextRangeProvider;
+    }
+    interface ITextRangeProvider {
+      Clone(): Microsoft.UI.Xaml.Automation.Provider.ITextRangeProvider;
+      Compare(result: Microsoft.UI.Xaml.Automation.Provider.ITextRangeProvider): boolean;
+      CompareEndpoints(result: number, endpoint: Microsoft.UI.Xaml.Automation.Provider.ITextRangeProvider, textRangeProvider: number): number;
+      ExpandToEnclosingUnit(unit: number): void;
+      FindAttribute(result: number, attributeId: any, value: boolean): Microsoft.UI.Xaml.Automation.Provider.ITextRangeProvider;
+      FindText(result: string, text: boolean, backward: boolean): Microsoft.UI.Xaml.Automation.Provider.ITextRangeProvider;
+      GetAttributeValue(result: number): any;
+      GetBoundingRectangles(returnValue: number[]): void;
+      GetEnclosingElement(): Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+      GetText(result: number): string;
+      Move(result: number, unit: number): number;
+      MoveEndpointByUnit(result: number, endpoint: number, unit: number): number;
+      MoveEndpointByRange(endpoint: number, textRangeProvider: Microsoft.UI.Xaml.Automation.Provider.ITextRangeProvider, targetEndpoint: number): void;
+      Select(): void;
+      AddToSelection(): void;
+      RemoveFromSelection(): void;
+      ScrollIntoView(alignToTop: boolean): void;
+      GetChildren(): Microsoft.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    }
+    interface ITextRangeProvider2 extends Microsoft.UI.Xaml.Automation.Provider.ITextRangeProvider {
+      ShowContextMenu(): void;
+    }
+    interface IToggleProvider {
+      readonly ToggleState: number;
+      Toggle(): void;
+    }
+    interface ITransformProvider {
+      readonly CanMove: boolean;
+      readonly CanResize: boolean;
+      readonly CanRotate: boolean;
+      Move(x: number, y: number): void;
+      Resize(width: number, height: number): void;
+      Rotate(degrees: number): void;
+    }
+    interface ITransformProvider2 extends Microsoft.UI.Xaml.Automation.Provider.ITransformProvider {
+      readonly CanZoom: boolean;
+      readonly MaxZoom: number;
+      readonly MinZoom: number;
+      readonly ZoomLevel: number;
+      Zoom(zoom: number): void;
+      ZoomByUnit(zoomUnit: number): void;
+    }
+    interface IValueProvider {
+      readonly IsReadOnly: boolean;
+      readonly Value: string;
+      SetValue(value: string): void;
+    }
+    interface IVirtualizedItemProvider {
+      Realize(): void;
+    }
+    interface IWindowProvider {
+      readonly InteractionState: number;
+      readonly IsModal: boolean;
+      readonly IsTopmost: boolean;
+      readonly Maximizable: boolean;
+      readonly Minimizable: boolean;
+      readonly VisualState: number;
+      Close(): void;
+      SetVisualState(state: number): void;
+      WaitForInputIdle(result: number): boolean;
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Automation.Text {
+    class TextPatternRangeEndpoint extends System.Enum {
+      value__: number;
+      static Start: number;
+      static End: number;
+    }
+    class TextUnit extends System.Enum {
+      value__: number;
+      static Character: number;
+      static Format: number;
+      static Word: number;
+      static Line: number;
+      static Paragraph: number;
+      static Page: number;
+      static Document: number;
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Controls {
+    class AnchorRequestedEventArgs implements Microsoft.UI.Xaml.Controls.IAnchorRequestedEventArgs {
+      Anchor: Microsoft.UI.Xaml.UIElement;
+      readonly AnchorCandidates: System.Collections.Generic.IList<Microsoft.UI.Xaml.UIElement>;
+    }
+    class IconElement extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.IIconElement {
+      Foreground: Microsoft.UI.Xaml.Media.Brush;
+      static readonly ForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class AnimatedIcon extends Microsoft.UI.Xaml.Controls.IconElement implements Microsoft.UI.Xaml.Controls.IAnimatedIcon {
+      Source: Microsoft.UI.Xaml.Controls.IAnimatedVisualSource2;
+      MirroredWhenRightToLeft: boolean;
+      FallbackIconSource: Microsoft.UI.Xaml.Controls.IconSource;
+      static readonly FallbackIconSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MirroredWhenRightToLeftProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      static SetState(object: Microsoft.UI.Xaml.DependencyObject, value: string): void;
+      static GetState(result: Microsoft.UI.Xaml.DependencyObject): string;
+    }
+    class IconSource extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IIconSource, Microsoft.UI.Xaml.Controls.IIconSourceOverrides {
+      Foreground: Microsoft.UI.Xaml.Media.Brush;
+      static readonly ForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      CreateIconElement(): Microsoft.UI.Xaml.Controls.IconElement;
+    }
+    class AnimatedIconSource extends Microsoft.UI.Xaml.Controls.IconSource implements Microsoft.UI.Xaml.Controls.IAnimatedIconSource {
+      Source: Microsoft.UI.Xaml.Controls.IAnimatedVisualSource2;
+      MirroredWhenRightToLeft: boolean;
+      FallbackIconSource: Microsoft.UI.Xaml.Controls.IconSource;
+      static readonly FallbackIconSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MirroredWhenRightToLeftProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class AnimatedVisualPlayer extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.IAnimatedVisualPlayer, Microsoft.UI.Xaml.Controls.IAnimatedVisualPlayer2 {
+      Stretch: number;
+      Source: Microsoft.UI.Xaml.Controls.IAnimatedVisualSource;
+      PlaybackRate: number;
+      FallbackContent: Microsoft.UI.Xaml.DataTemplate;
+      AutoPlay: boolean;
+      readonly Diagnostics: any;
+      readonly Duration: System.TimeSpan;
+      readonly IsAnimatedVisualLoaded: boolean;
+      readonly IsPlaying: boolean;
+      readonly ProgressObject: Microsoft.UI.Composition.CompositionObject;
+      AnimationOptimization: number;
+      static readonly AutoPlayProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DiagnosticsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DurationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FallbackContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsAnimatedVisualLoadedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsPlayingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlaybackRateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StretchProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AnimationOptimizationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      Pause(): void;
+      PlayAsync(operation: number, fromProgress: number, toProgress: boolean): Windows.Foundation.IAsyncAction;
+      Resume(): void;
+      SetProgress(progress: number): void;
+      Stop(): void;
+    }
+    class Control extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.IControl, Microsoft.UI.Xaml.Controls.IControlProtected, Microsoft.UI.Xaml.Controls.IControlOverrides {
+      FocusDisengaged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Control, Microsoft.UI.Xaml.Controls.FocusDisengagedEventArgs> | null;
+      FocusEngaged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Control, Microsoft.UI.Xaml.Controls.FocusEngagedEventArgs> | null;
+      IsEnabledChanged: Microsoft.UI.Xaml.DependencyPropertyChangedEventHandler | null;
+      VerticalContentAlignment: number;
+      Template: Microsoft.UI.Xaml.Controls.ControlTemplate;
+      TabNavigation: number;
+      RequiresPointer: number;
+      Padding: Microsoft.UI.Xaml.Thickness;
+      IsTextScaleFactorEnabled: boolean;
+      IsFocusEngagementEnabled: boolean;
+      IsFocusEngaged: boolean;
+      IsEnabled: boolean;
+      HorizontalContentAlignment: number;
+      Foreground: Microsoft.UI.Xaml.Media.Brush;
+      FontWeight: Windows.UI.Text.FontWeight;
+      FontStyle: Windows.UI.Text.FontStyle;
+      FontStretch: Windows.UI.Text.FontStretch;
+      FontSize: number;
+      FontFamily: Microsoft.UI.Xaml.Media.FontFamily;
+      ElementSoundMode: number;
+      DefaultStyleResourceUri: System.Uri;
+      CornerRadius: Microsoft.UI.Xaml.CornerRadius;
+      CharacterSpacing: number;
+      BorderThickness: Microsoft.UI.Xaml.Thickness;
+      BorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      BackgroundSizing: number;
+      Background: Microsoft.UI.Xaml.Media.Brush;
+      static readonly BackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BackgroundSizingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BorderThicknessProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CharacterSpacingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CornerRadiusProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DefaultStyleKeyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DefaultStyleResourceUriProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ElementSoundModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontFamilyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontSizeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontStretchProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontWeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalContentAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsFocusEngagedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsFocusEngagementEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTemplateFocusTargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTemplateKeyTipTargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTextScaleFactorEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaddingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RequiresPointerProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TabNavigationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalContentAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      RemoveFocusEngagement(): void;
+      ApplyTemplate(): boolean;
+      static GetIsTemplateFocusTarget(result: Microsoft.UI.Xaml.FrameworkElement): boolean;
+      static SetIsTemplateFocusTarget(element: Microsoft.UI.Xaml.FrameworkElement, value: boolean): void;
+      static GetIsTemplateKeyTipTarget(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetIsTemplateKeyTipTarget(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+    }
+    class AnnotatedScrollBar extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IAnnotatedScrollBar {
+      DetailLabelRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.AnnotatedScrollBar, Microsoft.UI.Xaml.Controls.AnnotatedScrollBarDetailLabelRequestedEventArgs> | null;
+      Scrolling: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.AnnotatedScrollBar, Microsoft.UI.Xaml.Controls.AnnotatedScrollBarScrollingEventArgs> | null;
+      SmallChange: number;
+      Labels: System.Collections.Generic.IList<Microsoft.UI.Xaml.Controls.AnnotatedScrollBarLabel>;
+      LabelTemplate: Microsoft.UI.Xaml.IElementFactory;
+      DetailLabelTemplate: Microsoft.UI.Xaml.IElementFactory;
+      readonly ScrollController: Microsoft.UI.Xaml.Controls.Primitives.IScrollController;
+      static readonly DetailLabelTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LabelTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LabelsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SmallChangeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class AnnotatedScrollBarDetailLabelRequestedEventArgs implements Microsoft.UI.Xaml.Controls.IAnnotatedScrollBarDetailLabelRequestedEventArgs {
+      Content: any;
+      readonly ScrollOffset: number;
+    }
+    class AnnotatedScrollBarLabel implements Microsoft.UI.Xaml.Controls.IAnnotatedScrollBarLabel {
+      readonly Content: any;
+      readonly ScrollOffset: number;
+      constructor(content: any, scrollOffset: number);
+    }
+    class AnnotatedScrollBarScrollingEventArgs implements Microsoft.UI.Xaml.Controls.IAnnotatedScrollBarScrollingEventArgs {
+      Cancel: boolean;
+      readonly ScrollOffset: number;
+      readonly ScrollingEventKind: number;
+    }
+    class AnnotatedScrollBarScrollingEventKind extends System.Enum {
+      value__: number;
+      static Click: number;
+      static Drag: number;
+      static IncrementButton: number;
+      static DecrementButton: number;
+    }
+    class ContentControl extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IContentControl, Microsoft.UI.Xaml.Controls.IContentControlOverrides {
+      ContentTransitions: Microsoft.UI.Xaml.Media.Animation.TransitionCollection;
+      ContentTemplateSelector: Microsoft.UI.Xaml.Controls.DataTemplateSelector;
+      ContentTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Content: any;
+      readonly ContentTemplateRoot: Microsoft.UI.Xaml.UIElement;
+      static readonly ContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentTemplateSelectorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentTransitionsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class AppBar extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.IAppBar, Microsoft.UI.Xaml.Controls.IAppBarOverrides {
+      Closed: System.EventHandler<any> | null;
+      Closing: System.EventHandler<any> | null;
+      Opened: System.EventHandler<any> | null;
+      Opening: System.EventHandler<any> | null;
+      LightDismissOverlayMode: number;
+      IsSticky: boolean;
+      IsOpen: boolean;
+      ClosedDisplayMode: number;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.Primitives.AppBarTemplateSettings;
+      static readonly ClosedDisplayModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsOpenProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsStickyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LightDismissOverlayModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class Button extends Microsoft.UI.Xaml.Controls.Primitives.ButtonBase implements Microsoft.UI.Xaml.Controls.IButton {
+      Flyout: Microsoft.UI.Xaml.Controls.Primitives.FlyoutBase;
+      static readonly FlyoutProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class AppBarButton extends Microsoft.UI.Xaml.Controls.Button implements Microsoft.UI.Xaml.Controls.IAppBarButton, Microsoft.UI.Xaml.Controls.ICommandBarElement {
+      LabelPosition: number;
+      Label: string;
+      KeyboardAcceleratorTextOverride: string;
+      Icon: Microsoft.UI.Xaml.Controls.IconElement;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.Primitives.AppBarButtonTemplateSettings;
+      IsCompact: boolean;
+      DynamicOverflowOrder: number;
+      readonly IsInOverflow: boolean;
+      static readonly DynamicOverflowOrderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IconProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsCompactProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsInOverflowProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly KeyboardAcceleratorTextOverrideProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LabelPositionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LabelProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class AppBarClosedDisplayMode extends System.Enum {
+      value__: number;
+      static Compact: number;
+      static Minimal: number;
+      static Hidden: number;
+    }
+    class AppBarElementContainer extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.IAppBarElementContainer, Microsoft.UI.Xaml.Controls.ICommandBarElement {
+      IsCompact: boolean;
+      DynamicOverflowOrder: number;
+      readonly IsInOverflow: boolean;
+      static readonly DynamicOverflowOrderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsCompactProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsInOverflowProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class AppBarSeparator extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IAppBarSeparator, Microsoft.UI.Xaml.Controls.ICommandBarElement {
+      IsCompact: boolean;
+      DynamicOverflowOrder: number;
+      readonly IsInOverflow: boolean;
+      static readonly DynamicOverflowOrderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsCompactProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsInOverflowProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class AppBarToggleButton extends Microsoft.UI.Xaml.Controls.Primitives.ToggleButton implements Microsoft.UI.Xaml.Controls.IAppBarToggleButton, Microsoft.UI.Xaml.Controls.ICommandBarElement {
+      LabelPosition: number;
+      Label: string;
+      KeyboardAcceleratorTextOverride: string;
+      Icon: Microsoft.UI.Xaml.Controls.IconElement;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.Primitives.AppBarToggleButtonTemplateSettings;
+      IsCompact: boolean;
+      DynamicOverflowOrder: number;
+      readonly IsInOverflow: boolean;
+      static readonly DynamicOverflowOrderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IconProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsCompactProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsInOverflowProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly KeyboardAcceleratorTextOverrideProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LabelPositionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LabelProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ItemsControl extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IItemsControl, Microsoft.UI.Xaml.Controls.IItemsControlOverrides, Microsoft.UI.Xaml.Controls.IItemContainerMapping {
+      ItemsSource: any;
+      ItemsPanel: Microsoft.UI.Xaml.Controls.ItemsPanelTemplate;
+      ItemTemplateSelector: Microsoft.UI.Xaml.Controls.DataTemplateSelector;
+      ItemTemplate: Microsoft.UI.Xaml.DataTemplate;
+      ItemContainerTransitions: Microsoft.UI.Xaml.Media.Animation.TransitionCollection;
+      ItemContainerStyleSelector: Microsoft.UI.Xaml.Controls.StyleSelector;
+      ItemContainerStyle: Microsoft.UI.Xaml.Style;
+      GroupStyleSelector: Microsoft.UI.Xaml.Controls.GroupStyleSelector;
+      DisplayMemberPath: string;
+      readonly GroupStyle: Windows.Foundation.Collections.IObservableVector<Microsoft.UI.Xaml.Controls.GroupStyle>;
+      readonly IsGrouping: boolean;
+      readonly ItemContainerGenerator: Microsoft.UI.Xaml.Controls.ItemContainerGenerator;
+      readonly Items: Microsoft.UI.Xaml.Controls.ItemCollection;
+      readonly ItemsPanelRoot: Microsoft.UI.Xaml.Controls.Panel;
+      static readonly DisplayMemberPathProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GroupStyleSelectorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsGroupingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemContainerStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemContainerStyleSelectorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemContainerTransitionsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemTemplateSelectorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemsPanelProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemsSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      GroupHeaderContainerFromItemContainer(result: Microsoft.UI.Xaml.DependencyObject): Microsoft.UI.Xaml.DependencyObject;
+      ItemFromContainer(result: Microsoft.UI.Xaml.DependencyObject): any;
+      ContainerFromItem(result: any): Microsoft.UI.Xaml.DependencyObject;
+      IndexFromContainer(result: Microsoft.UI.Xaml.DependencyObject): number;
+      ContainerFromIndex(result: number): Microsoft.UI.Xaml.DependencyObject;
+      static GetItemsOwner(result: Microsoft.UI.Xaml.DependencyObject): Microsoft.UI.Xaml.Controls.ItemsControl;
+      static ItemsControlFromItemContainer(result: Microsoft.UI.Xaml.DependencyObject): Microsoft.UI.Xaml.Controls.ItemsControl;
+    }
+    class AutoSuggestBox extends Microsoft.UI.Xaml.Controls.ItemsControl implements Microsoft.UI.Xaml.Controls.IAutoSuggestBox {
+      QuerySubmitted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.AutoSuggestBox, Microsoft.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs> | null;
+      SuggestionChosen: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.AutoSuggestBox, Microsoft.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs> | null;
+      TextChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.AutoSuggestBox, Microsoft.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs> | null;
+      UpdateTextOnSelect: boolean;
+      TextMemberPath: string;
+      TextBoxStyle: Microsoft.UI.Xaml.Style;
+      Text: string;
+      QueryIcon: Microsoft.UI.Xaml.Controls.IconElement;
+      PlaceholderText: string;
+      MaxSuggestionListHeight: number;
+      LightDismissOverlayMode: number;
+      IsSuggestionListOpen: boolean;
+      Header: any;
+      Description: any;
+      AutoMaximizeSuggestionArea: boolean;
+      static readonly AutoMaximizeSuggestionAreaProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DescriptionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsSuggestionListOpenProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LightDismissOverlayModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxSuggestionListHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlaceholderTextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly QueryIconProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextBoxStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextMemberPathProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly UpdateTextOnSelectProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class AutoSuggestBoxQuerySubmittedEventArgs extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IAutoSuggestBoxQuerySubmittedEventArgs {
+      readonly ChosenSuggestion: any;
+      readonly QueryText: string;
+      constructor();
+    }
+    class AutoSuggestBoxSuggestionChosenEventArgs extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IAutoSuggestBoxSuggestionChosenEventArgs {
+      readonly SelectedItem: any;
+      constructor();
+    }
+    class AutoSuggestBoxTextChangedEventArgs extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IAutoSuggestBoxTextChangedEventArgs {
+      Reason: number;
+      static readonly ReasonProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      CheckCurrent(): boolean;
+    }
+    class AutoSuggestionBoxTextChangeReason extends System.Enum {
+      value__: number;
+      static UserInput: number;
+      static ProgrammaticChange: number;
+      static SuggestionChosen: number;
+    }
+    class BackgroundSizing extends System.Enum {
+      value__: number;
+      static InnerBorderEdge: number;
+      static OuterBorderEdge: number;
+    }
+    class BitmapIcon extends Microsoft.UI.Xaml.Controls.IconElement implements Microsoft.UI.Xaml.Controls.IBitmapIcon {
+      UriSource: System.Uri;
+      ShowAsMonochrome: boolean;
+      static readonly ShowAsMonochromeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly UriSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class BitmapIconSource extends Microsoft.UI.Xaml.Controls.IconSource implements Microsoft.UI.Xaml.Controls.IBitmapIconSource {
+      UriSource: System.Uri;
+      ShowAsMonochrome: boolean;
+      static readonly ShowAsMonochromeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly UriSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class Border extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.IBorder {
+      Padding: Microsoft.UI.Xaml.Thickness;
+      CornerRadius: Microsoft.UI.Xaml.CornerRadius;
+      ChildTransitions: Microsoft.UI.Xaml.Media.Animation.TransitionCollection;
+      Child: Microsoft.UI.Xaml.UIElement;
+      BorderThickness: Microsoft.UI.Xaml.Thickness;
+      BorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      BackgroundTransition: Microsoft.UI.Xaml.BrushTransition;
+      BackgroundSizing: number;
+      Background: Microsoft.UI.Xaml.Media.Brush;
+      static readonly BackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BackgroundSizingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BorderThicknessProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ChildTransitionsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CornerRadiusProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaddingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class BreadcrumbBar extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IBreadcrumbBar {
+      ItemClicked: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.BreadcrumbBar, Microsoft.UI.Xaml.Controls.BreadcrumbBarItemClickedEventArgs> | null;
+      ItemsSource: any;
+      ItemTemplate: any;
+      static readonly ItemTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemsSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class BreadcrumbBarItem extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.IBreadcrumbBarItem {
+      constructor();
+    }
+    class BreadcrumbBarItemClickedEventArgs implements Microsoft.UI.Xaml.Controls.IBreadcrumbBarItemClickedEventArgs {
+      readonly Index: number;
+      readonly Item: any;
+    }
+    class CalendarDatePicker extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.ICalendarDatePicker {
+      CalendarViewDayItemChanging: Microsoft.UI.Xaml.Controls.CalendarViewDayItemChangingEventHandler | null;
+      Closed: System.EventHandler<any> | null;
+      DateChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.CalendarDatePicker, Microsoft.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs> | null;
+      Opened: System.EventHandler<any> | null;
+      PlaceholderText: string;
+      MinDate: System.DateTimeOffset;
+      MaxDate: System.DateTimeOffset;
+      LightDismissOverlayMode: number;
+      IsTodayHighlighted: boolean;
+      IsOutOfScopeEnabled: boolean;
+      IsGroupLabelVisible: boolean;
+      IsCalendarOpen: boolean;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Header: any;
+      FirstDayOfWeek: Windows.Globalization.DayOfWeek;
+      DisplayMode: number;
+      Description: any;
+      DayOfWeekFormat: string;
+      DateFormat: string;
+      Date: System.Nullable<System.DateTimeOffset>;
+      CalendarViewStyle: Microsoft.UI.Xaml.Style;
+      CalendarIdentifier: string;
+      static readonly CalendarIdentifierProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CalendarViewStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DateFormatProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DayOfWeekFormatProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DescriptionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DisplayModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FirstDayOfWeekProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsCalendarOpenProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsGroupLabelVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsOutOfScopeEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTodayHighlightedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LightDismissOverlayModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxDateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinDateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlaceholderTextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      SetDisplayDate(date: System.DateTimeOffset): void;
+      SetYearDecadeDisplayDimensions(columns: number, rows: number): void;
+    }
+    class CalendarDatePickerDateChangedEventArgs implements Microsoft.UI.Xaml.Controls.ICalendarDatePickerDateChangedEventArgs {
+      readonly NewDate: System.Nullable<System.DateTimeOffset>;
+      readonly OldDate: System.Nullable<System.DateTimeOffset>;
+    }
+    class CalendarView extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.ICalendarView {
+      CalendarViewDayItemChanging: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.CalendarView, Microsoft.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs> | null;
+      SelectedDatesChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.CalendarView, Microsoft.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs> | null;
+      DayItemMargin: Microsoft.UI.Xaml.Thickness;
+      DayItemFontWeight: Windows.UI.Text.FontWeight;
+      DayItemFontStyle: Windows.UI.Text.FontStyle;
+      DayItemFontSize: number;
+      DayItemFontFamily: Microsoft.UI.Xaml.Media.FontFamily;
+      CalendarViewDayItemStyle: Microsoft.UI.Xaml.Style;
+      CalendarItemPressedBackground: Microsoft.UI.Xaml.Media.Brush;
+      CalendarItemHoverBackground: Microsoft.UI.Xaml.Media.Brush;
+      TodayBlackoutBackground: Microsoft.UI.Xaml.Media.Brush;
+      CalendarItemDisabledBackground: Microsoft.UI.Xaml.Media.Brush;
+      CalendarItemCornerRadius: Microsoft.UI.Xaml.CornerRadius;
+      CalendarItemBorderThickness: Microsoft.UI.Xaml.Thickness;
+      CalendarItemBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      CalendarItemBackground: Microsoft.UI.Xaml.Media.Brush;
+      CalendarIdentifier: string;
+      BlackoutStrikethroughBrush: Microsoft.UI.Xaml.Media.Brush;
+      BlackoutForeground: Microsoft.UI.Xaml.Media.Brush;
+      IsGroupLabelVisible: boolean;
+      BlackoutBackground: Microsoft.UI.Xaml.Media.Brush;
+      DayOfWeekFormat: string;
+      HoverBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      HorizontalFirstOfMonthLabelAlignment: number;
+      HorizontalDayItemAlignment: number;
+      FocusBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      FirstOfYearDecadeLabelMargin: Microsoft.UI.Xaml.Thickness;
+      FirstOfYearDecadeLabelFontWeight: Windows.UI.Text.FontWeight;
+      FirstOfYearDecadeLabelFontStyle: Windows.UI.Text.FontStyle;
+      NumberOfWeeksInView: number;
+      FirstOfYearDecadeLabelFontFamily: Microsoft.UI.Xaml.Media.FontFamily;
+      FirstOfMonthLabelMargin: Microsoft.UI.Xaml.Thickness;
+      FirstOfMonthLabelFontWeight: Windows.UI.Text.FontWeight;
+      FirstOfMonthLabelFontStyle: Windows.UI.Text.FontStyle;
+      FirstOfMonthLabelFontSize: number;
+      FirstOfMonthLabelFontFamily: Microsoft.UI.Xaml.Media.FontFamily;
+      FirstDayOfWeek: Windows.Globalization.DayOfWeek;
+      DisplayMode: number;
+      DisabledForeground: Microsoft.UI.Xaml.Media.Brush;
+      IsOutOfScopeEnabled: boolean;
+      SelectedDisabledBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      SelectedBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      PressedForeground: Microsoft.UI.Xaml.Media.Brush;
+      PressedBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      OutOfScopePressedForeground: Microsoft.UI.Xaml.Media.Brush;
+      OutOfScopeHoverForeground: Microsoft.UI.Xaml.Media.Brush;
+      OutOfScopeForeground: Microsoft.UI.Xaml.Media.Brush;
+      OutOfScopeBackground: Microsoft.UI.Xaml.Media.Brush;
+      FirstOfYearDecadeLabelFontSize: number;
+      MonthYearItemMargin: Microsoft.UI.Xaml.Thickness;
+      MonthYearItemFontWeight: Windows.UI.Text.FontWeight;
+      MonthYearItemFontStyle: Windows.UI.Text.FontStyle;
+      MonthYearItemFontSize: number;
+      MonthYearItemFontFamily: Microsoft.UI.Xaml.Media.FontFamily;
+      MinDate: System.DateTimeOffset;
+      MaxDate: System.DateTimeOffset;
+      SelectedDisabledForeground: Microsoft.UI.Xaml.Media.Brush;
+      VerticalFirstOfMonthLabelAlignment: number;
+      IsTodayHighlighted: boolean;
+      VerticalDayItemAlignment: number;
+      TodaySelectedInnerBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      TodayPressedBackground: Microsoft.UI.Xaml.Media.Brush;
+      TodayHoverBackground: Microsoft.UI.Xaml.Media.Brush;
+      TodayForeground: Microsoft.UI.Xaml.Media.Brush;
+      TodayFontWeight: Windows.UI.Text.FontWeight;
+      TodayDisabledBackground: Microsoft.UI.Xaml.Media.Brush;
+      TodayBlackoutForeground: Microsoft.UI.Xaml.Media.Brush;
+      CalendarItemForeground: Microsoft.UI.Xaml.Media.Brush;
+      TodayBackground: Microsoft.UI.Xaml.Media.Brush;
+      SelectionMode: number;
+      SelectedPressedForeground: Microsoft.UI.Xaml.Media.Brush;
+      SelectedPressedBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      SelectedHoverForeground: Microsoft.UI.Xaml.Media.Brush;
+      SelectedHoverBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      SelectedForeground: Microsoft.UI.Xaml.Media.Brush;
+      readonly SelectedDates: System.Collections.Generic.IList<System.DateTimeOffset>;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.Primitives.CalendarViewTemplateSettings;
+      static readonly BlackoutBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BlackoutForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BlackoutStrikethroughBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CalendarIdentifierProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CalendarItemBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CalendarItemBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CalendarItemBorderThicknessProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CalendarItemCornerRadiusProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CalendarItemDisabledBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CalendarItemForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CalendarItemHoverBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CalendarItemPressedBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CalendarViewDayItemStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DayItemFontFamilyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DayItemFontSizeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DayItemFontStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DayItemFontWeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DayItemMarginProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DayOfWeekFormatProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DisabledForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DisplayModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FirstDayOfWeekProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FirstOfMonthLabelFontFamilyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FirstOfMonthLabelFontSizeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FirstOfMonthLabelFontStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FirstOfMonthLabelFontWeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FirstOfMonthLabelMarginProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FirstOfYearDecadeLabelFontFamilyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FirstOfYearDecadeLabelFontSizeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FirstOfYearDecadeLabelFontStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FirstOfYearDecadeLabelFontWeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FirstOfYearDecadeLabelMarginProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FocusBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalDayItemAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalFirstOfMonthLabelAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HoverBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsGroupLabelVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsOutOfScopeEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTodayHighlightedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxDateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinDateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MonthYearItemFontFamilyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MonthYearItemFontSizeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MonthYearItemFontStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MonthYearItemFontWeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MonthYearItemMarginProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly NumberOfWeeksInViewProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OutOfScopeBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OutOfScopeForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OutOfScopeHoverForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OutOfScopePressedForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PressedBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PressedForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedDatesProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedDisabledBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedDisabledForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedHoverBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedHoverForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedPressedBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedPressedForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TemplateSettingsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TodayBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TodayBlackoutBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TodayBlackoutForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TodayDisabledBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TodayFontWeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TodayForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TodayHoverBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TodayPressedBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TodaySelectedInnerBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalDayItemAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalFirstOfMonthLabelAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      SetDisplayDate(date: System.DateTimeOffset): void;
+      SetYearDecadeDisplayDimensions(columns: number, rows: number): void;
+    }
+    class CalendarViewDayItem extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.ICalendarViewDayItem {
+      IsBlackout: boolean;
+      readonly Date: System.DateTimeOffset;
+      static readonly DateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsBlackoutProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      SetDensityColors(colors: System.Collections.Generic.IEnumerable<Windows.UI.Color>): void;
+    }
+    class CalendarViewDayItemChangingEventArgs implements Microsoft.UI.Xaml.Controls.ICalendarViewDayItemChangingEventArgs {
+      readonly InRecycleQueue: boolean;
+      readonly Item: Microsoft.UI.Xaml.Controls.CalendarViewDayItem;
+      readonly Phase: number;
+      RegisterUpdateCallback(callback: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.CalendarView, Microsoft.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs>): void;
+      RegisterUpdateCallback(callbackPhase: number, callback: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.CalendarView, Microsoft.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs>): void;
+    }
+    class CalendarViewDayItemChangingEventHandler {
+      constructor(handler: (sender: Microsoft.UI.Xaml.Controls.CalendarView, e: Microsoft.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs) => void);
+      Invoke(sender: Microsoft.UI.Xaml.Controls.CalendarView, e: Microsoft.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs): void;
+    }
+    class CalendarViewDisplayMode extends System.Enum {
+      value__: number;
+      static Month: number;
+      static Year: number;
+      static Decade: number;
+    }
+    class CalendarViewSelectedDatesChangedEventArgs implements Microsoft.UI.Xaml.Controls.ICalendarViewSelectedDatesChangedEventArgs {
+      readonly AddedDates: System.Collections.Generic.IReadOnlyList<System.DateTimeOffset>;
+      readonly RemovedDates: System.Collections.Generic.IReadOnlyList<System.DateTimeOffset>;
+    }
+    class CalendarViewSelectionMode extends System.Enum {
+      value__: number;
+      static None: number;
+      static Single: number;
+      static Multiple: number;
+    }
+    class CandidateWindowAlignment extends System.Enum {
+      value__: number;
+      static Default: number;
+      static BottomEdge: number;
+    }
+    class CandidateWindowBoundsChangedEventArgs implements Microsoft.UI.Xaml.Controls.ICandidateWindowBoundsChangedEventArgs {
+      readonly Bounds: Windows.Foundation.Rect;
+    }
+    class Panel extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.IPanel {
+      ChildrenTransitions: Microsoft.UI.Xaml.Media.Animation.TransitionCollection;
+      BackgroundTransition: Microsoft.UI.Xaml.BrushTransition;
+      Background: Microsoft.UI.Xaml.Media.Brush;
+      readonly Children: Microsoft.UI.Xaml.Controls.UIElementCollection;
+      readonly IsItemsHost: boolean;
+      static readonly BackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ChildrenTransitionsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsItemsHostProperty: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class Canvas extends Microsoft.UI.Xaml.Controls.Panel implements Microsoft.UI.Xaml.Controls.ICanvas {
+      static readonly LeftProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TopProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ZIndexProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      static GetLeft(result: Microsoft.UI.Xaml.UIElement): number;
+      static SetLeft(element: Microsoft.UI.Xaml.UIElement, length: number): void;
+      static GetTop(result: Microsoft.UI.Xaml.UIElement): number;
+      static SetTop(element: Microsoft.UI.Xaml.UIElement, length: number): void;
+      static GetZIndex(result: Microsoft.UI.Xaml.UIElement): number;
+      static SetZIndex(element: Microsoft.UI.Xaml.UIElement, value: number): void;
+    }
+    class CharacterCasing extends System.Enum {
+      value__: number;
+      static Normal: number;
+      static Lower: number;
+      static Upper: number;
+    }
+    class CheckBox extends Microsoft.UI.Xaml.Controls.Primitives.ToggleButton implements Microsoft.UI.Xaml.Controls.ICheckBox {
+      constructor();
+    }
+    class ChoosingGroupHeaderContainerEventArgs implements Microsoft.UI.Xaml.Controls.IChoosingGroupHeaderContainerEventArgs {
+      GroupHeaderContainer: Microsoft.UI.Xaml.Controls.ListViewBaseHeaderItem;
+      readonly Group: any;
+      readonly GroupIndex: number;
+      constructor();
+    }
+    class ChoosingItemContainerEventArgs implements Microsoft.UI.Xaml.Controls.IChoosingItemContainerEventArgs {
+      ItemContainer: Microsoft.UI.Xaml.Controls.Primitives.SelectorItem;
+      IsContainerPrepared: boolean;
+      readonly Item: any;
+      readonly ItemIndex: number;
+      constructor();
+    }
+    class CleanUpVirtualizedItemEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Controls.ICleanUpVirtualizedItemEventArgs {
+      Cancel: boolean;
+      readonly UIElement: Microsoft.UI.Xaml.UIElement;
+      readonly Value: any;
+    }
+    class CleanUpVirtualizedItemEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs): void;
+    }
+    class ClickMode extends System.Enum {
+      value__: number;
+      static Release: number;
+      static Press: number;
+      static Hover: number;
+    }
+    class ColorChangedEventArgs implements Microsoft.UI.Xaml.Controls.IColorChangedEventArgs {
+      readonly NewColor: Windows.UI.Color;
+      readonly OldColor: Windows.UI.Color;
+    }
+    class ColorPicker extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IColorPicker, Microsoft.UI.Xaml.Controls.IColorPicker2 {
+      ColorChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ColorPicker, Microsoft.UI.Xaml.Controls.ColorChangedEventArgs> | null;
+      PreviousColor: System.Nullable<Windows.UI.Color>;
+      MinValue: number;
+      MinSaturation: number;
+      MinHue: number;
+      MaxValue: number;
+      MaxSaturation: number;
+      MaxHue: number;
+      IsMoreButtonVisible: boolean;
+      IsHexInputVisible: boolean;
+      IsColorSpectrumVisible: boolean;
+      IsColorSliderVisible: boolean;
+      IsColorPreviewVisible: boolean;
+      IsColorChannelTextInputVisible: boolean;
+      IsAlphaTextInputVisible: boolean;
+      IsAlphaSliderVisible: boolean;
+      IsAlphaEnabled: boolean;
+      ColorSpectrumShape: number;
+      ColorSpectrumComponents: number;
+      Color: Windows.UI.Color;
+      Orientation: number;
+      static readonly ColorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ColorSpectrumComponentsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ColorSpectrumShapeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsAlphaEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsAlphaSliderVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsAlphaTextInputVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsColorChannelTextInputVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsColorPreviewVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsColorSliderVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsColorSpectrumVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsHexInputVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsMoreButtonVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxHueProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxSaturationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxValueProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinHueProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinSaturationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinValueProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PreviousColorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OrientationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ColorPickerHsvChannel extends System.Enum {
+      value__: number;
+      static Hue: number;
+      static Saturation: number;
+      static Value: number;
+      static Alpha: number;
+    }
+    class ColorSpectrumComponents extends System.Enum {
+      value__: number;
+      static HueValue: number;
+      static ValueHue: number;
+      static HueSaturation: number;
+      static SaturationHue: number;
+      static SaturationValue: number;
+      static ValueSaturation: number;
+    }
+    class ColorSpectrumShape extends System.Enum {
+      value__: number;
+      static Box: number;
+      static Ring: number;
+    }
+    class ColumnDefinition extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IColumnDefinition {
+      Width: Microsoft.UI.Xaml.GridLength;
+      MinWidth: number;
+      MaxWidth: number;
+      readonly ActualWidth: number;
+      static readonly MaxWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly WidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ColumnDefinitionCollection {
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class ComboBox extends Microsoft.UI.Xaml.Controls.Primitives.Selector implements Microsoft.UI.Xaml.Controls.IComboBox, Microsoft.UI.Xaml.Controls.IComboBoxOverrides {
+      DropDownClosed: System.EventHandler<any> | null;
+      DropDownOpened: System.EventHandler<any> | null;
+      TextSubmitted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ComboBox, Microsoft.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs> | null;
+      TextBoxStyle: Microsoft.UI.Xaml.Style;
+      Text: string;
+      SelectionChangedTrigger: number;
+      PlaceholderText: string;
+      PlaceholderForeground: Microsoft.UI.Xaml.Media.Brush;
+      MaxDropDownHeight: number;
+      LightDismissOverlayMode: number;
+      IsTextSearchEnabled: boolean;
+      IsEditable: boolean;
+      IsDropDownOpen: boolean;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Header: any;
+      Description: any;
+      readonly IsSelectionBoxHighlighted: boolean;
+      readonly SelectionBoxItem: any;
+      readonly SelectionBoxItemTemplate: Microsoft.UI.Xaml.DataTemplate;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.Primitives.ComboBoxTemplateSettings;
+      static readonly DescriptionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsDropDownOpenProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsEditableProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTextSearchEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LightDismissOverlayModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxDropDownHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlaceholderForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlaceholderTextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionChangedTriggerProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextBoxStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ComboBoxItem extends Microsoft.UI.Xaml.Controls.Primitives.SelectorItem implements Microsoft.UI.Xaml.Controls.IComboBoxItem {
+      constructor();
+    }
+    class ComboBoxSelectionChangedTrigger extends System.Enum {
+      value__: number;
+      static Committed: number;
+      static Always: number;
+    }
+    class ComboBoxTextSubmittedEventArgs implements Microsoft.UI.Xaml.Controls.IComboBoxTextSubmittedEventArgs {
+      Handled: boolean;
+      readonly Text: string;
+    }
+    class CommandBar extends Microsoft.UI.Xaml.Controls.AppBar implements Microsoft.UI.Xaml.Controls.ICommandBar {
+      DynamicOverflowItemsChanging: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.CommandBar, Microsoft.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs> | null;
+      OverflowButtonVisibility: number;
+      IsDynamicOverflowEnabled: boolean;
+      DefaultLabelPosition: number;
+      CommandBarOverflowPresenterStyle: Microsoft.UI.Xaml.Style;
+      readonly CommandBarTemplateSettings: Microsoft.UI.Xaml.Controls.Primitives.CommandBarTemplateSettings;
+      readonly PrimaryCommands: Windows.Foundation.Collections.IObservableVector<Microsoft.UI.Xaml.Controls.ICommandBarElement>;
+      readonly SecondaryCommands: Windows.Foundation.Collections.IObservableVector<Microsoft.UI.Xaml.Controls.ICommandBarElement>;
+      static readonly CommandBarOverflowPresenterStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DefaultLabelPositionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsDynamicOverflowEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OverflowButtonVisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PrimaryCommandsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SecondaryCommandsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class CommandBarDefaultLabelPosition extends System.Enum {
+      value__: number;
+      static Bottom: number;
+      static Right: number;
+      static Collapsed: number;
+    }
+    class CommandBarDynamicOverflowAction extends System.Enum {
+      value__: number;
+      static AddingToOverflow: number;
+      static RemovingFromOverflow: number;
+    }
+    class CommandBarFlyout extends Microsoft.UI.Xaml.Controls.Primitives.FlyoutBase implements Microsoft.UI.Xaml.Controls.ICommandBarFlyout, Microsoft.UI.Xaml.Controls.ICommandBarFlyout2 {
+      readonly PrimaryCommands: Windows.Foundation.Collections.IObservableVector<Microsoft.UI.Xaml.Controls.ICommandBarElement>;
+      readonly SecondaryCommands: Windows.Foundation.Collections.IObservableVector<Microsoft.UI.Xaml.Controls.ICommandBarElement>;
+      AlwaysExpanded: boolean;
+      constructor();
+    }
+    class CommandBarLabelPosition extends System.Enum {
+      value__: number;
+      static Default: number;
+      static Collapsed: number;
+    }
+    class CommandBarOverflowButtonVisibility extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Visible: number;
+      static Collapsed: number;
+    }
+    class CommandBarOverflowPresenter extends Microsoft.UI.Xaml.Controls.ItemsControl implements Microsoft.UI.Xaml.Controls.ICommandBarOverflowPresenter {
+      constructor();
+    }
+    class ContainerContentChangingEventArgs implements Microsoft.UI.Xaml.Controls.IContainerContentChangingEventArgs {
+      Handled: boolean;
+      readonly InRecycleQueue: boolean;
+      readonly Item: any;
+      readonly ItemContainer: Microsoft.UI.Xaml.Controls.Primitives.SelectorItem;
+      readonly ItemIndex: number;
+      readonly Phase: number;
+      constructor();
+      RegisterUpdateCallback(callback: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ListViewBase, Microsoft.UI.Xaml.Controls.ContainerContentChangingEventArgs>): void;
+      RegisterUpdateCallback(callbackPhase: number, callback: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ListViewBase, Microsoft.UI.Xaml.Controls.ContainerContentChangingEventArgs>): void;
+    }
+    class ContentDialog extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.IContentDialog {
+      CloseButtonClick: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ContentDialog, Microsoft.UI.Xaml.Controls.ContentDialogButtonClickEventArgs> | null;
+      Closed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ContentDialog, Microsoft.UI.Xaml.Controls.ContentDialogClosedEventArgs> | null;
+      Closing: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ContentDialog, Microsoft.UI.Xaml.Controls.ContentDialogClosingEventArgs> | null;
+      Opened: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ContentDialog, Microsoft.UI.Xaml.Controls.ContentDialogOpenedEventArgs> | null;
+      PrimaryButtonClick: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ContentDialog, Microsoft.UI.Xaml.Controls.ContentDialogButtonClickEventArgs> | null;
+      SecondaryButtonClick: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ContentDialog, Microsoft.UI.Xaml.Controls.ContentDialogButtonClickEventArgs> | null;
+      TitleTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Title: any;
+      SecondaryButtonText: string;
+      SecondaryButtonStyle: Microsoft.UI.Xaml.Style;
+      SecondaryButtonCommandParameter: any;
+      SecondaryButtonCommand: Microsoft.UI.Xaml.Input.ICommand;
+      PrimaryButtonText: string;
+      PrimaryButtonStyle: Microsoft.UI.Xaml.Style;
+      PrimaryButtonCommandParameter: any;
+      PrimaryButtonCommand: Microsoft.UI.Xaml.Input.ICommand;
+      IsSecondaryButtonEnabled: boolean;
+      IsPrimaryButtonEnabled: boolean;
+      FullSizeDesired: boolean;
+      DefaultButton: number;
+      CloseButtonText: string;
+      CloseButtonStyle: Microsoft.UI.Xaml.Style;
+      CloseButtonCommandParameter: any;
+      CloseButtonCommand: Microsoft.UI.Xaml.Input.ICommand;
+      static readonly CloseButtonCommandParameterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CloseButtonCommandProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CloseButtonStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CloseButtonTextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DefaultButtonProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FullSizeDesiredProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsPrimaryButtonEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsSecondaryButtonEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PrimaryButtonCommandParameterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PrimaryButtonCommandProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PrimaryButtonStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PrimaryButtonTextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SecondaryButtonCommandParameterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SecondaryButtonCommandProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SecondaryButtonStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SecondaryButtonTextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TitleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TitleTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      Hide(): void;
+      ShowAsync(): Windows.Foundation.IAsyncOperation<number>;
+      ShowAsync(operation: number): Windows.Foundation.IAsyncOperation<number>;
+    }
+    class ContentDialogButton extends System.Enum {
+      value__: number;
+      static None: number;
+      static Primary: number;
+      static Secondary: number;
+      static Close: number;
+    }
+    class ContentDialogButtonClickDeferral implements Microsoft.UI.Xaml.Controls.IContentDialogButtonClickDeferral {
+      Complete(): void;
+    }
+    class ContentDialogButtonClickEventArgs implements Microsoft.UI.Xaml.Controls.IContentDialogButtonClickEventArgs {
+      Cancel: boolean;
+      GetDeferral(): Microsoft.UI.Xaml.Controls.ContentDialogButtonClickDeferral;
+    }
+    class ContentDialogClosedEventArgs implements Microsoft.UI.Xaml.Controls.IContentDialogClosedEventArgs {
+      readonly Result: number;
+    }
+    class ContentDialogClosingDeferral implements Microsoft.UI.Xaml.Controls.IContentDialogClosingDeferral {
+      Complete(): void;
+    }
+    class ContentDialogClosingEventArgs implements Microsoft.UI.Xaml.Controls.IContentDialogClosingEventArgs {
+      Cancel: boolean;
+      readonly Result: number;
+      GetDeferral(): Microsoft.UI.Xaml.Controls.ContentDialogClosingDeferral;
+    }
+    class ContentDialogOpenedEventArgs implements Microsoft.UI.Xaml.Controls.IContentDialogOpenedEventArgs {
+    }
+    class ContentDialogPlacement extends System.Enum {
+      value__: number;
+      static Popup: number;
+      static InPlace: number;
+    }
+    class ContentDialogResult extends System.Enum {
+      value__: number;
+      static None: number;
+      static Primary: number;
+      static Secondary: number;
+    }
+    class ContentPresenter extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.IContentPresenter, Microsoft.UI.Xaml.Controls.IContentPresenterOverrides {
+      VerticalContentAlignment: number;
+      TextWrapping: number;
+      TextLineBounds: number;
+      Padding: Microsoft.UI.Xaml.Thickness;
+      OpticalMarginAlignment: number;
+      MaxLines: number;
+      LineStackingStrategy: number;
+      LineHeight: number;
+      IsTextScaleFactorEnabled: boolean;
+      HorizontalContentAlignment: number;
+      Foreground: Microsoft.UI.Xaml.Media.Brush;
+      FontWeight: Windows.UI.Text.FontWeight;
+      FontStyle: Windows.UI.Text.FontStyle;
+      FontStretch: Windows.UI.Text.FontStretch;
+      FontSize: number;
+      FontFamily: Microsoft.UI.Xaml.Media.FontFamily;
+      CornerRadius: Microsoft.UI.Xaml.CornerRadius;
+      ContentTransitions: Microsoft.UI.Xaml.Media.Animation.TransitionCollection;
+      ContentTemplateSelector: Microsoft.UI.Xaml.Controls.DataTemplateSelector;
+      ContentTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Content: any;
+      CharacterSpacing: number;
+      BorderThickness: Microsoft.UI.Xaml.Thickness;
+      BorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      BackgroundTransition: Microsoft.UI.Xaml.BrushTransition;
+      BackgroundSizing: number;
+      Background: Microsoft.UI.Xaml.Media.Brush;
+      static readonly BackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BackgroundSizingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BorderThicknessProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CharacterSpacingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentTemplateSelectorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentTransitionsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CornerRadiusProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontFamilyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontSizeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontStretchProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontWeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalContentAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTextScaleFactorEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LineHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LineStackingStrategyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxLinesProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OpticalMarginAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaddingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextLineBoundsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextWrappingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalContentAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ContextMenuEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Controls.IContextMenuEventArgs {
+      Handled: boolean;
+      readonly CursorLeft: number;
+      readonly CursorTop: number;
+    }
+    class ContextMenuOpeningEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Controls.ContextMenuEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Controls.ContextMenuEventArgs): void;
+    }
+    class ControlTemplate extends Microsoft.UI.Xaml.FrameworkTemplate implements Microsoft.UI.Xaml.Controls.IControlTemplate {
+      TargetType: System.Type;
+      constructor();
+    }
+    class CoreWebView2InitializedEventArgs implements Microsoft.UI.Xaml.Controls.ICoreWebView2InitializedEventArgs {
+      readonly Exception: System.Exception;
+    }
+    class DataTemplateSelector implements Microsoft.UI.Xaml.Controls.IDataTemplateSelector, Microsoft.UI.Xaml.Controls.IDataTemplateSelectorOverrides, Microsoft.UI.Xaml.IElementFactory {
+      constructor();
+      SelectTemplate(result: any, item: Microsoft.UI.Xaml.DependencyObject): Microsoft.UI.Xaml.DataTemplate;
+      SelectTemplate(result: any): Microsoft.UI.Xaml.DataTemplate;
+      GetElement(result: Microsoft.UI.Xaml.ElementFactoryGetArgs): Microsoft.UI.Xaml.UIElement;
+      RecycleElement(args: Microsoft.UI.Xaml.ElementFactoryRecycleArgs): void;
+    }
+    class DatePickedEventArgs extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IDatePickedEventArgs {
+      readonly NewDate: System.DateTimeOffset;
+      readonly OldDate: System.DateTimeOffset;
+      constructor();
+    }
+    class DatePicker extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IDatePicker {
+      DateChanged: System.EventHandler<Microsoft.UI.Xaml.Controls.DatePickerValueChangedEventArgs> | null;
+      SelectedDateChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.DatePicker, Microsoft.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs> | null;
+      YearVisible: boolean;
+      YearFormat: string;
+      SelectedDate: System.Nullable<System.DateTimeOffset>;
+      Orientation: number;
+      MonthVisible: boolean;
+      MonthFormat: string;
+      MinYear: System.DateTimeOffset;
+      MaxYear: System.DateTimeOffset;
+      LightDismissOverlayMode: number;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Header: any;
+      DayVisible: boolean;
+      DayFormat: string;
+      Date: System.DateTimeOffset;
+      CalendarIdentifier: string;
+      static readonly CalendarIdentifierProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DayFormatProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DayVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LightDismissOverlayModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxYearProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinYearProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MonthFormatProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MonthVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OrientationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedDateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly YearFormatProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly YearVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class DatePickerFlyout extends Microsoft.UI.Xaml.Controls.Primitives.PickerFlyoutBase implements Microsoft.UI.Xaml.Controls.IDatePickerFlyout {
+      DatePicked: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.DatePickerFlyout, Microsoft.UI.Xaml.Controls.DatePickedEventArgs> | null;
+      YearVisible: boolean;
+      YearFormat: string;
+      MonthVisible: boolean;
+      MonthFormat: string;
+      MinYear: System.DateTimeOffset;
+      MaxYear: System.DateTimeOffset;
+      DayVisible: boolean;
+      DayFormat: string;
+      Date: System.DateTimeOffset;
+      CalendarIdentifier: string;
+      static readonly CalendarIdentifierProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DayFormatProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DayVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxYearProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinYearProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MonthFormatProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MonthVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly YearFormatProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly YearVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      ShowAtAsync(operation: Microsoft.UI.Xaml.FrameworkElement): Windows.Foundation.IAsyncOperation<System.Nullable<System.DateTimeOffset>>;
+    }
+    class DatePickerFlyoutItem extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IDatePickerFlyoutItem, Microsoft.UI.Xaml.Data.ICustomPropertyProvider {
+      SecondaryText: string;
+      PrimaryText: string;
+      readonly Type: System.Type;
+      static readonly PrimaryTextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SecondaryTextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      GetCustomProperty(result: string): Microsoft.UI.Xaml.Data.ICustomProperty;
+      GetIndexedProperty(result: string, name: System.Type): Microsoft.UI.Xaml.Data.ICustomProperty;
+      GetStringRepresentation(): string;
+    }
+    class DatePickerFlyoutPresenter extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IDatePickerFlyoutPresenter {
+      IsDefaultShadowEnabled: boolean;
+      static readonly IsDefaultShadowEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class DatePickerSelectedValueChangedEventArgs implements Microsoft.UI.Xaml.Controls.IDatePickerSelectedValueChangedEventArgs {
+      readonly NewDate: System.Nullable<System.DateTimeOffset>;
+      readonly OldDate: System.Nullable<System.DateTimeOffset>;
+    }
+    class DatePickerValueChangedEventArgs implements Microsoft.UI.Xaml.Controls.IDatePickerValueChangedEventArgs {
+      readonly NewDate: System.DateTimeOffset;
+      readonly OldDate: System.DateTimeOffset;
+    }
+    class DisabledFormattingAccelerators extends System.Enum {
+      value__: number;
+      static None: number;
+      static Bold: number;
+      static Italic: number;
+      static Underline: number;
+      static All: number;
+    }
+    class DragItemsCompletedEventArgs implements Microsoft.UI.Xaml.Controls.IDragItemsCompletedEventArgs {
+      readonly DropResult: Windows.ApplicationModel.DataTransfer.DataPackageOperation;
+      readonly Items: System.Collections.Generic.IReadOnlyList<any>;
+    }
+    class DragItemsStartingEventArgs implements Microsoft.UI.Xaml.Controls.IDragItemsStartingEventArgs {
+      Cancel: boolean;
+      readonly Data: Windows.ApplicationModel.DataTransfer.DataPackage;
+      readonly Items: System.Collections.Generic.IList<any>;
+      constructor();
+    }
+    class DragItemsStartingEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Controls.DragItemsStartingEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Controls.DragItemsStartingEventArgs): void;
+    }
+    class DropDownButton extends Microsoft.UI.Xaml.Controls.Button implements Microsoft.UI.Xaml.Controls.IDropDownButton {
+      constructor();
+    }
+    class DynamicOverflowItemsChangingEventArgs implements Microsoft.UI.Xaml.Controls.IDynamicOverflowItemsChangingEventArgs {
+      readonly Action: number;
+      constructor();
+    }
+    class ElementRealizationOptions extends System.Enum {
+      value__: number;
+      static None: number;
+      static ForceCreate: number;
+      static SuppressAutoRecycle: number;
+    }
+    class ExpandDirection extends System.Enum {
+      value__: number;
+      static Down: number;
+      static Up: number;
+    }
+    class Expander extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.IExpander {
+      Collapsed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Expander, Microsoft.UI.Xaml.Controls.ExpanderCollapsedEventArgs> | null;
+      Expanding: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Expander, Microsoft.UI.Xaml.Controls.ExpanderExpandingEventArgs> | null;
+      IsExpanded: boolean;
+      HeaderTemplateSelector: Microsoft.UI.Xaml.Controls.DataTemplateSelector;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Header: any;
+      ExpandDirection: number;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.ExpanderTemplateSettings;
+      static readonly ExpandDirectionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateSelectorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsExpandedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ExpanderCollapsedEventArgs implements Microsoft.UI.Xaml.Controls.IExpanderCollapsedEventArgs {
+    }
+    class ExpanderExpandingEventArgs implements Microsoft.UI.Xaml.Controls.IExpanderExpandingEventArgs {
+    }
+    class ExpanderTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IExpanderTemplateSettings {
+      readonly ContentHeight: number;
+      readonly NegativeContentHeight: number;
+    }
+    class FlipView extends Microsoft.UI.Xaml.Controls.Primitives.Selector implements Microsoft.UI.Xaml.Controls.IFlipView {
+      UseTouchAnimationsForAllNavigation: boolean;
+      static readonly UseTouchAnimationsForAllNavigationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class FlipViewItem extends Microsoft.UI.Xaml.Controls.Primitives.SelectorItem implements Microsoft.UI.Xaml.Controls.IFlipViewItem {
+      constructor();
+    }
+    class Flyout extends Microsoft.UI.Xaml.Controls.Primitives.FlyoutBase implements Microsoft.UI.Xaml.Controls.IFlyout {
+      FlyoutPresenterStyle: Microsoft.UI.Xaml.Style;
+      Content: Microsoft.UI.Xaml.UIElement;
+      static readonly ContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FlyoutPresenterStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class FlyoutPresenter extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.IFlyoutPresenter {
+      IsDefaultShadowEnabled: boolean;
+      static readonly IsDefaultShadowEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class FocusDisengagedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Controls.IFocusDisengagedEventArgs {
+    }
+    class FocusEngagedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Controls.IFocusEngagedEventArgs {
+      Handled: boolean;
+    }
+    class FontIcon extends Microsoft.UI.Xaml.Controls.IconElement implements Microsoft.UI.Xaml.Controls.IFontIcon {
+      MirroredWhenRightToLeft: boolean;
+      IsTextScaleFactorEnabled: boolean;
+      Glyph: string;
+      FontWeight: Windows.UI.Text.FontWeight;
+      FontStyle: Windows.UI.Text.FontStyle;
+      FontSize: number;
+      FontFamily: Microsoft.UI.Xaml.Media.FontFamily;
+      static readonly FontFamilyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontSizeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontWeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GlyphProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTextScaleFactorEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MirroredWhenRightToLeftProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class FontIconSource extends Microsoft.UI.Xaml.Controls.IconSource implements Microsoft.UI.Xaml.Controls.IFontIconSource {
+      MirroredWhenRightToLeft: boolean;
+      IsTextScaleFactorEnabled: boolean;
+      Glyph: string;
+      FontWeight: Windows.UI.Text.FontWeight;
+      FontStyle: Windows.UI.Text.FontStyle;
+      FontSize: number;
+      FontFamily: Microsoft.UI.Xaml.Media.FontFamily;
+      static readonly FontFamilyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontSizeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontWeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GlyphProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTextScaleFactorEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MirroredWhenRightToLeftProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class Frame extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.IFrame, Microsoft.UI.Xaml.Controls.INavigate {
+      Navigated: Microsoft.UI.Xaml.Navigation.NavigatedEventHandler | null;
+      Navigating: Microsoft.UI.Xaml.Navigation.NavigatingCancelEventHandler | null;
+      NavigationFailed: Microsoft.UI.Xaml.Navigation.NavigationFailedEventHandler | null;
+      NavigationStopped: Microsoft.UI.Xaml.Navigation.NavigationStoppedEventHandler | null;
+      SourcePageType: System.Type;
+      IsNavigationStackEnabled: boolean;
+      CacheSize: number;
+      readonly BackStack: System.Collections.Generic.IList<Microsoft.UI.Xaml.Navigation.PageStackEntry>;
+      readonly BackStackDepth: number;
+      readonly CanGoBack: boolean;
+      readonly CanGoForward: boolean;
+      readonly CurrentSourcePageType: System.Type;
+      readonly ForwardStack: System.Collections.Generic.IList<Microsoft.UI.Xaml.Navigation.PageStackEntry>;
+      static readonly BackStackDepthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BackStackProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CacheSizeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CanGoBackProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CanGoForwardProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CurrentSourcePageTypeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ForwardStackProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsNavigationStackEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SourcePageTypeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      GoBack(): void;
+      GoBack(transitionInfoOverride: Microsoft.UI.Xaml.Media.Animation.NavigationTransitionInfo): void;
+      GoForward(): void;
+      Navigate(result: System.Type, sourcePageType: any): boolean;
+      Navigate(result: System.Type, sourcePageType: any, parameter: Microsoft.UI.Xaml.Media.Animation.NavigationTransitionInfo): boolean;
+      NavigateToType(result: System.Type, sourcePageType: any, parameter: Microsoft.UI.Xaml.Navigation.FrameNavigationOptions): boolean;
+      GetNavigationState(): string;
+      SetNavigationState(navigationState: string): void;
+      SetNavigationState(navigationState: string, suppressNavigate: boolean): void;
+      Navigate(result: System.Type): boolean;
+    }
+    class Grid extends Microsoft.UI.Xaml.Controls.Panel implements Microsoft.UI.Xaml.Controls.IGrid {
+      RowSpacing: number;
+      Padding: Microsoft.UI.Xaml.Thickness;
+      CornerRadius: Microsoft.UI.Xaml.CornerRadius;
+      ColumnSpacing: number;
+      BorderThickness: Microsoft.UI.Xaml.Thickness;
+      BorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      BackgroundSizing: number;
+      readonly ColumnDefinitions: Microsoft.UI.Xaml.Controls.ColumnDefinitionCollection;
+      readonly RowDefinitions: Microsoft.UI.Xaml.Controls.RowDefinitionCollection;
+      static readonly BackgroundSizingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BorderThicknessProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ColumnProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ColumnSpacingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ColumnSpanProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CornerRadiusProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaddingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RowProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RowSpacingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RowSpanProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      static GetRow(result: Microsoft.UI.Xaml.FrameworkElement): number;
+      static SetRow(element: Microsoft.UI.Xaml.FrameworkElement, value: number): void;
+      static GetColumn(result: Microsoft.UI.Xaml.FrameworkElement): number;
+      static SetColumn(element: Microsoft.UI.Xaml.FrameworkElement, value: number): void;
+      static GetRowSpan(result: Microsoft.UI.Xaml.FrameworkElement): number;
+      static SetRowSpan(element: Microsoft.UI.Xaml.FrameworkElement, value: number): void;
+      static GetColumnSpan(result: Microsoft.UI.Xaml.FrameworkElement): number;
+      static SetColumnSpan(element: Microsoft.UI.Xaml.FrameworkElement, value: number): void;
+    }
+    class ListViewBase extends Microsoft.UI.Xaml.Controls.Primitives.Selector implements Microsoft.UI.Xaml.Controls.IListViewBase, Microsoft.UI.Xaml.Controls.ISemanticZoomInformation {
+      ChoosingGroupHeaderContainer: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ListViewBase, Microsoft.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs> | null;
+      ChoosingItemContainer: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ListViewBase, Microsoft.UI.Xaml.Controls.ChoosingItemContainerEventArgs> | null;
+      ContainerContentChanging: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ListViewBase, Microsoft.UI.Xaml.Controls.ContainerContentChangingEventArgs> | null;
+      DragItemsCompleted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ListViewBase, Microsoft.UI.Xaml.Controls.DragItemsCompletedEventArgs> | null;
+      DragItemsStarting: Microsoft.UI.Xaml.Controls.DragItemsStartingEventHandler | null;
+      ItemClick: Microsoft.UI.Xaml.Controls.ItemClickEventHandler | null;
+      SingleSelectionFollowsFocus: boolean;
+      ShowsScrollingPlaceholders: boolean;
+      SelectionMode: number;
+      ReorderMode: number;
+      IsSwipeEnabled: boolean;
+      IsMultiSelectCheckBoxEnabled: boolean;
+      IsItemClickEnabled: boolean;
+      IncrementalLoadingTrigger: number;
+      IncrementalLoadingThreshold: number;
+      HeaderTransitions: Microsoft.UI.Xaml.Media.Animation.TransitionCollection;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Header: any;
+      FooterTransitions: Microsoft.UI.Xaml.Media.Animation.TransitionCollection;
+      FooterTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Footer: any;
+      DataFetchSize: number;
+      CanReorderItems: boolean;
+      CanDragItems: boolean;
+      readonly SelectedItems: System.Collections.Generic.IList<any>;
+      readonly SelectedRanges: System.Collections.Generic.IReadOnlyList<Microsoft.UI.Xaml.Data.ItemIndexRange>;
+      SemanticZoomOwner: Microsoft.UI.Xaml.Controls.SemanticZoom;
+      IsZoomedInView: boolean;
+      IsActiveView: boolean;
+      static readonly CanDragItemsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CanReorderItemsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DataFetchSizeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FooterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FooterTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FooterTransitionsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTransitionsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IncrementalLoadingThresholdProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IncrementalLoadingTriggerProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsActiveViewProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsItemClickEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsMultiSelectCheckBoxEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsSwipeEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsZoomedInViewProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ReorderModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SemanticZoomOwnerProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ShowsScrollingPlaceholdersProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SingleSelectionFollowsFocusProperty: Microsoft.UI.Xaml.DependencyProperty;
+      ScrollIntoView(item: any): void;
+      SelectAll(): void;
+      LoadMoreItemsAsync(): Windows.Foundation.IAsyncOperation<Microsoft.UI.Xaml.Data.LoadMoreItemsResult>;
+      ScrollIntoView(item: any, alignment: number): void;
+      SetDesiredContainerUpdateDuration(duration: System.TimeSpan): void;
+      SelectRange(itemIndexRange: Microsoft.UI.Xaml.Data.ItemIndexRange): void;
+      DeselectRange(itemIndexRange: Microsoft.UI.Xaml.Data.ItemIndexRange): void;
+      IsDragSource(): boolean;
+      TryStartConnectedAnimationAsync(operation: Microsoft.UI.Xaml.Media.Animation.ConnectedAnimation, animation: any, item: string): Windows.Foundation.IAsyncOperation<boolean>;
+      PrepareConnectedAnimation(result: string, key: any, item: string): Microsoft.UI.Xaml.Media.Animation.ConnectedAnimation;
+      InitializeViewChange(): void;
+      CompleteViewChange(): void;
+      MakeVisible(item: Microsoft.UI.Xaml.Controls.SemanticZoomLocation): void;
+      StartViewChangeFrom(source: Microsoft.UI.Xaml.Controls.SemanticZoomLocation, destination: Microsoft.UI.Xaml.Controls.SemanticZoomLocation): void;
+      StartViewChangeTo(source: Microsoft.UI.Xaml.Controls.SemanticZoomLocation, destination: Microsoft.UI.Xaml.Controls.SemanticZoomLocation): void;
+      CompleteViewChangeFrom(source: Microsoft.UI.Xaml.Controls.SemanticZoomLocation, destination: Microsoft.UI.Xaml.Controls.SemanticZoomLocation): void;
+      CompleteViewChangeTo(source: Microsoft.UI.Xaml.Controls.SemanticZoomLocation, destination: Microsoft.UI.Xaml.Controls.SemanticZoomLocation): void;
+    }
+    class GridView extends Microsoft.UI.Xaml.Controls.ListViewBase implements Microsoft.UI.Xaml.Controls.IGridView {
+      constructor();
+    }
+    class ListViewBaseHeaderItem extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.IListViewBaseHeaderItem {
+    }
+    class GridViewHeaderItem extends Microsoft.UI.Xaml.Controls.ListViewBaseHeaderItem implements Microsoft.UI.Xaml.Controls.IGridViewHeaderItem {
+      constructor();
+    }
+    class GridViewItem extends Microsoft.UI.Xaml.Controls.Primitives.SelectorItem implements Microsoft.UI.Xaml.Controls.IGridViewItem {
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.Primitives.GridViewItemTemplateSettings;
+      constructor();
+    }
+    class GroupItem extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.IGroupItem {
+      constructor();
+    }
+    class GroupStyle implements Microsoft.UI.Xaml.Controls.IGroupStyle, Microsoft.UI.Xaml.Data.INotifyPropertyChanged {
+      PropertyChanged: Microsoft.UI.Xaml.Data.PropertyChangedEventHandler | null;
+      Panel: Microsoft.UI.Xaml.Controls.ItemsPanelTemplate;
+      HidesIfEmpty: boolean;
+      HeaderTemplateSelector: Microsoft.UI.Xaml.Controls.DataTemplateSelector;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      HeaderContainerStyle: Microsoft.UI.Xaml.Style;
+      ContainerStyleSelector: Microsoft.UI.Xaml.Controls.StyleSelector;
+      ContainerStyle: Microsoft.UI.Xaml.Style;
+      constructor();
+    }
+    class GroupStyleSelector implements Microsoft.UI.Xaml.Controls.IGroupStyleSelector, Microsoft.UI.Xaml.Controls.IGroupStyleSelectorOverrides {
+      constructor();
+      SelectGroupStyle(result: any, group: number): Microsoft.UI.Xaml.Controls.GroupStyle;
+    }
+    class HasValidationErrorsChangedEventArgs implements Microsoft.UI.Xaml.Controls.IHasValidationErrorsChangedEventArgs {
+      readonly NewValue: boolean;
+    }
+    class Hub extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IHub, Microsoft.UI.Xaml.Controls.ISemanticZoomInformation {
+      SectionHeaderClick: Microsoft.UI.Xaml.Controls.HubSectionHeaderClickEventHandler | null;
+      SectionsInViewChanged: Microsoft.UI.Xaml.Controls.SectionsInViewChangedEventHandler | null;
+      Orientation: number;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Header: any;
+      DefaultSectionIndex: number;
+      readonly SectionHeaders: Windows.Foundation.Collections.IObservableVector<any>;
+      readonly Sections: System.Collections.Generic.IList<Microsoft.UI.Xaml.Controls.HubSection>;
+      readonly SectionsInView: System.Collections.Generic.IList<Microsoft.UI.Xaml.Controls.HubSection>;
+      SemanticZoomOwner: Microsoft.UI.Xaml.Controls.SemanticZoom;
+      IsZoomedInView: boolean;
+      IsActiveView: boolean;
+      static readonly DefaultSectionIndexProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsActiveViewProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsZoomedInViewProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OrientationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SemanticZoomOwnerProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      ScrollToSection(section: Microsoft.UI.Xaml.Controls.HubSection): void;
+      InitializeViewChange(): void;
+      CompleteViewChange(): void;
+      MakeVisible(item: Microsoft.UI.Xaml.Controls.SemanticZoomLocation): void;
+      StartViewChangeFrom(source: Microsoft.UI.Xaml.Controls.SemanticZoomLocation, destination: Microsoft.UI.Xaml.Controls.SemanticZoomLocation): void;
+      StartViewChangeTo(source: Microsoft.UI.Xaml.Controls.SemanticZoomLocation, destination: Microsoft.UI.Xaml.Controls.SemanticZoomLocation): void;
+      CompleteViewChangeFrom(source: Microsoft.UI.Xaml.Controls.SemanticZoomLocation, destination: Microsoft.UI.Xaml.Controls.SemanticZoomLocation): void;
+      CompleteViewChangeTo(source: Microsoft.UI.Xaml.Controls.SemanticZoomLocation, destination: Microsoft.UI.Xaml.Controls.SemanticZoomLocation): void;
+    }
+    class HubSection extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IHubSection {
+      IsHeaderInteractive: boolean;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Header: any;
+      ContentTemplate: Microsoft.UI.Xaml.DataTemplate;
+      static readonly ContentTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsHeaderInteractiveProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class HubSectionCollection {
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class HubSectionHeaderClickEventArgs implements Microsoft.UI.Xaml.Controls.IHubSectionHeaderClickEventArgs {
+      readonly Section: Microsoft.UI.Xaml.Controls.HubSection;
+      constructor();
+    }
+    class HubSectionHeaderClickEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Controls.HubSectionHeaderClickEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Controls.HubSectionHeaderClickEventArgs): void;
+    }
+    class HyperlinkButton extends Microsoft.UI.Xaml.Controls.Primitives.ButtonBase implements Microsoft.UI.Xaml.Controls.IHyperlinkButton {
+      NavigateUri: System.Uri;
+      static readonly NavigateUriProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    interface IAnimatedVisual {
+      readonly Duration: System.TimeSpan;
+      readonly RootVisual: Microsoft.UI.Composition.Visual;
+      readonly Size: System.Numerics.Vector2;
+    }
+    interface IAnimatedVisual2 extends Microsoft.UI.Xaml.Controls.IAnimatedVisual {
+      CreateAnimations(): void;
+      DestroyAnimations(): void;
+    }
+    interface IAnimatedVisualSource {
+      TryCreateAnimatedVisual(result: Microsoft.UI.Composition.Compositor, compositor: any): Microsoft.UI.Xaml.Controls.IAnimatedVisual;
+    }
+    interface IAnimatedVisualSource2 extends Microsoft.UI.Xaml.Controls.IAnimatedVisualSource {
+      readonly Markers: System.Collections.Generic.IReadOnlyDictionary<string, number>;
+      SetColorProperty(propertyName: string, value: Windows.UI.Color): void;
+    }
+    interface IAnimatedVisualSource3 {
+      TryCreateAnimatedVisual(result: Microsoft.UI.Composition.Compositor, compositor: any, diagnostics: boolean): Microsoft.UI.Xaml.Controls.IAnimatedVisual2;
+    }
+    interface ICommandBarElement {
+      DynamicOverflowOrder: number;
+      IsCompact: boolean;
+      readonly IsInOverflow: boolean;
+    }
+    interface IDynamicAnimatedVisualSource extends Microsoft.UI.Xaml.Controls.IAnimatedVisualSource {
+      AnimatedVisualInvalidated: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.IDynamicAnimatedVisualSource, any> | null;
+    }
+    interface IInsertionPanel {
+      GetInsertionIndexes(position: Windows.Foundation.Point, first: number, second: number): void;
+    }
+    interface IItemContainerMapping {
+      ItemFromContainer(result: Microsoft.UI.Xaml.DependencyObject): any;
+      ContainerFromItem(result: any): Microsoft.UI.Xaml.DependencyObject;
+      IndexFromContainer(result: Microsoft.UI.Xaml.DependencyObject): number;
+      ContainerFromIndex(result: number): Microsoft.UI.Xaml.DependencyObject;
+    }
+    interface IKeyIndexMapping {
+      KeyFromIndex(result: number): string;
+      IndexFromKey(result: string): number;
+    }
+    interface INavigate {
+      Navigate(result: System.Type): boolean;
+    }
+    interface IScrollAnchorProvider {
+      readonly CurrentAnchor: Microsoft.UI.Xaml.UIElement;
+      RegisterAnchorCandidate(element: Microsoft.UI.Xaml.UIElement): void;
+      UnregisterAnchorCandidate(element: Microsoft.UI.Xaml.UIElement): void;
+    }
+    interface ISemanticZoomInformation {
+      IsActiveView: boolean;
+      IsZoomedInView: boolean;
+      SemanticZoomOwner: Microsoft.UI.Xaml.Controls.SemanticZoom;
+      InitializeViewChange(): void;
+      CompleteViewChange(): void;
+      MakeVisible(item: Microsoft.UI.Xaml.Controls.SemanticZoomLocation): void;
+      StartViewChangeFrom(source: Microsoft.UI.Xaml.Controls.SemanticZoomLocation, destination: Microsoft.UI.Xaml.Controls.SemanticZoomLocation): void;
+      StartViewChangeTo(source: Microsoft.UI.Xaml.Controls.SemanticZoomLocation, destination: Microsoft.UI.Xaml.Controls.SemanticZoomLocation): void;
+      CompleteViewChangeFrom(source: Microsoft.UI.Xaml.Controls.SemanticZoomLocation, destination: Microsoft.UI.Xaml.Controls.SemanticZoomLocation): void;
+      CompleteViewChangeTo(source: Microsoft.UI.Xaml.Controls.SemanticZoomLocation, destination: Microsoft.UI.Xaml.Controls.SemanticZoomLocation): void;
+    }
+    class IconSourceElement extends Microsoft.UI.Xaml.Controls.IconElement implements Microsoft.UI.Xaml.Controls.IIconSourceElement {
+      IconSource: Microsoft.UI.Xaml.Controls.IconSource;
+      static readonly IconSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class Image extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.IImage {
+      ImageFailed: Microsoft.UI.Xaml.ExceptionRoutedEventHandler | null;
+      ImageOpened: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      Stretch: number;
+      Source: Microsoft.UI.Xaml.Media.ImageSource;
+      NineGrid: Microsoft.UI.Xaml.Thickness;
+      static readonly NineGridProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StretchProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      GetAsCastingSource(): Windows.Media.Casting.CastingSource;
+      GetAlphaMask(): Microsoft.UI.Composition.CompositionBrush;
+    }
+    class ImageIcon extends Microsoft.UI.Xaml.Controls.IconElement implements Microsoft.UI.Xaml.Controls.IImageIcon {
+      Source: Microsoft.UI.Xaml.Media.ImageSource;
+      static readonly SourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ImageIconSource extends Microsoft.UI.Xaml.Controls.IconSource implements Microsoft.UI.Xaml.Controls.IImageIconSource {
+      ImageSource: Microsoft.UI.Xaml.Media.ImageSource;
+      static readonly ImageSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class IncrementalLoadingTrigger extends System.Enum {
+      value__: number;
+      static None: number;
+      static Edge: number;
+    }
+    class IndexBasedLayoutOrientation extends System.Enum {
+      value__: number;
+      static None: number;
+      static TopToBottom: number;
+      static LeftToRight: number;
+    }
+    class InfoBadge extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IInfoBadge {
+      Value: number;
+      IconSource: Microsoft.UI.Xaml.Controls.IconSource;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.InfoBadgeTemplateSettings;
+      static readonly IconSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TemplateSettingsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ValueProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class InfoBadgeTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IInfoBadgeTemplateSettings {
+      InfoBadgeCornerRadius: Microsoft.UI.Xaml.CornerRadius;
+      IconElement: Microsoft.UI.Xaml.Controls.IconElement;
+      static readonly IconElementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly InfoBadgeCornerRadiusProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class InfoBar extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IInfoBar {
+      CloseButtonClick: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.InfoBar, any> | null;
+      Closed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.InfoBar, Microsoft.UI.Xaml.Controls.InfoBarClosedEventArgs> | null;
+      Closing: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.InfoBar, Microsoft.UI.Xaml.Controls.InfoBarClosingEventArgs> | null;
+      Title: string;
+      Severity: number;
+      Message: string;
+      IsOpen: boolean;
+      IsIconVisible: boolean;
+      IsClosable: boolean;
+      IconSource: Microsoft.UI.Xaml.Controls.IconSource;
+      ContentTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Content: any;
+      CloseButtonStyle: Microsoft.UI.Xaml.Style;
+      CloseButtonCommandParameter: any;
+      CloseButtonCommand: Microsoft.UI.Xaml.Input.ICommand;
+      ActionButton: Microsoft.UI.Xaml.Controls.Primitives.ButtonBase;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.InfoBarTemplateSettings;
+      static readonly ActionButtonProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CloseButtonCommandParameterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CloseButtonCommandProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CloseButtonStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IconSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsClosableProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsIconVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsOpenProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MessageProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SeverityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TemplateSettingsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TitleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class InfoBarCloseReason extends System.Enum {
+      value__: number;
+      static CloseButton: number;
+      static Programmatic: number;
+    }
+    class InfoBarClosedEventArgs implements Microsoft.UI.Xaml.Controls.IInfoBarClosedEventArgs {
+      readonly Reason: number;
+    }
+    class InfoBarClosingEventArgs implements Microsoft.UI.Xaml.Controls.IInfoBarClosingEventArgs {
+      Cancel: boolean;
+      readonly Reason: number;
+    }
+    class InfoBarSeverity extends System.Enum {
+      value__: number;
+      static Informational: number;
+      static Success: number;
+      static Warning: number;
+      static Error: number;
+    }
+    class InfoBarTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IInfoBarTemplateSettings {
+      IconElement: Microsoft.UI.Xaml.Controls.IconElement;
+      static readonly IconElementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class InputPropertyAttribute extends System.Attribute {
+      Name: string;
+      constructor();
+    }
+    class IsTextTrimmedChangedEventArgs implements Microsoft.UI.Xaml.Controls.IIsTextTrimmedChangedEventArgs {
+    }
+    class ItemClickEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Controls.IItemClickEventArgs {
+      readonly ClickedItem: any;
+      constructor();
+    }
+    class ItemClickEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Controls.ItemClickEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Controls.ItemClickEventArgs): void;
+    }
+    class ItemCollection implements Windows.Foundation.Collections.IObservableVector<any> {
+      VectorChanged: Windows.Foundation.Collections.VectorChangedEventHandler<any> | null;
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class ItemCollectionTransition implements Microsoft.UI.Xaml.Controls.IItemCollectionTransition {
+      readonly HasStarted: boolean;
+      readonly NewBounds: Windows.Foundation.Rect;
+      readonly OldBounds: Windows.Foundation.Rect;
+      readonly Operation: number;
+      readonly Triggers: number;
+      Start(): Microsoft.UI.Xaml.Controls.ItemCollectionTransitionProgress;
+    }
+    class ItemCollectionTransitionCompletedEventArgs implements Microsoft.UI.Xaml.Controls.IItemCollectionTransitionCompletedEventArgs {
+      readonly Element: Microsoft.UI.Xaml.UIElement;
+      readonly Transition: Microsoft.UI.Xaml.Controls.ItemCollectionTransition;
+    }
+    class ItemCollectionTransitionOperation extends System.Enum {
+      value__: number;
+      static Add: number;
+      static Remove: number;
+      static Move: number;
+    }
+    class ItemCollectionTransitionProgress implements Microsoft.UI.Xaml.Controls.IItemCollectionTransitionProgress {
+      readonly Element: Microsoft.UI.Xaml.UIElement;
+      readonly Transition: Microsoft.UI.Xaml.Controls.ItemCollectionTransition;
+      Complete(): void;
+    }
+    class ItemCollectionTransitionProvider implements Microsoft.UI.Xaml.Controls.IItemCollectionTransitionProvider, Microsoft.UI.Xaml.Controls.IItemCollectionTransitionProviderOverrides {
+      TransitionCompleted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ItemCollectionTransitionProvider, Microsoft.UI.Xaml.Controls.ItemCollectionTransitionCompletedEventArgs> | null;
+      constructor();
+      ShouldAnimate(result: Microsoft.UI.Xaml.Controls.ItemCollectionTransition): boolean;
+      QueueTransition(transition: Microsoft.UI.Xaml.Controls.ItemCollectionTransition): void;
+    }
+    class ItemCollectionTransitionTriggers extends System.Enum {
+      value__: number;
+      static CollectionChangeAdd: number;
+      static CollectionChangeRemove: number;
+      static CollectionChangeReset: number;
+      static LayoutTransition: number;
+    }
+    class ItemContainer extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IItemContainer {
+      IsSelected: boolean;
+      Child: Microsoft.UI.Xaml.UIElement;
+      static readonly ChildProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsSelectedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ItemContainerGenerator implements Microsoft.UI.Xaml.Controls.IItemContainerGenerator {
+      ItemsChanged: Microsoft.UI.Xaml.Controls.Primitives.ItemsChangedEventHandler | null;
+      ItemFromContainer(result: Microsoft.UI.Xaml.DependencyObject): any;
+      ContainerFromItem(result: any): Microsoft.UI.Xaml.DependencyObject;
+      IndexFromContainer(result: Microsoft.UI.Xaml.DependencyObject): number;
+      ContainerFromIndex(result: number): Microsoft.UI.Xaml.DependencyObject;
+      GetItemContainerGeneratorForPanel(result: Microsoft.UI.Xaml.Controls.Panel): Microsoft.UI.Xaml.Controls.ItemContainerGenerator;
+      StartAt(position: Microsoft.UI.Xaml.Controls.Primitives.GeneratorPosition, direction: number, allowStartAtRealizedItem: boolean): void;
+      Stop(): void;
+      GenerateNext(returnValue: boolean): Microsoft.UI.Xaml.DependencyObject;
+      PrepareItemContainer(container: Microsoft.UI.Xaml.DependencyObject): void;
+      RemoveAll(): void;
+      Remove(position: Microsoft.UI.Xaml.Controls.Primitives.GeneratorPosition, count: number): void;
+      GeneratorPositionFromIndex(result: number): Microsoft.UI.Xaml.Controls.Primitives.GeneratorPosition;
+      IndexFromGeneratorPosition(result: Microsoft.UI.Xaml.Controls.Primitives.GeneratorPosition): number;
+      Recycle(position: Microsoft.UI.Xaml.Controls.Primitives.GeneratorPosition, count: number): void;
+    }
+    class ItemsPanelTemplate extends Microsoft.UI.Xaml.FrameworkTemplate implements Microsoft.UI.Xaml.Controls.IItemsPanelTemplate {
+      constructor();
+    }
+    class ItemsPickedEventArgs extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IItemsPickedEventArgs {
+      readonly AddedItems: System.Collections.Generic.IList<any>;
+      readonly RemovedItems: System.Collections.Generic.IList<any>;
+      constructor();
+    }
+    class ItemsPresenter extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.IItemsPresenter, Microsoft.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo {
+      HorizontalSnapPointsChanged: System.EventHandler<any> | null;
+      VerticalSnapPointsChanged: System.EventHandler<any> | null;
+      Padding: Microsoft.UI.Xaml.Thickness;
+      HeaderTransitions: Microsoft.UI.Xaml.Media.Animation.TransitionCollection;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Header: any;
+      FooterTransitions: Microsoft.UI.Xaml.Media.Animation.TransitionCollection;
+      FooterTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Footer: any;
+      readonly AreHorizontalSnapPointsRegular: boolean;
+      readonly AreVerticalSnapPointsRegular: boolean;
+      static readonly FooterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FooterTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FooterTransitionsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTransitionsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaddingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      GetIrregularSnapPoints(result: number, orientation: number): System.Collections.Generic.IReadOnlyList<number>;
+      GetRegularSnapPoints(returnValue: number, orientation: number, alignment: number): number;
+    }
+    class ItemsRepeater extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.IItemsRepeater, Microsoft.UI.Xaml.Controls.IItemsRepeater2 {
+      ElementClearing: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ItemsRepeater, Microsoft.UI.Xaml.Controls.ItemsRepeaterElementClearingEventArgs> | null;
+      ElementIndexChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ItemsRepeater, Microsoft.UI.Xaml.Controls.ItemsRepeaterElementIndexChangedEventArgs> | null;
+      ElementPrepared: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ItemsRepeater, Microsoft.UI.Xaml.Controls.ItemsRepeaterElementPreparedEventArgs> | null;
+      VerticalCacheLength: number;
+      Layout: Microsoft.UI.Xaml.Controls.Layout;
+      ItemsSource: any;
+      ItemTemplate: any;
+      HorizontalCacheLength: number;
+      Background: Microsoft.UI.Xaml.Media.Brush;
+      readonly ItemsSourceView: Microsoft.UI.Xaml.Controls.ItemsSourceView;
+      ItemTransitionProvider: Microsoft.UI.Xaml.Controls.ItemCollectionTransitionProvider;
+      static readonly BackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalCacheLengthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemsSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LayoutProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalCacheLengthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemTransitionProviderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      GetElementIndex(result: Microsoft.UI.Xaml.UIElement): number;
+      TryGetElement(result: number): Microsoft.UI.Xaml.UIElement;
+      GetOrCreateElement(result: number): Microsoft.UI.Xaml.UIElement;
+    }
+    class ItemsRepeaterElementClearingEventArgs implements Microsoft.UI.Xaml.Controls.IItemsRepeaterElementClearingEventArgs {
+      readonly Element: Microsoft.UI.Xaml.UIElement;
+    }
+    class ItemsRepeaterElementIndexChangedEventArgs implements Microsoft.UI.Xaml.Controls.IItemsRepeaterElementIndexChangedEventArgs {
+      readonly Element: Microsoft.UI.Xaml.UIElement;
+      readonly NewIndex: number;
+      readonly OldIndex: number;
+    }
+    class ItemsRepeaterElementPreparedEventArgs implements Microsoft.UI.Xaml.Controls.IItemsRepeaterElementPreparedEventArgs {
+      readonly Element: Microsoft.UI.Xaml.UIElement;
+      readonly Index: number;
+    }
+    class ItemsRepeaterScrollHost extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.IItemsRepeaterScrollHost {
+      VerticalAnchorRatio: number;
+      ScrollViewer: Microsoft.UI.Xaml.Controls.ScrollViewer;
+      HorizontalAnchorRatio: number;
+      readonly CurrentAnchor: Microsoft.UI.Xaml.UIElement;
+      constructor();
+    }
+    class ItemsSourceView implements Microsoft.UI.Xaml.Controls.IItemsSourceView, Microsoft.UI.Xaml.Interop.INotifyCollectionChanged {
+      CollectionChanged: Microsoft.UI.Xaml.Interop.NotifyCollectionChangedEventHandler | null;
+      readonly Count: number;
+      readonly HasKeyIndexMapping: boolean;
+      constructor(source: any);
+      GetAt(result: number): any;
+      KeyFromIndex(result: number): string;
+      IndexFromKey(result: string): number;
+      IndexOf(result: any): number;
+    }
+    class ItemsStackPanel extends Microsoft.UI.Xaml.Controls.Panel implements Microsoft.UI.Xaml.Controls.IItemsStackPanel {
+      Orientation: number;
+      ItemsUpdatingScrollMode: number;
+      GroupPadding: Microsoft.UI.Xaml.Thickness;
+      GroupHeaderPlacement: number;
+      CacheLength: number;
+      AreStickyGroupHeadersEnabled: boolean;
+      readonly FirstCacheIndex: number;
+      readonly FirstVisibleIndex: number;
+      readonly LastCacheIndex: number;
+      readonly LastVisibleIndex: number;
+      readonly ScrollingDirection: number;
+      static readonly AreStickyGroupHeadersEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CacheLengthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GroupHeaderPlacementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GroupPaddingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OrientationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ItemsUpdatingScrollMode extends System.Enum {
+      value__: number;
+      static KeepItemsInView: number;
+      static KeepScrollOffset: number;
+      static KeepLastItemInView: number;
+    }
+    class ItemsView extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IItemsView {
+      ItemInvoked: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ItemsView, Microsoft.UI.Xaml.Controls.ItemsViewItemInvokedEventArgs> | null;
+      SelectionChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ItemsView, Microsoft.UI.Xaml.Controls.ItemsViewSelectionChangedEventArgs> | null;
+      VerticalScrollController: Microsoft.UI.Xaml.Controls.Primitives.IScrollController;
+      SelectionMode: number;
+      Layout: Microsoft.UI.Xaml.Controls.Layout;
+      ItemsSource: any;
+      ItemTransitionProvider: Microsoft.UI.Xaml.Controls.ItemCollectionTransitionProvider;
+      ItemTemplate: Microsoft.UI.Xaml.IElementFactory;
+      IsItemInvokedEnabled: boolean;
+      readonly CurrentItemIndex: number;
+      readonly ScrollView: Microsoft.UI.Xaml.Controls.ScrollView;
+      readonly SelectedItem: any;
+      readonly SelectedItems: System.Collections.Generic.IReadOnlyList<any>;
+      static readonly CurrentItemIndexProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsItemInvokedEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemTransitionProviderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemsSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LayoutProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ScrollViewProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedItemProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalScrollControllerProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      TryGetItemIndex(result: number, horizontalViewportRatio: number, verticalViewportRatio: number): boolean;
+      StartBringItemIntoView(index: number, options: Microsoft.UI.Xaml.BringIntoViewOptions): void;
+      Select(itemIndex: number): void;
+      Deselect(itemIndex: number): void;
+      IsSelected(result: number): boolean;
+      SelectAll(): void;
+      DeselectAll(): void;
+      InvertSelection(): void;
+    }
+    class ItemsViewItemInvokedEventArgs implements Microsoft.UI.Xaml.Controls.IItemsViewItemInvokedEventArgs {
+      readonly InvokedItem: any;
+    }
+    class ItemsViewSelectionChangedEventArgs implements Microsoft.UI.Xaml.Controls.IItemsViewSelectionChangedEventArgs {
+    }
+    class ItemsViewSelectionMode extends System.Enum {
+      value__: number;
+      static None: number;
+      static Single: number;
+      static Multiple: number;
+      static Extended: number;
+    }
+    class ItemsWrapGrid extends Microsoft.UI.Xaml.Controls.Panel implements Microsoft.UI.Xaml.Controls.IItemsWrapGrid {
+      Orientation: number;
+      MaximumRowsOrColumns: number;
+      ItemWidth: number;
+      ItemHeight: number;
+      GroupPadding: Microsoft.UI.Xaml.Thickness;
+      GroupHeaderPlacement: number;
+      CacheLength: number;
+      AreStickyGroupHeadersEnabled: boolean;
+      readonly FirstCacheIndex: number;
+      readonly FirstVisibleIndex: number;
+      readonly LastCacheIndex: number;
+      readonly LastVisibleIndex: number;
+      readonly ScrollingDirection: number;
+      static readonly AreStickyGroupHeadersEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CacheLengthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GroupHeaderPlacementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GroupPaddingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaximumRowsOrColumnsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OrientationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class Layout extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.ILayout, Microsoft.UI.Xaml.Controls.ILayout2, Microsoft.UI.Xaml.Controls.ILayoutProtected, Microsoft.UI.Xaml.Controls.ILayoutProtected2, Microsoft.UI.Xaml.Controls.ILayoutOverrides {
+      ArrangeInvalidated: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Layout, any> | null;
+      MeasureInvalidated: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Layout, any> | null;
+      readonly IndexBasedLayoutOrientation: number;
+      InitializeForContext(context: Microsoft.UI.Xaml.Controls.LayoutContext): void;
+      UninitializeForContext(context: Microsoft.UI.Xaml.Controls.LayoutContext): void;
+      Measure(result: Microsoft.UI.Xaml.Controls.LayoutContext, context: Windows.Foundation.Size): Windows.Foundation.Size;
+      Arrange(result: Microsoft.UI.Xaml.Controls.LayoutContext, context: Windows.Foundation.Size): Windows.Foundation.Size;
+    }
+    class LayoutContext extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.ILayoutContext, Microsoft.UI.Xaml.Controls.ILayoutContextOverrides {
+      LayoutState: any;
+    }
+    class LightDismissOverlayMode extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static On: number;
+      static Off: number;
+    }
+    class VirtualizingLayout extends Microsoft.UI.Xaml.Controls.Layout implements Microsoft.UI.Xaml.Controls.IVirtualizingLayout, Microsoft.UI.Xaml.Controls.IVirtualizingLayoutOverrides {
+      constructor();
+    }
+    class LinedFlowLayout extends Microsoft.UI.Xaml.Controls.VirtualizingLayout implements Microsoft.UI.Xaml.Controls.ILinedFlowLayout {
+      ItemsInfoRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.LinedFlowLayout, Microsoft.UI.Xaml.Controls.LinedFlowLayoutItemsInfoRequestedEventArgs> | null;
+      ItemsUnlocked: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.LinedFlowLayout, any> | null;
+      MinItemSpacing: number;
+      LineSpacing: number;
+      LineHeight: number;
+      ItemsStretch: number;
+      ItemsJustification: number;
+      readonly ActualLineHeight: number;
+      readonly RequestedRangeLength: number;
+      readonly RequestedRangeStartIndex: number;
+      static readonly ActualLineHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemsJustificationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemsStretchProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LineHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LineSpacingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinItemSpacingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      InvalidateItemsInfo(): void;
+      LockItemToLine(result: number): number;
+    }
+    class LinedFlowLayoutItemCollectionTransitionProvider extends Microsoft.UI.Xaml.Controls.ItemCollectionTransitionProvider implements Microsoft.UI.Xaml.Controls.ILinedFlowLayoutItemCollectionTransitionProvider {
+      constructor();
+    }
+    class LinedFlowLayoutItemsInfoRequestedEventArgs implements Microsoft.UI.Xaml.Controls.ILinedFlowLayoutItemsInfoRequestedEventArgs {
+      MinWidth: number;
+      MaxWidth: number;
+      ItemsRangeStartIndex: number;
+      readonly ItemsRangeRequestedLength: number;
+      SetDesiredAspectRatios(values: number[]): void;
+      SetMinWidths(values: number[]): void;
+      SetMaxWidths(values: number[]): void;
+    }
+    class LinedFlowLayoutItemsJustification extends System.Enum {
+      value__: number;
+      static Start: number;
+      static Center: number;
+      static End: number;
+      static SpaceAround: number;
+      static SpaceBetween: number;
+      static SpaceEvenly: number;
+    }
+    class LinedFlowLayoutItemsStretch extends System.Enum {
+      value__: number;
+      static None: number;
+      static Fill: number;
+    }
+    class ListBox extends Microsoft.UI.Xaml.Controls.Primitives.Selector implements Microsoft.UI.Xaml.Controls.IListBox {
+      SingleSelectionFollowsFocus: boolean;
+      SelectionMode: number;
+      readonly SelectedItems: System.Collections.Generic.IList<any>;
+      static readonly SelectionModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SingleSelectionFollowsFocusProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      ScrollIntoView(item: any): void;
+      SelectAll(): void;
+    }
+    class ListBoxItem extends Microsoft.UI.Xaml.Controls.Primitives.SelectorItem implements Microsoft.UI.Xaml.Controls.IListBoxItem {
+      constructor();
+    }
+    class ListPickerFlyout extends Microsoft.UI.Xaml.Controls.Primitives.PickerFlyoutBase implements Microsoft.UI.Xaml.Controls.IListPickerFlyout {
+      ItemsPicked: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ListPickerFlyout, Microsoft.UI.Xaml.Controls.ItemsPickedEventArgs> | null;
+      SelectionMode: number;
+      SelectedValuePath: string;
+      SelectedValue: any;
+      SelectedItem: any;
+      SelectedIndex: number;
+      ItemsSource: any;
+      ItemTemplate: Microsoft.UI.Xaml.DataTemplate;
+      DisplayMemberPath: string;
+      readonly SelectedItems: System.Collections.Generic.IList<any>;
+      static readonly DisplayMemberPathProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemsSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedIndexProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedItemProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedValuePathProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedValueProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      ShowAtAsync(operation: Microsoft.UI.Xaml.FrameworkElement): Windows.Foundation.IAsyncOperation<System.Collections.Generic.IReadOnlyList<any>>;
+    }
+    class ListPickerFlyoutPresenter extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IListPickerFlyoutPresenter {
+    }
+    class ListPickerFlyoutSelectionMode extends System.Enum {
+      value__: number;
+      static Single: number;
+      static Multiple: number;
+    }
+    class ListView extends Microsoft.UI.Xaml.Controls.ListViewBase implements Microsoft.UI.Xaml.Controls.IListView {
+      constructor();
+    }
+    class ListViewHeaderItem extends Microsoft.UI.Xaml.Controls.ListViewBaseHeaderItem implements Microsoft.UI.Xaml.Controls.IListViewHeaderItem {
+      constructor();
+    }
+    class ListViewItem extends Microsoft.UI.Xaml.Controls.Primitives.SelectorItem implements Microsoft.UI.Xaml.Controls.IListViewItem {
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.Primitives.ListViewItemTemplateSettings;
+      constructor();
+    }
+    class ListViewItemToKeyHandler {
+      constructor(handler: (result: any) => string);
+      Invoke(result: any): string;
+    }
+    class ListViewKeyToItemHandler {
+      constructor(handler: (operation: string) => Windows.Foundation.IAsyncOperation<any>);
+      Invoke(operation: string): Windows.Foundation.IAsyncOperation<any>;
+    }
+    class ListViewPersistenceHelper implements Microsoft.UI.Xaml.Controls.IListViewPersistenceHelper {
+      static GetRelativeScrollPosition(result: Microsoft.UI.Xaml.Controls.ListViewBase, listViewBase: Microsoft.UI.Xaml.Controls.ListViewItemToKeyHandler): string;
+      static SetRelativeScrollPositionAsync(operation: Microsoft.UI.Xaml.Controls.ListViewBase, listViewBase: string, relativeScrollPosition: Microsoft.UI.Xaml.Controls.ListViewKeyToItemHandler): Windows.Foundation.IAsyncAction;
+    }
+    class ListViewReorderMode extends System.Enum {
+      value__: number;
+      static Disabled: number;
+      static Enabled: number;
+    }
+    class ListViewSelectionMode extends System.Enum {
+      value__: number;
+      static None: number;
+      static Single: number;
+      static Multiple: number;
+      static Extended: number;
+    }
+    class MapControl extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IMapControl {
+      MapElementClick: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.MapControl, Microsoft.UI.Xaml.Controls.MapElementClickEventArgs> | null;
+      MapServiceErrorOccurred: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.MapControl, Microsoft.UI.Xaml.Controls.MapControlMapServiceErrorOccurredEventArgs> | null;
+      ZoomLevel: number;
+      MapServiceToken: string;
+      Layers: System.Collections.Generic.IList<Microsoft.UI.Xaml.Controls.MapLayer>;
+      InteractiveControlsVisible: boolean;
+      Center: Windows.Devices.Geolocation.Geopoint;
+      static readonly CenterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly InteractiveControlsVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LayersProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MapServiceTokenProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ZoomLevelProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class MapControlMapServiceErrorOccurredEventArgs implements Microsoft.UI.Xaml.Controls.IMapControlMapServiceErrorOccurredEventArgs {
+      readonly DiagnosticMessage: string;
+    }
+    class MapElement extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IMapElement {
+    }
+    class MapElementClickEventArgs implements Microsoft.UI.Xaml.Controls.IMapElementClickEventArgs {
+      readonly Element: Microsoft.UI.Xaml.Controls.MapElement;
+      readonly Location: Windows.Devices.Geolocation.Geopoint;
+    }
+    class MapLayer extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IMapLayer {
+    }
+    class MapElementsLayer extends Microsoft.UI.Xaml.Controls.MapLayer implements Microsoft.UI.Xaml.Controls.IMapElementsLayer {
+      MapElementClick: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.MapElementsLayer, Microsoft.UI.Xaml.Controls.MapElementClickEventArgs> | null;
+      MapElements: System.Collections.Generic.IList<Microsoft.UI.Xaml.Controls.MapElement>;
+      static readonly MapElementsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class MapIcon extends Microsoft.UI.Xaml.Controls.MapElement implements Microsoft.UI.Xaml.Controls.IMapIcon {
+      Location: Windows.Devices.Geolocation.Geopoint;
+      static readonly LocationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class MediaPlayerElement extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IMediaPlayerElement {
+      TransportControls: Microsoft.UI.Xaml.Controls.MediaTransportControls;
+      Stretch: number;
+      Source: Windows.Media.Playback.IMediaPlaybackSource;
+      PosterSource: Microsoft.UI.Xaml.Media.ImageSource;
+      IsFullWindow: boolean;
+      AutoPlay: boolean;
+      AreTransportControlsEnabled: boolean;
+      readonly MediaPlayer: Windows.Media.Playback.MediaPlayer;
+      static readonly AreTransportControlsEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AutoPlayProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsFullWindowProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MediaPlayerProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PosterSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StretchProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      SetMediaPlayer(mediaPlayer: Windows.Media.Playback.MediaPlayer): void;
+    }
+    class MediaPlayerPresenter extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.IMediaPlayerPresenter {
+      Stretch: number;
+      MediaPlayer: Windows.Media.Playback.MediaPlayer;
+      IsFullWindow: boolean;
+      static readonly IsFullWindowProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MediaPlayerProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StretchProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class MediaTransportControls extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IMediaTransportControls {
+      ThumbnailRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.MediaTransportControls, Microsoft.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs> | null;
+      ShowAndHideAutomatically: boolean;
+      IsZoomEnabled: boolean;
+      IsZoomButtonVisible: boolean;
+      IsVolumeEnabled: boolean;
+      IsVolumeButtonVisible: boolean;
+      IsStopEnabled: boolean;
+      IsStopButtonVisible: boolean;
+      IsSkipForwardEnabled: boolean;
+      IsSkipForwardButtonVisible: boolean;
+      IsSkipBackwardEnabled: boolean;
+      IsSkipBackwardButtonVisible: boolean;
+      IsSeekEnabled: boolean;
+      IsSeekBarVisible: boolean;
+      IsRepeatEnabled: boolean;
+      IsRepeatButtonVisible: boolean;
+      IsPreviousTrackButtonVisible: boolean;
+      IsPlaybackRateEnabled: boolean;
+      IsPlaybackRateButtonVisible: boolean;
+      IsNextTrackButtonVisible: boolean;
+      IsFastRewindEnabled: boolean;
+      IsFastRewindButtonVisible: boolean;
+      IsFastForwardEnabled: boolean;
+      IsFastForwardButtonVisible: boolean;
+      IsCompact: boolean;
+      FastPlayFallbackBehaviour: number;
+      static readonly FastPlayFallbackBehaviourProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsCompactProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsFastForwardButtonVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsFastForwardEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsFastRewindButtonVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsFastRewindEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsNextTrackButtonVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsPlaybackRateButtonVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsPlaybackRateEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsPreviousTrackButtonVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsRepeatButtonVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsRepeatEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsSeekBarVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsSeekEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsSkipBackwardButtonVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsSkipBackwardEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsSkipForwardButtonVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsSkipForwardEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsStopButtonVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsStopEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsVolumeButtonVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsVolumeEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsZoomButtonVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsZoomEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ShowAndHideAutomaticallyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      Show(): void;
+      Hide(): void;
+    }
+    class MediaTransportControlsHelper implements Microsoft.UI.Xaml.Controls.IMediaTransportControlsHelper {
+      static readonly DropoutOrderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static GetDropoutOrder(result: Microsoft.UI.Xaml.UIElement): System.Nullable<number>;
+      static SetDropoutOrder(element: Microsoft.UI.Xaml.UIElement, value: System.Nullable<number>): void;
+    }
+    class MenuBar extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IMenuBar {
+      readonly Items: System.Collections.Generic.IList<Microsoft.UI.Xaml.Controls.MenuBarItem>;
+      static readonly ItemsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class MenuBarItem extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IMenuBarItem {
+      Title: string;
+      readonly Items: System.Collections.Generic.IList<Microsoft.UI.Xaml.Controls.MenuFlyoutItemBase>;
+      static readonly ItemsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TitleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class MenuFlyout extends Microsoft.UI.Xaml.Controls.Primitives.FlyoutBase implements Microsoft.UI.Xaml.Controls.IMenuFlyout {
+      MenuFlyoutPresenterStyle: Microsoft.UI.Xaml.Style;
+      readonly Items: System.Collections.Generic.IList<Microsoft.UI.Xaml.Controls.MenuFlyoutItemBase>;
+      static readonly MenuFlyoutPresenterStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      ShowAt(targetElement: Microsoft.UI.Xaml.UIElement, point: Windows.Foundation.Point): void;
+    }
+    class MenuBarItemFlyout extends Microsoft.UI.Xaml.Controls.MenuFlyout implements Microsoft.UI.Xaml.Controls.IMenuBarItemFlyout {
+      constructor();
+    }
+    class MenuFlyoutItemBase extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IMenuFlyoutItemBase {
+    }
+    class MenuFlyoutItem extends Microsoft.UI.Xaml.Controls.MenuFlyoutItemBase implements Microsoft.UI.Xaml.Controls.IMenuFlyoutItem {
+      Click: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      Text: string;
+      KeyboardAcceleratorTextOverride: string;
+      Icon: Microsoft.UI.Xaml.Controls.IconElement;
+      CommandParameter: any;
+      Command: Microsoft.UI.Xaml.Input.ICommand;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.Primitives.MenuFlyoutItemTemplateSettings;
+      static readonly CommandParameterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CommandProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IconProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly KeyboardAcceleratorTextOverrideProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class MenuFlyoutPresenter extends Microsoft.UI.Xaml.Controls.ItemsControl implements Microsoft.UI.Xaml.Controls.IMenuFlyoutPresenter, Microsoft.UI.Xaml.Controls.IMenuFlyoutPresenter2 {
+      IsDefaultShadowEnabled: boolean;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.Primitives.MenuFlyoutPresenterTemplateSettings;
+      SystemBackdrop: Microsoft.UI.Xaml.Media.SystemBackdrop;
+      static readonly IsDefaultShadowEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SystemBackdropProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class MenuFlyoutSeparator extends Microsoft.UI.Xaml.Controls.MenuFlyoutItemBase implements Microsoft.UI.Xaml.Controls.IMenuFlyoutSeparator {
+      constructor();
+    }
+    class MenuFlyoutSubItem extends Microsoft.UI.Xaml.Controls.MenuFlyoutItemBase implements Microsoft.UI.Xaml.Controls.IMenuFlyoutSubItem {
+      Text: string;
+      Icon: Microsoft.UI.Xaml.Controls.IconElement;
+      readonly Items: System.Collections.Generic.IList<Microsoft.UI.Xaml.Controls.MenuFlyoutItemBase>;
+      static readonly IconProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class NavigationView extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.INavigationView, Microsoft.UI.Xaml.Controls.INavigationView2 {
+      DisplayModeChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.NavigationView, Microsoft.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs> | null;
+      ItemInvoked: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.NavigationView, Microsoft.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs> | null;
+      SelectionChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.NavigationView, Microsoft.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs> | null;
+      BackRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.NavigationView, Microsoft.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs> | null;
+      Collapsed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.NavigationView, Microsoft.UI.Xaml.Controls.NavigationViewItemCollapsedEventArgs> | null;
+      Expanding: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.NavigationView, Microsoft.UI.Xaml.Controls.NavigationViewItemExpandingEventArgs> | null;
+      PaneClosed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.NavigationView, any> | null;
+      PaneClosing: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.NavigationView, Microsoft.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs> | null;
+      PaneOpened: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.NavigationView, any> | null;
+      PaneOpening: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.NavigationView, any> | null;
+      SelectedItem: any;
+      PaneToggleButtonStyle: Microsoft.UI.Xaml.Style;
+      PaneFooter: Microsoft.UI.Xaml.UIElement;
+      OpenPaneLength: number;
+      MenuItemsSource: any;
+      MenuItemContainerStyleSelector: Microsoft.UI.Xaml.Controls.StyleSelector;
+      MenuItemContainerStyle: Microsoft.UI.Xaml.Style;
+      IsTitleBarAutoPaddingEnabled: boolean;
+      IsSettingsVisible: boolean;
+      IsPaneToggleButtonVisible: boolean;
+      IsPaneOpen: boolean;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Header: any;
+      FooterMenuItemsSource: any;
+      MenuItemTemplateSelector: Microsoft.UI.Xaml.Controls.DataTemplateSelector;
+      ExpandedModeThresholdWidth: number;
+      MenuItemTemplate: Microsoft.UI.Xaml.DataTemplate;
+      CompactPaneLength: number;
+      CompactModeThresholdWidth: number;
+      AutoSuggestBox: Microsoft.UI.Xaml.Controls.AutoSuggestBox;
+      AlwaysShowHeader: boolean;
+      readonly MenuItems: System.Collections.Generic.IList<any>;
+      readonly DisplayMode: number;
+      readonly FooterMenuItems: System.Collections.Generic.IList<any>;
+      readonly SettingsItem: any;
+      ShoulderNavigationEnabled: number;
+      SelectionFollowsFocus: number;
+      PaneTitle: string;
+      PaneHeader: Microsoft.UI.Xaml.UIElement;
+      PaneDisplayMode: number;
+      PaneCustomContent: Microsoft.UI.Xaml.UIElement;
+      OverflowLabelMode: number;
+      IsPaneVisible: boolean;
+      IsBackEnabled: boolean;
+      IsBackButtonVisible: number;
+      ContentOverlay: Microsoft.UI.Xaml.UIElement;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings;
+      static readonly FooterMenuItemsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTitleBarAutoPaddingEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MenuItemContainerStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MenuItemContainerStyleSelectorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MenuItemTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MenuItemTemplateSelectorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MenuItemsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MenuItemsSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OpenPaneLengthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaneFooterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaneToggleButtonStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedItemProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AlwaysShowHeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AutoSuggestBoxProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CompactModeThresholdWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CompactPaneLengthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DisplayModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ExpandedModeThresholdWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SettingsItemProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FooterMenuItemsSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsPaneOpenProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsPaneToggleButtonVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsSettingsVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsBackButtonVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsBackEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsPaneVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OverflowLabelModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaneCustomContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaneDisplayModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaneHeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaneTitleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionFollowsFocusProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ShoulderNavigationEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TemplateSettingsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentOverlayProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      MenuItemFromContainer(result: Microsoft.UI.Xaml.DependencyObject): any;
+      ContainerFromMenuItem(result: any): Microsoft.UI.Xaml.DependencyObject;
+      Expand(item: Microsoft.UI.Xaml.Controls.NavigationViewItem): void;
+      Collapse(item: Microsoft.UI.Xaml.Controls.NavigationViewItem): void;
+    }
+    class NavigationViewBackButtonVisible extends System.Enum {
+      value__: number;
+      static Collapsed: number;
+      static Visible: number;
+      static Auto: number;
+    }
+    class NavigationViewBackRequestedEventArgs implements Microsoft.UI.Xaml.Controls.INavigationViewBackRequestedEventArgs {
+    }
+    class NavigationViewDisplayMode extends System.Enum {
+      value__: number;
+      static Minimal: number;
+      static Compact: number;
+      static Expanded: number;
+    }
+    class NavigationViewDisplayModeChangedEventArgs implements Microsoft.UI.Xaml.Controls.INavigationViewDisplayModeChangedEventArgs {
+      readonly DisplayMode: number;
+    }
+    class NavigationViewItemBase extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.INavigationViewItemBase, Microsoft.UI.Xaml.Controls.INavigationViewItemBase2 {
+      IsSelected: boolean;
+      static readonly IsSelectedProperty: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class NavigationViewItem extends Microsoft.UI.Xaml.Controls.NavigationViewItemBase implements Microsoft.UI.Xaml.Controls.INavigationViewItem, Microsoft.UI.Xaml.Controls.INavigationViewItem2, Microsoft.UI.Xaml.Controls.INavigationViewItem3 {
+      Icon: Microsoft.UI.Xaml.Controls.IconElement;
+      readonly CompactPaneLength: number;
+      SelectsOnInvoked: boolean;
+      MenuItemsSource: any;
+      IsExpanded: boolean;
+      IsChildSelected: boolean;
+      HasUnrealizedChildren: boolean;
+      readonly MenuItems: System.Collections.Generic.IList<any>;
+      InfoBadge: Microsoft.UI.Xaml.Controls.InfoBadge;
+      static readonly CompactPaneLengthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IconProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HasUnrealizedChildrenProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsChildSelectedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsExpandedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MenuItemsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MenuItemsSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectsOnInvokedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly InfoBadgeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class NavigationViewItemCollapsedEventArgs implements Microsoft.UI.Xaml.Controls.INavigationViewItemCollapsedEventArgs {
+      readonly CollapsedItem: any;
+      readonly CollapsedItemContainer: Microsoft.UI.Xaml.Controls.NavigationViewItemBase;
+    }
+    class NavigationViewItemExpandingEventArgs implements Microsoft.UI.Xaml.Controls.INavigationViewItemExpandingEventArgs {
+      readonly ExpandingItem: any;
+      readonly ExpandingItemContainer: Microsoft.UI.Xaml.Controls.NavigationViewItemBase;
+    }
+    class NavigationViewItemHeader extends Microsoft.UI.Xaml.Controls.NavigationViewItemBase implements Microsoft.UI.Xaml.Controls.INavigationViewItemHeader {
+      constructor();
+    }
+    class NavigationViewItemInvokedEventArgs implements Microsoft.UI.Xaml.Controls.INavigationViewItemInvokedEventArgs, Microsoft.UI.Xaml.Controls.INavigationViewItemInvokedEventArgs2 {
+      readonly InvokedItem: any;
+      readonly IsSettingsInvoked: boolean;
+      readonly InvokedItemContainer: Microsoft.UI.Xaml.Controls.NavigationViewItemBase;
+      readonly RecommendedNavigationTransitionInfo: Microsoft.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+      constructor();
+    }
+    class NavigationViewItemSeparator extends Microsoft.UI.Xaml.Controls.NavigationViewItemBase implements Microsoft.UI.Xaml.Controls.INavigationViewItemSeparator {
+      constructor();
+    }
+    class NavigationViewOverflowLabelMode extends System.Enum {
+      value__: number;
+      static MoreLabel: number;
+      static NoLabel: number;
+    }
+    class NavigationViewPaneClosingEventArgs implements Microsoft.UI.Xaml.Controls.INavigationViewPaneClosingEventArgs {
+      Cancel: boolean;
+    }
+    class NavigationViewPaneDisplayMode extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Left: number;
+      static Top: number;
+      static LeftCompact: number;
+      static LeftMinimal: number;
+    }
+    class NavigationViewSelectionChangedEventArgs implements Microsoft.UI.Xaml.Controls.INavigationViewSelectionChangedEventArgs, Microsoft.UI.Xaml.Controls.INavigationViewSelectionChangedEventArgs2 {
+      readonly IsSettingsSelected: boolean;
+      readonly SelectedItem: any;
+      readonly RecommendedNavigationTransitionInfo: Microsoft.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+      readonly SelectedItemContainer: Microsoft.UI.Xaml.Controls.NavigationViewItemBase;
+    }
+    class NavigationViewSelectionFollowsFocus extends System.Enum {
+      value__: number;
+      static Disabled: number;
+      static Enabled: number;
+    }
+    class NavigationViewShoulderNavigationEnabled extends System.Enum {
+      value__: number;
+      static WhenSelectionFollowsFocus: number;
+      static Always: number;
+      static Never: number;
+    }
+    class NavigationViewTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.INavigationViewTemplateSettings, Microsoft.UI.Xaml.Controls.INavigationViewTemplateSettings2 {
+      readonly BackButtonVisibility: number;
+      readonly LeftPaneVisibility: number;
+      readonly OverflowButtonVisibility: number;
+      readonly PaneToggleButtonVisibility: number;
+      readonly PaneToggleButtonWidth: number;
+      readonly SingleSelectionFollowsFocus: boolean;
+      readonly SmallerPaneToggleButtonWidth: number;
+      readonly TopPadding: number;
+      readonly TopPaneVisibility: number;
+      readonly OpenPaneLength: number;
+      static readonly BackButtonVisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LeftPaneVisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OverflowButtonVisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaneToggleButtonVisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaneToggleButtonWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SingleSelectionFollowsFocusProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SmallerPaneToggleButtonWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TopPaddingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TopPaneVisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OpenPaneLengthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class NonVirtualizingLayout extends Microsoft.UI.Xaml.Controls.Layout implements Microsoft.UI.Xaml.Controls.INonVirtualizingLayout, Microsoft.UI.Xaml.Controls.INonVirtualizingLayoutOverrides {
+      constructor();
+    }
+    class NonVirtualizingLayoutContext extends Microsoft.UI.Xaml.Controls.LayoutContext implements Microsoft.UI.Xaml.Controls.INonVirtualizingLayoutContext, Microsoft.UI.Xaml.Controls.INonVirtualizingLayoutContextOverrides {
+      readonly Children: System.Collections.Generic.IReadOnlyList<Microsoft.UI.Xaml.UIElement>;
+      constructor();
+    }
+    class NumberBox extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.INumberBox {
+      ValueChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.NumberBox, Microsoft.UI.Xaml.Controls.NumberBoxValueChangedEventArgs> | null;
+      Value: number;
+      ValidationMode: number;
+      TextReadingOrder: number;
+      Text: string;
+      SpinButtonPlacementMode: number;
+      SmallChange: number;
+      SelectionHighlightColor: Microsoft.UI.Xaml.Media.SolidColorBrush;
+      SelectionFlyout: Microsoft.UI.Xaml.Controls.Primitives.FlyoutBase;
+      PreventKeyboardDisplayOnProgrammaticFocus: boolean;
+      PlaceholderText: string;
+      NumberFormatter: Windows.Globalization.NumberFormatting.INumberFormatter2;
+      Minimum: number;
+      Maximum: number;
+      LargeChange: number;
+      IsWrapEnabled: boolean;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Header: any;
+      Description: any;
+      AcceptsExpression: boolean;
+      static readonly AcceptsExpressionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DescriptionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsWrapEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LargeChangeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaximumProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinimumProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly NumberFormatterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlaceholderTextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PreventKeyboardDisplayOnProgrammaticFocusProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionFlyoutProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionHighlightColorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SmallChangeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SpinButtonPlacementModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextReadingOrderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ValidationModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ValueProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class NumberBoxSpinButtonPlacementMode extends System.Enum {
+      value__: number;
+      static Hidden: number;
+      static Compact: number;
+      static Inline: number;
+    }
+    class NumberBoxValidationMode extends System.Enum {
+      value__: number;
+      static InvalidInputOverwritten: number;
+      static Disabled: number;
+    }
+    class NumberBoxValueChangedEventArgs implements Microsoft.UI.Xaml.Controls.INumberBoxValueChangedEventArgs {
+      readonly NewValue: number;
+      readonly OldValue: number;
+    }
+    class Orientation extends System.Enum {
+      value__: number;
+      static Vertical: number;
+      static Horizontal: number;
+    }
+    class UserControl extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IUserControl {
+      Content: Microsoft.UI.Xaml.UIElement;
+      static readonly ContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class Page extends Microsoft.UI.Xaml.Controls.UserControl implements Microsoft.UI.Xaml.Controls.IPage, Microsoft.UI.Xaml.Controls.IPageOverrides {
+      TopAppBar: Microsoft.UI.Xaml.Controls.AppBar;
+      NavigationCacheMode: number;
+      BottomAppBar: Microsoft.UI.Xaml.Controls.AppBar;
+      readonly Frame: Microsoft.UI.Xaml.Controls.Frame;
+      static readonly BottomAppBarProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FrameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TopAppBarProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PanelScrollingDirection extends System.Enum {
+      value__: number;
+      static None: number;
+      static Forward: number;
+      static Backward: number;
+    }
+    class ParallaxSourceOffsetKind extends System.Enum {
+      value__: number;
+      static Absolute: number;
+      static Relative: number;
+    }
+    class ParallaxView extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.IParallaxView {
+      VerticalSourceStartOffset: number;
+      VerticalSourceOffsetKind: number;
+      VerticalSourceEndOffset: number;
+      VerticalShift: number;
+      Source: Microsoft.UI.Xaml.UIElement;
+      MaxVerticalShiftRatio: number;
+      MaxHorizontalShiftRatio: number;
+      IsVerticalShiftClamped: boolean;
+      IsHorizontalShiftClamped: boolean;
+      HorizontalSourceStartOffset: number;
+      HorizontalSourceOffsetKind: number;
+      HorizontalSourceEndOffset: number;
+      HorizontalShift: number;
+      Child: Microsoft.UI.Xaml.UIElement;
+      static readonly ChildProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalShiftProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalSourceEndOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalSourceOffsetKindProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalSourceStartOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsHorizontalShiftClampedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsVerticalShiftClampedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxHorizontalShiftRatioProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxVerticalShiftRatioProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalShiftProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalSourceEndOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalSourceOffsetKindProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalSourceStartOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      RefreshAutomaticHorizontalOffsets(): void;
+      RefreshAutomaticVerticalOffsets(): void;
+    }
+    class PasswordBox extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IPasswordBox {
+      ContextMenuOpening: Microsoft.UI.Xaml.Controls.ContextMenuOpeningEventHandler | null;
+      PasswordChanged: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      PasswordChanging: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.PasswordBox, Microsoft.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs> | null;
+      Paste: Microsoft.UI.Xaml.Controls.TextControlPasteEventHandler | null;
+      TextReadingOrder: number;
+      SelectionHighlightColor: Microsoft.UI.Xaml.Media.SolidColorBrush;
+      SelectionFlyout: Microsoft.UI.Xaml.Controls.Primitives.FlyoutBase;
+      PreventKeyboardDisplayOnProgrammaticFocus: boolean;
+      PlaceholderText: string;
+      PasswordRevealMode: number;
+      PasswordChar: string;
+      Password: string;
+      MaxLength: number;
+      IsPasswordRevealButtonEnabled: boolean;
+      InputScope: Microsoft.UI.Xaml.Input.InputScope;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Header: any;
+      Description: any;
+      readonly CanPasteClipboardContent: boolean;
+      static readonly CanPasteClipboardContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DescriptionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly InputScopeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsPasswordRevealButtonEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxLengthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PasswordCharProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PasswordProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PasswordRevealModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlaceholderTextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PreventKeyboardDisplayOnProgrammaticFocusProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionFlyoutProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionHighlightColorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextReadingOrderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      SelectAll(): void;
+      PasteFromClipboard(): void;
+    }
+    class PasswordBoxPasswordChangingEventArgs implements Microsoft.UI.Xaml.Controls.IPasswordBoxPasswordChangingEventArgs {
+      readonly IsContentChanging: boolean;
+    }
+    class PasswordRevealMode extends System.Enum {
+      value__: number;
+      static Peek: number;
+      static Hidden: number;
+      static Visible: number;
+    }
+    class PathIcon extends Microsoft.UI.Xaml.Controls.IconElement implements Microsoft.UI.Xaml.Controls.IPathIcon {
+      Data: Microsoft.UI.Xaml.Media.Geometry;
+      static readonly DataProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PathIconSource extends Microsoft.UI.Xaml.Controls.IconSource implements Microsoft.UI.Xaml.Controls.IPathIconSource {
+      Data: Microsoft.UI.Xaml.Media.Geometry;
+      static readonly DataProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PersonPicture extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IPersonPicture {
+      ProfilePicture: Microsoft.UI.Xaml.Media.ImageSource;
+      PreferSmallImage: boolean;
+      IsGroup: boolean;
+      Initials: string;
+      DisplayName: string;
+      Contact: Windows.ApplicationModel.Contacts.Contact;
+      BadgeText: string;
+      BadgeNumber: number;
+      BadgeImageSource: Microsoft.UI.Xaml.Media.ImageSource;
+      BadgeGlyph: string;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.PersonPictureTemplateSettings;
+      static readonly BadgeGlyphProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BadgeImageSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BadgeNumberProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BadgeTextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContactProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DisplayNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly InitialsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsGroupProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PreferSmallImageProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ProfilePictureProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PersonPictureTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IPersonPictureTemplateSettings {
+      readonly ActualImageBrush: Microsoft.UI.Xaml.Media.ImageBrush;
+      readonly ActualInitials: string;
+    }
+    class PickerConfirmedEventArgs extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IPickerConfirmedEventArgs {
+      constructor();
+    }
+    class PickerFlyout extends Microsoft.UI.Xaml.Controls.Primitives.PickerFlyoutBase implements Microsoft.UI.Xaml.Controls.IPickerFlyout {
+      Confirmed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.PickerFlyout, Microsoft.UI.Xaml.Controls.PickerConfirmedEventArgs> | null;
+      Content: Microsoft.UI.Xaml.UIElement;
+      ConfirmationButtonsVisible: boolean;
+      static readonly ConfirmationButtonsVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      ShowAtAsync(operation: Microsoft.UI.Xaml.FrameworkElement): Windows.Foundation.IAsyncOperation<boolean>;
+    }
+    class PickerFlyoutPresenter extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.IPickerFlyoutPresenter {
+    }
+    class PipsPager extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IPipsPager, Microsoft.UI.Xaml.Controls.IPipsPager2 {
+      SelectedIndexChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.PipsPager, Microsoft.UI.Xaml.Controls.PipsPagerSelectedIndexChangedEventArgs> | null;
+      SelectedPipStyle: Microsoft.UI.Xaml.Style;
+      SelectedPageIndex: number;
+      PreviousButtonVisibility: number;
+      PreviousButtonStyle: Microsoft.UI.Xaml.Style;
+      Orientation: number;
+      NumberOfPages: number;
+      NormalPipStyle: Microsoft.UI.Xaml.Style;
+      NextButtonVisibility: number;
+      NextButtonStyle: Microsoft.UI.Xaml.Style;
+      MaxVisiblePips: number;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.PipsPagerTemplateSettings;
+      WrapMode: number;
+      static readonly MaxVisiblePipsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly NextButtonStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly NextButtonVisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly NormalPipStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly NumberOfPagesProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OrientationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PreviousButtonStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PreviousButtonVisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedPageIndexProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedPipStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly WrapModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PipsPagerButtonVisibility extends System.Enum {
+      value__: number;
+      static Visible: number;
+      static VisibleOnPointerOver: number;
+      static Collapsed: number;
+    }
+    class PipsPagerSelectedIndexChangedEventArgs implements Microsoft.UI.Xaml.Controls.IPipsPagerSelectedIndexChangedEventArgs {
+    }
+    class PipsPagerTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IPipsPagerTemplateSettings {
+      readonly PipsPagerItems: System.Collections.Generic.IList<number>;
+    }
+    class PipsPagerWrapMode extends System.Enum {
+      value__: number;
+      static None: number;
+      static Wrap: number;
+    }
+    class Pivot extends Microsoft.UI.Xaml.Controls.ItemsControl implements Microsoft.UI.Xaml.Controls.IPivot {
+      PivotItemLoaded: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Pivot, Microsoft.UI.Xaml.Controls.PivotItemEventArgs> | null;
+      PivotItemLoading: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Pivot, Microsoft.UI.Xaml.Controls.PivotItemEventArgs> | null;
+      PivotItemUnloaded: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Pivot, Microsoft.UI.Xaml.Controls.PivotItemEventArgs> | null;
+      PivotItemUnloading: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Pivot, Microsoft.UI.Xaml.Controls.PivotItemEventArgs> | null;
+      SelectionChanged: Microsoft.UI.Xaml.Controls.SelectionChangedEventHandler | null;
+      TitleTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Title: any;
+      SelectedItem: any;
+      SelectedIndex: number;
+      RightHeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      RightHeader: any;
+      LeftHeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      LeftHeader: any;
+      IsLocked: boolean;
+      IsHeaderItemsCarouselEnabled: boolean;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      HeaderFocusVisualPlacement: number;
+      static readonly HeaderFocusVisualPlacementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsHeaderItemsCarouselEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsLockedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LeftHeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LeftHeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RightHeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RightHeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedIndexProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedItemProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SlideInAnimationGroupProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TitleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TitleTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      static GetSlideInAnimationGroup(result: Microsoft.UI.Xaml.FrameworkElement): number;
+      static SetSlideInAnimationGroup(element: Microsoft.UI.Xaml.FrameworkElement, value: number): void;
+    }
+    class PivotHeaderFocusVisualPlacement extends System.Enum {
+      value__: number;
+      static ItemHeaders: number;
+      static SelectedItemHeader: number;
+    }
+    class PivotItem extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.IPivotItem {
+      Header: any;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PivotItemEventArgs implements Microsoft.UI.Xaml.Controls.IPivotItemEventArgs {
+      Item: Microsoft.UI.Xaml.Controls.PivotItem;
+      constructor();
+    }
+    class PivotSlideInAnimationGroup extends System.Enum {
+      value__: number;
+      static Default: number;
+      static GroupOne: number;
+      static GroupTwo: number;
+      static GroupThree: number;
+    }
+    class PlayerAnimationOptimization extends System.Enum {
+      value__: number;
+      static Latency: number;
+      static Resources: number;
+    }
+    class VirtualizingPanel extends Microsoft.UI.Xaml.Controls.Panel implements Microsoft.UI.Xaml.Controls.IVirtualizingPanel, Microsoft.UI.Xaml.Controls.IVirtualizingPanelProtected, Microsoft.UI.Xaml.Controls.IVirtualizingPanelOverrides {
+      readonly ItemContainerGenerator: Microsoft.UI.Xaml.Controls.ItemContainerGenerator;
+    }
+    class Slider extends Microsoft.UI.Xaml.Controls.Primitives.RangeBase implements Microsoft.UI.Xaml.Controls.ISlider {
+      TickPlacement: number;
+      TickFrequency: number;
+      ThumbToolTipValueConverter: Microsoft.UI.Xaml.Data.IValueConverter;
+      StepFrequency: number;
+      SnapsTo: number;
+      Orientation: number;
+      IsThumbToolTipEnabled: boolean;
+      IsDirectionReversed: boolean;
+      IntermediateValue: number;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Header: any;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IntermediateValueProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsDirectionReversedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsThumbToolTipEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OrientationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SnapsToProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StepFrequencyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ThumbToolTipValueConverterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TickFrequencyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TickPlacementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ProgressBar extends Microsoft.UI.Xaml.Controls.Primitives.RangeBase implements Microsoft.UI.Xaml.Controls.IProgressBar {
+      ShowPaused: boolean;
+      ShowError: boolean;
+      IsIndeterminate: boolean;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.ProgressBarTemplateSettings;
+      static readonly IsIndeterminateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ShowErrorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ShowPausedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ProgressBarTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IProgressBarTemplateSettings {
+      readonly ClipRect: Microsoft.UI.Xaml.Media.RectangleGeometry;
+      readonly Container2AnimationEndPosition: number;
+      readonly Container2AnimationStartPosition: number;
+      readonly ContainerAnimationEndPosition: number;
+      readonly ContainerAnimationMidPosition: number;
+      readonly ContainerAnimationStartPosition: number;
+      readonly EllipseAnimationEndPosition: number;
+      readonly EllipseAnimationWellPosition: number;
+      readonly EllipseDiameter: number;
+      readonly EllipseOffset: number;
+      readonly IndicatorLengthDelta: number;
+    }
+    class ProgressRing extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IProgressRing {
+      Value: number;
+      Minimum: number;
+      Maximum: number;
+      IsIndeterminate: boolean;
+      IsActive: boolean;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.ProgressRingTemplateSettings;
+      static readonly IsActiveProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsIndeterminateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaximumProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinimumProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ValueProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ProgressRingTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IProgressRingTemplateSettings {
+      readonly EllipseDiameter: number;
+      readonly EllipseOffset: Microsoft.UI.Xaml.Thickness;
+      readonly MaxSideLength: number;
+    }
+    class RadioButton extends Microsoft.UI.Xaml.Controls.Primitives.ToggleButton implements Microsoft.UI.Xaml.Controls.IRadioButton {
+      GroupName: string;
+      static readonly GroupNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class RadioButtons extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IRadioButtons {
+      SelectionChanged: Microsoft.UI.Xaml.Controls.SelectionChangedEventHandler | null;
+      SelectedItem: any;
+      SelectedIndex: number;
+      MaxColumns: number;
+      ItemsSource: any;
+      ItemTemplate: any;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Header: any;
+      readonly Items: System.Collections.Generic.IList<any>;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemsSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxColumnsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedIndexProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedItemProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      ContainerFromIndex(result: number): Microsoft.UI.Xaml.UIElement;
+    }
+    class RadioMenuFlyoutItem extends Microsoft.UI.Xaml.Controls.MenuFlyoutItem implements Microsoft.UI.Xaml.Controls.IRadioMenuFlyoutItem {
+      IsChecked: boolean;
+      GroupName: string;
+      static readonly GroupNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsCheckedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AreCheckStatesEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      static SetAreCheckStatesEnabled(object: Microsoft.UI.Xaml.Controls.MenuFlyoutSubItem, value: boolean): void;
+      static GetAreCheckStatesEnabled(result: Microsoft.UI.Xaml.Controls.MenuFlyoutSubItem): boolean;
+    }
+    class RatingControl extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IRatingControl {
+      ValueChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.RatingControl, any> | null;
+      Value: number;
+      PlaceholderValue: number;
+      MaxRating: number;
+      ItemInfo: Microsoft.UI.Xaml.Controls.RatingItemInfo;
+      IsReadOnly: boolean;
+      IsClearEnabled: boolean;
+      InitialSetValue: number;
+      Caption: string;
+      static readonly CaptionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly InitialSetValueProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsClearEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsReadOnlyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemInfoProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxRatingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlaceholderValueProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ValueProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class RatingItemInfo extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IRatingItemInfo {
+      constructor();
+    }
+    class RatingItemFontInfo extends Microsoft.UI.Xaml.Controls.RatingItemInfo implements Microsoft.UI.Xaml.Controls.IRatingItemFontInfo {
+      UnsetGlyph: string;
+      PointerOverPlaceholderGlyph: string;
+      PointerOverGlyph: string;
+      PlaceholderGlyph: string;
+      Glyph: string;
+      DisabledGlyph: string;
+      static readonly DisabledGlyphProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GlyphProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlaceholderGlyphProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PointerOverGlyphProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PointerOverPlaceholderGlyphProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly UnsetGlyphProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class RatingItemImageInfo extends Microsoft.UI.Xaml.Controls.RatingItemInfo implements Microsoft.UI.Xaml.Controls.IRatingItemImageInfo {
+      UnsetImage: Microsoft.UI.Xaml.Media.ImageSource;
+      PointerOverPlaceholderImage: Microsoft.UI.Xaml.Media.ImageSource;
+      PointerOverImage: Microsoft.UI.Xaml.Media.ImageSource;
+      PlaceholderImage: Microsoft.UI.Xaml.Media.ImageSource;
+      Image: Microsoft.UI.Xaml.Media.ImageSource;
+      DisabledImage: Microsoft.UI.Xaml.Media.ImageSource;
+      static readonly DisabledImageProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ImageProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlaceholderImageProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PointerOverImageProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PointerOverPlaceholderImageProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly UnsetImageProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class RefreshContainer extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.IRefreshContainer {
+      RefreshRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.RefreshContainer, Microsoft.UI.Xaml.Controls.RefreshRequestedEventArgs> | null;
+      Visualizer: Microsoft.UI.Xaml.Controls.RefreshVisualizer;
+      PullDirection: number;
+      static readonly PullDirectionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VisualizerProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      RequestRefresh(): void;
+    }
+    class RefreshInteractionRatioChangedEventArgs implements Microsoft.UI.Xaml.Controls.IRefreshInteractionRatioChangedEventArgs {
+      readonly InteractionRatio: number;
+    }
+    class RefreshPullDirection extends System.Enum {
+      value__: number;
+      static LeftToRight: number;
+      static TopToBottom: number;
+      static RightToLeft: number;
+      static BottomToTop: number;
+    }
+    class RefreshRequestedEventArgs implements Microsoft.UI.Xaml.Controls.IRefreshRequestedEventArgs {
+      GetDeferral(): Windows.Foundation.Deferral;
+    }
+    class RefreshStateChangedEventArgs implements Microsoft.UI.Xaml.Controls.IRefreshStateChangedEventArgs {
+      readonly NewState: number;
+      readonly OldState: number;
+    }
+    class RefreshVisualizer extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IRefreshVisualizer {
+      RefreshRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.RefreshVisualizer, Microsoft.UI.Xaml.Controls.RefreshRequestedEventArgs> | null;
+      RefreshStateChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.RefreshVisualizer, Microsoft.UI.Xaml.Controls.RefreshStateChangedEventArgs> | null;
+      Orientation: number;
+      Content: Microsoft.UI.Xaml.UIElement;
+      readonly State: number;
+      static readonly ContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly InfoProviderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OrientationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      RequestRefresh(): void;
+    }
+    class RefreshVisualizerOrientation extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Normal: number;
+      static Rotate90DegreesCounterclockwise: number;
+      static Rotate270DegreesCounterclockwise: number;
+    }
+    class RefreshVisualizerState extends System.Enum {
+      value__: number;
+      static Idle: number;
+      static Peeking: number;
+      static Interacting: number;
+      static Pending: number;
+      static Refreshing: number;
+    }
+    class RelativePanel extends Microsoft.UI.Xaml.Controls.Panel implements Microsoft.UI.Xaml.Controls.IRelativePanel {
+      Padding: Microsoft.UI.Xaml.Thickness;
+      CornerRadius: Microsoft.UI.Xaml.CornerRadius;
+      BorderThickness: Microsoft.UI.Xaml.Thickness;
+      BorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      BackgroundSizing: number;
+      static readonly AboveProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AlignBottomWithPanelProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AlignBottomWithProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AlignHorizontalCenterWithPanelProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AlignHorizontalCenterWithProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AlignLeftWithPanelProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AlignLeftWithProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AlignRightWithPanelProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AlignRightWithProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AlignTopWithPanelProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AlignTopWithProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AlignVerticalCenterWithPanelProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AlignVerticalCenterWithProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BackgroundSizingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BelowProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BorderThicknessProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CornerRadiusProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LeftOfProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaddingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RightOfProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      static GetLeftOf(result: Microsoft.UI.Xaml.UIElement): any;
+      static SetLeftOf(element: Microsoft.UI.Xaml.UIElement, value: any): void;
+      static GetAbove(result: Microsoft.UI.Xaml.UIElement): any;
+      static SetAbove(element: Microsoft.UI.Xaml.UIElement, value: any): void;
+      static GetRightOf(result: Microsoft.UI.Xaml.UIElement): any;
+      static SetRightOf(element: Microsoft.UI.Xaml.UIElement, value: any): void;
+      static GetBelow(result: Microsoft.UI.Xaml.UIElement): any;
+      static SetBelow(element: Microsoft.UI.Xaml.UIElement, value: any): void;
+      static GetAlignHorizontalCenterWith(result: Microsoft.UI.Xaml.UIElement): any;
+      static SetAlignHorizontalCenterWith(element: Microsoft.UI.Xaml.UIElement, value: any): void;
+      static GetAlignVerticalCenterWith(result: Microsoft.UI.Xaml.UIElement): any;
+      static SetAlignVerticalCenterWith(element: Microsoft.UI.Xaml.UIElement, value: any): void;
+      static GetAlignLeftWith(result: Microsoft.UI.Xaml.UIElement): any;
+      static SetAlignLeftWith(element: Microsoft.UI.Xaml.UIElement, value: any): void;
+      static GetAlignTopWith(result: Microsoft.UI.Xaml.UIElement): any;
+      static SetAlignTopWith(element: Microsoft.UI.Xaml.UIElement, value: any): void;
+      static GetAlignRightWith(result: Microsoft.UI.Xaml.UIElement): any;
+      static SetAlignRightWith(element: Microsoft.UI.Xaml.UIElement, value: any): void;
+      static GetAlignBottomWith(result: Microsoft.UI.Xaml.UIElement): any;
+      static SetAlignBottomWith(element: Microsoft.UI.Xaml.UIElement, value: any): void;
+      static GetAlignLeftWithPanel(result: Microsoft.UI.Xaml.UIElement): boolean;
+      static SetAlignLeftWithPanel(element: Microsoft.UI.Xaml.UIElement, value: boolean): void;
+      static GetAlignTopWithPanel(result: Microsoft.UI.Xaml.UIElement): boolean;
+      static SetAlignTopWithPanel(element: Microsoft.UI.Xaml.UIElement, value: boolean): void;
+      static GetAlignRightWithPanel(result: Microsoft.UI.Xaml.UIElement): boolean;
+      static SetAlignRightWithPanel(element: Microsoft.UI.Xaml.UIElement, value: boolean): void;
+      static GetAlignBottomWithPanel(result: Microsoft.UI.Xaml.UIElement): boolean;
+      static SetAlignBottomWithPanel(element: Microsoft.UI.Xaml.UIElement, value: boolean): void;
+      static GetAlignHorizontalCenterWithPanel(result: Microsoft.UI.Xaml.UIElement): boolean;
+      static SetAlignHorizontalCenterWithPanel(element: Microsoft.UI.Xaml.UIElement, value: boolean): void;
+      static GetAlignVerticalCenterWithPanel(result: Microsoft.UI.Xaml.UIElement): boolean;
+      static SetAlignVerticalCenterWithPanel(element: Microsoft.UI.Xaml.UIElement, value: boolean): void;
+    }
+    class RequiresPointer extends System.Enum {
+      value__: number;
+      static Never: number;
+      static WhenEngaged: number;
+      static WhenFocused: number;
+    }
+    class RevealListViewItemPresenter extends Microsoft.UI.Xaml.Controls.Primitives.ListViewItemPresenter implements Microsoft.UI.Xaml.Controls.IRevealListViewItemPresenter {
+      constructor();
+    }
+    class RichEditBox extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IRichEditBox {
+      CandidateWindowBoundsChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.RichEditBox, Microsoft.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs> | null;
+      ContextMenuOpening: Microsoft.UI.Xaml.Controls.ContextMenuOpeningEventHandler | null;
+      CopyingToClipboard: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.RichEditBox, Microsoft.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs> | null;
+      CuttingToClipboard: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.RichEditBox, Microsoft.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs> | null;
+      Paste: Microsoft.UI.Xaml.Controls.TextControlPasteEventHandler | null;
+      SelectionChanged: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      SelectionChanging: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.RichEditBox, Microsoft.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs> | null;
+      TextChanged: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      TextChanging: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.RichEditBox, Microsoft.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs> | null;
+      TextCompositionChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.RichEditBox, Microsoft.UI.Xaml.Controls.TextCompositionChangedEventArgs> | null;
+      TextCompositionEnded: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.RichEditBox, Microsoft.UI.Xaml.Controls.TextCompositionEndedEventArgs> | null;
+      TextCompositionStarted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.RichEditBox, Microsoft.UI.Xaml.Controls.TextCompositionStartedEventArgs> | null;
+      TextWrapping: number;
+      TextReadingOrder: number;
+      TextAlignment: number;
+      SelectionHighlightColorWhenNotFocused: Microsoft.UI.Xaml.Media.SolidColorBrush;
+      SelectionHighlightColor: Microsoft.UI.Xaml.Media.SolidColorBrush;
+      SelectionFlyout: Microsoft.UI.Xaml.Controls.Primitives.FlyoutBase;
+      PreventKeyboardDisplayOnProgrammaticFocus: boolean;
+      PlaceholderText: string;
+      MaxLength: number;
+      IsTextPredictionEnabled: boolean;
+      IsSpellCheckEnabled: boolean;
+      IsReadOnly: boolean;
+      IsColorFontEnabled: boolean;
+      InputScope: Microsoft.UI.Xaml.Input.InputScope;
+      HorizontalTextAlignment: number;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Header: any;
+      DisabledFormattingAccelerators: number;
+      DesiredCandidateWindowAlignment: number;
+      Description: any;
+      ClipboardCopyFormat: number;
+      CharacterCasing: number;
+      AcceptsReturn: boolean;
+      readonly Document: Microsoft.UI.Text.RichEditTextDocument;
+      readonly ProofingMenuFlyout: Microsoft.UI.Xaml.Controls.Primitives.FlyoutBase;
+      readonly TextDocument: Microsoft.UI.Text.RichEditTextDocument;
+      static readonly AcceptsReturnProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CharacterCasingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ClipboardCopyFormatProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DescriptionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DesiredCandidateWindowAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DisabledFormattingAcceleratorsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalTextAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly InputScopeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsColorFontEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsReadOnlyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsSpellCheckEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTextPredictionEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxLengthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlaceholderTextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PreventKeyboardDisplayOnProgrammaticFocusProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ProofingMenuFlyoutProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionFlyoutProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionHighlightColorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionHighlightColorWhenNotFocusedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextReadingOrderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextWrappingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      GetLinguisticAlternativesAsync(): Windows.Foundation.IAsyncOperation<System.Collections.Generic.IReadOnlyList<string>>;
+    }
+    class RichEditBoxSelectionChangingEventArgs implements Microsoft.UI.Xaml.Controls.IRichEditBoxSelectionChangingEventArgs {
+      Cancel: boolean;
+      readonly SelectionLength: number;
+      readonly SelectionStart: number;
+    }
+    class RichEditBoxTextChangingEventArgs implements Microsoft.UI.Xaml.Controls.IRichEditBoxTextChangingEventArgs {
+      readonly IsContentChanging: boolean;
+    }
+    class RichEditClipboardFormat extends System.Enum {
+      value__: number;
+      static AllFormats: number;
+      static PlainText: number;
+    }
+    class RichTextBlock extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.IRichTextBlock {
+      ContextMenuOpening: Microsoft.UI.Xaml.Controls.ContextMenuOpeningEventHandler | null;
+      IsTextTrimmedChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.RichTextBlock, Microsoft.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs> | null;
+      SelectionChanged: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      HorizontalTextAlignment: number;
+      LineHeight: number;
+      Foreground: Microsoft.UI.Xaml.Media.Brush;
+      FontWeight: Windows.UI.Text.FontWeight;
+      FontStyle: Windows.UI.Text.FontStyle;
+      FontStretch: Windows.UI.Text.FontStretch;
+      FontSize: number;
+      FontFamily: Microsoft.UI.Xaml.Media.FontFamily;
+      IsTextSelectionEnabled: boolean;
+      IsTextScaleFactorEnabled: boolean;
+      CharacterSpacing: number;
+      IsColorFontEnabled: boolean;
+      TextWrapping: number;
+      LineStackingStrategy: number;
+      TextTrimming: number;
+      TextReadingOrder: number;
+      TextLineBounds: number;
+      TextIndent: number;
+      TextDecorations: Windows.UI.Text.TextDecorations;
+      TextAlignment: number;
+      SelectionHighlightColor: Microsoft.UI.Xaml.Media.SolidColorBrush;
+      SelectionFlyout: Microsoft.UI.Xaml.Controls.Primitives.FlyoutBase;
+      Padding: Microsoft.UI.Xaml.Thickness;
+      OverflowContentTarget: Microsoft.UI.Xaml.Controls.RichTextBlockOverflow;
+      OpticalMarginAlignment: number;
+      MaxLines: number;
+      readonly Blocks: Microsoft.UI.Xaml.Documents.BlockCollection;
+      readonly ContentEnd: Microsoft.UI.Xaml.Documents.TextPointer;
+      readonly ContentStart: Microsoft.UI.Xaml.Documents.TextPointer;
+      readonly HasOverflowContent: boolean;
+      readonly IsTextTrimmed: boolean;
+      readonly SelectedText: string;
+      readonly SelectionEnd: Microsoft.UI.Xaml.Documents.TextPointer;
+      readonly SelectionStart: Microsoft.UI.Xaml.Documents.TextPointer;
+      readonly TextHighlighters: System.Collections.Generic.IList<Microsoft.UI.Xaml.Documents.TextHighlighter>;
+      readonly BaselineOffset: number;
+      static readonly CharacterSpacingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontFamilyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontSizeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontStretchProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontWeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HasOverflowContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalTextAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsColorFontEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTextScaleFactorEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTextSelectionEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTextTrimmedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LineHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LineStackingStrategyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxLinesProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OpticalMarginAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OverflowContentTargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaddingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedTextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionFlyoutProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionHighlightColorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextDecorationsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextIndentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextLineBoundsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextReadingOrderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextTrimmingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextWrappingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      SelectAll(): void;
+      Select(start: Microsoft.UI.Xaml.Documents.TextPointer, end: Microsoft.UI.Xaml.Documents.TextPointer): void;
+      GetPositionFromPoint(result: Windows.Foundation.Point): Microsoft.UI.Xaml.Documents.TextPointer;
+      CopySelectionToClipboard(): void;
+    }
+    class RichTextBlockOverflow extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.IRichTextBlockOverflow {
+      IsTextTrimmedChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.RichTextBlockOverflow, Microsoft.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs> | null;
+      Padding: Microsoft.UI.Xaml.Thickness;
+      OverflowContentTarget: Microsoft.UI.Xaml.Controls.RichTextBlockOverflow;
+      MaxLines: number;
+      readonly BaselineOffset: number;
+      readonly ContentEnd: Microsoft.UI.Xaml.Documents.TextPointer;
+      readonly ContentSource: Microsoft.UI.Xaml.Controls.RichTextBlock;
+      readonly ContentStart: Microsoft.UI.Xaml.Documents.TextPointer;
+      readonly HasOverflowContent: boolean;
+      readonly IsTextTrimmed: boolean;
+      static readonly HasOverflowContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTextTrimmedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxLinesProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OverflowContentTargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaddingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      GetPositionFromPoint(result: Windows.Foundation.Point): Microsoft.UI.Xaml.Documents.TextPointer;
+    }
+    class RowDefinition extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.IRowDefinition {
+      MinHeight: number;
+      MaxHeight: number;
+      Height: Microsoft.UI.Xaml.GridLength;
+      readonly ActualHeight: number;
+      static readonly HeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class RowDefinitionCollection {
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class ScrollBarVisibility extends System.Enum {
+      value__: number;
+      static Disabled: number;
+      static Auto: number;
+      static Hidden: number;
+      static Visible: number;
+    }
+    class ScrollContentPresenter extends Microsoft.UI.Xaml.Controls.ContentPresenter implements Microsoft.UI.Xaml.Controls.IScrollContentPresenter {
+      SizesContentToTemplatedParent: boolean;
+      ScrollOwner: any;
+      CanVerticallyScroll: boolean;
+      CanHorizontallyScroll: boolean;
+      CanContentRenderOutsideBounds: boolean;
+      readonly ExtentHeight: number;
+      readonly ExtentWidth: number;
+      readonly HorizontalOffset: number;
+      readonly VerticalOffset: number;
+      readonly ViewportHeight: number;
+      readonly ViewportWidth: number;
+      static readonly CanContentRenderOutsideBoundsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SizesContentToTemplatedParentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      LineUp(): void;
+      LineDown(): void;
+      LineLeft(): void;
+      LineRight(): void;
+      PageUp(): void;
+      PageDown(): void;
+      PageLeft(): void;
+      PageRight(): void;
+      MouseWheelUp(): void;
+      MouseWheelDown(): void;
+      MouseWheelLeft(): void;
+      MouseWheelRight(): void;
+      SetHorizontalOffset(offset: number): void;
+      SetVerticalOffset(offset: number): void;
+      MakeVisible(result: Microsoft.UI.Xaml.UIElement, visual: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    }
+    class ScrollIntoViewAlignment extends System.Enum {
+      value__: number;
+      static Default: number;
+      static Leading: number;
+    }
+    class ScrollMode extends System.Enum {
+      value__: number;
+      static Disabled: number;
+      static Enabled: number;
+      static Auto: number;
+    }
+    class ScrollView extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IScrollView {
+      AnchorRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ScrollView, Microsoft.UI.Xaml.Controls.ScrollingAnchorRequestedEventArgs> | null;
+      BringingIntoView: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ScrollView, Microsoft.UI.Xaml.Controls.ScrollingBringingIntoViewEventArgs> | null;
+      ExtentChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ScrollView, any> | null;
+      ScrollAnimationStarting: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ScrollView, Microsoft.UI.Xaml.Controls.ScrollingScrollAnimationStartingEventArgs> | null;
+      ScrollCompleted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ScrollView, Microsoft.UI.Xaml.Controls.ScrollingScrollCompletedEventArgs> | null;
+      StateChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ScrollView, any> | null;
+      ViewChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ScrollView, any> | null;
+      ZoomAnimationStarting: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ScrollView, Microsoft.UI.Xaml.Controls.ScrollingZoomAnimationStartingEventArgs> | null;
+      ZoomCompleted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ScrollView, Microsoft.UI.Xaml.Controls.ScrollingZoomCompletedEventArgs> | null;
+      HorizontalScrollMode: number;
+      HorizontalScrollChainMode: number;
+      HorizontalScrollBarVisibility: number;
+      ContentOrientation: number;
+      Content: Microsoft.UI.Xaml.UIElement;
+      IgnoredInputKinds: number;
+      HorizontalAnchorRatio: number;
+      HorizontalScrollRailMode: number;
+      ZoomMode: number;
+      MaxZoomFactor: number;
+      ZoomChainMode: number;
+      VerticalScrollRailMode: number;
+      VerticalScrollMode: number;
+      VerticalScrollChainMode: number;
+      VerticalScrollBarVisibility: number;
+      VerticalAnchorRatio: number;
+      MinZoomFactor: number;
+      readonly ComputedHorizontalScrollMode: number;
+      readonly ComputedVerticalScrollBarVisibility: number;
+      readonly ComputedVerticalScrollMode: number;
+      readonly CurrentAnchor: Microsoft.UI.Xaml.UIElement;
+      readonly ExpressionAnimationSources: Microsoft.UI.Composition.CompositionPropertySet;
+      readonly ExtentHeight: number;
+      readonly ExtentWidth: number;
+      readonly HorizontalOffset: number;
+      readonly ScrollPresenter: Microsoft.UI.Xaml.Controls.Primitives.ScrollPresenter;
+      readonly ScrollableHeight: number;
+      readonly ScrollableWidth: number;
+      readonly State: number;
+      readonly VerticalOffset: number;
+      readonly ViewportHeight: number;
+      readonly ViewportWidth: number;
+      readonly ZoomFactor: number;
+      readonly ComputedHorizontalScrollBarVisibility: number;
+      static readonly ComputedHorizontalScrollBarVisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ComputedHorizontalScrollModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ComputedVerticalScrollBarVisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ComputedVerticalScrollModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentOrientationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalAnchorRatioProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalScrollBarVisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalScrollChainModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalScrollModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalScrollRailModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IgnoredInputKindsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxZoomFactorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinZoomFactorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ScrollPresenterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalAnchorRatioProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalScrollBarVisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalScrollChainModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalScrollModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalScrollRailModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ZoomChainModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ZoomModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      RegisterAnchorCandidate(element: Microsoft.UI.Xaml.UIElement): void;
+      UnregisterAnchorCandidate(element: Microsoft.UI.Xaml.UIElement): void;
+      ScrollTo(result: number, horizontalOffset: number): number;
+      ScrollTo(result: number, horizontalOffset: number, verticalOffset: Microsoft.UI.Xaml.Controls.ScrollingScrollOptions): number;
+      ScrollBy(result: number, horizontalOffsetDelta: number): number;
+      ScrollBy(result: number, horizontalOffsetDelta: number, verticalOffsetDelta: Microsoft.UI.Xaml.Controls.ScrollingScrollOptions): number;
+      AddScrollVelocity(result: System.Numerics.Vector2, offsetsVelocity: System.Nullable<System.Numerics.Vector2>): number;
+      ZoomTo(result: number, zoomFactor: System.Nullable<System.Numerics.Vector2>): number;
+      ZoomTo(result: number, zoomFactor: System.Nullable<System.Numerics.Vector2>, centerPoint: Microsoft.UI.Xaml.Controls.ScrollingZoomOptions): number;
+      ZoomBy(result: number, zoomFactorDelta: System.Nullable<System.Numerics.Vector2>): number;
+      ZoomBy(result: number, zoomFactorDelta: System.Nullable<System.Numerics.Vector2>, centerPoint: Microsoft.UI.Xaml.Controls.ScrollingZoomOptions): number;
+      AddZoomVelocity(result: number, zoomFactorVelocity: System.Nullable<System.Numerics.Vector2>, centerPoint: System.Nullable<number>): number;
+    }
+    class ScrollViewer extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.IScrollViewer, Microsoft.UI.Xaml.Controls.IScrollAnchorProvider {
+      AnchorRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ScrollViewer, Microsoft.UI.Xaml.Controls.AnchorRequestedEventArgs> | null;
+      DirectManipulationCompleted: System.EventHandler<any> | null;
+      DirectManipulationStarted: System.EventHandler<any> | null;
+      ViewChanged: System.EventHandler<Microsoft.UI.Xaml.Controls.ScrollViewerViewChangedEventArgs> | null;
+      ViewChanging: System.EventHandler<Microsoft.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs> | null;
+      readonly CurrentAnchor: Microsoft.UI.Xaml.UIElement;
+      IsHorizontalScrollChainingEnabled: boolean;
+      IsHorizontalRailEnabled: boolean;
+      IsDeferredScrollingEnabled: boolean;
+      HorizontalSnapPointsType: number;
+      HorizontalSnapPointsAlignment: number;
+      HorizontalScrollMode: number;
+      HorizontalScrollBarVisibility: number;
+      IsZoomInertiaEnabled: boolean;
+      HorizontalAnchorRatio: number;
+      IsZoomChainingEnabled: boolean;
+      IsVerticalScrollChainingEnabled: boolean;
+      IsVerticalRailEnabled: boolean;
+      IsScrollInertiaEnabled: boolean;
+      CanContentRenderOutsideBounds: boolean;
+      LeftHeader: Microsoft.UI.Xaml.UIElement;
+      BringIntoViewOnFocusChange: boolean;
+      ZoomSnapPointsType: number;
+      ZoomMode: number;
+      VerticalSnapPointsType: number;
+      VerticalSnapPointsAlignment: number;
+      VerticalScrollMode: number;
+      VerticalScrollBarVisibility: number;
+      VerticalAnchorRatio: number;
+      TopLeftHeader: Microsoft.UI.Xaml.UIElement;
+      TopHeader: Microsoft.UI.Xaml.UIElement;
+      ReduceViewportForCoreInputViewOcclusions: boolean;
+      MinZoomFactor: number;
+      MaxZoomFactor: number;
+      readonly ComputedHorizontalScrollBarVisibility: number;
+      readonly ComputedVerticalScrollBarVisibility: number;
+      readonly ExtentHeight: number;
+      readonly ExtentWidth: number;
+      readonly HorizontalOffset: number;
+      readonly ScrollableHeight: number;
+      readonly ScrollableWidth: number;
+      readonly VerticalOffset: number;
+      readonly ViewportHeight: number;
+      readonly ViewportWidth: number;
+      readonly ZoomFactor: number;
+      readonly ZoomSnapPoints: System.Collections.Generic.IList<number>;
+      static readonly BringIntoViewOnFocusChangeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CanContentRenderOutsideBoundsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ComputedHorizontalScrollBarVisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ComputedVerticalScrollBarVisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ExtentHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ExtentWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalAnchorRatioProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalScrollBarVisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalScrollModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalSnapPointsAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalSnapPointsTypeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsDeferredScrollingEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsHorizontalRailEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsHorizontalScrollChainingEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsScrollInertiaEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsVerticalRailEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsVerticalScrollChainingEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsZoomChainingEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsZoomInertiaEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LeftHeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxZoomFactorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinZoomFactorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ReduceViewportForCoreInputViewOcclusionsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ScrollableHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ScrollableWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TopHeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TopLeftHeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalAnchorRatioProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalScrollBarVisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalScrollModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalSnapPointsAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalSnapPointsTypeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ViewportHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ViewportWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ZoomFactorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ZoomModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ZoomSnapPointsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ZoomSnapPointsTypeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      ScrollToHorizontalOffset(offset: number): void;
+      ScrollToVerticalOffset(offset: number): void;
+      ZoomToFactor(factor: number): void;
+      ChangeView(result: System.Nullable<number>, horizontalOffset: System.Nullable<number>, verticalOffset: System.Nullable<number>): boolean;
+      ChangeView(result: System.Nullable<number>, horizontalOffset: System.Nullable<number>, verticalOffset: System.Nullable<number>, zoomFactor: boolean): boolean;
+      InvalidateScrollInfo(): void;
+      RegisterAnchorCandidate(element: Microsoft.UI.Xaml.UIElement): void;
+      UnregisterAnchorCandidate(element: Microsoft.UI.Xaml.UIElement): void;
+      static GetHorizontalScrollBarVisibility(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetHorizontalScrollBarVisibility(element: Microsoft.UI.Xaml.DependencyObject, horizontalScrollBarVisibility: number): void;
+      static GetVerticalScrollBarVisibility(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetVerticalScrollBarVisibility(element: Microsoft.UI.Xaml.DependencyObject, verticalScrollBarVisibility: number): void;
+      static GetIsHorizontalRailEnabled(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetIsHorizontalRailEnabled(element: Microsoft.UI.Xaml.DependencyObject, isHorizontalRailEnabled: boolean): void;
+      static GetIsVerticalRailEnabled(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetIsVerticalRailEnabled(element: Microsoft.UI.Xaml.DependencyObject, isVerticalRailEnabled: boolean): void;
+      static GetIsHorizontalScrollChainingEnabled(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetIsHorizontalScrollChainingEnabled(element: Microsoft.UI.Xaml.DependencyObject, isHorizontalScrollChainingEnabled: boolean): void;
+      static GetIsVerticalScrollChainingEnabled(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetIsVerticalScrollChainingEnabled(element: Microsoft.UI.Xaml.DependencyObject, isVerticalScrollChainingEnabled: boolean): void;
+      static GetIsZoomChainingEnabled(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetIsZoomChainingEnabled(element: Microsoft.UI.Xaml.DependencyObject, isZoomChainingEnabled: boolean): void;
+      static GetIsScrollInertiaEnabled(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetIsScrollInertiaEnabled(element: Microsoft.UI.Xaml.DependencyObject, isScrollInertiaEnabled: boolean): void;
+      static GetIsZoomInertiaEnabled(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetIsZoomInertiaEnabled(element: Microsoft.UI.Xaml.DependencyObject, isZoomInertiaEnabled: boolean): void;
+      static GetHorizontalScrollMode(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetHorizontalScrollMode(element: Microsoft.UI.Xaml.DependencyObject, horizontalScrollMode: number): void;
+      static GetVerticalScrollMode(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetVerticalScrollMode(element: Microsoft.UI.Xaml.DependencyObject, verticalScrollMode: number): void;
+      static GetZoomMode(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetZoomMode(element: Microsoft.UI.Xaml.DependencyObject, zoomMode: number): void;
+      static GetCanContentRenderOutsideBounds(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetCanContentRenderOutsideBounds(element: Microsoft.UI.Xaml.DependencyObject, canContentRenderOutsideBounds: boolean): void;
+      static GetIsDeferredScrollingEnabled(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetIsDeferredScrollingEnabled(element: Microsoft.UI.Xaml.DependencyObject, isDeferredScrollingEnabled: boolean): void;
+      static GetBringIntoViewOnFocusChange(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetBringIntoViewOnFocusChange(element: Microsoft.UI.Xaml.DependencyObject, bringIntoViewOnFocusChange: boolean): void;
+    }
+    class ScrollViewerView implements Microsoft.UI.Xaml.Controls.IScrollViewerView {
+      readonly HorizontalOffset: number;
+      readonly VerticalOffset: number;
+      readonly ZoomFactor: number;
+    }
+    class ScrollViewerViewChangedEventArgs implements Microsoft.UI.Xaml.Controls.IScrollViewerViewChangedEventArgs {
+      readonly IsIntermediate: boolean;
+      constructor();
+    }
+    class ScrollViewerViewChangingEventArgs implements Microsoft.UI.Xaml.Controls.IScrollViewerViewChangingEventArgs {
+      readonly FinalView: Microsoft.UI.Xaml.Controls.ScrollViewerView;
+      readonly IsInertial: boolean;
+      readonly NextView: Microsoft.UI.Xaml.Controls.ScrollViewerView;
+    }
+    class ScrollingAnchorRequestedEventArgs implements Microsoft.UI.Xaml.Controls.IScrollingAnchorRequestedEventArgs {
+      AnchorElement: Microsoft.UI.Xaml.UIElement;
+      readonly AnchorCandidates: System.Collections.Generic.IList<Microsoft.UI.Xaml.UIElement>;
+    }
+    class ScrollingAnimationMode extends System.Enum {
+      value__: number;
+      static Disabled: number;
+      static Enabled: number;
+      static Auto: number;
+    }
+    class ScrollingBringingIntoViewEventArgs implements Microsoft.UI.Xaml.Controls.IScrollingBringingIntoViewEventArgs {
+      SnapPointsMode: number;
+      Cancel: boolean;
+      readonly CorrelationId: number;
+      readonly RequestEventArgs: Microsoft.UI.Xaml.BringIntoViewRequestedEventArgs;
+      readonly TargetHorizontalOffset: number;
+      readonly TargetVerticalOffset: number;
+    }
+    class ScrollingChainMode extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Always: number;
+      static Never: number;
+    }
+    class ScrollingContentOrientation extends System.Enum {
+      value__: number;
+      static Vertical: number;
+      static Horizontal: number;
+      static None: number;
+      static Both: number;
+    }
+    class ScrollingInputKinds extends System.Enum {
+      value__: number;
+      static None: number;
+      static Touch: number;
+      static Pen: number;
+      static MouseWheel: number;
+      static Keyboard: number;
+      static Gamepad: number;
+      static All: number;
+    }
+    class ScrollingInteractionState extends System.Enum {
+      value__: number;
+      static Idle: number;
+      static Interaction: number;
+      static Inertia: number;
+      static Animation: number;
+    }
+    class ScrollingRailMode extends System.Enum {
+      value__: number;
+      static Enabled: number;
+      static Disabled: number;
+    }
+    class ScrollingScrollAnimationStartingEventArgs implements Microsoft.UI.Xaml.Controls.IScrollingScrollAnimationStartingEventArgs {
+      Animation: Microsoft.UI.Composition.CompositionAnimation;
+      readonly CorrelationId: number;
+      readonly EndPosition: System.Numerics.Vector2;
+      readonly StartPosition: System.Numerics.Vector2;
+    }
+    class ScrollingScrollBarVisibility extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Visible: number;
+      static Hidden: number;
+    }
+    class ScrollingScrollCompletedEventArgs implements Microsoft.UI.Xaml.Controls.IScrollingScrollCompletedEventArgs {
+      readonly CorrelationId: number;
+    }
+    class ScrollingScrollMode extends System.Enum {
+      value__: number;
+      static Enabled: number;
+      static Disabled: number;
+      static Auto: number;
+    }
+    class ScrollingScrollOptions implements Microsoft.UI.Xaml.Controls.IScrollingScrollOptions {
+      SnapPointsMode: number;
+      AnimationMode: number;
+      constructor(animationMode: number);
+      constructor(animationMode: number, snapPointsMode: number);
+    }
+    class ScrollingSnapPointsMode extends System.Enum {
+      value__: number;
+      static Default: number;
+      static Ignore: number;
+    }
+    class ScrollingZoomAnimationStartingEventArgs implements Microsoft.UI.Xaml.Controls.IScrollingZoomAnimationStartingEventArgs {
+      Animation: Microsoft.UI.Composition.CompositionAnimation;
+      readonly CenterPoint: System.Numerics.Vector2;
+      readonly CorrelationId: number;
+      readonly EndZoomFactor: number;
+      readonly StartZoomFactor: number;
+    }
+    class ScrollingZoomCompletedEventArgs implements Microsoft.UI.Xaml.Controls.IScrollingZoomCompletedEventArgs {
+      readonly CorrelationId: number;
+    }
+    class ScrollingZoomMode extends System.Enum {
+      value__: number;
+      static Enabled: number;
+      static Disabled: number;
+    }
+    class ScrollingZoomOptions implements Microsoft.UI.Xaml.Controls.IScrollingZoomOptions {
+      SnapPointsMode: number;
+      AnimationMode: number;
+      constructor(animationMode: number);
+      constructor(animationMode: number, snapPointsMode: number);
+    }
+    class SectionsInViewChangedEventArgs implements Microsoft.UI.Xaml.Controls.ISectionsInViewChangedEventArgs {
+      readonly AddedSections: System.Collections.Generic.IList<Microsoft.UI.Xaml.Controls.HubSection>;
+      readonly RemovedSections: System.Collections.Generic.IList<Microsoft.UI.Xaml.Controls.HubSection>;
+    }
+    class SectionsInViewChangedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Controls.SectionsInViewChangedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Controls.SectionsInViewChangedEventArgs): void;
+    }
+    class SelectionChangedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Controls.ISelectionChangedEventArgs {
+      readonly AddedItems: System.Collections.Generic.IList<any>;
+      readonly RemovedItems: System.Collections.Generic.IList<any>;
+      constructor(removedItems: System.Collections.Generic.IList<any>, addedItems: System.Collections.Generic.IList<any>);
+    }
+    class SelectionChangedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Controls.SelectionChangedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Controls.SelectionChangedEventArgs): void;
+    }
+    class SelectionMode extends System.Enum {
+      value__: number;
+      static Single: number;
+      static Multiple: number;
+      static Extended: number;
+    }
+    class SelectorBar extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.ISelectorBar {
+      SelectionChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.SelectorBar, Microsoft.UI.Xaml.Controls.SelectorBarSelectionChangedEventArgs> | null;
+      SelectedItem: Microsoft.UI.Xaml.Controls.SelectorBarItem;
+      readonly Items: System.Collections.Generic.IList<Microsoft.UI.Xaml.Controls.SelectorBarItem>;
+      static readonly ItemsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedItemProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class SelectorBarItem extends Microsoft.UI.Xaml.Controls.ItemContainer implements Microsoft.UI.Xaml.Controls.ISelectorBarItem {
+      Text: string;
+      Icon: Microsoft.UI.Xaml.Controls.IconElement;
+      static readonly IconProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class SelectorBarSelectionChangedEventArgs implements Microsoft.UI.Xaml.Controls.ISelectorBarSelectionChangedEventArgs {
+    }
+    class SemanticZoom extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.ISemanticZoom {
+      ViewChangeCompleted: Microsoft.UI.Xaml.Controls.SemanticZoomViewChangedEventHandler | null;
+      ViewChangeStarted: Microsoft.UI.Xaml.Controls.SemanticZoomViewChangedEventHandler | null;
+      ZoomedOutView: Microsoft.UI.Xaml.Controls.ISemanticZoomInformation;
+      ZoomedInView: Microsoft.UI.Xaml.Controls.ISemanticZoomInformation;
+      IsZoomedInViewActive: boolean;
+      IsZoomOutButtonEnabled: boolean;
+      CanChangeViews: boolean;
+      static readonly CanChangeViewsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsZoomOutButtonEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsZoomedInViewActiveProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ZoomedInViewProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ZoomedOutViewProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      ToggleActiveView(): void;
+    }
+    class SemanticZoomLocation implements Microsoft.UI.Xaml.Controls.ISemanticZoomLocation {
+      Item: any;
+      Bounds: Windows.Foundation.Rect;
+      constructor();
+    }
+    class SemanticZoomViewChangedEventArgs implements Microsoft.UI.Xaml.Controls.ISemanticZoomViewChangedEventArgs {
+      SourceItem: Microsoft.UI.Xaml.Controls.SemanticZoomLocation;
+      IsSourceZoomedInView: boolean;
+      DestinationItem: Microsoft.UI.Xaml.Controls.SemanticZoomLocation;
+      constructor();
+    }
+    class SemanticZoomViewChangedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs): void;
+    }
+    class SnapPointsType extends System.Enum {
+      value__: number;
+      static None: number;
+      static Optional: number;
+      static Mandatory: number;
+      static OptionalSingle: number;
+      static MandatorySingle: number;
+    }
+    class SplitButton extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.ISplitButton {
+      Click: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.SplitButton, Microsoft.UI.Xaml.Controls.SplitButtonClickEventArgs> | null;
+      Flyout: Microsoft.UI.Xaml.Controls.Primitives.FlyoutBase;
+      CommandParameter: any;
+      Command: Microsoft.UI.Xaml.Input.ICommand;
+      static readonly CommandParameterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CommandProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FlyoutProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class SplitButtonClickEventArgs implements Microsoft.UI.Xaml.Controls.ISplitButtonClickEventArgs {
+    }
+    class SplitView extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.ISplitView {
+      PaneClosed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.SplitView, any> | null;
+      PaneClosing: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.SplitView, Microsoft.UI.Xaml.Controls.SplitViewPaneClosingEventArgs> | null;
+      PaneOpened: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.SplitView, any> | null;
+      PaneOpening: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.SplitView, any> | null;
+      PanePlacement: number;
+      PaneBackground: Microsoft.UI.Xaml.Media.Brush;
+      Pane: Microsoft.UI.Xaml.UIElement;
+      OpenPaneLength: number;
+      LightDismissOverlayMode: number;
+      IsPaneOpen: boolean;
+      DisplayMode: number;
+      Content: Microsoft.UI.Xaml.UIElement;
+      CompactPaneLength: number;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.Primitives.SplitViewTemplateSettings;
+      static readonly CompactPaneLengthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DisplayModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsPaneOpenProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LightDismissOverlayModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OpenPaneLengthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaneBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PanePlacementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaneProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TemplateSettingsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class SplitViewDisplayMode extends System.Enum {
+      value__: number;
+      static Overlay: number;
+      static Inline: number;
+      static CompactOverlay: number;
+      static CompactInline: number;
+    }
+    class SplitViewPaneClosingEventArgs implements Microsoft.UI.Xaml.Controls.ISplitViewPaneClosingEventArgs {
+      Cancel: boolean;
+    }
+    class SplitViewPanePlacement extends System.Enum {
+      value__: number;
+      static Left: number;
+      static Right: number;
+    }
+    class StackLayout extends Microsoft.UI.Xaml.Controls.VirtualizingLayout implements Microsoft.UI.Xaml.Controls.IStackLayout {
+      Spacing: number;
+      Orientation: number;
+      static readonly OrientationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SpacingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class StackPanel extends Microsoft.UI.Xaml.Controls.Panel implements Microsoft.UI.Xaml.Controls.IStackPanel, Microsoft.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo, Microsoft.UI.Xaml.Controls.IInsertionPanel {
+      HorizontalSnapPointsChanged: System.EventHandler<any> | null;
+      VerticalSnapPointsChanged: System.EventHandler<any> | null;
+      Spacing: number;
+      Padding: Microsoft.UI.Xaml.Thickness;
+      Orientation: number;
+      CornerRadius: Microsoft.UI.Xaml.CornerRadius;
+      BorderThickness: Microsoft.UI.Xaml.Thickness;
+      BorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      BackgroundSizing: number;
+      AreScrollSnapPointsRegular: boolean;
+      readonly AreHorizontalSnapPointsRegular: boolean;
+      readonly AreVerticalSnapPointsRegular: boolean;
+      static readonly AreScrollSnapPointsRegularProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BackgroundSizingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BorderThicknessProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CornerRadiusProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OrientationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaddingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SpacingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      GetIrregularSnapPoints(result: number, orientation: number): System.Collections.Generic.IReadOnlyList<number>;
+      GetRegularSnapPoints(returnValue: number, orientation: number, alignment: number): number;
+      GetInsertionIndexes(position: Windows.Foundation.Point, first: number, second: number): void;
+    }
+    class StretchDirection extends System.Enum {
+      value__: number;
+      static UpOnly: number;
+      static DownOnly: number;
+      static Both: number;
+    }
+    class StyleSelector implements Microsoft.UI.Xaml.Controls.IStyleSelector, Microsoft.UI.Xaml.Controls.IStyleSelectorOverrides {
+      constructor();
+      SelectStyle(result: any, item: Microsoft.UI.Xaml.DependencyObject): Microsoft.UI.Xaml.Style;
+    }
+    class SwapChainBackgroundPanel extends Microsoft.UI.Xaml.Controls.Grid implements Microsoft.UI.Xaml.Controls.ISwapChainBackgroundPanel {
+      constructor();
+    }
+    class SwapChainPanel extends Microsoft.UI.Xaml.Controls.Grid implements Microsoft.UI.Xaml.Controls.ISwapChainPanel {
+      CompositionScaleChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.SwapChainPanel, any> | null;
+      readonly CompositionScaleX: number;
+      readonly CompositionScaleY: number;
+      static readonly CompositionScaleXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CompositionScaleYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      CreateCoreIndependentInputSource(result: number): Microsoft.UI.Input.InputPointerSource;
+    }
+    class SwipeBehaviorOnInvoked extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Close: number;
+      static RemainOpen: number;
+    }
+    class SwipeControl extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.ISwipeControl {
+      TopItems: Microsoft.UI.Xaml.Controls.SwipeItems;
+      RightItems: Microsoft.UI.Xaml.Controls.SwipeItems;
+      LeftItems: Microsoft.UI.Xaml.Controls.SwipeItems;
+      BottomItems: Microsoft.UI.Xaml.Controls.SwipeItems;
+      static readonly BottomItemsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LeftItemsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RightItemsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TopItemsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      Close(): void;
+    }
+    class SwipeItem extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.ISwipeItem {
+      Invoked: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.SwipeItem, Microsoft.UI.Xaml.Controls.SwipeItemInvokedEventArgs> | null;
+      Text: string;
+      IconSource: Microsoft.UI.Xaml.Controls.IconSource;
+      Foreground: Microsoft.UI.Xaml.Media.Brush;
+      CommandParameter: any;
+      Command: Microsoft.UI.Xaml.Input.ICommand;
+      BehaviorOnInvoked: number;
+      Background: Microsoft.UI.Xaml.Media.Brush;
+      static readonly BackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BehaviorOnInvokedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CommandParameterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CommandProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IconSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class SwipeItemInvokedEventArgs implements Microsoft.UI.Xaml.Controls.ISwipeItemInvokedEventArgs {
+      readonly SwipeControl: Microsoft.UI.Xaml.Controls.SwipeControl;
+    }
+    class SwipeItems extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.ISwipeItems {
+      Mode: number;
+      static readonly ModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class SwipeMode extends System.Enum {
+      value__: number;
+      static Reveal: number;
+      static Execute: number;
+    }
+    class Symbol extends System.Enum {
+      value__: number;
+      static Previous: number;
+      static Next: number;
+      static Play: number;
+      static Pause: number;
+      static Edit: number;
+      static Save: number;
+      static Clear: number;
+      static Delete: number;
+      static Remove: number;
+      static Add: number;
+      static Cancel: number;
+      static Accept: number;
+      static More: number;
+      static Redo: number;
+      static Undo: number;
+      static Home: number;
+      static Up: number;
+      static Forward: number;
+      static Back: number;
+      static Favorite: number;
+      static Camera: number;
+      static Setting: number;
+      static Video: number;
+      static Sync: number;
+      static Download: number;
+      static Mail: number;
+      static Find: number;
+      static Help: number;
+      static Upload: number;
+      static Emoji: number;
+      static TwoPage: number;
+      static LeaveChat: number;
+      static MailForward: number;
+      static Clock: number;
+      static Send: number;
+      static Crop: number;
+      static RotateCamera: number;
+      static People: number;
+      static OpenPane: number;
+      static ClosePane: number;
+      static World: number;
+      static Flag: number;
+      static PreviewLink: number;
+      static Globe: number;
+      static Trim: number;
+      static AttachCamera: number;
+      static ZoomIn: number;
+      static Bookmarks: number;
+      static Document: number;
+      static ProtectedDocument: number;
+      static Page: number;
+      static Bullets: number;
+      static Comment: number;
+      static MailFilled: number;
+      static ContactInfo: number;
+      static HangUp: number;
+      static ViewAll: number;
+      static MapPin: number;
+      static Phone: number;
+      static VideoChat: number;
+      static Switch: number;
+      static Contact: number;
+      static Rename: number;
+      static Pin: number;
+      static MusicInfo: number;
+      static Go: number;
+      static Keyboard: number;
+      static DockLeft: number;
+      static DockRight: number;
+      static DockBottom: number;
+      static Remote: number;
+      static Refresh: number;
+      static Rotate: number;
+      static Shuffle: number;
+      static List: number;
+      static Shop: number;
+      static SelectAll: number;
+      static Orientation: number;
+      static Import: number;
+      static ImportAll: number;
+      static BrowsePhotos: number;
+      static WebCam: number;
+      static Pictures: number;
+      static SaveLocal: number;
+      static Caption: number;
+      static Stop: number;
+      static ShowResults: number;
+      static Volume: number;
+      static Repair: number;
+      static Message: number;
+      static Page2: number;
+      static CalendarDay: number;
+      static CalendarWeek: number;
+      static Calendar: number;
+      static Character: number;
+      static MailReplyAll: number;
+      static Read: number;
+      static Link: number;
+      static Account: number;
+      static ShowBcc: number;
+      static HideBcc: number;
+      static Cut: number;
+      static Attach: number;
+      static Paste: number;
+      static Filter: number;
+      static Copy: number;
+      static Emoji2: number;
+      static Important: number;
+      static MailReply: number;
+      static SlideShow: number;
+      static Sort: number;
+      static Manage: number;
+      static AllApps: number;
+      static DisconnectDrive: number;
+      static MapDrive: number;
+      static NewWindow: number;
+      static OpenWith: number;
+      static ContactPresence: number;
+      static Priority: number;
+      static GoToToday: number;
+      static Font: number;
+      static FontColor: number;
+      static Contact2: number;
+      static Folder: number;
+      static Audio: number;
+      static Placeholder: number;
+      static View: number;
+      static SetLockScreen: number;
+      static SetTile: number;
+      static ClosedCaption: number;
+      static StopSlideShow: number;
+      static Permissions: number;
+      static Highlight: number;
+      static DisableUpdates: number;
+      static UnFavorite: number;
+      static UnPin: number;
+      static OpenLocal: number;
+      static Mute: number;
+      static Italic: number;
+      static Underline: number;
+      static Bold: number;
+      static MoveToFolder: number;
+      static LikeDislike: number;
+      static Dislike: number;
+      static Like: number;
+      static AlignRight: number;
+      static AlignCenter: number;
+      static AlignLeft: number;
+      static Zoom: number;
+      static ZoomOut: number;
+      static OpenFile: number;
+      static OtherUser: number;
+      static Admin: number;
+      static Street: number;
+      static Map: number;
+      static ClearSelection: number;
+      static FontDecrease: number;
+      static FontIncrease: number;
+      static FontSize: number;
+      static CellPhone: number;
+      static ReShare: number;
+      static Tag: number;
+      static RepeatOne: number;
+      static RepeatAll: number;
+      static OutlineStar: number;
+      static SolidStar: number;
+      static Calculator: number;
+      static Directions: number;
+      static Target: number;
+      static Library: number;
+      static PhoneBook: number;
+      static Memo: number;
+      static Microphone: number;
+      static PostUpdate: number;
+      static BackToWindow: number;
+      static FullScreen: number;
+      static NewFolder: number;
+      static CalendarReply: number;
+      static UnSyncFolder: number;
+      static ReportHacked: number;
+      static SyncFolder: number;
+      static BlockContact: number;
+      static SwitchApps: number;
+      static AddFriend: number;
+      static TouchPointer: number;
+      static GoToStart: number;
+      static ZeroBars: number;
+      static OneBar: number;
+      static TwoBars: number;
+      static ThreeBars: number;
+      static FourBars: number;
+      static Scan: number;
+      static Preview: number;
+      static GlobalNavigationButton: number;
+      static Share: number;
+      static Print: number;
+      static XboxOneConsole: number;
+    }
+    class SymbolIcon extends Microsoft.UI.Xaml.Controls.IconElement implements Microsoft.UI.Xaml.Controls.ISymbolIcon {
+      Symbol: number;
+      static readonly SymbolProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor(symbol: number);
+      constructor();
+    }
+    class SymbolIconSource extends Microsoft.UI.Xaml.Controls.IconSource implements Microsoft.UI.Xaml.Controls.ISymbolIconSource {
+      Symbol: number;
+      static readonly SymbolProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class TabView extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.ITabView, Microsoft.UI.Xaml.Controls.ITabView2 {
+      AddTabButtonClick: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TabView, any> | null;
+      SelectionChanged: Microsoft.UI.Xaml.Controls.SelectionChangedEventHandler | null;
+      TabCloseRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TabView, Microsoft.UI.Xaml.Controls.TabViewTabCloseRequestedEventArgs> | null;
+      TabDragCompleted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TabView, Microsoft.UI.Xaml.Controls.TabViewTabDragCompletedEventArgs> | null;
+      TabDragStarting: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TabView, Microsoft.UI.Xaml.Controls.TabViewTabDragStartingEventArgs> | null;
+      TabDroppedOutside: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TabView, Microsoft.UI.Xaml.Controls.TabViewTabDroppedOutsideEventArgs> | null;
+      TabItemsChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TabView, Windows.Foundation.Collections.IVectorChangedEventArgs> | null;
+      TabStripDragOver: Microsoft.UI.Xaml.DragEventHandler | null;
+      TabStripDrop: Microsoft.UI.Xaml.DragEventHandler | null;
+      ExternalTornOutTabsDropped: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TabView, Microsoft.UI.Xaml.Controls.TabViewExternalTornOutTabsDroppedEventArgs> | null;
+      ExternalTornOutTabsDropping: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TabView, Microsoft.UI.Xaml.Controls.TabViewExternalTornOutTabsDroppingEventArgs> | null;
+      TabTearOutRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TabView, Microsoft.UI.Xaml.Controls.TabViewTabTearOutRequestedEventArgs> | null;
+      TabTearOutWindowRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TabView, Microsoft.UI.Xaml.Controls.TabViewTabTearOutWindowRequestedEventArgs> | null;
+      TabWidthMode: number;
+      TabStripHeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      TabStripHeader: any;
+      TabStripFooterTemplate: Microsoft.UI.Xaml.DataTemplate;
+      TabStripFooter: any;
+      TabItemsSource: any;
+      TabItemTemplateSelector: Microsoft.UI.Xaml.Controls.DataTemplateSelector;
+      TabItemTemplate: Microsoft.UI.Xaml.DataTemplate;
+      SelectedItem: any;
+      SelectedIndex: number;
+      IsAddTabButtonVisible: boolean;
+      CloseButtonOverlayMode: number;
+      CanReorderTabs: boolean;
+      CanDragTabs: boolean;
+      AllowDropTabs: boolean;
+      AddTabButtonCommandParameter: any;
+      AddTabButtonCommand: Microsoft.UI.Xaml.Input.ICommand;
+      readonly TabItems: System.Collections.Generic.IList<any>;
+      CanTearOutTabs: boolean;
+      static readonly AddTabButtonCommandParameterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AddTabButtonCommandProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AllowDropTabsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CanDragTabsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CanReorderTabsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CloseButtonOverlayModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsAddTabButtonVisibleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedIndexProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedItemProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TabItemTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TabItemTemplateSelectorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TabItemsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TabItemsSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TabStripFooterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TabStripFooterTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TabStripHeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TabStripHeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TabWidthModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CanTearOutTabsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      ContainerFromItem(result: any): Microsoft.UI.Xaml.DependencyObject;
+      ContainerFromIndex(result: number): Microsoft.UI.Xaml.DependencyObject;
+    }
+    class TabViewCloseButtonOverlayMode extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static OnPointerOver: number;
+      static Always: number;
+    }
+    class TabViewExternalTornOutTabsDroppedEventArgs implements Microsoft.UI.Xaml.Controls.ITabViewExternalTornOutTabsDroppedEventArgs {
+      readonly DropIndex: number;
+      readonly Items: any[];
+      readonly Tabs: Microsoft.UI.Xaml.UIElement[];
+    }
+    class TabViewExternalTornOutTabsDroppingEventArgs implements Microsoft.UI.Xaml.Controls.ITabViewExternalTornOutTabsDroppingEventArgs {
+      AllowDrop: boolean;
+      readonly DropIndex: number;
+      readonly Items: any[];
+      readonly Tabs: Microsoft.UI.Xaml.UIElement[];
+    }
+    class TabViewItem extends Microsoft.UI.Xaml.Controls.ListViewItem implements Microsoft.UI.Xaml.Controls.ITabViewItem {
+      CloseRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TabViewItem, Microsoft.UI.Xaml.Controls.TabViewTabCloseRequestedEventArgs> | null;
+      IsClosable: boolean;
+      IconSource: Microsoft.UI.Xaml.Controls.IconSource;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Header: any;
+      readonly TabViewTemplateSettings: Microsoft.UI.Xaml.Controls.TabViewItemTemplateSettings;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IconSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsClosableProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TabViewTemplateSettingsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class TabViewItemTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.ITabViewItemTemplateSettings, Microsoft.UI.Xaml.Controls.ITabViewItemTemplateSettings2 {
+      IconElement: Microsoft.UI.Xaml.Controls.IconElement;
+      TabGeometry: Microsoft.UI.Xaml.Media.Geometry;
+      static readonly IconElementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TabGeometryProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class TabViewTabCloseRequestedEventArgs implements Microsoft.UI.Xaml.Controls.ITabViewTabCloseRequestedEventArgs {
+      readonly Item: any;
+      readonly Tab: Microsoft.UI.Xaml.Controls.TabViewItem;
+    }
+    class TabViewTabDragCompletedEventArgs implements Microsoft.UI.Xaml.Controls.ITabViewTabDragCompletedEventArgs {
+      readonly DropResult: Windows.ApplicationModel.DataTransfer.DataPackageOperation;
+      readonly Item: any;
+      readonly Tab: Microsoft.UI.Xaml.Controls.TabViewItem;
+    }
+    class TabViewTabDragStartingEventArgs implements Microsoft.UI.Xaml.Controls.ITabViewTabDragStartingEventArgs {
+      Cancel: boolean;
+      readonly Data: Windows.ApplicationModel.DataTransfer.DataPackage;
+      readonly Item: any;
+      readonly Tab: Microsoft.UI.Xaml.Controls.TabViewItem;
+    }
+    class TabViewTabDroppedOutsideEventArgs implements Microsoft.UI.Xaml.Controls.ITabViewTabDroppedOutsideEventArgs {
+      readonly Item: any;
+      readonly Tab: Microsoft.UI.Xaml.Controls.TabViewItem;
+    }
+    class TabViewTabTearOutRequestedEventArgs implements Microsoft.UI.Xaml.Controls.ITabViewTabTearOutRequestedEventArgs {
+      readonly Items: any[];
+      readonly NewWindowId: Microsoft.UI.WindowId;
+      readonly Tabs: Microsoft.UI.Xaml.UIElement[];
+    }
+    class TabViewTabTearOutWindowRequestedEventArgs implements Microsoft.UI.Xaml.Controls.ITabViewTabTearOutWindowRequestedEventArgs {
+      NewWindowId: Microsoft.UI.WindowId;
+      readonly Items: any[];
+      readonly Tabs: Microsoft.UI.Xaml.UIElement[];
+    }
+    class TabViewWidthMode extends System.Enum {
+      value__: number;
+      static Equal: number;
+      static SizeToContent: number;
+      static Compact: number;
+    }
+    class TeachingTip extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.ITeachingTip {
+      ActionButtonClick: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TeachingTip, any> | null;
+      CloseButtonClick: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TeachingTip, any> | null;
+      Closed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TeachingTip, Microsoft.UI.Xaml.Controls.TeachingTipClosedEventArgs> | null;
+      Closing: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TeachingTip, Microsoft.UI.Xaml.Controls.TeachingTipClosingEventArgs> | null;
+      Title: string;
+      Target: Microsoft.UI.Xaml.FrameworkElement;
+      TailVisibility: number;
+      Subtitle: string;
+      ShouldConstrainToRootBounds: boolean;
+      PreferredPlacement: number;
+      PlacementMargin: Microsoft.UI.Xaml.Thickness;
+      IsOpen: boolean;
+      IsLightDismissEnabled: boolean;
+      IconSource: Microsoft.UI.Xaml.Controls.IconSource;
+      HeroContentPlacement: number;
+      HeroContent: Microsoft.UI.Xaml.UIElement;
+      CloseButtonStyle: Microsoft.UI.Xaml.Style;
+      CloseButtonContent: any;
+      CloseButtonCommandParameter: any;
+      CloseButtonCommand: Microsoft.UI.Xaml.Input.ICommand;
+      ActionButtonStyle: Microsoft.UI.Xaml.Style;
+      ActionButtonContent: any;
+      ActionButtonCommandParameter: any;
+      ActionButtonCommand: Microsoft.UI.Xaml.Input.ICommand;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.TeachingTipTemplateSettings;
+      static readonly ActionButtonCommandParameterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ActionButtonCommandProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ActionButtonContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ActionButtonStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CloseButtonCommandParameterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CloseButtonCommandProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CloseButtonContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CloseButtonStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeroContentPlacementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeroContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IconSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsLightDismissEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsOpenProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlacementMarginProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PreferredPlacementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ShouldConstrainToRootBoundsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SubtitleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TailVisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TemplateSettingsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TitleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class TeachingTipCloseReason extends System.Enum {
+      value__: number;
+      static CloseButton: number;
+      static LightDismiss: number;
+      static Programmatic: number;
+    }
+    class TeachingTipClosedEventArgs implements Microsoft.UI.Xaml.Controls.ITeachingTipClosedEventArgs {
+      readonly Reason: number;
+    }
+    class TeachingTipClosingEventArgs implements Microsoft.UI.Xaml.Controls.ITeachingTipClosingEventArgs {
+      Cancel: boolean;
+      readonly Reason: number;
+      GetDeferral(): Windows.Foundation.Deferral;
+    }
+    class TeachingTipHeroContentPlacementMode extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Top: number;
+      static Bottom: number;
+    }
+    class TeachingTipPlacementMode extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Top: number;
+      static Bottom: number;
+      static Left: number;
+      static Right: number;
+      static TopRight: number;
+      static TopLeft: number;
+      static BottomRight: number;
+      static BottomLeft: number;
+      static LeftTop: number;
+      static LeftBottom: number;
+      static RightTop: number;
+      static RightBottom: number;
+      static Center: number;
+    }
+    class TeachingTipTailVisibility extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Visible: number;
+      static Collapsed: number;
+    }
+    class TeachingTipTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.ITeachingTipTemplateSettings {
+      TopRightHighlightMargin: Microsoft.UI.Xaml.Thickness;
+      TopLeftHighlightMargin: Microsoft.UI.Xaml.Thickness;
+      IconElement: Microsoft.UI.Xaml.Controls.IconElement;
+      static readonly IconElementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TopLeftHighlightMarginProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TopRightHighlightMarginProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class TextBlock extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.ITextBlock {
+      ContextMenuOpening: Microsoft.UI.Xaml.Controls.ContextMenuOpeningEventHandler | null;
+      IsTextTrimmedChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TextBlock, Microsoft.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs> | null;
+      SelectionChanged: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      IsColorFontEnabled: boolean;
+      LineHeight: number;
+      HorizontalTextAlignment: number;
+      Foreground: Microsoft.UI.Xaml.Media.Brush;
+      FontWeight: Windows.UI.Text.FontWeight;
+      FontStyle: Windows.UI.Text.FontStyle;
+      FontStretch: Windows.UI.Text.FontStretch;
+      FontSize: number;
+      FontFamily: Microsoft.UI.Xaml.Media.FontFamily;
+      IsTextSelectionEnabled: boolean;
+      IsTextScaleFactorEnabled: boolean;
+      CharacterSpacing: number;
+      TextWrapping: number;
+      LineStackingStrategy: number;
+      TextTrimming: number;
+      TextReadingOrder: number;
+      TextLineBounds: number;
+      TextDecorations: Windows.UI.Text.TextDecorations;
+      TextAlignment: number;
+      Text: string;
+      SelectionHighlightColor: Microsoft.UI.Xaml.Media.SolidColorBrush;
+      SelectionFlyout: Microsoft.UI.Xaml.Controls.Primitives.FlyoutBase;
+      Padding: Microsoft.UI.Xaml.Thickness;
+      OpticalMarginAlignment: number;
+      MaxLines: number;
+      readonly ContentEnd: Microsoft.UI.Xaml.Documents.TextPointer;
+      readonly ContentStart: Microsoft.UI.Xaml.Documents.TextPointer;
+      readonly Inlines: Microsoft.UI.Xaml.Documents.InlineCollection;
+      readonly IsTextTrimmed: boolean;
+      readonly SelectedText: string;
+      readonly SelectionEnd: Microsoft.UI.Xaml.Documents.TextPointer;
+      readonly SelectionStart: Microsoft.UI.Xaml.Documents.TextPointer;
+      readonly TextHighlighters: System.Collections.Generic.IList<Microsoft.UI.Xaml.Documents.TextHighlighter>;
+      readonly BaselineOffset: number;
+      static readonly CharacterSpacingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontFamilyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontSizeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontStretchProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontWeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalTextAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsColorFontEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTextScaleFactorEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTextSelectionEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTextTrimmedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LineHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LineStackingStrategyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxLinesProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OpticalMarginAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PaddingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedTextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionFlyoutProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionHighlightColorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextDecorationsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextLineBoundsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextReadingOrderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextTrimmingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextWrappingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      SelectAll(): void;
+      Select(start: Microsoft.UI.Xaml.Documents.TextPointer, end: Microsoft.UI.Xaml.Documents.TextPointer): void;
+      GetAlphaMask(): Microsoft.UI.Composition.CompositionBrush;
+      CopySelectionToClipboard(): void;
+    }
+    class TextBox extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.ITextBox {
+      BeforeTextChanging: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TextBox, Microsoft.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs> | null;
+      CandidateWindowBoundsChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TextBox, Microsoft.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs> | null;
+      ContextMenuOpening: Microsoft.UI.Xaml.Controls.ContextMenuOpeningEventHandler | null;
+      CopyingToClipboard: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TextBox, Microsoft.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs> | null;
+      CuttingToClipboard: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TextBox, Microsoft.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs> | null;
+      Paste: Microsoft.UI.Xaml.Controls.TextControlPasteEventHandler | null;
+      SelectionChanged: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      SelectionChanging: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TextBox, Microsoft.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs> | null;
+      TextChanged: Microsoft.UI.Xaml.Controls.TextChangedEventHandler | null;
+      TextChanging: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TextBox, Microsoft.UI.Xaml.Controls.TextBoxTextChangingEventArgs> | null;
+      TextCompositionChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TextBox, Microsoft.UI.Xaml.Controls.TextCompositionChangedEventArgs> | null;
+      TextCompositionEnded: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TextBox, Microsoft.UI.Xaml.Controls.TextCompositionEndedEventArgs> | null;
+      TextCompositionStarted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TextBox, Microsoft.UI.Xaml.Controls.TextCompositionStartedEventArgs> | null;
+      TextWrapping: number;
+      TextReadingOrder: number;
+      TextAlignment: number;
+      Text: string;
+      SelectionStart: number;
+      SelectionLength: number;
+      SelectionHighlightColorWhenNotFocused: Microsoft.UI.Xaml.Media.SolidColorBrush;
+      SelectionHighlightColor: Microsoft.UI.Xaml.Media.SolidColorBrush;
+      SelectionFlyout: Microsoft.UI.Xaml.Controls.Primitives.FlyoutBase;
+      SelectedText: string;
+      PreventKeyboardDisplayOnProgrammaticFocus: boolean;
+      PlaceholderText: string;
+      PlaceholderForeground: Microsoft.UI.Xaml.Media.Brush;
+      MaxLength: number;
+      IsTextPredictionEnabled: boolean;
+      IsSpellCheckEnabled: boolean;
+      IsReadOnly: boolean;
+      IsColorFontEnabled: boolean;
+      InputScope: Microsoft.UI.Xaml.Input.InputScope;
+      HorizontalTextAlignment: number;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Header: any;
+      DesiredCandidateWindowAlignment: number;
+      Description: any;
+      CharacterCasing: number;
+      AcceptsReturn: boolean;
+      readonly CanPasteClipboardContent: boolean;
+      readonly CanRedo: boolean;
+      readonly CanUndo: boolean;
+      readonly ProofingMenuFlyout: Microsoft.UI.Xaml.Controls.Primitives.FlyoutBase;
+      static readonly AcceptsReturnProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CanPasteClipboardContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CanRedoProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CanUndoProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CharacterCasingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DescriptionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DesiredCandidateWindowAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalTextAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly InputScopeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsColorFontEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsReadOnlyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsSpellCheckEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTextPredictionEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxLengthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlaceholderForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlaceholderTextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PreventKeyboardDisplayOnProgrammaticFocusProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ProofingMenuFlyoutProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionFlyoutProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionHighlightColorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionHighlightColorWhenNotFocusedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextReadingOrderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextWrappingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      Select(start: number, length: number): void;
+      SelectAll(): void;
+      GetRectFromCharacterIndex(result: number, charIndex: boolean): Windows.Foundation.Rect;
+      GetLinguisticAlternativesAsync(): Windows.Foundation.IAsyncOperation<System.Collections.Generic.IReadOnlyList<string>>;
+      Undo(): void;
+      Redo(): void;
+      PasteFromClipboard(): void;
+      CopySelectionToClipboard(): void;
+      CutSelectionToClipboard(): void;
+      ClearUndoRedoHistory(): void;
+    }
+    class TextBoxBeforeTextChangingEventArgs implements Microsoft.UI.Xaml.Controls.ITextBoxBeforeTextChangingEventArgs {
+      Cancel: boolean;
+      readonly NewText: string;
+    }
+    class TextBoxSelectionChangingEventArgs implements Microsoft.UI.Xaml.Controls.ITextBoxSelectionChangingEventArgs {
+      Cancel: boolean;
+      readonly SelectionLength: number;
+      readonly SelectionStart: number;
+    }
+    class TextBoxTextChangingEventArgs implements Microsoft.UI.Xaml.Controls.ITextBoxTextChangingEventArgs {
+      readonly IsContentChanging: boolean;
+    }
+    class TextChangedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Controls.ITextChangedEventArgs {
+    }
+    class TextChangedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Controls.TextChangedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Controls.TextChangedEventArgs): void;
+    }
+    class TextCommandBarFlyout extends Microsoft.UI.Xaml.Controls.CommandBarFlyout implements Microsoft.UI.Xaml.Controls.ITextCommandBarFlyout {
+      constructor();
+    }
+    class TextCompositionChangedEventArgs implements Microsoft.UI.Xaml.Controls.ITextCompositionChangedEventArgs {
+      readonly Length: number;
+      readonly StartIndex: number;
+    }
+    class TextCompositionEndedEventArgs implements Microsoft.UI.Xaml.Controls.ITextCompositionEndedEventArgs {
+      readonly Length: number;
+      readonly StartIndex: number;
+    }
+    class TextCompositionStartedEventArgs implements Microsoft.UI.Xaml.Controls.ITextCompositionStartedEventArgs {
+      readonly Length: number;
+      readonly StartIndex: number;
+    }
+    class TextControlCopyingToClipboardEventArgs implements Microsoft.UI.Xaml.Controls.ITextControlCopyingToClipboardEventArgs {
+      Handled: boolean;
+    }
+    class TextControlCuttingToClipboardEventArgs implements Microsoft.UI.Xaml.Controls.ITextControlCuttingToClipboardEventArgs {
+      Handled: boolean;
+    }
+    class TextControlPasteEventArgs implements Microsoft.UI.Xaml.Controls.ITextControlPasteEventArgs {
+      Handled: boolean;
+    }
+    class TextControlPasteEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Controls.TextControlPasteEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Controls.TextControlPasteEventArgs): void;
+    }
+    class TimePickedEventArgs extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.ITimePickedEventArgs {
+      readonly NewTime: System.TimeSpan;
+      readonly OldTime: System.TimeSpan;
+      constructor();
+    }
+    class TimePicker extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.ITimePicker {
+      SelectedTimeChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TimePicker, Microsoft.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs> | null;
+      TimeChanged: System.EventHandler<Microsoft.UI.Xaml.Controls.TimePickerValueChangedEventArgs> | null;
+      Time: System.TimeSpan;
+      SelectedTime: System.Nullable<System.TimeSpan>;
+      MinuteIncrement: number;
+      LightDismissOverlayMode: number;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Header: any;
+      ClockIdentifier: string;
+      static readonly ClockIdentifierProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LightDismissOverlayModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinuteIncrementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedTimeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TimeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class TimePickerFlyout extends Microsoft.UI.Xaml.Controls.Primitives.PickerFlyoutBase implements Microsoft.UI.Xaml.Controls.ITimePickerFlyout {
+      TimePicked: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TimePickerFlyout, Microsoft.UI.Xaml.Controls.TimePickedEventArgs> | null;
+      Time: System.TimeSpan;
+      MinuteIncrement: number;
+      ClockIdentifier: string;
+      static readonly ClockIdentifierProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinuteIncrementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TimeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      ShowAtAsync(operation: Microsoft.UI.Xaml.FrameworkElement): Windows.Foundation.IAsyncOperation<System.Nullable<System.TimeSpan>>;
+    }
+    class TimePickerFlyoutPresenter extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.ITimePickerFlyoutPresenter {
+      IsDefaultShadowEnabled: boolean;
+      static readonly IsDefaultShadowEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class TimePickerSelectedValueChangedEventArgs implements Microsoft.UI.Xaml.Controls.ITimePickerSelectedValueChangedEventArgs {
+      readonly NewTime: System.Nullable<System.TimeSpan>;
+      readonly OldTime: System.Nullable<System.TimeSpan>;
+    }
+    class TimePickerValueChangedEventArgs implements Microsoft.UI.Xaml.Controls.ITimePickerValueChangedEventArgs {
+      readonly NewTime: System.TimeSpan;
+      readonly OldTime: System.TimeSpan;
+    }
+    class ToggleMenuFlyoutItem extends Microsoft.UI.Xaml.Controls.MenuFlyoutItem implements Microsoft.UI.Xaml.Controls.IToggleMenuFlyoutItem {
+      IsChecked: boolean;
+      static readonly IsCheckedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ToggleSplitButton extends Microsoft.UI.Xaml.Controls.SplitButton implements Microsoft.UI.Xaml.Controls.IToggleSplitButton {
+      IsCheckedChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.ToggleSplitButton, Microsoft.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs> | null;
+      IsChecked: boolean;
+      static readonly IsCheckedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ToggleSplitButtonIsCheckedChangedEventArgs implements Microsoft.UI.Xaml.Controls.IToggleSplitButtonIsCheckedChangedEventArgs {
+    }
+    class ToggleSwitch extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.IToggleSwitch, Microsoft.UI.Xaml.Controls.IToggleSwitchOverrides {
+      Toggled: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      OnContentTemplate: Microsoft.UI.Xaml.DataTemplate;
+      OnContent: any;
+      OffContentTemplate: Microsoft.UI.Xaml.DataTemplate;
+      OffContent: any;
+      IsOn: boolean;
+      HeaderTemplate: Microsoft.UI.Xaml.DataTemplate;
+      Header: any;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.Primitives.ToggleSwitchTemplateSettings;
+      static readonly HeaderProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HeaderTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsOnProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OffContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OffContentTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OnContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OnContentTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ToolTip extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.IToolTip {
+      Closed: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      Opened: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      VerticalOffset: number;
+      PlacementTarget: Microsoft.UI.Xaml.UIElement;
+      PlacementRect: System.Nullable<Windows.Foundation.Rect>;
+      Placement: number;
+      IsOpen: boolean;
+      HorizontalOffset: number;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.Primitives.ToolTipTemplateSettings;
+      static readonly HorizontalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsOpenProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlacementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlacementRectProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlacementTargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ToolTipService implements Microsoft.UI.Xaml.Controls.IToolTipService {
+      static readonly PlacementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlacementTargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ToolTipProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static GetPlacement(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetPlacement(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetPlacementTarget(result: Microsoft.UI.Xaml.DependencyObject): Microsoft.UI.Xaml.UIElement;
+      static SetPlacementTarget(element: Microsoft.UI.Xaml.DependencyObject, value: Microsoft.UI.Xaml.UIElement): void;
+      static GetToolTip(result: Microsoft.UI.Xaml.DependencyObject): any;
+      static SetToolTip(element: Microsoft.UI.Xaml.DependencyObject, value: any): void;
+    }
+    class TreeView extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.ITreeView, Microsoft.UI.Xaml.Controls.ITreeView2, Microsoft.UI.Xaml.Controls.ITreeView3 {
+      Collapsed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TreeView, Microsoft.UI.Xaml.Controls.TreeViewCollapsedEventArgs> | null;
+      Expanding: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TreeView, Microsoft.UI.Xaml.Controls.TreeViewExpandingEventArgs> | null;
+      ItemInvoked: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TreeView, Microsoft.UI.Xaml.Controls.TreeViewItemInvokedEventArgs> | null;
+      DragItemsCompleted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TreeView, Microsoft.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs> | null;
+      DragItemsStarting: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TreeView, Microsoft.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs> | null;
+      SelectionChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TreeView, Microsoft.UI.Xaml.Controls.TreeViewSelectionChangedEventArgs> | null;
+      SelectionMode: number;
+      readonly RootNodes: System.Collections.Generic.IList<Microsoft.UI.Xaml.Controls.TreeViewNode>;
+      readonly SelectedNodes: System.Collections.Generic.IList<Microsoft.UI.Xaml.Controls.TreeViewNode>;
+      SelectedNode: Microsoft.UI.Xaml.Controls.TreeViewNode;
+      SelectedItem: any;
+      ItemsSource: any;
+      ItemTemplateSelector: Microsoft.UI.Xaml.Controls.DataTemplateSelector;
+      ItemTemplate: Microsoft.UI.Xaml.DataTemplate;
+      ItemContainerTransitions: Microsoft.UI.Xaml.Media.Animation.TransitionCollection;
+      ItemContainerStyleSelector: Microsoft.UI.Xaml.Controls.StyleSelector;
+      ItemContainerStyle: Microsoft.UI.Xaml.Style;
+      CanReorderItems: boolean;
+      CanDragItems: boolean;
+      readonly SelectedItems: System.Collections.Generic.IList<any>;
+      static readonly SelectedItemProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CanDragItemsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CanReorderItemsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemContainerStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemContainerStyleSelectorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemContainerTransitionsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemTemplateSelectorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemsSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      Expand(value: Microsoft.UI.Xaml.Controls.TreeViewNode): void;
+      Collapse(value: Microsoft.UI.Xaml.Controls.TreeViewNode): void;
+      SelectAll(): void;
+      NodeFromContainer(result: Microsoft.UI.Xaml.DependencyObject): Microsoft.UI.Xaml.Controls.TreeViewNode;
+      ContainerFromNode(result: Microsoft.UI.Xaml.Controls.TreeViewNode): Microsoft.UI.Xaml.DependencyObject;
+      ItemFromContainer(result: Microsoft.UI.Xaml.DependencyObject): any;
+      ContainerFromItem(result: any): Microsoft.UI.Xaml.DependencyObject;
+    }
+    class TreeViewCollapsedEventArgs implements Microsoft.UI.Xaml.Controls.ITreeViewCollapsedEventArgs, Microsoft.UI.Xaml.Controls.ITreeViewCollapsedEventArgs2 {
+      readonly Node: Microsoft.UI.Xaml.Controls.TreeViewNode;
+      readonly Item: any;
+    }
+    class TreeViewDragItemsCompletedEventArgs implements Microsoft.UI.Xaml.Controls.ITreeViewDragItemsCompletedEventArgs, Microsoft.UI.Xaml.Controls.ITreeViewDragItemsCompletedEventArgs2 {
+      readonly DropResult: Windows.ApplicationModel.DataTransfer.DataPackageOperation;
+      readonly Items: System.Collections.Generic.IReadOnlyList<any>;
+      readonly NewParentItem: any;
+    }
+    class TreeViewDragItemsStartingEventArgs implements Microsoft.UI.Xaml.Controls.ITreeViewDragItemsStartingEventArgs {
+      Cancel: boolean;
+      readonly Data: Windows.ApplicationModel.DataTransfer.DataPackage;
+      readonly Items: System.Collections.Generic.IList<any>;
+    }
+    class TreeViewExpandingEventArgs implements Microsoft.UI.Xaml.Controls.ITreeViewExpandingEventArgs, Microsoft.UI.Xaml.Controls.ITreeViewExpandingEventArgs2 {
+      readonly Node: Microsoft.UI.Xaml.Controls.TreeViewNode;
+      readonly Item: any;
+    }
+    class TreeViewItem extends Microsoft.UI.Xaml.Controls.ListViewItem implements Microsoft.UI.Xaml.Controls.ITreeViewItem, Microsoft.UI.Xaml.Controls.ITreeViewItem2 {
+      IsExpanded: boolean;
+      GlyphSize: number;
+      GlyphOpacity: number;
+      GlyphBrush: Microsoft.UI.Xaml.Media.Brush;
+      ExpandedGlyph: string;
+      CollapsedGlyph: string;
+      readonly TreeViewItemTemplateSettings: Microsoft.UI.Xaml.Controls.TreeViewItemTemplateSettings;
+      ItemsSource: any;
+      HasUnrealizedChildren: boolean;
+      static readonly CollapsedGlyphProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ExpandedGlyphProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GlyphBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GlyphOpacityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GlyphSizeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsExpandedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TreeViewItemTemplateSettingsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HasUnrealizedChildrenProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemsSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class TreeViewItemInvokedEventArgs implements Microsoft.UI.Xaml.Controls.ITreeViewItemInvokedEventArgs {
+      Handled: boolean;
+      readonly InvokedItem: any;
+    }
+    class TreeViewItemTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.ITreeViewItemTemplateSettings {
+      readonly CollapsedGlyphVisibility: number;
+      readonly DragItemsCount: number;
+      readonly ExpandedGlyphVisibility: number;
+      readonly Indentation: Microsoft.UI.Xaml.Thickness;
+      static readonly CollapsedGlyphVisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DragItemsCountProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ExpandedGlyphVisibilityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IndentationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class TreeViewList extends Microsoft.UI.Xaml.Controls.ListView implements Microsoft.UI.Xaml.Controls.ITreeViewList {
+      constructor();
+    }
+    class TreeViewNode extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.ITreeViewNode {
+      IsExpanded: boolean;
+      HasUnrealizedChildren: boolean;
+      Content: any;
+      readonly Children: System.Collections.Generic.IList<Microsoft.UI.Xaml.Controls.TreeViewNode>;
+      readonly Depth: number;
+      readonly HasChildren: boolean;
+      readonly Parent: Microsoft.UI.Xaml.Controls.TreeViewNode;
+      static readonly ContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DepthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HasChildrenProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsExpandedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class TreeViewSelectionChangedEventArgs implements Microsoft.UI.Xaml.Controls.ITreeViewSelectionChangedEventArgs {
+      readonly AddedItems: System.Collections.Generic.IList<any>;
+      readonly RemovedItems: System.Collections.Generic.IList<any>;
+    }
+    class TreeViewSelectionMode extends System.Enum {
+      value__: number;
+      static None: number;
+      static Single: number;
+      static Multiple: number;
+    }
+    class TwoPaneView extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.ITwoPaneView {
+      ModeChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.TwoPaneView, any> | null;
+      WideModeConfiguration: number;
+      TallModeConfiguration: number;
+      PanePriority: number;
+      Pane2Length: Microsoft.UI.Xaml.GridLength;
+      Pane2: Microsoft.UI.Xaml.UIElement;
+      Pane1Length: Microsoft.UI.Xaml.GridLength;
+      Pane1: Microsoft.UI.Xaml.UIElement;
+      MinWideModeWidth: number;
+      MinTallModeHeight: number;
+      readonly Mode: number;
+      static readonly MinTallModeHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinWideModeWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly Pane1LengthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly Pane1Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly Pane2LengthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly Pane2Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PanePriorityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TallModeConfigurationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly WideModeConfigurationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class TwoPaneViewMode extends System.Enum {
+      value__: number;
+      static SinglePane: number;
+      static Wide: number;
+      static Tall: number;
+    }
+    class TwoPaneViewPriority extends System.Enum {
+      value__: number;
+      static Pane1: number;
+      static Pane2: number;
+    }
+    class TwoPaneViewTallModeConfiguration extends System.Enum {
+      value__: number;
+      static SinglePane: number;
+      static TopBottom: number;
+      static BottomTop: number;
+    }
+    class TwoPaneViewWideModeConfiguration extends System.Enum {
+      value__: number;
+      static SinglePane: number;
+      static LeftRight: number;
+      static RightLeft: number;
+    }
+    class UIElementCollection implements Microsoft.UI.Xaml.Controls.IUIElementCollection {
+      Move(oldIndex: number, newIndex: number): void;
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class UniformGridLayout extends Microsoft.UI.Xaml.Controls.VirtualizingLayout implements Microsoft.UI.Xaml.Controls.IUniformGridLayout {
+      Orientation: number;
+      MinRowSpacing: number;
+      MinItemWidth: number;
+      MinItemHeight: number;
+      MinColumnSpacing: number;
+      MaximumRowsOrColumns: number;
+      ItemsStretch: number;
+      ItemsJustification: number;
+      static readonly ItemsJustificationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemsStretchProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaximumRowsOrColumnsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinColumnSpacingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinItemHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinItemWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinRowSpacingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OrientationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class UniformGridLayoutItemsJustification extends System.Enum {
+      value__: number;
+      static Start: number;
+      static Center: number;
+      static End: number;
+      static SpaceAround: number;
+      static SpaceBetween: number;
+      static SpaceEvenly: number;
+    }
+    class UniformGridLayoutItemsStretch extends System.Enum {
+      value__: number;
+      static None: number;
+      static Fill: number;
+      static Uniform: number;
+    }
+    class VariableSizedWrapGrid extends Microsoft.UI.Xaml.Controls.Panel implements Microsoft.UI.Xaml.Controls.IVariableSizedWrapGrid {
+      VerticalChildrenAlignment: number;
+      Orientation: number;
+      MaximumRowsOrColumns: number;
+      ItemWidth: number;
+      ItemHeight: number;
+      HorizontalChildrenAlignment: number;
+      static readonly ColumnSpanProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalChildrenAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaximumRowsOrColumnsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OrientationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RowSpanProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalChildrenAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      static GetRowSpan(result: Microsoft.UI.Xaml.UIElement): number;
+      static SetRowSpan(element: Microsoft.UI.Xaml.UIElement, value: number): void;
+      static GetColumnSpan(result: Microsoft.UI.Xaml.UIElement): number;
+      static SetColumnSpan(element: Microsoft.UI.Xaml.UIElement, value: number): void;
+    }
+    class Viewbox extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.IViewbox {
+      StretchDirection: number;
+      Stretch: number;
+      Child: Microsoft.UI.Xaml.UIElement;
+      static readonly StretchDirectionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StretchProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class VirtualizationMode extends System.Enum {
+      value__: number;
+      static Standard: number;
+      static Recycling: number;
+    }
+    class VirtualizingLayoutContext extends Microsoft.UI.Xaml.Controls.LayoutContext implements Microsoft.UI.Xaml.Controls.IVirtualizingLayoutContext, Microsoft.UI.Xaml.Controls.IVirtualizingLayoutContext2, Microsoft.UI.Xaml.Controls.IVirtualizingLayoutContextOverrides, Microsoft.UI.Xaml.Controls.IVirtualizingLayoutContextOverrides2 {
+      LayoutOrigin: Windows.Foundation.Point;
+      readonly ItemCount: number;
+      readonly RealizationRect: Windows.Foundation.Rect;
+      readonly RecommendedAnchorIndex: number;
+      readonly VisibleRect: Windows.Foundation.Rect;
+      constructor();
+      GetItemAt(result: number): any;
+      GetOrCreateElementAt(result: number): Microsoft.UI.Xaml.UIElement;
+      GetOrCreateElementAt(result: number, index: number): Microsoft.UI.Xaml.UIElement;
+      RecycleElement(element: Microsoft.UI.Xaml.UIElement): void;
+    }
+    class VirtualizingStackPanel extends Microsoft.UI.Xaml.Controls.Primitives.OrientedVirtualizingPanel implements Microsoft.UI.Xaml.Controls.IVirtualizingStackPanel, Microsoft.UI.Xaml.Controls.IVirtualizingStackPanelOverrides {
+      CleanUpVirtualizedItemEvent: Microsoft.UI.Xaml.Controls.CleanUpVirtualizedItemEventHandler | null;
+      Orientation: number;
+      AreScrollSnapPointsRegular: boolean;
+      static readonly AreScrollSnapPointsRegularProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsVirtualizingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OrientationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VirtualizationModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      static GetVirtualizationMode(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetVirtualizationMode(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetIsVirtualizing(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+    }
+    class WebView2 extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.IWebView2, Microsoft.UI.Xaml.Controls.IWebView22 {
+      CoreProcessFailed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.WebView2, Microsoft.Web.WebView2.Core.CoreWebView2ProcessFailedEventArgs> | null;
+      CoreWebView2Initialized: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.WebView2, Microsoft.UI.Xaml.Controls.CoreWebView2InitializedEventArgs> | null;
+      NavigationCompleted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.WebView2, Microsoft.Web.WebView2.Core.CoreWebView2NavigationCompletedEventArgs> | null;
+      NavigationStarting: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.WebView2, Microsoft.Web.WebView2.Core.CoreWebView2NavigationStartingEventArgs> | null;
+      WebMessageReceived: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.WebView2, Microsoft.Web.WebView2.Core.CoreWebView2WebMessageReceivedEventArgs> | null;
+      Source: System.Uri;
+      DefaultBackgroundColor: Windows.UI.Color;
+      CanGoForward: boolean;
+      CanGoBack: boolean;
+      readonly CoreWebView2: Microsoft.Web.WebView2.Core.CoreWebView2;
+      static readonly CanGoBackProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CanGoForwardProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DefaultBackgroundColorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      EnsureCoreWebView2Async(): Windows.Foundation.IAsyncAction;
+      ExecuteScriptAsync(operation: string): Windows.Foundation.IAsyncOperation<string>;
+      Reload(): void;
+      GoForward(): void;
+      GoBack(): void;
+      NavigateToString(htmlContent: string): void;
+      Close(): void;
+      EnsureCoreWebView2Async(operation: Microsoft.Web.WebView2.Core.CoreWebView2Environment): Windows.Foundation.IAsyncAction;
+      EnsureCoreWebView2Async(operation: Microsoft.Web.WebView2.Core.CoreWebView2Environment, environment: Microsoft.Web.WebView2.Core.CoreWebView2ControllerOptions): Windows.Foundation.IAsyncAction;
+    }
+    class WrapGrid extends Microsoft.UI.Xaml.Controls.Primitives.OrientedVirtualizingPanel implements Microsoft.UI.Xaml.Controls.IWrapGrid {
+      VerticalChildrenAlignment: number;
+      Orientation: number;
+      MaximumRowsOrColumns: number;
+      ItemWidth: number;
+      ItemHeight: number;
+      HorizontalChildrenAlignment: number;
+      static readonly HorizontalChildrenAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaximumRowsOrColumnsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OrientationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalChildrenAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class XamlControlsResources extends Microsoft.UI.Xaml.ResourceDictionary implements Microsoft.UI.Xaml.Controls.IXamlControlsResources {
+      UseCompactResources: boolean;
+      static readonly UseCompactResourcesProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      static EnsureRevealLights(element: Microsoft.UI.Xaml.UIElement): void;
+    }
+    class ZoomMode extends System.Enum {
+      value__: number;
+      static Disabled: number;
+      static Enabled: number;
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Controls.AnimatedVisuals {
+    class AnimatedAcceptVisualSource implements Microsoft.UI.Xaml.Controls.IAnimatedVisualSource, Microsoft.UI.Xaml.Controls.IAnimatedVisualSource2 {
+      readonly Markers: System.Collections.Generic.IReadOnlyDictionary<string, number>;
+      constructor();
+      TryCreateAnimatedVisual(result: Microsoft.UI.Composition.Compositor, compositor: any): Microsoft.UI.Xaml.Controls.IAnimatedVisual;
+      SetColorProperty(propertyName: string, value: Windows.UI.Color): void;
+    }
+    class AnimatedBackVisualSource implements Microsoft.UI.Xaml.Controls.IAnimatedVisualSource, Microsoft.UI.Xaml.Controls.IAnimatedVisualSource2 {
+      readonly Markers: System.Collections.Generic.IReadOnlyDictionary<string, number>;
+      constructor();
+      TryCreateAnimatedVisual(result: Microsoft.UI.Composition.Compositor, compositor: any): Microsoft.UI.Xaml.Controls.IAnimatedVisual;
+      SetColorProperty(propertyName: string, value: Windows.UI.Color): void;
+    }
+    class AnimatedChevronDownSmallVisualSource implements Microsoft.UI.Xaml.Controls.IAnimatedVisualSource, Microsoft.UI.Xaml.Controls.IAnimatedVisualSource2 {
+      readonly Markers: System.Collections.Generic.IReadOnlyDictionary<string, number>;
+      constructor();
+      TryCreateAnimatedVisual(result: Microsoft.UI.Composition.Compositor, compositor: any): Microsoft.UI.Xaml.Controls.IAnimatedVisual;
+      SetColorProperty(propertyName: string, value: Windows.UI.Color): void;
+    }
+    class AnimatedChevronRightDownSmallVisualSource implements Microsoft.UI.Xaml.Controls.IAnimatedVisualSource, Microsoft.UI.Xaml.Controls.IAnimatedVisualSource2 {
+      readonly Markers: System.Collections.Generic.IReadOnlyDictionary<string, number>;
+      constructor();
+      TryCreateAnimatedVisual(result: Microsoft.UI.Composition.Compositor, compositor: any): Microsoft.UI.Xaml.Controls.IAnimatedVisual;
+      SetColorProperty(propertyName: string, value: Windows.UI.Color): void;
+    }
+    class AnimatedChevronUpDownSmallVisualSource implements Microsoft.UI.Xaml.Controls.IAnimatedVisualSource, Microsoft.UI.Xaml.Controls.IAnimatedVisualSource2 {
+      readonly Markers: System.Collections.Generic.IReadOnlyDictionary<string, number>;
+      constructor();
+      TryCreateAnimatedVisual(result: Microsoft.UI.Composition.Compositor, compositor: any): Microsoft.UI.Xaml.Controls.IAnimatedVisual;
+      SetColorProperty(propertyName: string, value: Windows.UI.Color): void;
+    }
+    class AnimatedFindVisualSource implements Microsoft.UI.Xaml.Controls.IAnimatedVisualSource, Microsoft.UI.Xaml.Controls.IAnimatedVisualSource2 {
+      readonly Markers: System.Collections.Generic.IReadOnlyDictionary<string, number>;
+      constructor();
+      TryCreateAnimatedVisual(result: Microsoft.UI.Composition.Compositor, compositor: any): Microsoft.UI.Xaml.Controls.IAnimatedVisual;
+      SetColorProperty(propertyName: string, value: Windows.UI.Color): void;
+    }
+    class AnimatedGlobalNavigationButtonVisualSource implements Microsoft.UI.Xaml.Controls.IAnimatedVisualSource, Microsoft.UI.Xaml.Controls.IAnimatedVisualSource2 {
+      readonly Markers: System.Collections.Generic.IReadOnlyDictionary<string, number>;
+      constructor();
+      TryCreateAnimatedVisual(result: Microsoft.UI.Composition.Compositor, compositor: any): Microsoft.UI.Xaml.Controls.IAnimatedVisual;
+      SetColorProperty(propertyName: string, value: Windows.UI.Color): void;
+    }
+    class AnimatedSettingsVisualSource implements Microsoft.UI.Xaml.Controls.IAnimatedVisualSource, Microsoft.UI.Xaml.Controls.IAnimatedVisualSource2 {
+      readonly Markers: System.Collections.Generic.IReadOnlyDictionary<string, number>;
+      constructor();
+      TryCreateAnimatedVisual(result: Microsoft.UI.Composition.Compositor, compositor: any): Microsoft.UI.Xaml.Controls.IAnimatedVisual;
+      SetColorProperty(propertyName: string, value: Windows.UI.Color): void;
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Controls.Primitives {
+    class ButtonBase extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.Primitives.IButtonBase {
+      Click: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      CommandParameter: any;
+      Command: Microsoft.UI.Xaml.Input.ICommand;
+      ClickMode: number;
+      readonly IsPointerOver: boolean;
+      readonly IsPressed: boolean;
+      static readonly ClickModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CommandParameterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CommandProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsPointerOverProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsPressedProperty: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class ToggleButton extends Microsoft.UI.Xaml.Controls.Primitives.ButtonBase implements Microsoft.UI.Xaml.Controls.Primitives.IToggleButton, Microsoft.UI.Xaml.Controls.Primitives.IToggleButtonOverrides {
+      Checked: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      Indeterminate: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      Unchecked: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      IsThreeState: boolean;
+      IsChecked: System.Nullable<boolean>;
+      static readonly IsCheckedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsThreeStateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class Selector extends Microsoft.UI.Xaml.Controls.ItemsControl implements Microsoft.UI.Xaml.Controls.Primitives.ISelector {
+      SelectionChanged: Microsoft.UI.Xaml.Controls.SelectionChangedEventHandler | null;
+      SelectedValuePath: string;
+      SelectedValue: any;
+      SelectedItem: any;
+      SelectedIndex: number;
+      IsSynchronizedWithCurrentItem: System.Nullable<boolean>;
+      static readonly IsSynchronizedWithCurrentItemProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedIndexProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedItemProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedValuePathProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedValueProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static GetIsSelectionActive(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+    }
+    class SelectorItem extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.Primitives.ISelectorItem {
+      IsSelected: boolean;
+      static readonly IsSelectedProperty: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class FlyoutBase extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.IFlyoutBase, Microsoft.UI.Xaml.Controls.Primitives.IFlyoutBase2, Microsoft.UI.Xaml.Controls.Primitives.IFlyoutBaseOverrides {
+      Closed: System.EventHandler<any> | null;
+      Closing: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Primitives.FlyoutBase, Microsoft.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs> | null;
+      Opened: System.EventHandler<any> | null;
+      Opening: System.EventHandler<any> | null;
+      XamlRoot: Microsoft.UI.Xaml.XamlRoot;
+      ShowMode: number;
+      ShouldConstrainToRootBounds: boolean;
+      Placement: number;
+      OverlayInputPassThroughElement: Microsoft.UI.Xaml.DependencyObject;
+      LightDismissOverlayMode: number;
+      ElementSoundMode: number;
+      AreOpenCloseAnimationsEnabled: boolean;
+      AllowFocusWhenDisabled: boolean;
+      AllowFocusOnInteraction: boolean;
+      readonly InputDevicePrefersPrimaryCommands: boolean;
+      readonly IsConstrainedToRootBounds: boolean;
+      readonly IsOpen: boolean;
+      readonly Target: Microsoft.UI.Xaml.FrameworkElement;
+      SystemBackdrop: Microsoft.UI.Xaml.Media.SystemBackdrop;
+      static readonly AllowFocusOnInteractionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AllowFocusWhenDisabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AreOpenCloseAnimationsEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AttachedFlyoutProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ElementSoundModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly InputDevicePrefersPrimaryCommandsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsOpenProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LightDismissOverlayModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OverlayInputPassThroughElementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlacementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ShouldConstrainToRootBoundsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ShowModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SystemBackdropProperty: Microsoft.UI.Xaml.DependencyProperty;
+      ShowAt(placementTarget: Microsoft.UI.Xaml.FrameworkElement): void;
+      ShowAt(placementTarget: Microsoft.UI.Xaml.DependencyObject, showOptions: Microsoft.UI.Xaml.Controls.Primitives.FlyoutShowOptions): void;
+      Hide(): void;
+      TryInvokeKeyboardAccelerator(args: Microsoft.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+      static GetAttachedFlyout(result: Microsoft.UI.Xaml.FrameworkElement): Microsoft.UI.Xaml.Controls.Primitives.FlyoutBase;
+      static SetAttachedFlyout(element: Microsoft.UI.Xaml.FrameworkElement, value: Microsoft.UI.Xaml.Controls.Primitives.FlyoutBase): void;
+      static ShowAttachedFlyout(flyoutOwner: Microsoft.UI.Xaml.FrameworkElement): void;
+    }
+    class PickerFlyoutBase extends Microsoft.UI.Xaml.Controls.Primitives.FlyoutBase implements Microsoft.UI.Xaml.Controls.Primitives.IPickerFlyoutBase, Microsoft.UI.Xaml.Controls.Primitives.IPickerFlyoutBaseOverrides {
+      static readonly TitleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static GetTitle(result: Microsoft.UI.Xaml.DependencyObject): string;
+      static SetTitle(element: Microsoft.UI.Xaml.DependencyObject, value: string): void;
+    }
+    class AnimationDirection extends System.Enum {
+      value__: number;
+      static Left: number;
+      static Top: number;
+      static Right: number;
+      static Bottom: number;
+    }
+    class AppBarButtonTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.IAppBarButtonTemplateSettings {
+      readonly KeyboardAcceleratorTextMinWidth: number;
+    }
+    class AppBarTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.IAppBarTemplateSettings {
+      readonly ClipRect: Windows.Foundation.Rect;
+      readonly CompactRootMargin: Microsoft.UI.Xaml.Thickness;
+      readonly CompactVerticalDelta: number;
+      readonly HiddenRootMargin: Microsoft.UI.Xaml.Thickness;
+      readonly HiddenVerticalDelta: number;
+      readonly MinimalRootMargin: Microsoft.UI.Xaml.Thickness;
+      readonly MinimalVerticalDelta: number;
+      readonly NegativeCompactVerticalDelta: number;
+      readonly NegativeHiddenVerticalDelta: number;
+      readonly NegativeMinimalVerticalDelta: number;
+    }
+    class AppBarToggleButtonTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.IAppBarToggleButtonTemplateSettings {
+      readonly KeyboardAcceleratorTextMinWidth: number;
+    }
+    class AutoSuggestBoxHelper implements Microsoft.UI.Xaml.Controls.Primitives.IAutoSuggestBoxHelper {
+      static readonly KeepInteriorCornersSquareProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static SetKeepInteriorCornersSquare(autoSuggestBox: Microsoft.UI.Xaml.Controls.AutoSuggestBox, value: boolean): void;
+      static GetKeepInteriorCornersSquare(result: Microsoft.UI.Xaml.Controls.AutoSuggestBox): boolean;
+    }
+    class CalendarPanel extends Microsoft.UI.Xaml.Controls.Panel implements Microsoft.UI.Xaml.Controls.Primitives.ICalendarPanel {
+      constructor();
+    }
+    class CalendarViewTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.ICalendarViewTemplateSettings {
+      readonly CenterX: number;
+      readonly CenterY: number;
+      readonly ClipRect: Windows.Foundation.Rect;
+      readonly HasMoreContentAfter: boolean;
+      readonly HasMoreContentBefore: boolean;
+      readonly HasMoreViews: boolean;
+      readonly HeaderText: string;
+      readonly MinViewWidth: number;
+      readonly WeekDay1: string;
+      readonly WeekDay2: string;
+      readonly WeekDay3: string;
+      readonly WeekDay4: string;
+      readonly WeekDay5: string;
+      readonly WeekDay6: string;
+      readonly WeekDay7: string;
+    }
+    class CarouselPanel extends Microsoft.UI.Xaml.Controls.VirtualizingPanel implements Microsoft.UI.Xaml.Controls.Primitives.ICarouselPanel, Microsoft.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo {
+      HorizontalSnapPointsChanged: System.EventHandler<any> | null;
+      VerticalSnapPointsChanged: System.EventHandler<any> | null;
+      ScrollOwner: any;
+      CanVerticallyScroll: boolean;
+      CanHorizontallyScroll: boolean;
+      readonly ExtentHeight: number;
+      readonly ExtentWidth: number;
+      readonly HorizontalOffset: number;
+      readonly VerticalOffset: number;
+      readonly ViewportHeight: number;
+      readonly ViewportWidth: number;
+      readonly AreHorizontalSnapPointsRegular: boolean;
+      readonly AreVerticalSnapPointsRegular: boolean;
+      constructor();
+      LineUp(): void;
+      LineDown(): void;
+      LineLeft(): void;
+      LineRight(): void;
+      PageUp(): void;
+      PageDown(): void;
+      PageLeft(): void;
+      PageRight(): void;
+      MouseWheelUp(): void;
+      MouseWheelDown(): void;
+      MouseWheelLeft(): void;
+      MouseWheelRight(): void;
+      SetHorizontalOffset(offset: number): void;
+      SetVerticalOffset(offset: number): void;
+      MakeVisible(result: Microsoft.UI.Xaml.UIElement, visual: Windows.Foundation.Rect): Windows.Foundation.Rect;
+      GetIrregularSnapPoints(result: number, orientation: number): System.Collections.Generic.IReadOnlyList<number>;
+      GetRegularSnapPoints(returnValue: number, orientation: number, alignment: number): number;
+    }
+    class RangeBase extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.Primitives.IRangeBase, Microsoft.UI.Xaml.Controls.Primitives.IRangeBaseOverrides {
+      ValueChanged: Microsoft.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler | null;
+      Value: number;
+      SmallChange: number;
+      Minimum: number;
+      Maximum: number;
+      LargeChange: number;
+      static readonly LargeChangeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaximumProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinimumProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SmallChangeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ValueProperty: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class ColorPickerSlider extends Microsoft.UI.Xaml.Controls.Slider implements Microsoft.UI.Xaml.Controls.Primitives.IColorPickerSlider {
+      ColorChannel: number;
+      static readonly ColorChannelProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ColorSpectrum extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.Primitives.IColorSpectrum {
+      ColorChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Primitives.ColorSpectrum, Microsoft.UI.Xaml.Controls.ColorChangedEventArgs> | null;
+      Shape: number;
+      MinValue: number;
+      MinSaturation: number;
+      MinHue: number;
+      MaxValue: number;
+      MaxSaturation: number;
+      MaxHue: number;
+      HsvColor: System.Numerics.Vector4;
+      Components: number;
+      Color: Windows.UI.Color;
+      static readonly ColorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ComponentsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HsvColorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxHueProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxSaturationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxValueProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinHueProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinSaturationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinValueProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ShapeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ColumnMajorUniformToLargestGridLayout extends Microsoft.UI.Xaml.Controls.NonVirtualizingLayout implements Microsoft.UI.Xaml.Controls.Primitives.IColumnMajorUniformToLargestGridLayout {
+      RowSpacing: number;
+      MaxColumns: number;
+      ColumnSpacing: number;
+      static readonly ColumnSpacingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxColumnsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RowSpacingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ComboBoxHelper implements Microsoft.UI.Xaml.Controls.Primitives.IComboBoxHelper {
+      static readonly KeepInteriorCornersSquareProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static SetKeepInteriorCornersSquare(comboBox: Microsoft.UI.Xaml.Controls.ComboBox, value: boolean): void;
+      static GetKeepInteriorCornersSquare(result: Microsoft.UI.Xaml.Controls.ComboBox): boolean;
+    }
+    class ComboBoxTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.IComboBoxTemplateSettings {
+      readonly DropDownClosedHeight: number;
+      readonly DropDownContentMinWidth: number;
+      readonly DropDownOffset: number;
+      readonly DropDownOpenedHeight: number;
+      readonly SelectedItemDirection: number;
+    }
+    class CommandBarFlyoutCommandBar extends Microsoft.UI.Xaml.Controls.CommandBar implements Microsoft.UI.Xaml.Controls.Primitives.ICommandBarFlyoutCommandBar, Microsoft.UI.Xaml.Controls.Primitives.ICommandBarFlyoutCommandBar2 {
+      readonly FlyoutTemplateSettings: Microsoft.UI.Xaml.Controls.Primitives.CommandBarFlyoutCommandBarTemplateSettings;
+      SystemBackdrop: Microsoft.UI.Xaml.Media.SystemBackdrop;
+      static readonly SystemBackdropProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class CommandBarFlyoutCommandBarAutomationProperties {
+      static readonly ControlTypeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static GetControlType(result: Microsoft.UI.Xaml.UIElement): number;
+      static SetControlType(element: Microsoft.UI.Xaml.UIElement, value: number): void;
+    }
+    class CommandBarFlyoutCommandBarTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.ICommandBarFlyoutCommandBarTemplateSettings {
+      readonly CloseAnimationEndPosition: number;
+      readonly ContentClipRect: Windows.Foundation.Rect;
+      readonly CurrentWidth: number;
+      readonly ExpandDownAnimationEndPosition: number;
+      readonly ExpandDownAnimationHoldPosition: number;
+      readonly ExpandDownAnimationStartPosition: number;
+      readonly ExpandDownOverflowVerticalPosition: number;
+      readonly ExpandUpAnimationEndPosition: number;
+      readonly ExpandUpAnimationHoldPosition: number;
+      readonly ExpandUpAnimationStartPosition: number;
+      readonly ExpandUpOverflowVerticalPosition: number;
+      readonly ExpandedWidth: number;
+      readonly OpenAnimationEndPosition: number;
+      readonly OpenAnimationStartPosition: number;
+      readonly OverflowContentClipRect: Windows.Foundation.Rect;
+      readonly WidthExpansionAnimationEndPosition: number;
+      readonly WidthExpansionAnimationStartPosition: number;
+      readonly WidthExpansionDelta: number;
+      readonly WidthExpansionMoreButtonAnimationEndPosition: number;
+      readonly WidthExpansionMoreButtonAnimationStartPosition: number;
+    }
+    class CommandBarTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.ICommandBarTemplateSettings {
+      readonly ContentHeight: number;
+      readonly EffectiveOverflowButtonVisibility: number;
+      readonly NegativeOverflowContentHeight: number;
+      readonly OverflowContentClipRect: Windows.Foundation.Rect;
+      readonly OverflowContentCompactYTranslation: number;
+      readonly OverflowContentHeight: number;
+      readonly OverflowContentHiddenYTranslation: number;
+      readonly OverflowContentHorizontalOffset: number;
+      readonly OverflowContentMaxHeight: number;
+      readonly OverflowContentMaxWidth: number;
+      readonly OverflowContentMinWidth: number;
+      readonly OverflowContentMinimalYTranslation: number;
+    }
+    class ComponentResourceLocation extends System.Enum {
+      value__: number;
+      static Application: number;
+      static Nested: number;
+    }
+    class CornerRadiusFilterConverter extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.ICornerRadiusFilterConverter, Microsoft.UI.Xaml.Data.IValueConverter {
+      Scale: number;
+      Filter: number;
+      static readonly FilterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ScaleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      Convert(result: any, value: System.Type, targetType: any, parameter: string): any;
+      ConvertBack(result: any, value: System.Type, targetType: any, parameter: string): any;
+    }
+    class CornerRadiusFilterKind extends System.Enum {
+      value__: number;
+      static None: number;
+      static Top: number;
+      static Right: number;
+      static Bottom: number;
+      static Left: number;
+      static TopLeftValue: number;
+      static BottomRightValue: number;
+    }
+    class CornerRadiusToThicknessConverter extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.ICornerRadiusToThicknessConverter, Microsoft.UI.Xaml.Data.IValueConverter {
+      Multiplier: number;
+      ConversionKind: number;
+      static readonly ConversionKindProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MultiplierProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      Convert(result: any, value: System.Type, targetType: any, parameter: string): any;
+      ConvertBack(result: any, value: System.Type, targetType: any, parameter: string): any;
+    }
+    class CornerRadiusToThicknessConverterKind extends System.Enum {
+      value__: number;
+      static FilterTopAndBottomFromLeft: number;
+      static FilterTopAndBottomFromRight: number;
+      static FilterLeftAndRightFromTop: number;
+      static FilterLeftAndRightFromBottom: number;
+      static FilterTopFromTopLeft: number;
+      static FilterTopFromTopRight: number;
+      static FilterRightFromTopRight: number;
+      static FilterRightFromBottomRight: number;
+      static FilterBottomFromBottomRight: number;
+      static FilterBottomFromBottomLeft: number;
+      static FilterLeftFromBottomLeft: number;
+      static FilterLeftFromTopLeft: number;
+    }
+    class DragCompletedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Controls.Primitives.IDragCompletedEventArgs {
+      readonly Canceled: boolean;
+      readonly HorizontalChange: number;
+      readonly VerticalChange: number;
+      constructor(horizontalChange: number, verticalChange: number, canceled: boolean);
+    }
+    class DragCompletedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Controls.Primitives.DragCompletedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Controls.Primitives.DragCompletedEventArgs): void;
+    }
+    class DragDeltaEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Controls.Primitives.IDragDeltaEventArgs {
+      readonly HorizontalChange: number;
+      readonly VerticalChange: number;
+      constructor(horizontalChange: number, verticalChange: number);
+    }
+    class DragDeltaEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Controls.Primitives.DragDeltaEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Controls.Primitives.DragDeltaEventArgs): void;
+    }
+    class DragStartedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Controls.Primitives.IDragStartedEventArgs {
+      readonly HorizontalOffset: number;
+      readonly VerticalOffset: number;
+      constructor(horizontalOffset: number, verticalOffset: number);
+    }
+    class DragStartedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Controls.Primitives.DragStartedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Controls.Primitives.DragStartedEventArgs): void;
+    }
+    class EdgeTransitionLocation extends System.Enum {
+      value__: number;
+      static Left: number;
+      static Top: number;
+      static Right: number;
+      static Bottom: number;
+    }
+    class FlyoutBaseClosingEventArgs implements Microsoft.UI.Xaml.Controls.Primitives.IFlyoutBaseClosingEventArgs {
+      Cancel: boolean;
+    }
+    class FlyoutPlacementMode extends System.Enum {
+      value__: number;
+      static Top: number;
+      static Bottom: number;
+      static Left: number;
+      static Right: number;
+      static Full: number;
+      static TopEdgeAlignedLeft: number;
+      static TopEdgeAlignedRight: number;
+      static BottomEdgeAlignedLeft: number;
+      static BottomEdgeAlignedRight: number;
+      static LeftEdgeAlignedTop: number;
+      static LeftEdgeAlignedBottom: number;
+      static RightEdgeAlignedTop: number;
+      static RightEdgeAlignedBottom: number;
+      static Auto: number;
+    }
+    class FlyoutShowMode extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Standard: number;
+      static Transient: number;
+      static TransientWithDismissOnPointerMoveAway: number;
+    }
+    class FlyoutShowOptions implements Microsoft.UI.Xaml.Controls.Primitives.IFlyoutShowOptions {
+      ShowMode: number;
+      Position: System.Nullable<Windows.Foundation.Point>;
+      Placement: number;
+      ExclusionRect: System.Nullable<Windows.Foundation.Rect>;
+      constructor();
+    }
+    class GeneratorDirection extends System.Enum {
+      value__: number;
+      static Forward: number;
+      static Backward: number;
+    }
+    class GeneratorPosition extends System.ValueType {
+      Index: number;
+      Offset: number;
+    }
+    class GeneratorPositionHelper implements Microsoft.UI.Xaml.Controls.Primitives.IGeneratorPositionHelper {
+      static FromIndexAndOffset(result: number, index: number): Microsoft.UI.Xaml.Controls.Primitives.GeneratorPosition;
+    }
+    class GridViewItemPresenter extends Microsoft.UI.Xaml.Controls.ContentPresenter implements Microsoft.UI.Xaml.Controls.Primitives.IGridViewItemPresenter {
+      SelectionCheckMarkVisualEnabled: boolean;
+      SelectedPointerOverBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      SelectedPointerOverBackground: Microsoft.UI.Xaml.Media.Brush;
+      SelectedForeground: Microsoft.UI.Xaml.Media.Brush;
+      SelectedBorderThickness: Microsoft.UI.Xaml.Thickness;
+      SelectedBackground: Microsoft.UI.Xaml.Media.Brush;
+      ReorderHintOffset: number;
+      PointerOverBackgroundMargin: Microsoft.UI.Xaml.Thickness;
+      PointerOverBackground: Microsoft.UI.Xaml.Media.Brush;
+      PlaceholderBackground: Microsoft.UI.Xaml.Media.Brush;
+      GridViewItemPresenterVerticalContentAlignment: number;
+      GridViewItemPresenterPadding: Microsoft.UI.Xaml.Thickness;
+      GridViewItemPresenterHorizontalContentAlignment: number;
+      FocusBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      DragOpacity: number;
+      DragForeground: Microsoft.UI.Xaml.Media.Brush;
+      DragBackground: Microsoft.UI.Xaml.Media.Brush;
+      DisabledOpacity: number;
+      ContentMargin: Microsoft.UI.Xaml.Thickness;
+      CheckSelectingBrush: Microsoft.UI.Xaml.Media.Brush;
+      CheckHintBrush: Microsoft.UI.Xaml.Media.Brush;
+      CheckBrush: Microsoft.UI.Xaml.Media.Brush;
+      static readonly CheckBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckHintBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckSelectingBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentMarginProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DisabledOpacityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DragBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DragForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DragOpacityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FocusBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GridViewItemPresenterHorizontalContentAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GridViewItemPresenterPaddingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GridViewItemPresenterVerticalContentAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlaceholderBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PointerOverBackgroundMarginProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PointerOverBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ReorderHintOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedBorderThicknessProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedPointerOverBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedPointerOverBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionCheckMarkVisualEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class GridViewItemTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.IGridViewItemTemplateSettings {
+      readonly DragItemsCount: number;
+    }
+    class GroupHeaderPlacement extends System.Enum {
+      value__: number;
+      static Top: number;
+      static Left: number;
+    }
+    interface IScrollController {
+      AddScrollVelocityRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Primitives.IScrollController, Microsoft.UI.Xaml.Controls.Primitives.ScrollControllerAddScrollVelocityRequestedEventArgs> | null;
+      CanScrollChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Primitives.IScrollController, any> | null;
+      IsScrollingWithMouseChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Primitives.IScrollController, any> | null;
+      ScrollByRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Primitives.IScrollController, Microsoft.UI.Xaml.Controls.Primitives.ScrollControllerScrollByRequestedEventArgs> | null;
+      ScrollToRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Primitives.IScrollController, Microsoft.UI.Xaml.Controls.Primitives.ScrollControllerScrollToRequestedEventArgs> | null;
+      readonly CanScroll: boolean;
+      readonly IsScrollingWithMouse: boolean;
+      readonly PanningInfo: Microsoft.UI.Xaml.Controls.Primitives.IScrollControllerPanningInfo;
+      SetIsScrollable(isScrollable: boolean): void;
+      SetValues(minOffset: number, maxOffset: number, offset: number, viewportLength: number): void;
+      GetScrollAnimation(result: number, correlationId: System.Numerics.Vector2, startPosition: System.Numerics.Vector2, endPosition: Microsoft.UI.Composition.CompositionAnimation): Microsoft.UI.Composition.CompositionAnimation;
+      NotifyRequestedScrollCompleted(correlationId: number): void;
+    }
+    interface IScrollControllerPanningInfo {
+      Changed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Primitives.IScrollControllerPanningInfo, any> | null;
+      PanRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Primitives.IScrollControllerPanningInfo, Microsoft.UI.Xaml.Controls.Primitives.ScrollControllerPanRequestedEventArgs> | null;
+      readonly IsRailEnabled: boolean;
+      readonly PanOrientation: number;
+      readonly PanningElementAncestor: Microsoft.UI.Xaml.UIElement;
+      SetPanningElementExpressionAnimationSources(propertySet: Microsoft.UI.Composition.CompositionPropertySet, minOffsetPropertyName: string, maxOffsetPropertyName: string, offsetPropertyName: string, multiplierPropertyName: string): void;
+    }
+    interface IScrollSnapPointsInfo {
+      HorizontalSnapPointsChanged: System.EventHandler<any> | null;
+      VerticalSnapPointsChanged: System.EventHandler<any> | null;
+      readonly AreHorizontalSnapPointsRegular: boolean;
+      readonly AreVerticalSnapPointsRegular: boolean;
+      GetIrregularSnapPoints(result: number, orientation: number): System.Collections.Generic.IReadOnlyList<number>;
+      GetRegularSnapPoints(returnValue: number, orientation: number, alignment: number): number;
+    }
+    class InfoBarPanel extends Microsoft.UI.Xaml.Controls.Panel implements Microsoft.UI.Xaml.Controls.Primitives.IInfoBarPanel {
+      VerticalOrientationPadding: Microsoft.UI.Xaml.Thickness;
+      HorizontalOrientationPadding: Microsoft.UI.Xaml.Thickness;
+      static readonly HorizontalOrientationMarginProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalOrientationPaddingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalOrientationMarginProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalOrientationPaddingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      static SetHorizontalOrientationMargin(object: Microsoft.UI.Xaml.DependencyObject, value: Microsoft.UI.Xaml.Thickness): void;
+      static GetHorizontalOrientationMargin(result: Microsoft.UI.Xaml.DependencyObject): Microsoft.UI.Xaml.Thickness;
+      static SetVerticalOrientationMargin(object: Microsoft.UI.Xaml.DependencyObject, value: Microsoft.UI.Xaml.Thickness): void;
+      static GetVerticalOrientationMargin(result: Microsoft.UI.Xaml.DependencyObject): Microsoft.UI.Xaml.Thickness;
+    }
+    class ItemsChangedEventArgs implements Microsoft.UI.Xaml.Controls.Primitives.IItemsChangedEventArgs {
+      readonly Action: number;
+      readonly ItemCount: number;
+      readonly ItemUICount: number;
+      readonly OldPosition: Microsoft.UI.Xaml.Controls.Primitives.GeneratorPosition;
+      readonly Position: Microsoft.UI.Xaml.Controls.Primitives.GeneratorPosition;
+    }
+    class ItemsChangedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Controls.Primitives.ItemsChangedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Controls.Primitives.ItemsChangedEventArgs): void;
+    }
+    class JumpListItemBackgroundConverter extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.IJumpListItemBackgroundConverter, Microsoft.UI.Xaml.Data.IValueConverter {
+      Enabled: Microsoft.UI.Xaml.Media.Brush;
+      Disabled: Microsoft.UI.Xaml.Media.Brush;
+      static readonly DisabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly EnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      Convert(result: any, value: System.Type, targetType: any, parameter: string): any;
+      ConvertBack(result: any, value: System.Type, targetType: any, parameter: string): any;
+    }
+    class JumpListItemForegroundConverter extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.IJumpListItemForegroundConverter, Microsoft.UI.Xaml.Data.IValueConverter {
+      Enabled: Microsoft.UI.Xaml.Media.Brush;
+      Disabled: Microsoft.UI.Xaml.Media.Brush;
+      static readonly DisabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly EnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      Convert(result: any, value: System.Type, targetType: any, parameter: string): any;
+      ConvertBack(result: any, value: System.Type, targetType: any, parameter: string): any;
+    }
+    class LayoutInformation implements Microsoft.UI.Xaml.Controls.Primitives.ILayoutInformation {
+      static GetLayoutExceptionElement(result: any): Microsoft.UI.Xaml.UIElement;
+      static GetLayoutSlot(result: Microsoft.UI.Xaml.FrameworkElement): Windows.Foundation.Rect;
+      static GetAvailableSize(result: Microsoft.UI.Xaml.UIElement): Windows.Foundation.Size;
+    }
+    class ListViewItemPresenter extends Microsoft.UI.Xaml.Controls.ContentPresenter implements Microsoft.UI.Xaml.Controls.Primitives.IListViewItemPresenter {
+      ListViewItemPresenterVerticalContentAlignment: number;
+      ListViewItemPresenterPadding: Microsoft.UI.Xaml.Thickness;
+      ListViewItemPresenterHorizontalContentAlignment: number;
+      FocusSecondaryBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      FocusBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      DragOpacity: number;
+      RevealBackground: Microsoft.UI.Xaml.Media.Brush;
+      DragBackground: Microsoft.UI.Xaml.Media.Brush;
+      DisabledOpacity: number;
+      ContentMargin: Microsoft.UI.Xaml.Thickness;
+      CheckSelectingBrush: Microsoft.UI.Xaml.Media.Brush;
+      CheckPressedBrush: Microsoft.UI.Xaml.Media.Brush;
+      CheckMode: number;
+      CheckHintBrush: Microsoft.UI.Xaml.Media.Brush;
+      CheckBoxBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      CheckBrush: Microsoft.UI.Xaml.Media.Brush;
+      CheckBoxSelectedPressedBrush: Microsoft.UI.Xaml.Media.Brush;
+      CheckBoxSelectedPointerOverBrush: Microsoft.UI.Xaml.Media.Brush;
+      CheckBoxSelectedDisabledBrush: Microsoft.UI.Xaml.Media.Brush;
+      CheckBoxSelectedBrush: Microsoft.UI.Xaml.Media.Brush;
+      CheckBoxPressedBrush: Microsoft.UI.Xaml.Media.Brush;
+      SelectionCheckMarkVisualEnabled: boolean;
+      CheckBoxPointerOverBrush: Microsoft.UI.Xaml.Media.Brush;
+      CheckBoxPointerOverBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      CheckBoxDisabledBrush: Microsoft.UI.Xaml.Media.Brush;
+      CheckBoxDisabledBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      CheckBoxCornerRadius: Microsoft.UI.Xaml.CornerRadius;
+      CheckBoxBrush: Microsoft.UI.Xaml.Media.Brush;
+      CheckDisabledBrush: Microsoft.UI.Xaml.Media.Brush;
+      PlaceholderBackground: Microsoft.UI.Xaml.Media.Brush;
+      SelectedDisabledBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      SelectionIndicatorPressedBrush: Microsoft.UI.Xaml.Media.Brush;
+      SelectionIndicatorPointerOverBrush: Microsoft.UI.Xaml.Media.Brush;
+      SelectionIndicatorMode: number;
+      SelectionIndicatorDisabledBrush: Microsoft.UI.Xaml.Media.Brush;
+      SelectionIndicatorCornerRadius: Microsoft.UI.Xaml.CornerRadius;
+      SelectionIndicatorBrush: Microsoft.UI.Xaml.Media.Brush;
+      CheckBoxPressedBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      SelectedPressedBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      SelectedPressedBackground: Microsoft.UI.Xaml.Media.Brush;
+      SelectedPointerOverBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      SelectedPointerOverBackground: Microsoft.UI.Xaml.Media.Brush;
+      SelectedInnerBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      SelectedForeground: Microsoft.UI.Xaml.Media.Brush;
+      SelectionIndicatorVisualEnabled: boolean;
+      SelectedDisabledBackground: Microsoft.UI.Xaml.Media.Brush;
+      SelectedBorderThickness: Microsoft.UI.Xaml.Thickness;
+      SelectedBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      SelectedBackground: Microsoft.UI.Xaml.Media.Brush;
+      RevealBorderThickness: Microsoft.UI.Xaml.Thickness;
+      RevealBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      RevealBackgroundShowsAboveContent: boolean;
+      DragForeground: Microsoft.UI.Xaml.Media.Brush;
+      ReorderHintOffset: number;
+      PressedBackground: Microsoft.UI.Xaml.Media.Brush;
+      PointerOverForeground: Microsoft.UI.Xaml.Media.Brush;
+      PointerOverBorderBrush: Microsoft.UI.Xaml.Media.Brush;
+      PointerOverBackgroundMargin: Microsoft.UI.Xaml.Thickness;
+      PointerOverBackground: Microsoft.UI.Xaml.Media.Brush;
+      static readonly CheckBoxBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckBoxBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckBoxCornerRadiusProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckBoxDisabledBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckBoxDisabledBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckBoxPointerOverBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckBoxPointerOverBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckBoxPressedBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckBoxPressedBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckBoxSelectedBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckBoxSelectedDisabledBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckBoxSelectedPointerOverBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckBoxSelectedPressedBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckDisabledBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckHintBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckPressedBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CheckSelectingBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentMarginProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DisabledOpacityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DragBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DragForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DragOpacityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FocusBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FocusSecondaryBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ListViewItemPresenterHorizontalContentAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ListViewItemPresenterPaddingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ListViewItemPresenterVerticalContentAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlaceholderBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PointerOverBackgroundMarginProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PointerOverBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PointerOverBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PointerOverForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PressedBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ReorderHintOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RevealBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RevealBackgroundShowsAboveContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RevealBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RevealBorderThicknessProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedBorderThicknessProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedDisabledBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedDisabledBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedInnerBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedPointerOverBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedPointerOverBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedPressedBackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedPressedBorderBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionCheckMarkVisualEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionIndicatorBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionIndicatorCornerRadiusProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionIndicatorDisabledBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionIndicatorModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionIndicatorPointerOverBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionIndicatorPressedBrushProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectionIndicatorVisualEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ListViewItemPresenterCheckMode extends System.Enum {
+      value__: number;
+      static Inline: number;
+      static Overlay: number;
+    }
+    class ListViewItemPresenterSelectionIndicatorMode extends System.Enum {
+      value__: number;
+      static Inline: number;
+      static Overlay: number;
+    }
+    class ListViewItemTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.IListViewItemTemplateSettings {
+      readonly DragItemsCount: number;
+    }
+    class LoopingSelector extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.Primitives.ILoopingSelector {
+      SelectionChanged: Microsoft.UI.Xaml.Controls.SelectionChangedEventHandler | null;
+      ShouldLoop: boolean;
+      SelectedItem: any;
+      SelectedIndex: number;
+      Items: System.Collections.Generic.IList<any>;
+      ItemWidth: number;
+      ItemTemplate: Microsoft.UI.Xaml.DataTemplate;
+      ItemHeight: number;
+      static readonly ItemHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemTemplateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedIndexProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SelectedItemProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ShouldLoopProperty: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class LoopingSelectorItem extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.Primitives.ILoopingSelectorItem {
+    }
+    class LoopingSelectorPanel extends Microsoft.UI.Xaml.Controls.Canvas implements Microsoft.UI.Xaml.Controls.Primitives.ILoopingSelectorPanel, Microsoft.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo {
+      HorizontalSnapPointsChanged: System.EventHandler<any> | null;
+      VerticalSnapPointsChanged: System.EventHandler<any> | null;
+      readonly AreHorizontalSnapPointsRegular: boolean;
+      readonly AreVerticalSnapPointsRegular: boolean;
+      GetIrregularSnapPoints(result: number, orientation: number): System.Collections.Generic.IReadOnlyList<number>;
+      GetRegularSnapPoints(returnValue: number, orientation: number, alignment: number): number;
+    }
+    class MenuFlyoutItemTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.IMenuFlyoutItemTemplateSettings {
+      readonly KeyboardAcceleratorTextMinWidth: number;
+    }
+    class MenuFlyoutPresenterTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.IMenuFlyoutPresenterTemplateSettings {
+      readonly FlyoutContentMinWidth: number;
+    }
+    class MonochromaticOverlayPresenter extends Microsoft.UI.Xaml.Controls.Grid implements Microsoft.UI.Xaml.Controls.Primitives.IMonochromaticOverlayPresenter {
+      SourceElement: Microsoft.UI.Xaml.UIElement;
+      ReplacementColor: Windows.UI.Color;
+      static readonly ReplacementColorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SourceElementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class NavigationViewItemPresenter extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.Primitives.INavigationViewItemPresenter, Microsoft.UI.Xaml.Controls.Primitives.INavigationViewItemPresenter2 {
+      Icon: Microsoft.UI.Xaml.Controls.IconElement;
+      readonly TemplateSettings: Microsoft.UI.Xaml.Controls.Primitives.NavigationViewItemPresenterTemplateSettings;
+      InfoBadge: Microsoft.UI.Xaml.Controls.InfoBadge;
+      static readonly IconProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TemplateSettingsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly InfoBadgeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class NavigationViewItemPresenterTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.INavigationViewItemPresenterTemplateSettings {
+      readonly IconWidth: number;
+      readonly SmallerIconWidth: number;
+      static readonly IconWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SmallerIconWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class OrientedVirtualizingPanel extends Microsoft.UI.Xaml.Controls.VirtualizingPanel implements Microsoft.UI.Xaml.Controls.Primitives.IOrientedVirtualizingPanel, Microsoft.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo, Microsoft.UI.Xaml.Controls.IInsertionPanel {
+      HorizontalSnapPointsChanged: System.EventHandler<any> | null;
+      VerticalSnapPointsChanged: System.EventHandler<any> | null;
+      ScrollOwner: any;
+      CanVerticallyScroll: boolean;
+      CanHorizontallyScroll: boolean;
+      readonly ExtentHeight: number;
+      readonly ExtentWidth: number;
+      readonly HorizontalOffset: number;
+      readonly VerticalOffset: number;
+      readonly ViewportHeight: number;
+      readonly ViewportWidth: number;
+      readonly AreHorizontalSnapPointsRegular: boolean;
+      readonly AreVerticalSnapPointsRegular: boolean;
+      LineUp(): void;
+      LineDown(): void;
+      LineLeft(): void;
+      LineRight(): void;
+      PageUp(): void;
+      PageDown(): void;
+      PageLeft(): void;
+      PageRight(): void;
+      MouseWheelUp(): void;
+      MouseWheelDown(): void;
+      MouseWheelLeft(): void;
+      MouseWheelRight(): void;
+      SetHorizontalOffset(offset: number): void;
+      SetVerticalOffset(offset: number): void;
+      MakeVisible(result: Microsoft.UI.Xaml.UIElement, visual: Windows.Foundation.Rect): Windows.Foundation.Rect;
+      GetIrregularSnapPoints(result: number, orientation: number): System.Collections.Generic.IReadOnlyList<number>;
+      GetRegularSnapPoints(returnValue: number, orientation: number, alignment: number): number;
+      GetInsertionIndexes(position: Windows.Foundation.Point, first: number, second: number): void;
+    }
+    class PivotHeaderItem extends Microsoft.UI.Xaml.Controls.ContentControl implements Microsoft.UI.Xaml.Controls.Primitives.IPivotHeaderItem {
+      constructor();
+    }
+    class PivotHeaderPanel extends Microsoft.UI.Xaml.Controls.Canvas implements Microsoft.UI.Xaml.Controls.Primitives.IPivotHeaderPanel {
+      constructor();
+    }
+    class PivotPanel extends Microsoft.UI.Xaml.Controls.Panel implements Microsoft.UI.Xaml.Controls.Primitives.IPivotPanel, Microsoft.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo {
+      HorizontalSnapPointsChanged: System.EventHandler<any> | null;
+      VerticalSnapPointsChanged: System.EventHandler<any> | null;
+      readonly AreHorizontalSnapPointsRegular: boolean;
+      readonly AreVerticalSnapPointsRegular: boolean;
+      constructor();
+      GetIrregularSnapPoints(result: number, orientation: number): System.Collections.Generic.IReadOnlyList<number>;
+      GetRegularSnapPoints(returnValue: number, orientation: number, alignment: number): number;
+    }
+    class PlacementMode extends System.Enum {
+      value__: number;
+      static Bottom: number;
+      static Left: number;
+      static Mouse: number;
+      static Right: number;
+      static Top: number;
+    }
+    class Popup extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.Primitives.IPopup, Microsoft.UI.Xaml.Controls.Primitives.IPopup2, Microsoft.UI.Xaml.Controls.Primitives.IPopup3 {
+      Closed: System.EventHandler<any> | null;
+      Opened: System.EventHandler<any> | null;
+      ActualPlacementChanged: System.EventHandler<any> | null;
+      VerticalOffset: number;
+      ShouldConstrainToRootBounds: boolean;
+      LightDismissOverlayMode: number;
+      IsOpen: boolean;
+      IsLightDismissEnabled: boolean;
+      HorizontalOffset: number;
+      ChildTransitions: Microsoft.UI.Xaml.Media.Animation.TransitionCollection;
+      Child: Microsoft.UI.Xaml.UIElement;
+      readonly IsConstrainedToRootBounds: boolean;
+      PlacementTarget: Microsoft.UI.Xaml.FrameworkElement;
+      DesiredPlacement: number;
+      readonly ActualPlacement: number;
+      SystemBackdrop: Microsoft.UI.Xaml.Media.SystemBackdrop;
+      static readonly ChildProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ChildTransitionsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsLightDismissEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsOpenProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LightDismissOverlayModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ShouldConstrainToRootBoundsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DesiredPlacementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PlacementTargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SystemBackdropProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PopupPlacementMode extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Top: number;
+      static Bottom: number;
+      static Left: number;
+      static Right: number;
+      static TopEdgeAlignedLeft: number;
+      static TopEdgeAlignedRight: number;
+      static BottomEdgeAlignedLeft: number;
+      static BottomEdgeAlignedRight: number;
+      static LeftEdgeAlignedTop: number;
+      static LeftEdgeAlignedBottom: number;
+      static RightEdgeAlignedTop: number;
+      static RightEdgeAlignedBottom: number;
+    }
+    class RangeBaseValueChangedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Controls.Primitives.IRangeBaseValueChangedEventArgs {
+      readonly NewValue: number;
+      readonly OldValue: number;
+    }
+    class RangeBaseValueChangedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventArgs): void;
+    }
+    class RepeatButton extends Microsoft.UI.Xaml.Controls.Primitives.ButtonBase implements Microsoft.UI.Xaml.Controls.Primitives.IRepeatButton {
+      Interval: number;
+      Delay: number;
+      static readonly DelayProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IntervalProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class SnapPointBase implements Microsoft.UI.Xaml.Controls.Primitives.ISnapPointBase {
+    }
+    class ScrollSnapPointBase extends Microsoft.UI.Xaml.Controls.Primitives.SnapPointBase implements Microsoft.UI.Xaml.Controls.Primitives.IScrollSnapPointBase {
+      readonly Alignment: number;
+    }
+    class RepeatedScrollSnapPoint extends Microsoft.UI.Xaml.Controls.Primitives.ScrollSnapPointBase implements Microsoft.UI.Xaml.Controls.Primitives.IRepeatedScrollSnapPoint {
+      readonly End: number;
+      readonly Interval: number;
+      readonly Offset: number;
+      readonly Start: number;
+      constructor(offset: number, interval: number, start: number, end: number, alignment: number);
+    }
+    class ZoomSnapPointBase extends Microsoft.UI.Xaml.Controls.Primitives.SnapPointBase implements Microsoft.UI.Xaml.Controls.Primitives.IZoomSnapPointBase {
+    }
+    class RepeatedZoomSnapPoint extends Microsoft.UI.Xaml.Controls.Primitives.ZoomSnapPointBase implements Microsoft.UI.Xaml.Controls.Primitives.IRepeatedZoomSnapPoint {
+      readonly End: number;
+      readonly Interval: number;
+      readonly Offset: number;
+      readonly Start: number;
+      constructor(offset: number, interval: number, start: number, end: number);
+    }
+    class ScrollBar extends Microsoft.UI.Xaml.Controls.Primitives.RangeBase implements Microsoft.UI.Xaml.Controls.Primitives.IScrollBar {
+      Scroll: Microsoft.UI.Xaml.Controls.Primitives.ScrollEventHandler | null;
+      ViewportSize: number;
+      Orientation: number;
+      IndicatorMode: number;
+      static readonly IndicatorModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OrientationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ViewportSizeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ScrollControllerAddScrollVelocityRequestedEventArgs implements Microsoft.UI.Xaml.Controls.Primitives.IScrollControllerAddScrollVelocityRequestedEventArgs {
+      CorrelationId: number;
+      readonly InertiaDecayRate: System.Nullable<number>;
+      readonly OffsetVelocity: number;
+      constructor(offsetVelocity: number, inertiaDecayRate: System.Nullable<number>);
+    }
+    class ScrollControllerPanRequestedEventArgs implements Microsoft.UI.Xaml.Controls.Primitives.IScrollControllerPanRequestedEventArgs {
+      Handled: boolean;
+      readonly PointerPoint: Microsoft.UI.Input.PointerPoint;
+      constructor(pointerPoint: Microsoft.UI.Input.PointerPoint);
+    }
+    class ScrollControllerScrollByRequestedEventArgs implements Microsoft.UI.Xaml.Controls.Primitives.IScrollControllerScrollByRequestedEventArgs {
+      CorrelationId: number;
+      readonly OffsetDelta: number;
+      readonly Options: Microsoft.UI.Xaml.Controls.ScrollingScrollOptions;
+      constructor(offsetDelta: number, options: Microsoft.UI.Xaml.Controls.ScrollingScrollOptions);
+    }
+    class ScrollControllerScrollToRequestedEventArgs implements Microsoft.UI.Xaml.Controls.Primitives.IScrollControllerScrollToRequestedEventArgs {
+      CorrelationId: number;
+      readonly Offset: number;
+      readonly Options: Microsoft.UI.Xaml.Controls.ScrollingScrollOptions;
+      constructor(offset: number, options: Microsoft.UI.Xaml.Controls.ScrollingScrollOptions);
+    }
+    class ScrollEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Controls.Primitives.IScrollEventArgs {
+      readonly NewValue: number;
+      readonly ScrollEventType: number;
+      constructor();
+    }
+    class ScrollEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Controls.Primitives.ScrollEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Controls.Primitives.ScrollEventArgs): void;
+    }
+    class ScrollEventType extends System.Enum {
+      value__: number;
+      static SmallDecrement: number;
+      static SmallIncrement: number;
+      static LargeDecrement: number;
+      static LargeIncrement: number;
+      static ThumbPosition: number;
+      static ThumbTrack: number;
+      static First: number;
+      static Last: number;
+      static EndScroll: number;
+    }
+    class ScrollPresenter extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.Primitives.IScrollPresenter, Microsoft.UI.Xaml.Controls.IScrollAnchorProvider {
+      AnchorRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Primitives.ScrollPresenter, Microsoft.UI.Xaml.Controls.ScrollingAnchorRequestedEventArgs> | null;
+      BringingIntoView: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Primitives.ScrollPresenter, Microsoft.UI.Xaml.Controls.ScrollingBringingIntoViewEventArgs> | null;
+      ExtentChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Primitives.ScrollPresenter, any> | null;
+      ScrollAnimationStarting: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Primitives.ScrollPresenter, Microsoft.UI.Xaml.Controls.ScrollingScrollAnimationStartingEventArgs> | null;
+      ScrollCompleted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Primitives.ScrollPresenter, Microsoft.UI.Xaml.Controls.ScrollingScrollCompletedEventArgs> | null;
+      StateChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Primitives.ScrollPresenter, any> | null;
+      ViewChanged: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Primitives.ScrollPresenter, any> | null;
+      ZoomAnimationStarting: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Primitives.ScrollPresenter, Microsoft.UI.Xaml.Controls.ScrollingZoomAnimationStartingEventArgs> | null;
+      ZoomCompleted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Controls.Primitives.ScrollPresenter, Microsoft.UI.Xaml.Controls.ScrollingZoomCompletedEventArgs> | null;
+      readonly CurrentAnchor: Microsoft.UI.Xaml.UIElement;
+      IgnoredInputKinds: number;
+      HorizontalAnchorRatio: number;
+      MaxZoomFactor: number;
+      HorizontalScrollRailMode: number;
+      HorizontalScrollMode: number;
+      ContentOrientation: number;
+      Content: Microsoft.UI.Xaml.UIElement;
+      HorizontalScrollController: Microsoft.UI.Xaml.Controls.Primitives.IScrollController;
+      HorizontalScrollChainMode: number;
+      MinZoomFactor: number;
+      Background: Microsoft.UI.Xaml.Media.Brush;
+      ZoomMode: number;
+      ZoomChainMode: number;
+      VerticalScrollRailMode: number;
+      VerticalScrollMode: number;
+      VerticalScrollController: Microsoft.UI.Xaml.Controls.Primitives.IScrollController;
+      VerticalScrollChainMode: number;
+      VerticalAnchorRatio: number;
+      readonly ComputedHorizontalScrollMode: number;
+      readonly ComputedVerticalScrollMode: number;
+      readonly ExpressionAnimationSources: Microsoft.UI.Composition.CompositionPropertySet;
+      readonly ExtentHeight: number;
+      readonly ExtentWidth: number;
+      readonly HorizontalOffset: number;
+      readonly HorizontalSnapPoints: System.Collections.Generic.IList<Microsoft.UI.Xaml.Controls.Primitives.ScrollSnapPointBase>;
+      readonly ScrollableHeight: number;
+      readonly ScrollableWidth: number;
+      readonly State: number;
+      readonly VerticalOffset: number;
+      readonly VerticalSnapPoints: System.Collections.Generic.IList<Microsoft.UI.Xaml.Controls.Primitives.ScrollSnapPointBase>;
+      readonly ViewportHeight: number;
+      readonly ViewportWidth: number;
+      readonly ZoomFactor: number;
+      readonly ZoomSnapPoints: System.Collections.Generic.IList<Microsoft.UI.Xaml.Controls.Primitives.ZoomSnapPointBase>;
+      static readonly BackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ComputedHorizontalScrollModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ComputedVerticalScrollModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentOrientationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalAnchorRatioProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalScrollChainModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalScrollModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HorizontalScrollRailModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IgnoredInputKindsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MaxZoomFactorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MinZoomFactorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalAnchorRatioProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalScrollChainModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalScrollModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalScrollRailModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ZoomChainModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ZoomModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      ScrollTo(result: number, horizontalOffset: number): number;
+      ScrollTo(result: number, horizontalOffset: number, verticalOffset: Microsoft.UI.Xaml.Controls.ScrollingScrollOptions): number;
+      ScrollBy(result: number, horizontalOffsetDelta: number): number;
+      ScrollBy(result: number, horizontalOffsetDelta: number, verticalOffsetDelta: Microsoft.UI.Xaml.Controls.ScrollingScrollOptions): number;
+      AddScrollVelocity(result: System.Numerics.Vector2, offsetsVelocity: System.Nullable<System.Numerics.Vector2>): number;
+      ZoomTo(result: number, zoomFactor: System.Nullable<System.Numerics.Vector2>): number;
+      ZoomTo(result: number, zoomFactor: System.Nullable<System.Numerics.Vector2>, centerPoint: Microsoft.UI.Xaml.Controls.ScrollingZoomOptions): number;
+      ZoomBy(result: number, zoomFactorDelta: System.Nullable<System.Numerics.Vector2>): number;
+      ZoomBy(result: number, zoomFactorDelta: System.Nullable<System.Numerics.Vector2>, centerPoint: Microsoft.UI.Xaml.Controls.ScrollingZoomOptions): number;
+      AddZoomVelocity(result: number, zoomFactorVelocity: System.Nullable<System.Numerics.Vector2>, centerPoint: System.Nullable<number>): number;
+      RegisterAnchorCandidate(element: Microsoft.UI.Xaml.UIElement): void;
+      UnregisterAnchorCandidate(element: Microsoft.UI.Xaml.UIElement): void;
+    }
+    class ScrollSnapPoint extends Microsoft.UI.Xaml.Controls.Primitives.ScrollSnapPointBase implements Microsoft.UI.Xaml.Controls.Primitives.IScrollSnapPoint {
+      readonly Value: number;
+      constructor(snapPointValue: number, alignment: number);
+    }
+    class ScrollSnapPointsAlignment extends System.Enum {
+      value__: number;
+      static Near: number;
+      static Center: number;
+      static Far: number;
+    }
+    class ScrollingIndicatorMode extends System.Enum {
+      value__: number;
+      static None: number;
+      static TouchIndicator: number;
+      static MouseIndicator: number;
+    }
+    class SliderSnapsTo extends System.Enum {
+      value__: number;
+      static StepValues: number;
+      static Ticks: number;
+    }
+    class SnapPointsAlignment extends System.Enum {
+      value__: number;
+      static Near: number;
+      static Center: number;
+      static Far: number;
+    }
+    class SplitViewTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.ISplitViewTemplateSettings {
+      readonly CompactPaneGridLength: Microsoft.UI.Xaml.GridLength;
+      readonly NegativeOpenPaneLength: number;
+      readonly NegativeOpenPaneLengthMinusCompactLength: number;
+      readonly OpenPaneGridLength: Microsoft.UI.Xaml.GridLength;
+      readonly OpenPaneLength: number;
+      readonly OpenPaneLengthMinusCompactLength: number;
+    }
+    class TabViewListView extends Microsoft.UI.Xaml.Controls.ListView implements Microsoft.UI.Xaml.Controls.Primitives.ITabViewListView {
+      constructor();
+    }
+    class Thumb extends Microsoft.UI.Xaml.Controls.Control implements Microsoft.UI.Xaml.Controls.Primitives.IThumb {
+      DragCompleted: Microsoft.UI.Xaml.Controls.Primitives.DragCompletedEventHandler | null;
+      DragDelta: Microsoft.UI.Xaml.Controls.Primitives.DragDeltaEventHandler | null;
+      DragStarted: Microsoft.UI.Xaml.Controls.Primitives.DragStartedEventHandler | null;
+      readonly IsDragging: boolean;
+      static readonly IsDraggingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      CancelDrag(): void;
+    }
+    class TickBar extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Controls.Primitives.ITickBar {
+      Fill: Microsoft.UI.Xaml.Media.Brush;
+      static readonly FillProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class TickPlacement extends System.Enum {
+      value__: number;
+      static None: number;
+      static TopLeft: number;
+      static BottomRight: number;
+      static Outside: number;
+      static Inline: number;
+    }
+    class ToggleSwitchTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.IToggleSwitchTemplateSettings {
+      readonly CurtainCurrentToOffOffset: number;
+      readonly CurtainCurrentToOnOffset: number;
+      readonly CurtainOffToOnOffset: number;
+      readonly CurtainOnToOffOffset: number;
+      readonly KnobCurrentToOffOffset: number;
+      readonly KnobCurrentToOnOffset: number;
+      readonly KnobOffToOnOffset: number;
+      readonly KnobOnToOffOffset: number;
+    }
+    class ToolTipTemplateSettings extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Controls.Primitives.IToolTipTemplateSettings {
+      readonly FromHorizontalOffset: number;
+      readonly FromVerticalOffset: number;
+    }
+    class ZoomSnapPoint extends Microsoft.UI.Xaml.Controls.Primitives.ZoomSnapPointBase implements Microsoft.UI.Xaml.Controls.Primitives.IZoomSnapPoint {
+      readonly Value: number;
+      constructor(snapPointValue: number);
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.CustomAttributes {
+    class MUXHasCustomActivationFactoryAttribute extends System.Attribute {
+      constructor();
+    }
+    class MUXOverrideEnsurePropertiesAttribute extends System.Attribute {
+      constructor();
+    }
+    class MUXPropertyChangedCallbackAttribute extends System.Attribute {
+      enable: boolean;
+      constructor();
+    }
+    class MUXPropertyChangedCallbackMethodNameAttribute extends System.Attribute {
+      value: string;
+      constructor();
+    }
+    class MUXPropertyDefaultValueAttribute extends System.Attribute {
+      value: string;
+      constructor();
+    }
+    class MUXPropertyNeedsDependencyPropertyFieldAttribute extends System.Attribute {
+      constructor();
+    }
+    class MUXPropertyTypeAttribute extends System.Attribute {
+      value: string;
+      constructor();
+    }
+    class MUXPropertyValidationCallbackAttribute extends System.Attribute {
+      value: string;
+      constructor();
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Data {
+    class BindableAttribute extends System.Attribute {
+      constructor();
+    }
+    class BindingBase extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Data.IBindingBase {
+      constructor();
+    }
+    class Binding extends Microsoft.UI.Xaml.Data.BindingBase implements Microsoft.UI.Xaml.Data.IBinding {
+      UpdateSourceTrigger: number;
+      TargetNullValue: any;
+      Source: any;
+      RelativeSource: Microsoft.UI.Xaml.Data.RelativeSource;
+      Path: Microsoft.UI.Xaml.PropertyPath;
+      Mode: number;
+      FallbackValue: any;
+      ElementName: string;
+      ConverterParameter: any;
+      ConverterLanguage: string;
+      Converter: Microsoft.UI.Xaml.Data.IValueConverter;
+      constructor();
+    }
+    class BindingExpressionBase implements Microsoft.UI.Xaml.Data.IBindingExpressionBase {
+    }
+    class BindingExpression extends Microsoft.UI.Xaml.Data.BindingExpressionBase implements Microsoft.UI.Xaml.Data.IBindingExpression {
+      readonly DataItem: any;
+      readonly ParentBinding: Microsoft.UI.Xaml.Data.Binding;
+      UpdateSource(): void;
+    }
+    class BindingMode extends System.Enum {
+      value__: number;
+      static OneWay: number;
+      static OneTime: number;
+      static TwoWay: number;
+    }
+    class BindingOperations implements Microsoft.UI.Xaml.Data.IBindingOperations {
+      static SetBinding(target: Microsoft.UI.Xaml.DependencyObject, dp: Microsoft.UI.Xaml.DependencyProperty, binding: Microsoft.UI.Xaml.Data.BindingBase): void;
+    }
+    class CollectionViewSource extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Data.ICollectionViewSource {
+      Source: any;
+      ItemsPath: Microsoft.UI.Xaml.PropertyPath;
+      IsSourceGrouped: boolean;
+      readonly View: Microsoft.UI.Xaml.Data.ICollectionView;
+      static readonly IsSourceGroupedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ItemsPathProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ViewProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class CurrentChangingEventArgs implements Microsoft.UI.Xaml.Data.ICurrentChangingEventArgs {
+      Cancel: boolean;
+      readonly IsCancelable: boolean;
+      constructor();
+      constructor(isCancelable: boolean);
+    }
+    class CurrentChangingEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Data.CurrentChangingEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Data.CurrentChangingEventArgs): void;
+    }
+    class DataErrorsChangedEventArgs implements Microsoft.UI.Xaml.Data.IDataErrorsChangedEventArgs {
+      PropertyName: string;
+      constructor(name: string);
+    }
+    interface ICollectionView extends Windows.Foundation.Collections.IObservableVector<any> {
+      CurrentChanged: System.EventHandler<any> | null;
+      CurrentChanging: Microsoft.UI.Xaml.Data.CurrentChangingEventHandler | null;
+      readonly CollectionGroups: Windows.Foundation.Collections.IObservableVector<any>;
+      readonly CurrentItem: any;
+      readonly CurrentPosition: number;
+      readonly HasMoreItems: boolean;
+      readonly IsCurrentAfterLast: boolean;
+      readonly IsCurrentBeforeFirst: boolean;
+      MoveCurrentTo(result: any): boolean;
+      MoveCurrentToPosition(result: number): boolean;
+      MoveCurrentToFirst(): boolean;
+      MoveCurrentToLast(): boolean;
+      MoveCurrentToNext(): boolean;
+      MoveCurrentToPrevious(): boolean;
+      LoadMoreItemsAsync(operation: number): Windows.Foundation.IAsyncOperation<Microsoft.UI.Xaml.Data.LoadMoreItemsResult>;
+    }
+    interface ICollectionViewFactory {
+      CreateView(): Microsoft.UI.Xaml.Data.ICollectionView;
+    }
+    interface ICollectionViewGroup {
+      readonly Group: any;
+      readonly GroupItems: Windows.Foundation.Collections.IObservableVector<any>;
+    }
+    interface ICustomProperty {
+      readonly CanRead: boolean;
+      readonly CanWrite: boolean;
+      readonly Name: string;
+      readonly Type: System.Type;
+      GetValue(result: any): any;
+      SetValue(target: any, value: any): void;
+      GetIndexedValue(result: any, target: any): any;
+      SetIndexedValue(target: any, value: any, index: any): void;
+    }
+    interface ICustomPropertyProvider {
+      readonly Type: System.Type;
+      GetCustomProperty(result: string): Microsoft.UI.Xaml.Data.ICustomProperty;
+      GetIndexedProperty(result: string, name: System.Type): Microsoft.UI.Xaml.Data.ICustomProperty;
+      GetStringRepresentation(): string;
+    }
+    interface IItemsRangeInfo {
+      RangesChanged(visibleRange: Microsoft.UI.Xaml.Data.ItemIndexRange, trackedItems: System.Collections.Generic.IReadOnlyList<Microsoft.UI.Xaml.Data.ItemIndexRange>): void;
+    }
+    interface INotifyDataErrorInfo {
+      ErrorsChanged: System.EventHandler<Microsoft.UI.Xaml.Data.DataErrorsChangedEventArgs> | null;
+      readonly HasErrors: boolean;
+      GetErrors(result: string): System.Collections.Generic.IEnumerable<any>;
+    }
+    interface INotifyPropertyChanged {
+      PropertyChanged: Microsoft.UI.Xaml.Data.PropertyChangedEventHandler | null;
+    }
+    interface ISelectionInfo {
+      SelectRange(itemIndexRange: Microsoft.UI.Xaml.Data.ItemIndexRange): void;
+      DeselectRange(itemIndexRange: Microsoft.UI.Xaml.Data.ItemIndexRange): void;
+      IsSelected(result: number): boolean;
+      GetSelectedRanges(): System.Collections.Generic.IReadOnlyList<Microsoft.UI.Xaml.Data.ItemIndexRange>;
+    }
+    interface ISupportIncrementalLoading {
+      readonly HasMoreItems: boolean;
+      LoadMoreItemsAsync(operation: number): Windows.Foundation.IAsyncOperation<Microsoft.UI.Xaml.Data.LoadMoreItemsResult>;
+    }
+    interface IValueConverter {
+      Convert(result: any, value: System.Type, targetType: any, parameter: string): any;
+      ConvertBack(result: any, value: System.Type, targetType: any, parameter: string): any;
+    }
+    class ItemIndexRange implements Microsoft.UI.Xaml.Data.IItemIndexRange {
+      readonly FirstIndex: number;
+      readonly LastIndex: number;
+      readonly Length: number;
+      constructor(firstIndex: number, length: number);
+    }
+    class LoadMoreItemsResult extends System.ValueType {
+      Count: number;
+    }
+    class PropertyChangedEventArgs implements Microsoft.UI.Xaml.Data.IPropertyChangedEventArgs {
+      readonly PropertyName: string;
+      constructor(name: string);
+    }
+    class PropertyChangedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Data.PropertyChangedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Data.PropertyChangedEventArgs): void;
+    }
+    class RelativeSource extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Data.IRelativeSource {
+      Mode: number;
+      constructor();
+    }
+    class RelativeSourceMode extends System.Enum {
+      value__: number;
+      static None: number;
+      static TemplatedParent: number;
+      static Self: number;
+    }
+    class UpdateSourceTrigger extends System.Enum {
+      value__: number;
+      static Default: number;
+      static PropertyChanged: number;
+      static Explicit: number;
+      static LostFocus: number;
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Documents {
+    class TextElement extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Documents.ITextElement, Microsoft.UI.Xaml.Documents.ITextElementOverrides {
+      AccessKeyDisplayDismissed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Documents.TextElement, Microsoft.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs> | null;
+      AccessKeyDisplayRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Documents.TextElement, Microsoft.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs> | null;
+      AccessKeyInvoked: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Documents.TextElement, Microsoft.UI.Xaml.Input.AccessKeyInvokedEventArgs> | null;
+      XamlRoot: Microsoft.UI.Xaml.XamlRoot;
+      TextDecorations: Windows.UI.Text.TextDecorations;
+      Language: string;
+      KeyTipVerticalOffset: number;
+      KeyTipPlacementMode: number;
+      KeyTipHorizontalOffset: number;
+      IsTextScaleFactorEnabled: boolean;
+      IsAccessKeyScope: boolean;
+      Foreground: Microsoft.UI.Xaml.Media.Brush;
+      FontWeight: Windows.UI.Text.FontWeight;
+      FontStyle: Windows.UI.Text.FontStyle;
+      FontStretch: Windows.UI.Text.FontStretch;
+      FontSize: number;
+      FontFamily: Microsoft.UI.Xaml.Media.FontFamily;
+      ExitDisplayModeOnAccessKeyInvoked: boolean;
+      CharacterSpacing: number;
+      AllowFocusOnInteraction: boolean;
+      AccessKeyScopeOwner: Microsoft.UI.Xaml.DependencyObject;
+      AccessKey: string;
+      readonly ContentEnd: Microsoft.UI.Xaml.Documents.TextPointer;
+      readonly ContentStart: Microsoft.UI.Xaml.Documents.TextPointer;
+      readonly ElementEnd: Microsoft.UI.Xaml.Documents.TextPointer;
+      readonly ElementStart: Microsoft.UI.Xaml.Documents.TextPointer;
+      readonly Name: string;
+      static readonly AccessKeyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AccessKeyScopeOwnerProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AllowFocusOnInteractionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CharacterSpacingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ExitDisplayModeOnAccessKeyInvokedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontFamilyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontSizeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontStretchProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontWeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsAccessKeyScopeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTextScaleFactorEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly KeyTipHorizontalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly KeyTipPlacementModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly KeyTipVerticalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LanguageProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextDecorationsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      FindName(result: string): any;
+    }
+    class Block extends Microsoft.UI.Xaml.Documents.TextElement implements Microsoft.UI.Xaml.Documents.IBlock {
+      TextAlignment: number;
+      Margin: Microsoft.UI.Xaml.Thickness;
+      LineStackingStrategy: number;
+      LineHeight: number;
+      HorizontalTextAlignment: number;
+      static readonly HorizontalTextAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LineHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LineStackingStrategyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MarginProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TextAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class BlockCollection {
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class Inline extends Microsoft.UI.Xaml.Documents.TextElement implements Microsoft.UI.Xaml.Documents.IInline {
+    }
+    class Span extends Microsoft.UI.Xaml.Documents.Inline implements Microsoft.UI.Xaml.Documents.ISpan {
+      Inlines: Microsoft.UI.Xaml.Documents.InlineCollection;
+      constructor();
+    }
+    class Bold extends Microsoft.UI.Xaml.Documents.Span implements Microsoft.UI.Xaml.Documents.IBold {
+      constructor();
+    }
+    class Glyphs extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Documents.IGlyphs {
+      UnicodeString: string;
+      StyleSimulations: number;
+      OriginY: number;
+      OriginX: number;
+      IsColorFontEnabled: boolean;
+      Indices: string;
+      FontUri: System.Uri;
+      FontRenderingEmSize: number;
+      Fill: Microsoft.UI.Xaml.Media.Brush;
+      ColorFontPaletteIndex: number;
+      static readonly ColorFontPaletteIndexProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FillProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontRenderingEmSizeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FontUriProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IndicesProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsColorFontEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OriginXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OriginYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StyleSimulationsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly UnicodeStringProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class Hyperlink extends Microsoft.UI.Xaml.Documents.Span implements Microsoft.UI.Xaml.Documents.IHyperlink {
+      Click: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Documents.Hyperlink, Microsoft.UI.Xaml.Documents.HyperlinkClickEventArgs> | null;
+      GotFocus: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      LostFocus: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      XYFocusUpNavigationStrategy: number;
+      XYFocusUp: Microsoft.UI.Xaml.DependencyObject;
+      XYFocusRightNavigationStrategy: number;
+      XYFocusRight: Microsoft.UI.Xaml.DependencyObject;
+      XYFocusLeftNavigationStrategy: number;
+      XYFocusLeft: Microsoft.UI.Xaml.DependencyObject;
+      XYFocusDownNavigationStrategy: number;
+      XYFocusDown: Microsoft.UI.Xaml.DependencyObject;
+      UnderlineStyle: number;
+      TabIndex: number;
+      NavigateUri: System.Uri;
+      IsTabStop: boolean;
+      ElementSoundMode: number;
+      readonly FocusState: number;
+      static readonly ElementSoundModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FocusStateProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsTabStopProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly NavigateUriProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TabIndexProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly UnderlineStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly XYFocusDownNavigationStrategyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly XYFocusDownProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly XYFocusLeftNavigationStrategyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly XYFocusLeftProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly XYFocusRightNavigationStrategyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly XYFocusRightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly XYFocusUpNavigationStrategyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly XYFocusUpProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      Focus(result: number): boolean;
+    }
+    class HyperlinkClickEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Documents.IHyperlinkClickEventArgs {
+    }
+    class InlineCollection {
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class InlineUIContainer extends Microsoft.UI.Xaml.Documents.Inline implements Microsoft.UI.Xaml.Documents.IInlineUIContainer {
+      Child: Microsoft.UI.Xaml.UIElement;
+      constructor();
+    }
+    class Italic extends Microsoft.UI.Xaml.Documents.Span implements Microsoft.UI.Xaml.Documents.IItalic {
+      constructor();
+    }
+    class LineBreak extends Microsoft.UI.Xaml.Documents.Inline implements Microsoft.UI.Xaml.Documents.ILineBreak {
+      constructor();
+    }
+    class LogicalDirection extends System.Enum {
+      value__: number;
+      static Backward: number;
+      static Forward: number;
+    }
+    class Paragraph extends Microsoft.UI.Xaml.Documents.Block implements Microsoft.UI.Xaml.Documents.IParagraph {
+      TextIndent: number;
+      readonly Inlines: Microsoft.UI.Xaml.Documents.InlineCollection;
+      static readonly TextIndentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class Run extends Microsoft.UI.Xaml.Documents.Inline implements Microsoft.UI.Xaml.Documents.IRun {
+      Text: string;
+      FlowDirection: number;
+      static readonly FlowDirectionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class TextHighlighter implements Microsoft.UI.Xaml.Documents.ITextHighlighter {
+      Foreground: Microsoft.UI.Xaml.Media.Brush;
+      Background: Microsoft.UI.Xaml.Media.Brush;
+      readonly Ranges: System.Collections.Generic.IList<Microsoft.UI.Xaml.Documents.TextRange>;
+      static readonly BackgroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ForegroundProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class TextHighlighterBase extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Documents.ITextHighlighterBase {
+    }
+    class TextPointer implements Microsoft.UI.Xaml.Documents.ITextPointer {
+      readonly LogicalDirection: number;
+      readonly Offset: number;
+      readonly Parent: Microsoft.UI.Xaml.DependencyObject;
+      readonly VisualParent: Microsoft.UI.Xaml.FrameworkElement;
+      GetCharacterRect(result: number): Windows.Foundation.Rect;
+      GetPositionAtOffset(result: number, offset: number): Microsoft.UI.Xaml.Documents.TextPointer;
+    }
+    class TextRange extends System.ValueType {
+      StartIndex: number;
+      Length: number;
+    }
+    class Typography implements Microsoft.UI.Xaml.Documents.ITypography {
+      static readonly AnnotationAlternatesProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CapitalSpacingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CapitalsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CaseSensitiveFormsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContextualAlternatesProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContextualLigaturesProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContextualSwashesProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DiscretionaryLigaturesProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly EastAsianExpertFormsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly EastAsianLanguageProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly EastAsianWidthsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FractionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HistoricalFormsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly HistoricalLigaturesProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly KerningProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MathematicalGreekProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly NumeralAlignmentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly NumeralStyleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SlashedZeroProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StandardLigaturesProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StandardSwashesProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticAlternatesProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet10Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet11Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet12Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet13Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet14Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet15Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet16Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet17Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet18Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet19Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet1Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet20Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet2Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet3Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet4Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet5Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet6Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet7Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet8Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StylisticSet9Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VariantsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static GetAnnotationAlternates(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetAnnotationAlternates(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetEastAsianExpertForms(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetEastAsianExpertForms(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetEastAsianLanguage(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetEastAsianLanguage(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetEastAsianWidths(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetEastAsianWidths(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetStandardLigatures(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStandardLigatures(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetContextualLigatures(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetContextualLigatures(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetDiscretionaryLigatures(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetDiscretionaryLigatures(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetHistoricalLigatures(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetHistoricalLigatures(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStandardSwashes(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetStandardSwashes(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetContextualSwashes(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetContextualSwashes(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetContextualAlternates(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetContextualAlternates(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticAlternates(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetStylisticAlternates(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetStylisticSet1(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet1(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticSet2(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet2(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticSet3(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet3(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticSet4(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet4(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticSet5(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet5(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticSet6(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet6(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticSet7(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet7(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticSet8(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet8(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticSet9(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet9(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticSet10(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet10(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticSet11(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet11(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticSet12(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet12(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticSet13(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet13(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticSet14(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet14(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticSet15(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet15(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticSet16(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet16(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticSet17(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet17(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticSet18(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet18(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticSet19(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet19(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetStylisticSet20(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetStylisticSet20(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetCapitals(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetCapitals(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetCapitalSpacing(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetCapitalSpacing(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetKerning(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetKerning(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetCaseSensitiveForms(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetCaseSensitiveForms(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetHistoricalForms(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetHistoricalForms(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetFraction(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetFraction(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetNumeralStyle(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetNumeralStyle(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetNumeralAlignment(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetNumeralAlignment(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+      static GetSlashedZero(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetSlashedZero(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetMathematicalGreek(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+      static SetMathematicalGreek(element: Microsoft.UI.Xaml.DependencyObject, value: boolean): void;
+      static GetVariants(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static SetVariants(element: Microsoft.UI.Xaml.DependencyObject, value: number): void;
+    }
+    class Underline extends Microsoft.UI.Xaml.Documents.Span implements Microsoft.UI.Xaml.Documents.IUnderline {
+      constructor();
+    }
+    class UnderlineStyle extends System.Enum {
+      value__: number;
+      static None: number;
+      static Single: number;
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Hosting {
+    class DesktopWindowXamlSource implements Microsoft.UI.Xaml.Hosting.IDesktopWindowXamlSource, Microsoft.UI.Xaml.Hosting.IDesktopWindowXamlSource2 {
+      GotFocus: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Hosting.DesktopWindowXamlSource, Microsoft.UI.Xaml.Hosting.DesktopWindowXamlSourceGotFocusEventArgs> | null;
+      TakeFocusRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Hosting.DesktopWindowXamlSource, Microsoft.UI.Xaml.Hosting.DesktopWindowXamlSourceTakeFocusRequestedEventArgs> | null;
+      SystemBackdrop: Microsoft.UI.Xaml.Media.SystemBackdrop;
+      Content: Microsoft.UI.Xaml.UIElement;
+      readonly HasFocus: boolean;
+      readonly SiteBridge: Microsoft.UI.Content.DesktopChildSiteBridge;
+      ShouldConstrainPopupsToWorkArea: boolean;
+      constructor();
+      NavigateFocus(result: Microsoft.UI.Xaml.Hosting.XamlSourceFocusNavigationRequest): Microsoft.UI.Xaml.Hosting.XamlSourceFocusNavigationResult;
+      Initialize(parentWindowId: Microsoft.UI.WindowId): void;
+      Dispose(): void;
+    }
+    class DesktopWindowXamlSourceGotFocusEventArgs implements Microsoft.UI.Xaml.Hosting.IDesktopWindowXamlSourceGotFocusEventArgs {
+      readonly Request: Microsoft.UI.Xaml.Hosting.XamlSourceFocusNavigationRequest;
+    }
+    class DesktopWindowXamlSourceTakeFocusRequestedEventArgs implements Microsoft.UI.Xaml.Hosting.IDesktopWindowXamlSourceTakeFocusRequestedEventArgs {
+      readonly Request: Microsoft.UI.Xaml.Hosting.XamlSourceFocusNavigationRequest;
+    }
+    class ElementCompositionPreview implements Microsoft.UI.Xaml.Hosting.IElementCompositionPreview {
+      static GetElementVisual(result: Microsoft.UI.Xaml.UIElement): Microsoft.UI.Composition.Visual;
+      static GetElementChildVisual(result: Microsoft.UI.Xaml.UIElement): Microsoft.UI.Composition.Visual;
+      static SetElementChildVisual(element: Microsoft.UI.Xaml.UIElement, visual: Microsoft.UI.Composition.Visual): void;
+      static GetScrollViewerManipulationPropertySet(result: Microsoft.UI.Xaml.Controls.ScrollViewer): Microsoft.UI.Composition.CompositionPropertySet;
+      static SetImplicitShowAnimation(element: Microsoft.UI.Xaml.UIElement, animation: Microsoft.UI.Composition.ICompositionAnimationBase): void;
+      static SetImplicitHideAnimation(element: Microsoft.UI.Xaml.UIElement, animation: Microsoft.UI.Composition.ICompositionAnimationBase): void;
+      static SetIsTranslationEnabled(element: Microsoft.UI.Xaml.UIElement, value: boolean): void;
+      static GetPointerPositionPropertySet(result: Microsoft.UI.Xaml.UIElement): Microsoft.UI.Composition.CompositionPropertySet;
+    }
+    class WindowsXamlManager implements Microsoft.UI.Xaml.Hosting.IWindowsXamlManager, Microsoft.UI.Xaml.Hosting.IWindowsXamlManager2 {
+      XamlShutdownCompletedOnThread: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Hosting.WindowsXamlManager, Microsoft.UI.Xaml.Hosting.XamlShutdownCompletedOnThreadEventArgs> | null;
+      Dispose(): void;
+      static GetForCurrentThread(): Microsoft.UI.Xaml.Hosting.WindowsXamlManager;
+      static InitializeForCurrentThread(): Microsoft.UI.Xaml.Hosting.WindowsXamlManager;
+    }
+    class XamlShutdownCompletedOnThreadEventArgs implements Microsoft.UI.Xaml.Hosting.IXamlShutdownCompletedOnThreadEventArgs {
+      GetDispatcherQueueDeferral(): Windows.Foundation.Deferral;
+    }
+    class XamlSourceFocusNavigationReason extends System.Enum {
+      value__: number;
+      static Programmatic: number;
+      static Restore: number;
+      static First: number;
+      static Last: number;
+      static Left: number;
+      static Up: number;
+      static Right: number;
+      static Down: number;
+    }
+    class XamlSourceFocusNavigationRequest implements Microsoft.UI.Xaml.Hosting.IXamlSourceFocusNavigationRequest {
+      readonly CorrelationId: System.Guid;
+      readonly HintRect: Windows.Foundation.Rect;
+      readonly Reason: number;
+      constructor(reason: number);
+      constructor(reason: number, hintRect: Windows.Foundation.Rect);
+      constructor(reason: number, hintRect: Windows.Foundation.Rect, correlationId: System.Guid);
+    }
+    class XamlSourceFocusNavigationResult implements Microsoft.UI.Xaml.Hosting.IXamlSourceFocusNavigationResult {
+      readonly WasFocusMoved: boolean;
+      constructor(focusMoved: boolean);
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Input {
+    class AccessKeyDisplayDismissedEventArgs implements Microsoft.UI.Xaml.Input.IAccessKeyDisplayDismissedEventArgs {
+      constructor();
+    }
+    class AccessKeyDisplayRequestedEventArgs implements Microsoft.UI.Xaml.Input.IAccessKeyDisplayRequestedEventArgs {
+      readonly PressedKeys: string;
+      constructor();
+    }
+    class AccessKeyInvokedEventArgs implements Microsoft.UI.Xaml.Input.IAccessKeyInvokedEventArgs {
+      Handled: boolean;
+      constructor();
+    }
+    class AccessKeyManager implements Microsoft.UI.Xaml.Input.IAccessKeyManager {
+      static IsDisplayModeEnabledChanged: Windows.Foundation.TypedEventHandler<any, any> | null;
+      static AreKeyTipsEnabled: boolean;
+      static readonly IsDisplayModeEnabled: boolean;
+      static EnterDisplayMode(XamlRoot: Microsoft.UI.Xaml.XamlRoot): void;
+      static ExitDisplayMode(): void;
+    }
+    class CanExecuteRequestedEventArgs implements Microsoft.UI.Xaml.Input.ICanExecuteRequestedEventArgs {
+      CanExecute: boolean;
+      readonly Parameter: any;
+    }
+    class CharacterReceivedRoutedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Input.ICharacterReceivedRoutedEventArgs {
+      Handled: boolean;
+      readonly Character: string;
+      readonly KeyStatus: Windows.UI.Core.CorePhysicalKeyStatus;
+    }
+    class ContextRequestedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Input.IContextRequestedEventArgs {
+      Handled: boolean;
+      constructor();
+      TryGetPosition(returnValue: Microsoft.UI.Xaml.UIElement, relativeTo: Windows.Foundation.Point): boolean;
+    }
+    class DoubleTappedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Input.DoubleTappedRoutedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    }
+    class DoubleTappedRoutedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Input.IDoubleTappedRoutedEventArgs {
+      Handled: boolean;
+      readonly PointerDeviceType: number;
+      constructor();
+      GetPosition(result: Microsoft.UI.Xaml.UIElement): Windows.Foundation.Point;
+    }
+    class ExecuteRequestedEventArgs implements Microsoft.UI.Xaml.Input.IExecuteRequestedEventArgs {
+      readonly Parameter: any;
+    }
+    class FindNextElementOptions implements Microsoft.UI.Xaml.Input.IFindNextElementOptions {
+      XYFocusNavigationStrategyOverride: number;
+      SearchRoot: Microsoft.UI.Xaml.DependencyObject;
+      HintRect: Windows.Foundation.Rect;
+      ExclusionRect: Windows.Foundation.Rect;
+      constructor();
+    }
+    class FocusInputDeviceKind extends System.Enum {
+      value__: number;
+      static None: number;
+      static Mouse: number;
+      static Touch: number;
+      static Pen: number;
+      static Keyboard: number;
+      static GameController: number;
+    }
+    class FocusManager implements Microsoft.UI.Xaml.Input.IFocusManager {
+      static GettingFocus: System.EventHandler<Microsoft.UI.Xaml.Input.GettingFocusEventArgs> | null;
+      static GotFocus: System.EventHandler<Microsoft.UI.Xaml.Input.FocusManagerGotFocusEventArgs> | null;
+      static LosingFocus: System.EventHandler<Microsoft.UI.Xaml.Input.LosingFocusEventArgs> | null;
+      static LostFocus: System.EventHandler<Microsoft.UI.Xaml.Input.FocusManagerLostFocusEventArgs> | null;
+      static TryFocusAsync(operation: Microsoft.UI.Xaml.DependencyObject, element: number): Windows.Foundation.IAsyncOperation<Microsoft.UI.Xaml.Input.FocusMovementResult>;
+      static TryMoveFocusAsync(operation: number): Windows.Foundation.IAsyncOperation<Microsoft.UI.Xaml.Input.FocusMovementResult>;
+      static TryMoveFocusAsync(operation: number, focusNavigationDirection: Microsoft.UI.Xaml.Input.FindNextElementOptions): Windows.Foundation.IAsyncOperation<Microsoft.UI.Xaml.Input.FocusMovementResult>;
+      static TryMoveFocus(result: number, focusNavigationDirection: Microsoft.UI.Xaml.Input.FindNextElementOptions): boolean;
+      static FindNextElement(result: number): Microsoft.UI.Xaml.DependencyObject;
+      static FindFirstFocusableElement(result: Microsoft.UI.Xaml.DependencyObject): Microsoft.UI.Xaml.DependencyObject;
+      static FindLastFocusableElement(result: Microsoft.UI.Xaml.DependencyObject): Microsoft.UI.Xaml.DependencyObject;
+      static FindNextElement(result: number, focusNavigationDirection: Microsoft.UI.Xaml.Input.FindNextElementOptions): Microsoft.UI.Xaml.DependencyObject;
+      static FindNextFocusableElement(result: number): Microsoft.UI.Xaml.UIElement;
+      static FindNextFocusableElement(result: number, focusNavigationDirection: Windows.Foundation.Rect): Microsoft.UI.Xaml.UIElement;
+      static TryMoveFocus(result: number): boolean;
+      static GetFocusedElement(): any;
+      static GetFocusedElement(result: Microsoft.UI.Xaml.XamlRoot): any;
+    }
+    class FocusManagerGotFocusEventArgs implements Microsoft.UI.Xaml.Input.IFocusManagerGotFocusEventArgs {
+      readonly CorrelationId: System.Guid;
+      readonly NewFocusedElement: Microsoft.UI.Xaml.DependencyObject;
+    }
+    class FocusManagerLostFocusEventArgs implements Microsoft.UI.Xaml.Input.IFocusManagerLostFocusEventArgs {
+      readonly CorrelationId: System.Guid;
+      readonly OldFocusedElement: Microsoft.UI.Xaml.DependencyObject;
+    }
+    class FocusMovementResult implements Microsoft.UI.Xaml.Input.IFocusMovementResult {
+      readonly Succeeded: boolean;
+    }
+    class FocusNavigationDirection extends System.Enum {
+      value__: number;
+      static Next: number;
+      static Previous: number;
+      static Up: number;
+      static Down: number;
+      static Left: number;
+      static Right: number;
+      static None: number;
+    }
+    class GettingFocusEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Input.IGettingFocusEventArgs {
+      NewFocusedElement: Microsoft.UI.Xaml.DependencyObject;
+      Handled: boolean;
+      Cancel: boolean;
+      readonly CorrelationId: System.Guid;
+      readonly Direction: number;
+      readonly FocusState: number;
+      readonly InputDevice: number;
+      readonly OldFocusedElement: Microsoft.UI.Xaml.DependencyObject;
+      TryCancel(): boolean;
+      TrySetNewFocusedElement(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+    }
+    class HoldingEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Input.HoldingRoutedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    }
+    class HoldingRoutedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Input.IHoldingRoutedEventArgs {
+      Handled: boolean;
+      readonly HoldingState: number;
+      readonly PointerDeviceType: number;
+      constructor();
+      GetPosition(result: Microsoft.UI.Xaml.UIElement): Windows.Foundation.Point;
+    }
+    interface ICommand {
+      CanExecuteChanged: System.EventHandler<any> | null;
+      CanExecute(result: any): boolean;
+      Execute(parameter: any): void;
+    }
+    class InertiaExpansionBehavior implements Microsoft.UI.Xaml.Input.IInertiaExpansionBehavior {
+      DesiredExpansion: number;
+      DesiredDeceleration: number;
+    }
+    class InertiaRotationBehavior implements Microsoft.UI.Xaml.Input.IInertiaRotationBehavior {
+      DesiredRotation: number;
+      DesiredDeceleration: number;
+    }
+    class InertiaTranslationBehavior implements Microsoft.UI.Xaml.Input.IInertiaTranslationBehavior {
+      DesiredDisplacement: number;
+      DesiredDeceleration: number;
+    }
+    class InputScope extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Input.IInputScope {
+      readonly Names: System.Collections.Generic.IList<Microsoft.UI.Xaml.Input.InputScopeName>;
+      constructor();
+    }
+    class InputScopeName extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Input.IInputScopeName {
+      NameValue: number;
+      constructor(nameValue: number);
+      constructor();
+    }
+    class InputScopeNameValue extends System.Enum {
+      value__: number;
+      static Default: number;
+      static Url: number;
+      static EmailSmtpAddress: number;
+      static PersonalFullName: number;
+      static CurrencyAmountAndSymbol: number;
+      static CurrencyAmount: number;
+      static DateMonthNumber: number;
+      static DateDayNumber: number;
+      static DateYear: number;
+      static Digits: number;
+      static Number: number;
+      static Password: number;
+      static TelephoneNumber: number;
+      static TelephoneCountryCode: number;
+      static TelephoneAreaCode: number;
+      static TelephoneLocalNumber: number;
+      static TimeHour: number;
+      static TimeMinutesOrSeconds: number;
+      static NumberFullWidth: number;
+      static AlphanumericHalfWidth: number;
+      static AlphanumericFullWidth: number;
+      static Hiragana: number;
+      static KatakanaHalfWidth: number;
+      static KatakanaFullWidth: number;
+      static Hanja: number;
+      static HangulHalfWidth: number;
+      static HangulFullWidth: number;
+      static Search: number;
+      static Formula: number;
+      static SearchIncremental: number;
+      static ChineseHalfWidth: number;
+      static ChineseFullWidth: number;
+      static NativeScript: number;
+      static Text: number;
+      static Chat: number;
+      static NameOrPhoneNumber: number;
+      static EmailNameOrAddress: number;
+      static Maps: number;
+      static NumericPassword: number;
+      static NumericPin: number;
+      static AlphanumericPin: number;
+      static FormulaNumber: number;
+      static ChatWithoutEmoji: number;
+    }
+    class KeyEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Input.KeyRoutedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    }
+    class KeyRoutedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Input.IKeyRoutedEventArgs {
+      Handled: boolean;
+      readonly DeviceId: string;
+      readonly Key: Windows.System.VirtualKey;
+      readonly KeyStatus: Windows.UI.Core.CorePhysicalKeyStatus;
+      readonly OriginalKey: Windows.System.VirtualKey;
+    }
+    class KeyTipPlacementMode extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Bottom: number;
+      static Top: number;
+      static Left: number;
+      static Right: number;
+      static Center: number;
+      static Hidden: number;
+    }
+    class KeyboardAccelerator extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Input.IKeyboardAccelerator {
+      Invoked: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Input.KeyboardAccelerator, Microsoft.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs> | null;
+      ScopeOwner: Microsoft.UI.Xaml.DependencyObject;
+      Modifiers: Windows.System.VirtualKeyModifiers;
+      Key: Windows.System.VirtualKey;
+      IsEnabled: boolean;
+      static readonly IsEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly KeyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ModifiersProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ScopeOwnerProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class KeyboardAcceleratorInvokedEventArgs implements Microsoft.UI.Xaml.Input.IKeyboardAcceleratorInvokedEventArgs {
+      Handled: boolean;
+      readonly Element: Microsoft.UI.Xaml.DependencyObject;
+      readonly KeyboardAccelerator: Microsoft.UI.Xaml.Input.KeyboardAccelerator;
+    }
+    class KeyboardAcceleratorPlacementMode extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Hidden: number;
+    }
+    class KeyboardNavigationMode extends System.Enum {
+      value__: number;
+      static Local: number;
+      static Cycle: number;
+      static Once: number;
+    }
+    class LosingFocusEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Input.ILosingFocusEventArgs {
+      NewFocusedElement: Microsoft.UI.Xaml.DependencyObject;
+      Handled: boolean;
+      Cancel: boolean;
+      readonly CorrelationId: System.Guid;
+      readonly Direction: number;
+      readonly FocusState: number;
+      readonly InputDevice: number;
+      readonly OldFocusedElement: Microsoft.UI.Xaml.DependencyObject;
+      TryCancel(): boolean;
+      TrySetNewFocusedElement(result: Microsoft.UI.Xaml.DependencyObject): boolean;
+    }
+    class ManipulationCompletedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    }
+    class ManipulationCompletedRoutedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Input.IManipulationCompletedRoutedEventArgs {
+      Handled: boolean;
+      readonly Container: Microsoft.UI.Xaml.UIElement;
+      readonly Cumulative: Microsoft.UI.Input.ManipulationDelta;
+      readonly IsInertial: boolean;
+      readonly PointerDeviceType: number;
+      readonly Position: Windows.Foundation.Point;
+      readonly Velocities: Microsoft.UI.Input.ManipulationVelocities;
+      constructor();
+    }
+    class ManipulationDeltaEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    }
+    class ManipulationDeltaRoutedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Input.IManipulationDeltaRoutedEventArgs {
+      Handled: boolean;
+      readonly Container: Microsoft.UI.Xaml.UIElement;
+      readonly Cumulative: Microsoft.UI.Input.ManipulationDelta;
+      readonly Delta: Microsoft.UI.Input.ManipulationDelta;
+      readonly IsInertial: boolean;
+      readonly PointerDeviceType: number;
+      readonly Position: Windows.Foundation.Point;
+      readonly Velocities: Microsoft.UI.Input.ManipulationVelocities;
+      constructor();
+      Complete(): void;
+    }
+    class ManipulationInertiaStartingEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    }
+    class ManipulationInertiaStartingRoutedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Input.IManipulationInertiaStartingRoutedEventArgs {
+      TranslationBehavior: Microsoft.UI.Xaml.Input.InertiaTranslationBehavior;
+      RotationBehavior: Microsoft.UI.Xaml.Input.InertiaRotationBehavior;
+      Handled: boolean;
+      ExpansionBehavior: Microsoft.UI.Xaml.Input.InertiaExpansionBehavior;
+      readonly Container: Microsoft.UI.Xaml.UIElement;
+      readonly Cumulative: Microsoft.UI.Input.ManipulationDelta;
+      readonly Delta: Microsoft.UI.Input.ManipulationDelta;
+      readonly PointerDeviceType: number;
+      readonly Velocities: Microsoft.UI.Input.ManipulationVelocities;
+      constructor();
+    }
+    class ManipulationModes extends System.Enum {
+      value__: number;
+      static None: number;
+      static TranslateX: number;
+      static TranslateY: number;
+      static TranslateRailsX: number;
+      static TranslateRailsY: number;
+      static Rotate: number;
+      static Scale: number;
+      static TranslateInertia: number;
+      static RotateInertia: number;
+      static ScaleInertia: number;
+      static All: number;
+      static System: number;
+    }
+    class ManipulationPivot implements Microsoft.UI.Xaml.Input.IManipulationPivot {
+      Radius: number;
+      Center: Windows.Foundation.Point;
+      constructor(center: Windows.Foundation.Point, radius: number);
+      constructor();
+    }
+    class ManipulationStartedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Input.ManipulationStartedRoutedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    }
+    class ManipulationStartedRoutedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Input.IManipulationStartedRoutedEventArgs {
+      Handled: boolean;
+      readonly Container: Microsoft.UI.Xaml.UIElement;
+      readonly Cumulative: Microsoft.UI.Input.ManipulationDelta;
+      readonly PointerDeviceType: number;
+      readonly Position: Windows.Foundation.Point;
+      constructor();
+      Complete(): void;
+    }
+    class ManipulationStartingEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Input.ManipulationStartingRoutedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    }
+    class ManipulationStartingRoutedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Input.IManipulationStartingRoutedEventArgs {
+      Pivot: Microsoft.UI.Xaml.Input.ManipulationPivot;
+      Mode: number;
+      Handled: boolean;
+      Container: Microsoft.UI.Xaml.UIElement;
+      constructor();
+    }
+    class NoFocusCandidateFoundEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Input.INoFocusCandidateFoundEventArgs {
+      Handled: boolean;
+      readonly Direction: number;
+      readonly InputDevice: number;
+    }
+    class Pointer implements Microsoft.UI.Xaml.Input.IPointer {
+      readonly IsInContact: boolean;
+      readonly IsInRange: boolean;
+      readonly PointerDeviceType: number;
+      readonly PointerId: number;
+    }
+    class PointerEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Input.PointerRoutedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    }
+    class PointerRoutedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Input.IPointerRoutedEventArgs {
+      Handled: boolean;
+      readonly IsGenerated: boolean;
+      readonly KeyModifiers: Windows.System.VirtualKeyModifiers;
+      readonly Pointer: Microsoft.UI.Xaml.Input.Pointer;
+      GetCurrentPoint(result: Microsoft.UI.Xaml.UIElement): Microsoft.UI.Input.PointerPoint;
+      GetIntermediatePoints(result: Microsoft.UI.Xaml.UIElement): System.Collections.Generic.IList<Microsoft.UI.Input.PointerPoint>;
+    }
+    class ProcessKeyboardAcceleratorEventArgs implements Microsoft.UI.Xaml.Input.IProcessKeyboardAcceleratorEventArgs {
+      Handled: boolean;
+      readonly Key: Windows.System.VirtualKey;
+      readonly Modifiers: Windows.System.VirtualKeyModifiers;
+    }
+    class RightTappedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Input.RightTappedRoutedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    }
+    class RightTappedRoutedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Input.IRightTappedRoutedEventArgs {
+      Handled: boolean;
+      readonly PointerDeviceType: number;
+      constructor();
+      GetPosition(result: Microsoft.UI.Xaml.UIElement): Windows.Foundation.Point;
+    }
+    class XamlUICommand extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Input.IXamlUICommand, Microsoft.UI.Xaml.Input.ICommand {
+      CanExecuteRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Input.XamlUICommand, Microsoft.UI.Xaml.Input.CanExecuteRequestedEventArgs> | null;
+      ExecuteRequested: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Input.XamlUICommand, Microsoft.UI.Xaml.Input.ExecuteRequestedEventArgs> | null;
+      CanExecuteChanged: System.EventHandler<any> | null;
+      Label: string;
+      IconSource: Microsoft.UI.Xaml.Controls.IconSource;
+      Description: string;
+      Command: Microsoft.UI.Xaml.Input.ICommand;
+      AccessKey: string;
+      readonly KeyboardAccelerators: System.Collections.Generic.IList<Microsoft.UI.Xaml.Input.KeyboardAccelerator>;
+      static readonly AccessKeyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CommandProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DescriptionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IconSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly KeyboardAcceleratorsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LabelProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      NotifyCanExecuteChanged(): void;
+      CanExecute(result: any): boolean;
+      Execute(parameter: any): void;
+    }
+    class StandardUICommand extends Microsoft.UI.Xaml.Input.XamlUICommand implements Microsoft.UI.Xaml.Input.IStandardUICommand {
+      Kind: number;
+      static readonly KindProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      constructor(kind: number);
+    }
+    class StandardUICommandKind extends System.Enum {
+      value__: number;
+      static None: number;
+      static Cut: number;
+      static Copy: number;
+      static Paste: number;
+      static SelectAll: number;
+      static Delete: number;
+      static Share: number;
+      static Save: number;
+      static Open: number;
+      static Close: number;
+      static Pause: number;
+      static Play: number;
+      static Stop: number;
+      static Forward: number;
+      static Backward: number;
+      static Undo: number;
+      static Redo: number;
+    }
+    class TappedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Input.TappedRoutedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    }
+    class TappedRoutedEventArgs extends Microsoft.UI.Xaml.RoutedEventArgs implements Microsoft.UI.Xaml.Input.ITappedRoutedEventArgs {
+      Handled: boolean;
+      readonly PointerDeviceType: number;
+      constructor();
+      GetPosition(result: Microsoft.UI.Xaml.UIElement): Windows.Foundation.Point;
+    }
+    class XYFocusKeyboardNavigationMode extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Enabled: number;
+      static Disabled: number;
+    }
+    class XYFocusNavigationStrategy extends System.Enum {
+      value__: number;
+      static Auto: number;
+      static Projection: number;
+      static NavigationDirectionDistance: number;
+      static RectilinearDistance: number;
+    }
+    class XYFocusNavigationStrategyOverride extends System.Enum {
+      value__: number;
+      static None: number;
+      static Auto: number;
+      static Projection: number;
+      static NavigationDirectionDistance: number;
+      static RectilinearDistance: number;
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Interop {
+    class BindableVectorChangedEventHandler {
+      constructor(handler: (vector: Microsoft.UI.Xaml.Interop.IBindableObservableVector, e: any) => void);
+      Invoke(vector: Microsoft.UI.Xaml.Interop.IBindableObservableVector, e: any): void;
+    }
+    interface IBindableIterable {
+      First(): Microsoft.UI.Xaml.Interop.IBindableIterator;
+    }
+    interface IBindableIterator {
+      readonly Current: any;
+      readonly HasCurrent: boolean;
+      MoveNext(): boolean;
+    }
+    interface IBindableObservableVector extends Microsoft.UI.Xaml.Interop.IBindableVector, Microsoft.UI.Xaml.Interop.IBindableIterable {
+      VectorChanged: Microsoft.UI.Xaml.Interop.BindableVectorChangedEventHandler | null;
+    }
+    interface IBindableVector extends Microsoft.UI.Xaml.Interop.IBindableIterable {
+      readonly Size: number;
+      GetAt(result: number): any;
+      GetView(): Microsoft.UI.Xaml.Interop.IBindableVectorView;
+      IndexOf(returnValue: any, value: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+    }
+    interface IBindableVectorView extends Microsoft.UI.Xaml.Interop.IBindableIterable {
+      readonly Size: number;
+      GetAt(result: number): any;
+      IndexOf(returnValue: any, value: number): boolean;
+    }
+    interface INotifyCollectionChanged {
+      CollectionChanged: Microsoft.UI.Xaml.Interop.NotifyCollectionChangedEventHandler | null;
+    }
+    class NotifyCollectionChangedAction extends System.Enum {
+      value__: number;
+      static Add: number;
+      static Remove: number;
+      static Replace: number;
+      static Move: number;
+      static Reset: number;
+    }
+    class NotifyCollectionChangedEventArgs implements Microsoft.UI.Xaml.Interop.INotifyCollectionChangedEventArgs {
+      readonly Action: number;
+      readonly NewItems: Microsoft.UI.Xaml.Interop.IBindableVector;
+      readonly NewStartingIndex: number;
+      readonly OldItems: Microsoft.UI.Xaml.Interop.IBindableVector;
+      readonly OldStartingIndex: number;
+      constructor(action: number, newItems: Microsoft.UI.Xaml.Interop.IBindableVector, oldItems: Microsoft.UI.Xaml.Interop.IBindableVector, newIndex: number, oldIndex: number);
+    }
+    class NotifyCollectionChangedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Interop.NotifyCollectionChangedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Interop.NotifyCollectionChangedEventArgs): void;
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Markup {
+    class ContentPropertyAttribute extends System.Attribute {
+      Name: string;
+      constructor();
+    }
+    class FullXamlMetadataProviderAttribute extends System.Attribute {
+      constructor();
+    }
+    interface IComponentConnector {
+      Connect(connectionId: number, target: any): void;
+      GetBindingConnector(result: number, connectionId: any): Microsoft.UI.Xaml.Markup.IComponentConnector;
+    }
+    interface IDataTemplateComponent {
+      Recycle(): void;
+      ProcessBindings(item: any, itemIndex: number, phase: number, nextPhase: number): void;
+    }
+    interface IProvideValueTarget {
+      readonly TargetObject: any;
+      readonly TargetProperty: any;
+    }
+    interface IRootObjectProvider {
+      readonly RootObject: any;
+    }
+    interface IUriContext {
+      readonly BaseUri: System.Uri;
+    }
+    interface IXamlBindScopeDiagnostics {
+      Disable(lineNumber: number, columnNumber: number): void;
+    }
+    interface IXamlMember {
+      readonly IsAttachable: boolean;
+      readonly IsDependencyProperty: boolean;
+      readonly IsReadOnly: boolean;
+      readonly Name: string;
+      readonly TargetType: Microsoft.UI.Xaml.Markup.IXamlType;
+      readonly Type: Microsoft.UI.Xaml.Markup.IXamlType;
+      GetValue(result: any): any;
+      SetValue(instance: any, value: any): void;
+    }
+    interface IXamlMetadataProvider {
+      GetXamlType(result: System.Type): Microsoft.UI.Xaml.Markup.IXamlType;
+      GetXamlType(result: string): Microsoft.UI.Xaml.Markup.IXamlType;
+      GetXmlnsDefinitions(): Microsoft.UI.Xaml.Markup.XmlnsDefinition[];
+    }
+    interface IXamlType {
+      readonly BaseType: Microsoft.UI.Xaml.Markup.IXamlType;
+      readonly BoxedType: Microsoft.UI.Xaml.Markup.IXamlType;
+      readonly ContentProperty: Microsoft.UI.Xaml.Markup.IXamlMember;
+      readonly FullName: string;
+      readonly IsArray: boolean;
+      readonly IsBindable: boolean;
+      readonly IsCollection: boolean;
+      readonly IsConstructible: boolean;
+      readonly IsDictionary: boolean;
+      readonly IsMarkupExtension: boolean;
+      readonly ItemType: Microsoft.UI.Xaml.Markup.IXamlType;
+      readonly KeyType: Microsoft.UI.Xaml.Markup.IXamlType;
+      readonly UnderlyingType: System.Type;
+      ActivateInstance(): any;
+      CreateFromString(result: string): any;
+      GetMember(result: string): Microsoft.UI.Xaml.Markup.IXamlMember;
+      AddToVector(instance: any, value: any): void;
+      AddToMap(instance: any, key: any, value: any): void;
+      RunInitializer(): void;
+    }
+    interface IXamlTypeResolver {
+      Resolve(result: string): System.Type;
+    }
+    class MarkupExtension implements Microsoft.UI.Xaml.Markup.IMarkupExtension, Microsoft.UI.Xaml.Markup.IMarkupExtensionOverrides {
+      constructor();
+    }
+    class MarkupExtensionReturnTypeAttribute extends System.Attribute {
+      ReturnType: System.Type;
+      constructor();
+    }
+    class ProvideValueTargetProperty implements Microsoft.UI.Xaml.Markup.IProvideValueTargetProperty {
+      readonly DeclaringType: System.Type;
+      readonly Name: string;
+      readonly Type: System.Type;
+      constructor();
+    }
+    class XamlBinaryWriter implements Microsoft.UI.Xaml.Markup.IXamlBinaryWriter {
+      static Write(result: System.Collections.Generic.IList<Windows.Storage.Streams.IRandomAccessStream>, inputStreams: System.Collections.Generic.IList<Windows.Storage.Streams.IRandomAccessStream>, outputStreams: Microsoft.UI.Xaml.Markup.IXamlMetadataProvider): Microsoft.UI.Xaml.Markup.XamlBinaryWriterErrorInformation;
+    }
+    class XamlBinaryWriterErrorInformation extends System.ValueType {
+      InputStreamIndex: number;
+      LineNumber: number;
+      LinePosition: number;
+    }
+    class XamlBindingHelper implements Microsoft.UI.Xaml.Markup.IXamlBindingHelper {
+      static readonly DataTemplateComponentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static GetDataTemplateComponent(result: Microsoft.UI.Xaml.DependencyObject): Microsoft.UI.Xaml.Markup.IDataTemplateComponent;
+      static SetDataTemplateComponent(element: Microsoft.UI.Xaml.DependencyObject, value: Microsoft.UI.Xaml.Markup.IDataTemplateComponent): void;
+      static SuspendRendering(target: Microsoft.UI.Xaml.UIElement): void;
+      static ResumeRendering(target: Microsoft.UI.Xaml.UIElement): void;
+      static ConvertValue(result: System.Type, type: any): any;
+      static SetPropertyFromString(dependencyObject: any, propertyToSet: Microsoft.UI.Xaml.DependencyProperty, value: string): void;
+      static SetPropertyFromBoolean(dependencyObject: any, propertyToSet: Microsoft.UI.Xaml.DependencyProperty, value: boolean): void;
+      static SetPropertyFromChar16(dependencyObject: any, propertyToSet: Microsoft.UI.Xaml.DependencyProperty, value: string): void;
+      static SetPropertyFromDateTime(dependencyObject: any, propertyToSet: Microsoft.UI.Xaml.DependencyProperty, value: System.DateTimeOffset): void;
+      static SetPropertyFromDouble(dependencyObject: any, propertyToSet: Microsoft.UI.Xaml.DependencyProperty, value: number): void;
+      static SetPropertyFromInt32(dependencyObject: any, propertyToSet: Microsoft.UI.Xaml.DependencyProperty, value: number): void;
+      static SetPropertyFromUInt32(dependencyObject: any, propertyToSet: Microsoft.UI.Xaml.DependencyProperty, value: number): void;
+      static SetPropertyFromInt64(dependencyObject: any, propertyToSet: Microsoft.UI.Xaml.DependencyProperty, value: number): void;
+      static SetPropertyFromUInt64(dependencyObject: any, propertyToSet: Microsoft.UI.Xaml.DependencyProperty, value: number): void;
+      static SetPropertyFromSingle(dependencyObject: any, propertyToSet: Microsoft.UI.Xaml.DependencyProperty, value: number): void;
+      static SetPropertyFromPoint(dependencyObject: any, propertyToSet: Microsoft.UI.Xaml.DependencyProperty, value: Windows.Foundation.Point): void;
+      static SetPropertyFromRect(dependencyObject: any, propertyToSet: Microsoft.UI.Xaml.DependencyProperty, value: Windows.Foundation.Rect): void;
+      static SetPropertyFromSize(dependencyObject: any, propertyToSet: Microsoft.UI.Xaml.DependencyProperty, value: Windows.Foundation.Size): void;
+      static SetPropertyFromTimeSpan(dependencyObject: any, propertyToSet: Microsoft.UI.Xaml.DependencyProperty, value: System.TimeSpan): void;
+      static SetPropertyFromByte(dependencyObject: any, propertyToSet: Microsoft.UI.Xaml.DependencyProperty, value: number): void;
+      static SetPropertyFromUri(dependencyObject: any, propertyToSet: Microsoft.UI.Xaml.DependencyProperty, value: System.Uri): void;
+      static SetPropertyFromObject(dependencyObject: any, propertyToSet: Microsoft.UI.Xaml.DependencyProperty, value: any): void;
+    }
+    class XamlMarkupHelper implements Microsoft.UI.Xaml.Markup.IXamlMarkupHelper {
+      static UnloadObject(element: Microsoft.UI.Xaml.DependencyObject): void;
+    }
+    class XamlReader implements Microsoft.UI.Xaml.Markup.IXamlReader {
+      static Load(result: string): any;
+      static LoadWithInitialTemplateValidation(result: string): any;
+    }
+    class XmlnsDefinition extends System.ValueType {
+      XmlNamespace: string;
+      Namespace: string;
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Media {
+    class Brush extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.IBrush, Microsoft.UI.Xaml.Media.IBrushOverrides, Microsoft.UI.Composition.IAnimationObject {
+      Transform: Microsoft.UI.Xaml.Media.Transform;
+      RelativeTransform: Microsoft.UI.Xaml.Media.Transform;
+      Opacity: number;
+      static readonly OpacityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RelativeTransformProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TransformProperty: Microsoft.UI.Xaml.DependencyProperty;
+      PopulatePropertyInfo(propertyName: string, propertyInfo: Microsoft.UI.Composition.AnimationPropertyInfo): void;
+    }
+    class XamlCompositionBrushBase extends Microsoft.UI.Xaml.Media.Brush implements Microsoft.UI.Xaml.Media.IXamlCompositionBrushBase, Microsoft.UI.Xaml.Media.IXamlCompositionBrushBaseProtected, Microsoft.UI.Xaml.Media.IXamlCompositionBrushBaseOverrides {
+      FallbackColor: Windows.UI.Color;
+      static readonly FallbackColorProperty: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class AcrylicBrush extends Microsoft.UI.Xaml.Media.XamlCompositionBrushBase implements Microsoft.UI.Xaml.Media.IAcrylicBrush, Microsoft.UI.Xaml.Media.IAcrylicBrush2 {
+      TintTransitionDuration: System.TimeSpan;
+      TintOpacity: number;
+      TintColor: Windows.UI.Color;
+      AlwaysUseFallback: boolean;
+      TintLuminosityOpacity: System.Nullable<number>;
+      static readonly AlwaysUseFallbackProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TintColorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TintOpacityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TintTransitionDurationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TintLuminosityOpacityProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class AlignmentX extends System.Enum {
+      value__: number;
+      static Left: number;
+      static Center: number;
+      static Right: number;
+    }
+    class AlignmentY extends System.Enum {
+      value__: number;
+      static Top: number;
+      static Center: number;
+      static Bottom: number;
+    }
+    class PathSegment extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.IPathSegment {
+    }
+    class ArcSegment extends Microsoft.UI.Xaml.Media.PathSegment implements Microsoft.UI.Xaml.Media.IArcSegment {
+      SweepDirection: number;
+      Size: Windows.Foundation.Size;
+      RotationAngle: number;
+      Point: Windows.Foundation.Point;
+      IsLargeArc: boolean;
+      static readonly IsLargeArcProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PointProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RotationAngleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SizeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SweepDirectionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class BezierSegment extends Microsoft.UI.Xaml.Media.PathSegment implements Microsoft.UI.Xaml.Media.IBezierSegment {
+      Point3: Windows.Foundation.Point;
+      Point2: Windows.Foundation.Point;
+      Point1: Windows.Foundation.Point;
+      static readonly Point1Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly Point2Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly Point3Property: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class CacheMode extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.ICacheMode {
+    }
+    class BitmapCache extends Microsoft.UI.Xaml.Media.CacheMode implements Microsoft.UI.Xaml.Media.IBitmapCache {
+      constructor();
+    }
+    class BrushCollection {
+      constructor();
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class BrushMappingMode extends System.Enum {
+      value__: number;
+      static Absolute: number;
+      static RelativeToBoundingBox: number;
+    }
+    class ColorInterpolationMode extends System.Enum {
+      value__: number;
+      static ScRgbLinearInterpolation: number;
+      static SRgbLinearInterpolation: number;
+    }
+    class GeneralTransform extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.IGeneralTransform, Microsoft.UI.Xaml.Media.IGeneralTransformOverrides {
+      readonly Inverse: Microsoft.UI.Xaml.Media.GeneralTransform;
+      TransformPoint(result: Windows.Foundation.Point): Windows.Foundation.Point;
+      TryTransform(returnValue: Windows.Foundation.Point, inPoint: Windows.Foundation.Point): boolean;
+      TransformBounds(result: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    }
+    class Transform extends Microsoft.UI.Xaml.Media.GeneralTransform implements Microsoft.UI.Xaml.Media.ITransform {
+    }
+    class CompositeTransform extends Microsoft.UI.Xaml.Media.Transform implements Microsoft.UI.Xaml.Media.ICompositeTransform {
+      TranslateY: number;
+      TranslateX: number;
+      SkewY: number;
+      SkewX: number;
+      ScaleY: number;
+      ScaleX: number;
+      Rotation: number;
+      CenterY: number;
+      CenterX: number;
+      static readonly CenterXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CenterYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RotationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ScaleXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ScaleYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SkewXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SkewYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TranslateXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TranslateYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class CompositionTarget implements Microsoft.UI.Xaml.Media.ICompositionTarget {
+      static Rendered: System.EventHandler<Microsoft.UI.Xaml.Media.RenderedEventArgs> | null;
+      static Rendering: System.EventHandler<any> | null;
+      static SurfaceContentsLost: System.EventHandler<any> | null;
+      static GetCompositorForCurrentThread(): Microsoft.UI.Composition.Compositor;
+    }
+    class SystemBackdrop extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.ISystemBackdrop, Microsoft.UI.Xaml.Media.ISystemBackdropOverrides {
+      GetDefaultSystemBackdropConfiguration(result: Microsoft.UI.Composition.ICompositionSupportsSystemBackdrop, target: Microsoft.UI.Xaml.XamlRoot): Microsoft.UI.Composition.SystemBackdrops.SystemBackdropConfiguration;
+    }
+    class DesktopAcrylicBackdrop extends Microsoft.UI.Xaml.Media.SystemBackdrop implements Microsoft.UI.Xaml.Media.IDesktopAcrylicBackdrop {
+      constructor();
+    }
+    class DoubleCollection {
+      constructor();
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class ElementCompositeMode extends System.Enum {
+      value__: number;
+      static Inherit: number;
+      static SourceOver: number;
+      static MinBlend: number;
+    }
+    class Geometry extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.IGeometry {
+      Transform: Microsoft.UI.Xaml.Media.Transform;
+      readonly Bounds: Windows.Foundation.Rect;
+      static readonly Empty: Microsoft.UI.Xaml.Media.Geometry;
+      static readonly StandardFlatteningTolerance: number;
+      static readonly TransformProperty: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class EllipseGeometry extends Microsoft.UI.Xaml.Media.Geometry implements Microsoft.UI.Xaml.Media.IEllipseGeometry {
+      RadiusY: number;
+      RadiusX: number;
+      Center: Windows.Foundation.Point;
+      static readonly CenterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RadiusXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RadiusYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class FastPlayFallbackBehaviour extends System.Enum {
+      value__: number;
+      static Skip: number;
+      static Hide: number;
+      static Disable: number;
+    }
+    class FillRule extends System.Enum {
+      value__: number;
+      static EvenOdd: number;
+      static Nonzero: number;
+    }
+    class FontFamily implements Microsoft.UI.Xaml.Media.IFontFamily {
+      readonly Source: string;
+      static readonly XamlAutoFontFamily: Microsoft.UI.Xaml.Media.FontFamily;
+      constructor(familyName: string);
+    }
+    class GeometryCollection {
+      constructor();
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class GeometryGroup extends Microsoft.UI.Xaml.Media.Geometry implements Microsoft.UI.Xaml.Media.IGeometryGroup {
+      FillRule: number;
+      Children: Microsoft.UI.Xaml.Media.GeometryCollection;
+      static readonly ChildrenProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FillRuleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class GradientBrush extends Microsoft.UI.Xaml.Media.Brush implements Microsoft.UI.Xaml.Media.IGradientBrush {
+      SpreadMethod: number;
+      MappingMode: number;
+      GradientStops: Microsoft.UI.Xaml.Media.GradientStopCollection;
+      ColorInterpolationMode: number;
+      static readonly ColorInterpolationModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GradientStopsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MappingModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SpreadMethodProperty: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class GradientSpreadMethod extends System.Enum {
+      value__: number;
+      static Pad: number;
+      static Reflect: number;
+      static Repeat: number;
+    }
+    class GradientStop extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.IGradientStop {
+      Offset: number;
+      Color: Windows.UI.Color;
+      static readonly ColorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class GradientStopCollection {
+      constructor();
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class TileBrush extends Microsoft.UI.Xaml.Media.Brush implements Microsoft.UI.Xaml.Media.ITileBrush {
+      Stretch: number;
+      AlignmentY: number;
+      AlignmentX: number;
+      static readonly AlignmentXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AlignmentYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StretchProperty: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class ImageBrush extends Microsoft.UI.Xaml.Media.TileBrush implements Microsoft.UI.Xaml.Media.IImageBrush {
+      ImageFailed: Microsoft.UI.Xaml.ExceptionRoutedEventHandler | null;
+      ImageOpened: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      ImageSource: Microsoft.UI.Xaml.Media.ImageSource;
+      static readonly ImageSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ImageSource extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.IImageSource {
+    }
+    class LineGeometry extends Microsoft.UI.Xaml.Media.Geometry implements Microsoft.UI.Xaml.Media.ILineGeometry {
+      StartPoint: Windows.Foundation.Point;
+      EndPoint: Windows.Foundation.Point;
+      static readonly EndPointProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StartPointProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class LineSegment extends Microsoft.UI.Xaml.Media.PathSegment implements Microsoft.UI.Xaml.Media.ILineSegment {
+      Point: Windows.Foundation.Point;
+      static readonly PointProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class LinearGradientBrush extends Microsoft.UI.Xaml.Media.GradientBrush implements Microsoft.UI.Xaml.Media.ILinearGradientBrush {
+      StartPoint: Windows.Foundation.Point;
+      EndPoint: Windows.Foundation.Point;
+      static readonly EndPointProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StartPointProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor(gradientStopCollection: Microsoft.UI.Xaml.Media.GradientStopCollection, angle: number);
+      constructor();
+    }
+    class LoadedImageSourceLoadCompletedEventArgs implements Microsoft.UI.Xaml.Media.ILoadedImageSourceLoadCompletedEventArgs {
+      readonly Status: number;
+    }
+    class LoadedImageSourceLoadStatus extends System.Enum {
+      value__: number;
+      static Success: number;
+      static NetworkError: number;
+      static InvalidFormat: number;
+      static Other: number;
+    }
+    class LoadedImageSurface implements Microsoft.UI.Xaml.Media.ILoadedImageSurface, Microsoft.UI.Composition.ICompositionSurface {
+      LoadCompleted: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Media.LoadedImageSurface, Microsoft.UI.Xaml.Media.LoadedImageSourceLoadCompletedEventArgs> | null;
+      readonly DecodedPhysicalSize: Windows.Foundation.Size;
+      readonly DecodedSize: Windows.Foundation.Size;
+      readonly NaturalSize: Windows.Foundation.Size;
+      Dispose(): void;
+      static StartLoadFromUri(result: System.Uri, uri: Windows.Foundation.Size): Microsoft.UI.Xaml.Media.LoadedImageSurface;
+      static StartLoadFromUri(result: System.Uri): Microsoft.UI.Xaml.Media.LoadedImageSurface;
+      static StartLoadFromStream(result: Windows.Storage.Streams.IRandomAccessStream, stream: Windows.Foundation.Size): Microsoft.UI.Xaml.Media.LoadedImageSurface;
+      static StartLoadFromStream(result: Windows.Storage.Streams.IRandomAccessStream): Microsoft.UI.Xaml.Media.LoadedImageSurface;
+    }
+    class Matrix extends System.ValueType {
+      M11: number;
+      M12: number;
+      M21: number;
+      M22: number;
+      OffsetX: number;
+      OffsetY: number;
+    }
+    class Projection extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.IProjection {
+    }
+    class Matrix3DProjection extends Microsoft.UI.Xaml.Media.Projection implements Microsoft.UI.Xaml.Media.IMatrix3DProjection {
+      ProjectionMatrix: Microsoft.UI.Xaml.Media.Media3D.Matrix3D;
+      static readonly ProjectionMatrixProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class MatrixHelper implements Microsoft.UI.Xaml.Media.IMatrixHelper {
+      static readonly Identity: Microsoft.UI.Xaml.Media.Matrix;
+      static FromElements(result: number, m11: number, m12: number, m21: number, m22: number, offsetX: number): Microsoft.UI.Xaml.Media.Matrix;
+      static GetIsIdentity(result: Microsoft.UI.Xaml.Media.Matrix): boolean;
+      static Transform(result: Microsoft.UI.Xaml.Media.Matrix, target: Windows.Foundation.Point): Windows.Foundation.Point;
+    }
+    class MatrixTransform extends Microsoft.UI.Xaml.Media.Transform implements Microsoft.UI.Xaml.Media.IMatrixTransform {
+      Matrix: Microsoft.UI.Xaml.Media.Matrix;
+      static readonly MatrixProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class MediaTransportControlsThumbnailRequestedEventArgs implements Microsoft.UI.Xaml.Media.IMediaTransportControlsThumbnailRequestedEventArgs {
+      SetThumbnailImage(source: Windows.Storage.Streams.IInputStream): void;
+      GetDeferral(): Windows.Foundation.Deferral;
+    }
+    class MicaBackdrop extends Microsoft.UI.Xaml.Media.SystemBackdrop implements Microsoft.UI.Xaml.Media.IMicaBackdrop {
+      Kind: number;
+      static readonly KindProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PathFigure extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.IPathFigure {
+      StartPoint: Windows.Foundation.Point;
+      Segments: Microsoft.UI.Xaml.Media.PathSegmentCollection;
+      IsFilled: boolean;
+      IsClosed: boolean;
+      static readonly IsClosedProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsFilledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SegmentsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StartPointProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PathFigureCollection {
+      constructor();
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class PathGeometry extends Microsoft.UI.Xaml.Media.Geometry implements Microsoft.UI.Xaml.Media.IPathGeometry {
+      FillRule: number;
+      Figures: Microsoft.UI.Xaml.Media.PathFigureCollection;
+      static readonly FiguresProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FillRuleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PathSegmentCollection {
+      constructor();
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class PenLineCap extends System.Enum {
+      value__: number;
+      static Flat: number;
+      static Square: number;
+      static Round: number;
+      static Triangle: number;
+    }
+    class PenLineJoin extends System.Enum {
+      value__: number;
+      static Miter: number;
+      static Bevel: number;
+      static Round: number;
+    }
+    class PlaneProjection extends Microsoft.UI.Xaml.Media.Projection implements Microsoft.UI.Xaml.Media.IPlaneProjection {
+      RotationZ: number;
+      RotationY: number;
+      RotationX: number;
+      LocalOffsetZ: number;
+      LocalOffsetY: number;
+      LocalOffsetX: number;
+      GlobalOffsetZ: number;
+      GlobalOffsetY: number;
+      GlobalOffsetX: number;
+      CenterOfRotationZ: number;
+      CenterOfRotationY: number;
+      CenterOfRotationX: number;
+      readonly ProjectionMatrix: Microsoft.UI.Xaml.Media.Media3D.Matrix3D;
+      static readonly CenterOfRotationXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CenterOfRotationYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CenterOfRotationZProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GlobalOffsetXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GlobalOffsetYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GlobalOffsetZProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LocalOffsetXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LocalOffsetYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly LocalOffsetZProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ProjectionMatrixProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RotationXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RotationYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RotationZProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PointCollection {
+      constructor();
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class PolyBezierSegment extends Microsoft.UI.Xaml.Media.PathSegment implements Microsoft.UI.Xaml.Media.IPolyBezierSegment {
+      Points: Microsoft.UI.Xaml.Media.PointCollection;
+      static readonly PointsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PolyLineSegment extends Microsoft.UI.Xaml.Media.PathSegment implements Microsoft.UI.Xaml.Media.IPolyLineSegment {
+      Points: Microsoft.UI.Xaml.Media.PointCollection;
+      static readonly PointsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PolyQuadraticBezierSegment extends Microsoft.UI.Xaml.Media.PathSegment implements Microsoft.UI.Xaml.Media.IPolyQuadraticBezierSegment {
+      Points: Microsoft.UI.Xaml.Media.PointCollection;
+      static readonly PointsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class QuadraticBezierSegment extends Microsoft.UI.Xaml.Media.PathSegment implements Microsoft.UI.Xaml.Media.IQuadraticBezierSegment {
+      Point2: Windows.Foundation.Point;
+      Point1: Windows.Foundation.Point;
+      static readonly Point1Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly Point2Property: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class RadialGradientBrush extends Microsoft.UI.Xaml.Media.XamlCompositionBrushBase implements Microsoft.UI.Xaml.Media.IRadialGradientBrush {
+      SpreadMethod: number;
+      RadiusY: number;
+      RadiusX: number;
+      MappingMode: number;
+      InterpolationSpace: number;
+      GradientOrigin: Windows.Foundation.Point;
+      Center: Windows.Foundation.Point;
+      readonly GradientStops: Windows.Foundation.Collections.IObservableVector<Microsoft.UI.Xaml.Media.GradientStop>;
+      static readonly CenterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly GradientOriginProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly InterpolationSpaceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly MappingModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RadiusXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RadiusYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SpreadMethodProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class RectangleGeometry extends Microsoft.UI.Xaml.Media.Geometry implements Microsoft.UI.Xaml.Media.IRectangleGeometry {
+      Rect: Windows.Foundation.Rect;
+      static readonly RectProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class RenderedEventArgs implements Microsoft.UI.Xaml.Media.IRenderedEventArgs {
+      readonly FrameDuration: System.TimeSpan;
+    }
+    class RenderingEventArgs implements Microsoft.UI.Xaml.Media.IRenderingEventArgs {
+      readonly RenderingTime: System.TimeSpan;
+    }
+    class RotateTransform extends Microsoft.UI.Xaml.Media.Transform implements Microsoft.UI.Xaml.Media.IRotateTransform {
+      CenterY: number;
+      CenterX: number;
+      Angle: number;
+      static readonly AngleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CenterXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CenterYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ScaleTransform extends Microsoft.UI.Xaml.Media.Transform implements Microsoft.UI.Xaml.Media.IScaleTransform {
+      ScaleY: number;
+      ScaleX: number;
+      CenterY: number;
+      CenterX: number;
+      static readonly CenterXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CenterYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ScaleXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ScaleYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class Shadow extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.IShadow {
+    }
+    class SkewTransform extends Microsoft.UI.Xaml.Media.Transform implements Microsoft.UI.Xaml.Media.ISkewTransform {
+      CenterY: number;
+      CenterX: number;
+      AngleY: number;
+      AngleX: number;
+      static readonly AngleXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly AngleYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CenterXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CenterYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class SolidColorBrush extends Microsoft.UI.Xaml.Media.Brush implements Microsoft.UI.Xaml.Media.ISolidColorBrush {
+      Color: Windows.UI.Color;
+      static readonly ColorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor(color: Windows.UI.Color);
+      constructor();
+    }
+    class Stretch extends System.Enum {
+      value__: number;
+      static None: number;
+      static Fill: number;
+      static Uniform: number;
+      static UniformToFill: number;
+    }
+    class StyleSimulations extends System.Enum {
+      value__: number;
+      static None: number;
+      static BoldSimulation: number;
+      static ItalicSimulation: number;
+      static BoldItalicSimulation: number;
+    }
+    class SweepDirection extends System.Enum {
+      value__: number;
+      static Counterclockwise: number;
+      static Clockwise: number;
+    }
+    class ThemeShadow extends Microsoft.UI.Xaml.Media.Shadow implements Microsoft.UI.Xaml.Media.IThemeShadow {
+      readonly Receivers: Microsoft.UI.Xaml.UIElementWeakCollection;
+      constructor();
+    }
+    class TransformCollection {
+      constructor();
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class TransformGroup extends Microsoft.UI.Xaml.Media.Transform implements Microsoft.UI.Xaml.Media.ITransformGroup {
+      Children: Microsoft.UI.Xaml.Media.TransformCollection;
+      readonly Value: Microsoft.UI.Xaml.Media.Matrix;
+      static readonly ChildrenProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class TranslateTransform extends Microsoft.UI.Xaml.Media.Transform implements Microsoft.UI.Xaml.Media.ITranslateTransform {
+      Y: number;
+      X: number;
+      static readonly XProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly YProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class VisualTreeHelper implements Microsoft.UI.Xaml.Media.IVisualTreeHelper {
+      static FindElementsInHostCoordinates(result: Windows.Foundation.Point, intersectingPoint: Microsoft.UI.Xaml.UIElement): System.Collections.Generic.IEnumerable<Microsoft.UI.Xaml.UIElement>;
+      static FindElementsInHostCoordinates(result: Windows.Foundation.Rect, intersectingRect: Microsoft.UI.Xaml.UIElement): System.Collections.Generic.IEnumerable<Microsoft.UI.Xaml.UIElement>;
+      static FindElementsInHostCoordinates(result: Windows.Foundation.Point, intersectingPoint: Microsoft.UI.Xaml.UIElement, subtree: boolean): System.Collections.Generic.IEnumerable<Microsoft.UI.Xaml.UIElement>;
+      static FindElementsInHostCoordinates(result: Windows.Foundation.Rect, intersectingRect: Microsoft.UI.Xaml.UIElement, subtree: boolean): System.Collections.Generic.IEnumerable<Microsoft.UI.Xaml.UIElement>;
+      static GetChild(result: Microsoft.UI.Xaml.DependencyObject, reference: number): Microsoft.UI.Xaml.DependencyObject;
+      static GetChildrenCount(result: Microsoft.UI.Xaml.DependencyObject): number;
+      static GetParent(result: Microsoft.UI.Xaml.DependencyObject): Microsoft.UI.Xaml.DependencyObject;
+      static DisconnectChildrenRecursive(element: Microsoft.UI.Xaml.UIElement): void;
+      static GetOpenPopups(result: Microsoft.UI.Xaml.Window): System.Collections.Generic.IReadOnlyList<Microsoft.UI.Xaml.Controls.Primitives.Popup>;
+      static GetOpenPopupsForXamlRoot(result: Microsoft.UI.Xaml.XamlRoot): System.Collections.Generic.IReadOnlyList<Microsoft.UI.Xaml.Controls.Primitives.Popup>;
+    }
+    class XamlLight extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.IXamlLight, Microsoft.UI.Xaml.Media.IXamlLightProtected, Microsoft.UI.Xaml.Media.IXamlLightOverrides {
+      constructor();
+      static AddTargetElement(lightId: string, element: Microsoft.UI.Xaml.UIElement): void;
+      static RemoveTargetElement(lightId: string, element: Microsoft.UI.Xaml.UIElement): void;
+      static AddTargetBrush(lightId: string, brush: Microsoft.UI.Xaml.Media.Brush): void;
+      static RemoveTargetBrush(lightId: string, brush: Microsoft.UI.Xaml.Media.Brush): void;
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Media.Animation {
+    class Transition extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.Animation.ITransition {
+    }
+    class AddDeleteThemeTransition extends Microsoft.UI.Xaml.Media.Animation.Transition implements Microsoft.UI.Xaml.Media.Animation.IAddDeleteThemeTransition {
+      constructor();
+    }
+    class EasingFunctionBase extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.Animation.IEasingFunctionBase {
+      EasingMode: number;
+      static readonly EasingModeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      Ease(result: number): number;
+    }
+    class BackEase extends Microsoft.UI.Xaml.Media.Animation.EasingFunctionBase implements Microsoft.UI.Xaml.Media.Animation.IBackEase {
+      Amplitude: number;
+      static readonly AmplitudeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ConnectedAnimationConfiguration implements Microsoft.UI.Xaml.Media.Animation.IConnectedAnimationConfiguration {
+    }
+    class BasicConnectedAnimationConfiguration extends Microsoft.UI.Xaml.Media.Animation.ConnectedAnimationConfiguration implements Microsoft.UI.Xaml.Media.Animation.IBasicConnectedAnimationConfiguration {
+      constructor();
+    }
+    class BeginStoryboard extends Microsoft.UI.Xaml.TriggerAction implements Microsoft.UI.Xaml.Media.Animation.IBeginStoryboard {
+      Storyboard: Microsoft.UI.Xaml.Media.Animation.Storyboard;
+      static readonly StoryboardProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class BounceEase extends Microsoft.UI.Xaml.Media.Animation.EasingFunctionBase implements Microsoft.UI.Xaml.Media.Animation.IBounceEase {
+      Bounciness: number;
+      Bounces: number;
+      static readonly BouncesProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BouncinessProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class CircleEase extends Microsoft.UI.Xaml.Media.Animation.EasingFunctionBase implements Microsoft.UI.Xaml.Media.Animation.ICircleEase {
+      constructor();
+    }
+    class ClockState extends System.Enum {
+      value__: number;
+      static Active: number;
+      static Filling: number;
+      static Stopped: number;
+    }
+    class Timeline extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.Animation.ITimeline {
+      Completed: System.EventHandler<any> | null;
+      SpeedRatio: number;
+      RepeatBehavior: Microsoft.UI.Xaml.Media.Animation.RepeatBehavior;
+      FillBehavior: number;
+      Duration: Microsoft.UI.Xaml.Duration;
+      BeginTime: System.Nullable<System.TimeSpan>;
+      AutoReverse: boolean;
+      static AllowDependentAnimations: boolean;
+      static readonly AutoReverseProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly BeginTimeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DurationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FillBehaviorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RepeatBehaviorProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SpeedRatioProperty: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class ColorAnimation extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IColorAnimation {
+      To: System.Nullable<Windows.UI.Color>;
+      From: System.Nullable<Windows.UI.Color>;
+      EnableDependentAnimation: boolean;
+      EasingFunction: Microsoft.UI.Xaml.Media.Animation.EasingFunctionBase;
+      By: System.Nullable<Windows.UI.Color>;
+      static readonly ByProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly EasingFunctionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly EnableDependentAnimationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FromProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ToProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ColorAnimationUsingKeyFrames extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IColorAnimationUsingKeyFrames {
+      EnableDependentAnimation: boolean;
+      readonly KeyFrames: Microsoft.UI.Xaml.Media.Animation.ColorKeyFrameCollection;
+      static readonly EnableDependentAnimationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ColorKeyFrame extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.Animation.IColorKeyFrame {
+      Value: Windows.UI.Color;
+      KeyTime: Microsoft.UI.Xaml.Media.Animation.KeyTime;
+      static readonly KeyTimeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ValueProperty: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class ColorKeyFrameCollection {
+      constructor();
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class NavigationTransitionInfo extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.Animation.INavigationTransitionInfo, Microsoft.UI.Xaml.Media.Animation.INavigationTransitionInfoOverrides {
+    }
+    class CommonNavigationTransitionInfo extends Microsoft.UI.Xaml.Media.Animation.NavigationTransitionInfo implements Microsoft.UI.Xaml.Media.Animation.ICommonNavigationTransitionInfo {
+      IsStaggeringEnabled: boolean;
+      static readonly IsStaggerElementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsStaggeringEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      static GetIsStaggerElement(result: Microsoft.UI.Xaml.UIElement): boolean;
+      static SetIsStaggerElement(element: Microsoft.UI.Xaml.UIElement, value: boolean): void;
+    }
+    class ConditionallyIndependentlyAnimatableAttribute extends System.Attribute {
+      constructor();
+    }
+    class ConnectedAnimation implements Microsoft.UI.Xaml.Media.Animation.IConnectedAnimation {
+      Completed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Media.Animation.ConnectedAnimation, any> | null;
+      IsScaleAnimationEnabled: boolean;
+      Configuration: Microsoft.UI.Xaml.Media.Animation.ConnectedAnimationConfiguration;
+      TryStart(result: Microsoft.UI.Xaml.UIElement): boolean;
+      TryStart(result: Microsoft.UI.Xaml.UIElement, destination: System.Collections.Generic.IEnumerable<Microsoft.UI.Xaml.UIElement>): boolean;
+      Cancel(): void;
+      SetAnimationComponent(component: number, animation: Microsoft.UI.Composition.ICompositionAnimationBase): void;
+    }
+    class ConnectedAnimationComponent extends System.Enum {
+      value__: number;
+      static OffsetX: number;
+      static OffsetY: number;
+      static CrossFade: number;
+      static Scale: number;
+    }
+    class ConnectedAnimationService implements Microsoft.UI.Xaml.Media.Animation.IConnectedAnimationService {
+      DefaultEasingFunction: Microsoft.UI.Composition.CompositionEasingFunction;
+      DefaultDuration: System.TimeSpan;
+      PrepareToAnimate(result: string, key: Microsoft.UI.Xaml.UIElement): Microsoft.UI.Xaml.Media.Animation.ConnectedAnimation;
+      GetAnimation(result: string): Microsoft.UI.Xaml.Media.Animation.ConnectedAnimation;
+      static GetForCurrentView(): Microsoft.UI.Xaml.Media.Animation.ConnectedAnimationService;
+    }
+    class ContentThemeTransition extends Microsoft.UI.Xaml.Media.Animation.Transition implements Microsoft.UI.Xaml.Media.Animation.IContentThemeTransition {
+      VerticalOffset: number;
+      HorizontalOffset: number;
+      static readonly HorizontalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly VerticalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ContinuumNavigationTransitionInfo extends Microsoft.UI.Xaml.Media.Animation.NavigationTransitionInfo implements Microsoft.UI.Xaml.Media.Animation.IContinuumNavigationTransitionInfo {
+      ExitElement: Microsoft.UI.Xaml.UIElement;
+      static readonly ExitElementContainerProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ExitElementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsEntranceElementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsExitElementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      static GetIsEntranceElement(result: Microsoft.UI.Xaml.UIElement): boolean;
+      static SetIsEntranceElement(element: Microsoft.UI.Xaml.UIElement, value: boolean): void;
+      static GetIsExitElement(result: Microsoft.UI.Xaml.UIElement): boolean;
+      static SetIsExitElement(element: Microsoft.UI.Xaml.UIElement, value: boolean): void;
+      static GetExitElementContainer(result: Microsoft.UI.Xaml.Controls.ListViewBase): boolean;
+      static SetExitElementContainer(element: Microsoft.UI.Xaml.Controls.ListViewBase, value: boolean): void;
+    }
+    class CubicEase extends Microsoft.UI.Xaml.Media.Animation.EasingFunctionBase implements Microsoft.UI.Xaml.Media.Animation.ICubicEase {
+      constructor();
+    }
+    class DirectConnectedAnimationConfiguration extends Microsoft.UI.Xaml.Media.Animation.ConnectedAnimationConfiguration implements Microsoft.UI.Xaml.Media.Animation.IDirectConnectedAnimationConfiguration {
+      constructor();
+    }
+    class DiscreteColorKeyFrame extends Microsoft.UI.Xaml.Media.Animation.ColorKeyFrame implements Microsoft.UI.Xaml.Media.Animation.IDiscreteColorKeyFrame {
+      constructor();
+    }
+    class DoubleKeyFrame extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.Animation.IDoubleKeyFrame {
+      Value: number;
+      KeyTime: Microsoft.UI.Xaml.Media.Animation.KeyTime;
+      static readonly KeyTimeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ValueProperty: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class DiscreteDoubleKeyFrame extends Microsoft.UI.Xaml.Media.Animation.DoubleKeyFrame implements Microsoft.UI.Xaml.Media.Animation.IDiscreteDoubleKeyFrame {
+      constructor();
+    }
+    class ObjectKeyFrame extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.Animation.IObjectKeyFrame {
+      Value: any;
+      KeyTime: Microsoft.UI.Xaml.Media.Animation.KeyTime;
+      static readonly KeyTimeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ValueProperty: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class DiscreteObjectKeyFrame extends Microsoft.UI.Xaml.Media.Animation.ObjectKeyFrame implements Microsoft.UI.Xaml.Media.Animation.IDiscreteObjectKeyFrame {
+      constructor();
+    }
+    class PointKeyFrame extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.Animation.IPointKeyFrame {
+      Value: Windows.Foundation.Point;
+      KeyTime: Microsoft.UI.Xaml.Media.Animation.KeyTime;
+      static readonly KeyTimeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ValueProperty: Microsoft.UI.Xaml.DependencyProperty;
+    }
+    class DiscretePointKeyFrame extends Microsoft.UI.Xaml.Media.Animation.PointKeyFrame implements Microsoft.UI.Xaml.Media.Animation.IDiscretePointKeyFrame {
+      constructor();
+    }
+    class DoubleAnimation extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IDoubleAnimation {
+      To: System.Nullable<number>;
+      From: System.Nullable<number>;
+      EnableDependentAnimation: boolean;
+      EasingFunction: Microsoft.UI.Xaml.Media.Animation.EasingFunctionBase;
+      By: System.Nullable<number>;
+      static readonly ByProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly EasingFunctionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly EnableDependentAnimationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FromProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ToProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class DoubleAnimationUsingKeyFrames extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IDoubleAnimationUsingKeyFrames {
+      EnableDependentAnimation: boolean;
+      readonly KeyFrames: Microsoft.UI.Xaml.Media.Animation.DoubleKeyFrameCollection;
+      static readonly EnableDependentAnimationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class DoubleKeyFrameCollection {
+      constructor();
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class DragItemThemeAnimation extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IDragItemThemeAnimation {
+      TargetName: string;
+      static readonly TargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class DragOverThemeAnimation extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IDragOverThemeAnimation {
+      ToOffset: number;
+      TargetName: string;
+      Direction: number;
+      static readonly DirectionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ToOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class DrillInNavigationTransitionInfo extends Microsoft.UI.Xaml.Media.Animation.NavigationTransitionInfo implements Microsoft.UI.Xaml.Media.Animation.IDrillInNavigationTransitionInfo {
+      constructor();
+    }
+    class DrillInThemeAnimation extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IDrillInThemeAnimation {
+      ExitTargetName: string;
+      ExitTarget: Microsoft.UI.Xaml.DependencyObject;
+      EntranceTargetName: string;
+      EntranceTarget: Microsoft.UI.Xaml.DependencyObject;
+      static readonly EntranceTargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly EntranceTargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ExitTargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ExitTargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class DrillOutThemeAnimation extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IDrillOutThemeAnimation {
+      ExitTargetName: string;
+      ExitTarget: Microsoft.UI.Xaml.DependencyObject;
+      EntranceTargetName: string;
+      EntranceTarget: Microsoft.UI.Xaml.DependencyObject;
+      static readonly EntranceTargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly EntranceTargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ExitTargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ExitTargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class DropTargetItemThemeAnimation extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IDropTargetItemThemeAnimation {
+      TargetName: string;
+      static readonly TargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class EasingColorKeyFrame extends Microsoft.UI.Xaml.Media.Animation.ColorKeyFrame implements Microsoft.UI.Xaml.Media.Animation.IEasingColorKeyFrame {
+      EasingFunction: Microsoft.UI.Xaml.Media.Animation.EasingFunctionBase;
+      static readonly EasingFunctionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class EasingDoubleKeyFrame extends Microsoft.UI.Xaml.Media.Animation.DoubleKeyFrame implements Microsoft.UI.Xaml.Media.Animation.IEasingDoubleKeyFrame {
+      EasingFunction: Microsoft.UI.Xaml.Media.Animation.EasingFunctionBase;
+      static readonly EasingFunctionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class EasingMode extends System.Enum {
+      value__: number;
+      static EaseOut: number;
+      static EaseIn: number;
+      static EaseInOut: number;
+    }
+    class EasingPointKeyFrame extends Microsoft.UI.Xaml.Media.Animation.PointKeyFrame implements Microsoft.UI.Xaml.Media.Animation.IEasingPointKeyFrame {
+      EasingFunction: Microsoft.UI.Xaml.Media.Animation.EasingFunctionBase;
+      static readonly EasingFunctionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class EdgeUIThemeTransition extends Microsoft.UI.Xaml.Media.Animation.Transition implements Microsoft.UI.Xaml.Media.Animation.IEdgeUIThemeTransition {
+      Edge: number;
+      static readonly EdgeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ElasticEase extends Microsoft.UI.Xaml.Media.Animation.EasingFunctionBase implements Microsoft.UI.Xaml.Media.Animation.IElasticEase {
+      Springiness: number;
+      Oscillations: number;
+      static readonly OscillationsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly SpringinessProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class EntranceNavigationTransitionInfo extends Microsoft.UI.Xaml.Media.Animation.NavigationTransitionInfo implements Microsoft.UI.Xaml.Media.Animation.IEntranceNavigationTransitionInfo {
+      static readonly IsTargetElementProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      static GetIsTargetElement(result: Microsoft.UI.Xaml.UIElement): boolean;
+      static SetIsTargetElement(element: Microsoft.UI.Xaml.UIElement, value: boolean): void;
+    }
+    class EntranceThemeTransition extends Microsoft.UI.Xaml.Media.Animation.Transition implements Microsoft.UI.Xaml.Media.Animation.IEntranceThemeTransition {
+      IsStaggeringEnabled: boolean;
+      FromVerticalOffset: number;
+      FromHorizontalOffset: number;
+      static readonly FromHorizontalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FromVerticalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsStaggeringEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ExponentialEase extends Microsoft.UI.Xaml.Media.Animation.EasingFunctionBase implements Microsoft.UI.Xaml.Media.Animation.IExponentialEase {
+      Exponent: number;
+      static readonly ExponentProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class FadeInThemeAnimation extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IFadeInThemeAnimation {
+      TargetName: string;
+      static readonly TargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class FadeOutThemeAnimation extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IFadeOutThemeAnimation {
+      TargetName: string;
+      static readonly TargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class FillBehavior extends System.Enum {
+      value__: number;
+      static HoldEnd: number;
+      static Stop: number;
+    }
+    class GravityConnectedAnimationConfiguration extends Microsoft.UI.Xaml.Media.Animation.ConnectedAnimationConfiguration implements Microsoft.UI.Xaml.Media.Animation.IGravityConnectedAnimationConfiguration {
+      IsShadowEnabled: boolean;
+      constructor();
+    }
+    class IndependentlyAnimatableAttribute extends System.Attribute {
+      constructor();
+    }
+    class KeySpline extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.Animation.IKeySpline {
+      ControlPoint2: Windows.Foundation.Point;
+      ControlPoint1: Windows.Foundation.Point;
+      constructor();
+    }
+    class KeyTime extends System.ValueType {
+      TimeSpan: System.TimeSpan;
+    }
+    class KeyTimeHelper implements Microsoft.UI.Xaml.Media.Animation.IKeyTimeHelper {
+      static FromTimeSpan(result: System.TimeSpan): Microsoft.UI.Xaml.Media.Animation.KeyTime;
+    }
+    class LinearColorKeyFrame extends Microsoft.UI.Xaml.Media.Animation.ColorKeyFrame implements Microsoft.UI.Xaml.Media.Animation.ILinearColorKeyFrame {
+      constructor();
+    }
+    class LinearDoubleKeyFrame extends Microsoft.UI.Xaml.Media.Animation.DoubleKeyFrame implements Microsoft.UI.Xaml.Media.Animation.ILinearDoubleKeyFrame {
+      constructor();
+    }
+    class LinearPointKeyFrame extends Microsoft.UI.Xaml.Media.Animation.PointKeyFrame implements Microsoft.UI.Xaml.Media.Animation.ILinearPointKeyFrame {
+      constructor();
+    }
+    class NavigationThemeTransition extends Microsoft.UI.Xaml.Media.Animation.Transition implements Microsoft.UI.Xaml.Media.Animation.INavigationThemeTransition {
+      DefaultNavigationTransitionInfo: Microsoft.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+      static readonly DefaultNavigationTransitionInfoProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ObjectAnimationUsingKeyFrames extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IObjectAnimationUsingKeyFrames {
+      EnableDependentAnimation: boolean;
+      readonly KeyFrames: Microsoft.UI.Xaml.Media.Animation.ObjectKeyFrameCollection;
+      static readonly EnableDependentAnimationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class ObjectKeyFrameCollection {
+      constructor();
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class PaneThemeTransition extends Microsoft.UI.Xaml.Media.Animation.Transition implements Microsoft.UI.Xaml.Media.Animation.IPaneThemeTransition {
+      Edge: number;
+      static readonly EdgeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PointAnimation extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IPointAnimation {
+      To: System.Nullable<Windows.Foundation.Point>;
+      From: System.Nullable<Windows.Foundation.Point>;
+      EnableDependentAnimation: boolean;
+      EasingFunction: Microsoft.UI.Xaml.Media.Animation.EasingFunctionBase;
+      By: System.Nullable<Windows.Foundation.Point>;
+      static readonly ByProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly EasingFunctionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly EnableDependentAnimationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FromProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ToProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PointAnimationUsingKeyFrames extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IPointAnimationUsingKeyFrames {
+      EnableDependentAnimation: boolean;
+      readonly KeyFrames: Microsoft.UI.Xaml.Media.Animation.PointKeyFrameCollection;
+      static readonly EnableDependentAnimationProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PointKeyFrameCollection {
+      constructor();
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class PointerDownThemeAnimation extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IPointerDownThemeAnimation {
+      TargetName: string;
+      static readonly TargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PointerUpThemeAnimation extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IPointerUpThemeAnimation {
+      TargetName: string;
+      static readonly TargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PopInThemeAnimation extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IPopInThemeAnimation {
+      TargetName: string;
+      FromVerticalOffset: number;
+      FromHorizontalOffset: number;
+      static readonly FromHorizontalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FromVerticalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PopOutThemeAnimation extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IPopOutThemeAnimation {
+      TargetName: string;
+      static readonly TargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PopupThemeTransition extends Microsoft.UI.Xaml.Media.Animation.Transition implements Microsoft.UI.Xaml.Media.Animation.IPopupThemeTransition {
+      FromVerticalOffset: number;
+      FromHorizontalOffset: number;
+      static readonly FromHorizontalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FromVerticalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class PowerEase extends Microsoft.UI.Xaml.Media.Animation.EasingFunctionBase implements Microsoft.UI.Xaml.Media.Animation.IPowerEase {
+      Power: number;
+      static readonly PowerProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class QuadraticEase extends Microsoft.UI.Xaml.Media.Animation.EasingFunctionBase implements Microsoft.UI.Xaml.Media.Animation.IQuadraticEase {
+      constructor();
+    }
+    class QuarticEase extends Microsoft.UI.Xaml.Media.Animation.EasingFunctionBase implements Microsoft.UI.Xaml.Media.Animation.IQuarticEase {
+      constructor();
+    }
+    class QuinticEase extends Microsoft.UI.Xaml.Media.Animation.EasingFunctionBase implements Microsoft.UI.Xaml.Media.Animation.IQuinticEase {
+      constructor();
+    }
+    class ReorderThemeTransition extends Microsoft.UI.Xaml.Media.Animation.Transition implements Microsoft.UI.Xaml.Media.Animation.IReorderThemeTransition {
+      constructor();
+    }
+    class RepeatBehavior extends System.ValueType {
+      Count: number;
+      Duration: System.TimeSpan;
+      Type: number;
+    }
+    class RepeatBehaviorHelper implements Microsoft.UI.Xaml.Media.Animation.IRepeatBehaviorHelper {
+      static readonly Forever: Microsoft.UI.Xaml.Media.Animation.RepeatBehavior;
+      static FromCount(result: number): Microsoft.UI.Xaml.Media.Animation.RepeatBehavior;
+      static FromDuration(result: System.TimeSpan): Microsoft.UI.Xaml.Media.Animation.RepeatBehavior;
+      static GetHasCount(result: Microsoft.UI.Xaml.Media.Animation.RepeatBehavior): boolean;
+      static GetHasDuration(result: Microsoft.UI.Xaml.Media.Animation.RepeatBehavior): boolean;
+      static Equals(result: Microsoft.UI.Xaml.Media.Animation.RepeatBehavior, target: Microsoft.UI.Xaml.Media.Animation.RepeatBehavior): boolean;
+    }
+    class RepeatBehaviorType extends System.Enum {
+      value__: number;
+      static Count: number;
+      static Duration: number;
+      static Forever: number;
+    }
+    class RepositionThemeAnimation extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IRepositionThemeAnimation {
+      TargetName: string;
+      FromVerticalOffset: number;
+      FromHorizontalOffset: number;
+      static readonly FromHorizontalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FromVerticalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class RepositionThemeTransition extends Microsoft.UI.Xaml.Media.Animation.Transition implements Microsoft.UI.Xaml.Media.Animation.IRepositionThemeTransition {
+      IsStaggeringEnabled: boolean;
+      static readonly IsStaggeringEnabledProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class SineEase extends Microsoft.UI.Xaml.Media.Animation.EasingFunctionBase implements Microsoft.UI.Xaml.Media.Animation.ISineEase {
+      constructor();
+    }
+    class SlideNavigationTransitionEffect extends System.Enum {
+      value__: number;
+      static FromBottom: number;
+      static FromLeft: number;
+      static FromRight: number;
+    }
+    class SlideNavigationTransitionInfo extends Microsoft.UI.Xaml.Media.Animation.NavigationTransitionInfo implements Microsoft.UI.Xaml.Media.Animation.ISlideNavigationTransitionInfo {
+      Effect: number;
+      static readonly EffectProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class SplineColorKeyFrame extends Microsoft.UI.Xaml.Media.Animation.ColorKeyFrame implements Microsoft.UI.Xaml.Media.Animation.ISplineColorKeyFrame {
+      KeySpline: Microsoft.UI.Xaml.Media.Animation.KeySpline;
+      static readonly KeySplineProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class SplineDoubleKeyFrame extends Microsoft.UI.Xaml.Media.Animation.DoubleKeyFrame implements Microsoft.UI.Xaml.Media.Animation.ISplineDoubleKeyFrame {
+      KeySpline: Microsoft.UI.Xaml.Media.Animation.KeySpline;
+      static readonly KeySplineProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class SplinePointKeyFrame extends Microsoft.UI.Xaml.Media.Animation.PointKeyFrame implements Microsoft.UI.Xaml.Media.Animation.ISplinePointKeyFrame {
+      KeySpline: Microsoft.UI.Xaml.Media.Animation.KeySpline;
+      static readonly KeySplineProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class SplitCloseThemeAnimation extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.ISplitCloseThemeAnimation {
+      OpenedTargetName: string;
+      OpenedTarget: Microsoft.UI.Xaml.DependencyObject;
+      OpenedLength: number;
+      OffsetFromCenter: number;
+      ContentTranslationOffset: number;
+      ContentTranslationDirection: number;
+      ContentTargetName: string;
+      ContentTarget: Microsoft.UI.Xaml.DependencyObject;
+      ClosedTargetName: string;
+      ClosedTarget: Microsoft.UI.Xaml.DependencyObject;
+      ClosedLength: number;
+      static readonly ClosedLengthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ClosedTargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ClosedTargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentTargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentTargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentTranslationDirectionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentTranslationOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OffsetFromCenterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OpenedLengthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OpenedTargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OpenedTargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class SplitOpenThemeAnimation extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.ISplitOpenThemeAnimation {
+      OpenedTargetName: string;
+      OpenedTarget: Microsoft.UI.Xaml.DependencyObject;
+      OpenedLength: number;
+      OffsetFromCenter: number;
+      ContentTranslationOffset: number;
+      ContentTranslationDirection: number;
+      ContentTargetName: string;
+      ContentTarget: Microsoft.UI.Xaml.DependencyObject;
+      ClosedTargetName: string;
+      ClosedTarget: Microsoft.UI.Xaml.DependencyObject;
+      ClosedLength: number;
+      static readonly ClosedLengthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ClosedTargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ClosedTargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentTargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentTargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentTranslationDirectionProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ContentTranslationOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OffsetFromCenterProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OpenedLengthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OpenedTargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OpenedTargetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class Storyboard extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.IStoryboard {
+      readonly Children: Microsoft.UI.Xaml.Media.Animation.TimelineCollection;
+      static readonly TargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TargetPropertyProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      Seek(offset: System.TimeSpan): void;
+      Stop(): void;
+      Begin(): void;
+      Pause(): void;
+      Resume(): void;
+      GetCurrentState(): number;
+      GetCurrentTime(): System.TimeSpan;
+      SeekAlignedToLastTick(offset: System.TimeSpan): void;
+      SkipToFill(): void;
+      static GetTargetProperty(result: Microsoft.UI.Xaml.Media.Animation.Timeline): string;
+      static SetTargetProperty(element: Microsoft.UI.Xaml.Media.Animation.Timeline, path: string): void;
+      static GetTargetName(result: Microsoft.UI.Xaml.Media.Animation.Timeline): string;
+      static SetTargetName(element: Microsoft.UI.Xaml.Media.Animation.Timeline, name: string): void;
+      static SetTarget(timeline: Microsoft.UI.Xaml.Media.Animation.Timeline, target: Microsoft.UI.Xaml.DependencyObject): void;
+    }
+    class SuppressNavigationTransitionInfo extends Microsoft.UI.Xaml.Media.Animation.NavigationTransitionInfo implements Microsoft.UI.Xaml.Media.Animation.ISuppressNavigationTransitionInfo {
+      constructor();
+    }
+    class SwipeBackThemeAnimation extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.ISwipeBackThemeAnimation {
+      TargetName: string;
+      FromVerticalOffset: number;
+      FromHorizontalOffset: number;
+      static readonly FromHorizontalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly FromVerticalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class SwipeHintThemeAnimation extends Microsoft.UI.Xaml.Media.Animation.Timeline implements Microsoft.UI.Xaml.Media.Animation.ISwipeHintThemeAnimation {
+      ToVerticalOffset: number;
+      ToHorizontalOffset: number;
+      TargetName: string;
+      static readonly TargetNameProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ToHorizontalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ToVerticalOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class TimelineCollection {
+      constructor();
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+    class TransitionCollection {
+      constructor();
+      GetAt(index: number): any;
+      readonly Size: number;
+      IndexOf(value: any, index: number): boolean;
+      SetAt(index: number, value: any): void;
+      InsertAt(index: number, value: any): void;
+      RemoveAt(index: number): void;
+      Append(value: any): void;
+      RemoveAtEnd(): void;
+      Clear(): void;
+      GetMany(startIndex: number, items: any[]): number;
+      ReplaceAll(items: any[]): void;
+      GetView(): any;
+      First(): any;
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Media.Imaging {
+    class BitmapCreateOptions extends System.Enum {
+      value__: number;
+      static None: number;
+      static IgnoreImageCache: number;
+    }
+    class BitmapSource extends Microsoft.UI.Xaml.Media.ImageSource implements Microsoft.UI.Xaml.Media.Imaging.IBitmapSource {
+      readonly PixelHeight: number;
+      readonly PixelWidth: number;
+      static readonly PixelHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PixelWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      SetSource(streamSource: Windows.Storage.Streams.IRandomAccessStream): void;
+      SetSourceAsync(operation: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    }
+    class BitmapImage extends Microsoft.UI.Xaml.Media.Imaging.BitmapSource implements Microsoft.UI.Xaml.Media.Imaging.IBitmapImage {
+      DownloadProgress: Microsoft.UI.Xaml.Media.Imaging.DownloadProgressEventHandler | null;
+      ImageFailed: Microsoft.UI.Xaml.ExceptionRoutedEventHandler | null;
+      ImageOpened: Microsoft.UI.Xaml.RoutedEventHandler | null;
+      UriSource: System.Uri;
+      DecodePixelWidth: number;
+      DecodePixelType: number;
+      DecodePixelHeight: number;
+      CreateOptions: number;
+      AutoPlay: boolean;
+      readonly IsAnimatedBitmap: boolean;
+      readonly IsPlaying: boolean;
+      static readonly AutoPlayProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CreateOptionsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DecodePixelHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DecodePixelTypeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly DecodePixelWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsAnimatedBitmapProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly IsPlayingProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly UriSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor(uriSource: System.Uri);
+      constructor();
+      Play(): void;
+      Stop(): void;
+    }
+    class DecodePixelType extends System.Enum {
+      value__: number;
+      static Physical: number;
+      static Logical: number;
+    }
+    class DownloadProgressEventArgs implements Microsoft.UI.Xaml.Media.Imaging.IDownloadProgressEventArgs {
+      Progress: number;
+    }
+    class DownloadProgressEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Media.Imaging.DownloadProgressEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Media.Imaging.DownloadProgressEventArgs): void;
+    }
+    class RenderTargetBitmap extends Microsoft.UI.Xaml.Media.ImageSource implements Microsoft.UI.Xaml.Media.Imaging.IRenderTargetBitmap {
+      readonly PixelHeight: number;
+      readonly PixelWidth: number;
+      static readonly PixelHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PixelWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      RenderAsync(operation: Microsoft.UI.Xaml.UIElement): Windows.Foundation.IAsyncAction;
+      RenderAsync(operation: Microsoft.UI.Xaml.UIElement, element: number, scaledWidth: number): Windows.Foundation.IAsyncAction;
+      GetPixelsAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    }
+    class SoftwareBitmapSource extends Microsoft.UI.Xaml.Media.ImageSource implements Microsoft.UI.Xaml.Media.Imaging.ISoftwareBitmapSource {
+      constructor();
+      SetBitmapAsync(operation: Windows.Graphics.Imaging.SoftwareBitmap): Windows.Foundation.IAsyncAction;
+      Dispose(): void;
+    }
+    class SurfaceImageSource extends Microsoft.UI.Xaml.Media.ImageSource implements Microsoft.UI.Xaml.Media.Imaging.ISurfaceImageSource {
+      constructor(pixelWidth: number, pixelHeight: number);
+      constructor(pixelWidth: number, pixelHeight: number, isOpaque: boolean);
+    }
+    class SvgImageSource extends Microsoft.UI.Xaml.Media.ImageSource implements Microsoft.UI.Xaml.Media.Imaging.ISvgImageSource {
+      OpenFailed: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Media.Imaging.SvgImageSource, Microsoft.UI.Xaml.Media.Imaging.SvgImageSourceFailedEventArgs> | null;
+      Opened: Windows.Foundation.TypedEventHandler<Microsoft.UI.Xaml.Media.Imaging.SvgImageSource, Microsoft.UI.Xaml.Media.Imaging.SvgImageSourceOpenedEventArgs> | null;
+      UriSource: System.Uri;
+      RasterizePixelWidth: number;
+      RasterizePixelHeight: number;
+      static readonly RasterizePixelHeightProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RasterizePixelWidthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly UriSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      constructor(uriSource: System.Uri);
+      SetSourceAsync(operation: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<number>;
+    }
+    class SvgImageSourceFailedEventArgs implements Microsoft.UI.Xaml.Media.Imaging.ISvgImageSourceFailedEventArgs {
+      readonly Status: number;
+    }
+    class SvgImageSourceLoadStatus extends System.Enum {
+      value__: number;
+      static Success: number;
+      static NetworkError: number;
+      static InvalidFormat: number;
+      static Other: number;
+    }
+    class SvgImageSourceOpenedEventArgs implements Microsoft.UI.Xaml.Media.Imaging.ISvgImageSourceOpenedEventArgs {
+    }
+    class VirtualSurfaceImageSource extends Microsoft.UI.Xaml.Media.Imaging.SurfaceImageSource implements Microsoft.UI.Xaml.Media.Imaging.IVirtualSurfaceImageSource {
+      constructor(pixelWidth: number, pixelHeight: number);
+      constructor(pixelWidth: number, pixelHeight: number, isOpaque: boolean);
+    }
+    class WriteableBitmap extends Microsoft.UI.Xaml.Media.Imaging.BitmapSource implements Microsoft.UI.Xaml.Media.Imaging.IWriteableBitmap {
+      readonly PixelBuffer: Windows.Storage.Streams.IBuffer;
+      constructor(pixelWidth: number, pixelHeight: number);
+      Invalidate(): void;
+    }
+    class XamlRenderingBackgroundTask implements Microsoft.UI.Xaml.Media.Imaging.IXamlRenderingBackgroundTask, Microsoft.UI.Xaml.Media.Imaging.IXamlRenderingBackgroundTaskOverrides {
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Media.Media3D {
+    class Transform3D extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Media.Media3D.ITransform3D {
+    }
+    class CompositeTransform3D extends Microsoft.UI.Xaml.Media.Media3D.Transform3D implements Microsoft.UI.Xaml.Media.Media3D.ICompositeTransform3D {
+      TranslateZ: number;
+      TranslateY: number;
+      TranslateX: number;
+      ScaleZ: number;
+      ScaleY: number;
+      ScaleX: number;
+      RotationZ: number;
+      RotationY: number;
+      RotationX: number;
+      CenterZ: number;
+      CenterY: number;
+      CenterX: number;
+      static readonly CenterXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CenterYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly CenterZProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RotationXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RotationYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RotationZProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ScaleXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ScaleYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly ScaleZProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TranslateXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TranslateYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly TranslateZProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class Matrix3D extends System.ValueType {
+      M11: number;
+      M12: number;
+      M13: number;
+      M14: number;
+      M21: number;
+      M22: number;
+      M23: number;
+      M24: number;
+      M31: number;
+      M32: number;
+      M33: number;
+      M34: number;
+      OffsetX: number;
+      OffsetY: number;
+      OffsetZ: number;
+      M44: number;
+    }
+    class Matrix3DHelper implements Microsoft.UI.Xaml.Media.Media3D.IMatrix3DHelper {
+      static readonly Identity: Microsoft.UI.Xaml.Media.Media3D.Matrix3D;
+      static Multiply(result: Microsoft.UI.Xaml.Media.Media3D.Matrix3D, matrix1: Microsoft.UI.Xaml.Media.Media3D.Matrix3D): Microsoft.UI.Xaml.Media.Media3D.Matrix3D;
+      static FromElements(result: number, m11: number, m12: number, m13: number, m14: number, m21: number, m22: number, m23: number, m24: number, m31: number, m32: number, m33: number, m34: number, offsetX: number, offsetY: number, offsetZ: number): Microsoft.UI.Xaml.Media.Media3D.Matrix3D;
+      static GetHasInverse(result: Microsoft.UI.Xaml.Media.Media3D.Matrix3D): boolean;
+      static GetIsIdentity(result: Microsoft.UI.Xaml.Media.Media3D.Matrix3D): boolean;
+      static Invert(result: Microsoft.UI.Xaml.Media.Media3D.Matrix3D): Microsoft.UI.Xaml.Media.Media3D.Matrix3D;
+    }
+    class PerspectiveTransform3D extends Microsoft.UI.Xaml.Media.Media3D.Transform3D implements Microsoft.UI.Xaml.Media.Media3D.IPerspectiveTransform3D {
+      OffsetY: number;
+      OffsetX: number;
+      Depth: number;
+      static readonly DepthProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OffsetXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly OffsetYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Navigation {
+    class FrameNavigationOptions implements Microsoft.UI.Xaml.Navigation.IFrameNavigationOptions {
+      TransitionInfoOverride: Microsoft.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+      IsNavigationStackEnabled: boolean;
+      constructor();
+    }
+    class NavigatedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Navigation.NavigationEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Navigation.NavigationEventArgs): void;
+    }
+    class NavigatingCancelEventArgs implements Microsoft.UI.Xaml.Navigation.INavigatingCancelEventArgs {
+      Cancel: boolean;
+      readonly NavigationMode: number;
+      readonly NavigationTransitionInfo: Microsoft.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+      readonly Parameter: any;
+      readonly SourcePageType: System.Type;
+    }
+    class NavigatingCancelEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Navigation.NavigatingCancelEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Navigation.NavigatingCancelEventArgs): void;
+    }
+    class NavigationCacheMode extends System.Enum {
+      value__: number;
+      static Disabled: number;
+      static Required: number;
+      static Enabled: number;
+    }
+    class NavigationEventArgs implements Microsoft.UI.Xaml.Navigation.INavigationEventArgs {
+      Uri: System.Uri;
+      readonly Content: any;
+      readonly NavigationMode: number;
+      readonly NavigationTransitionInfo: Microsoft.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+      readonly Parameter: any;
+      readonly SourcePageType: System.Type;
+    }
+    class NavigationFailedEventArgs implements Microsoft.UI.Xaml.Navigation.INavigationFailedEventArgs {
+      Handled: boolean;
+      readonly Exception: System.Exception;
+      readonly SourcePageType: System.Type;
+    }
+    class NavigationFailedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Navigation.NavigationFailedEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Navigation.NavigationFailedEventArgs): void;
+    }
+    class NavigationMode extends System.Enum {
+      value__: number;
+      static New: number;
+      static Back: number;
+      static Forward: number;
+      static Refresh: number;
+    }
+    class NavigationStoppedEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Navigation.NavigationEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Navigation.NavigationEventArgs): void;
+    }
+    class PageStackEntry extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Navigation.IPageStackEntry {
+      readonly NavigationTransitionInfo: Microsoft.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+      readonly Parameter: any;
+      readonly SourcePageType: System.Type;
+      static readonly SourcePageTypeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor(sourcePageType: System.Type, parameter: any, navigationTransitionInfo: Microsoft.UI.Xaml.Media.Animation.NavigationTransitionInfo);
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Printing {
+    class AddPagesEventArgs implements Microsoft.UI.Xaml.Printing.IAddPagesEventArgs {
+      readonly PrintTaskOptions: Windows.Graphics.Printing.PrintTaskOptions;
+      constructor();
+    }
+    class AddPagesEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Printing.AddPagesEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Printing.AddPagesEventArgs): void;
+    }
+    class GetPreviewPageEventArgs implements Microsoft.UI.Xaml.Printing.IGetPreviewPageEventArgs {
+      readonly PageNumber: number;
+      constructor();
+    }
+    class GetPreviewPageEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Printing.GetPreviewPageEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Printing.GetPreviewPageEventArgs): void;
+    }
+    class PaginateEventArgs implements Microsoft.UI.Xaml.Printing.IPaginateEventArgs {
+      readonly CurrentPreviewPageNumber: number;
+      readonly PrintTaskOptions: Windows.Graphics.Printing.PrintTaskOptions;
+      constructor();
+    }
+    class PaginateEventHandler {
+      constructor(handler: (sender: any, e: Microsoft.UI.Xaml.Printing.PaginateEventArgs) => void);
+      Invoke(sender: any, e: Microsoft.UI.Xaml.Printing.PaginateEventArgs): void;
+    }
+    class PreviewPageCountType extends System.Enum {
+      value__: number;
+      static Final: number;
+      static Intermediate: number;
+    }
+    class PrintDocument extends Microsoft.UI.Xaml.DependencyObject implements Microsoft.UI.Xaml.Printing.IPrintDocument {
+      AddPages: Microsoft.UI.Xaml.Printing.AddPagesEventHandler | null;
+      GetPreviewPage: Microsoft.UI.Xaml.Printing.GetPreviewPageEventHandler | null;
+      Paginate: Microsoft.UI.Xaml.Printing.PaginateEventHandler | null;
+      readonly DocumentSource: Windows.Graphics.Printing.IPrintDocumentSource;
+      static readonly DocumentSourceProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+      AddPage(pageVisual: Microsoft.UI.Xaml.UIElement): void;
+      AddPagesComplete(): void;
+      SetPreviewPageCount(count: number, type: number): void;
+      SetPreviewPage(pageNumber: number, pageVisual: Microsoft.UI.Xaml.UIElement): void;
+      InvalidatePreview(): void;
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Resources {
+    class CustomXamlResourceLoader implements Microsoft.UI.Xaml.Resources.ICustomXamlResourceLoader, Microsoft.UI.Xaml.Resources.ICustomXamlResourceLoaderOverrides {
+      static Current: Microsoft.UI.Xaml.Resources.CustomXamlResourceLoader;
+      constructor();
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.Shapes {
+    class Shape extends Microsoft.UI.Xaml.FrameworkElement implements Microsoft.UI.Xaml.Shapes.IShape {
+      StrokeThickness: number;
+      StrokeStartLineCap: number;
+      StrokeMiterLimit: number;
+      StrokeLineJoin: number;
+      StrokeEndLineCap: number;
+      StrokeDashOffset: number;
+      StrokeDashCap: number;
+      StrokeDashArray: Microsoft.UI.Xaml.Media.DoubleCollection;
+      Stroke: Microsoft.UI.Xaml.Media.Brush;
+      Stretch: number;
+      Fill: Microsoft.UI.Xaml.Media.Brush;
+      readonly GeometryTransform: Microsoft.UI.Xaml.Media.Transform;
+      static readonly FillProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StretchProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StrokeDashArrayProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StrokeDashCapProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StrokeDashOffsetProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StrokeEndLineCapProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StrokeLineJoinProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StrokeMiterLimitProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StrokeProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StrokeStartLineCapProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly StrokeThicknessProperty: Microsoft.UI.Xaml.DependencyProperty;
+      GetAlphaMask(): Microsoft.UI.Composition.CompositionBrush;
+    }
+    class Ellipse extends Microsoft.UI.Xaml.Shapes.Shape implements Microsoft.UI.Xaml.Shapes.IEllipse {
+      constructor();
+    }
+    class Line extends Microsoft.UI.Xaml.Shapes.Shape implements Microsoft.UI.Xaml.Shapes.ILine {
+      Y2: number;
+      Y1: number;
+      X2: number;
+      X1: number;
+      static readonly X1Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly X2Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly Y1Property: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly Y2Property: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class Path extends Microsoft.UI.Xaml.Shapes.Shape implements Microsoft.UI.Xaml.Shapes.IPath {
+      Data: Microsoft.UI.Xaml.Media.Geometry;
+      static readonly DataProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class Polygon extends Microsoft.UI.Xaml.Shapes.Shape implements Microsoft.UI.Xaml.Shapes.IPolygon {
+      Points: Microsoft.UI.Xaml.Media.PointCollection;
+      FillRule: number;
+      static readonly FillRuleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PointsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class Polyline extends Microsoft.UI.Xaml.Shapes.Shape implements Microsoft.UI.Xaml.Shapes.IPolyline {
+      Points: Microsoft.UI.Xaml.Media.PointCollection;
+      FillRule: number;
+      static readonly FillRuleProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly PointsProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+    class Rectangle extends Microsoft.UI.Xaml.Shapes.Shape implements Microsoft.UI.Xaml.Shapes.IRectangle {
+      RadiusY: number;
+      RadiusX: number;
+      static readonly RadiusXProperty: Microsoft.UI.Xaml.DependencyProperty;
+      static readonly RadiusYProperty: Microsoft.UI.Xaml.DependencyProperty;
+      constructor();
+    }
+}
+
+declare namespace Microsoft.UI.Xaml.XamlTypeInfo {
+    class XamlControlsXamlMetaDataProvider implements Microsoft.UI.Xaml.XamlTypeInfo.IXamlControlsXamlMetaDataProvider, Microsoft.UI.Xaml.Markup.IXamlMetadataProvider {
+      constructor();
+      GetXamlType(result: System.Type): Microsoft.UI.Xaml.Markup.IXamlType;
+      GetXamlType(result: string): Microsoft.UI.Xaml.Markup.IXamlType;
+      GetXmlnsDefinitions(): Microsoft.UI.Xaml.Markup.XmlnsDefinition[];
+      static Initialize(): void;
+    }
+}
+
diff --git a/packages/types-minimal/src/lib/windows/windows.d.ts b/packages/types-minimal/src/lib/windows/windows.d.ts
new file mode 100644
index 0000000000..e528783ef6
--- /dev/null
+++ b/packages/types-minimal/src/lib/windows/windows.d.ts
@@ -0,0 +1,151133 @@
+// Auto-generated by typings-generator
+// Experimental: incomplete WinRT projection coverage
+
+/** Projected WinRT GUID value struct. toString()/valueOf() return the standard
+ *  {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} string form. */
+interface Guid {
+  /** High 32 bits */
+  data1: number;
+  /** Bits 32-47 */
+  data2: number;
+  /** Bits 48-63 */
+  data3: number;
+  /** Low 64 bits as 8 individual bytes */
+  data4: number[];
+  toString(): string;
+  valueOf(): string;
+}
+
+// Roots: Windows
+
+declare namespace Windows.AI.Actions {
+  class ActionEntity implements Windows.AI.Actions.IActionEntity, Windows.AI.Actions.IActionEntity2, Windows.Foundation.IClosable {
+    Close(): void;
+    readonly DisplayInfo: Windows.AI.Actions.ActionEntityDisplayInfo;
+    readonly Id: string;
+    readonly Kind: number;
+  }
+
+  class ActionEntityDisplayInfo implements Windows.AI.Actions.IActionEntityDisplayInfo, Windows.Foundation.IClosable {
+    Close(): void;
+    readonly Title: string;
+  }
+
+  class ActionEntityFactory implements Windows.AI.Actions.IActionEntityFactory2, Windows.AI.Actions.IActionEntityFactory3, Windows.AI.Actions.IActionEntityFactory4, Windows.Foundation.IClosable {
+    Close(): void;
+    CreateContactEntity(contact: Windows.ApplicationModel.Contacts.Contact): Windows.AI.Actions.ContactActionEntity;
+    CreateDocumentEntity(path: string): Windows.AI.Actions.DocumentActionEntity;
+    CreateFileEntity(path: string): Windows.AI.Actions.FileActionEntity;
+    CreatePhotoEntity(path: string): Windows.AI.Actions.PhotoActionEntity;
+    CreateRemoteFileEntity(sourceId: string, fileKind: number, sourceUri: Windows.Foundation.Uri, fileId: string, contentType: string, driveId: string, accountId: string, extension: string): Windows.AI.Actions.RemoteFileActionEntity;
+    CreateStreamingTextActionEntityWriter(textFormat: number): Windows.AI.Actions.StreamingTextActionEntityWriter;
+    CreateTableEntity(data: string[], columnCount: number): Windows.AI.Actions.TableActionEntity;
+    CreateTextEntity(text: string): Windows.AI.Actions.TextActionEntity;
+    CreateTextEntity(text: string, textFormat: number): Windows.AI.Actions.TextActionEntity;
+  }
+
+  class ActionFeedback implements Windows.AI.Actions.IActionFeedback, Windows.Foundation.IClosable {
+    Close(): void;
+    readonly FeedbackKind: number;
+  }
+
+  class ActionInvocationContext implements Windows.AI.Actions.IActionInvocationContext, Windows.AI.Actions.IActionInvocationContext2, Windows.Foundation.IClosable {
+    Close(): void;
+    GetInputEntities(): Windows.AI.Actions.NamedActionEntity[];
+    GetOutputEntities(): Windows.AI.Actions.NamedActionEntity[];
+    SetInputEntity(inputName: string, inputValue: Windows.AI.Actions.ActionEntity): void;
+    SetOutputEntity(outputName: string, outputValue: Windows.AI.Actions.ActionEntity): void;
+    readonly ActionId: string;
+    readonly EntityFactory: Windows.AI.Actions.ActionEntityFactory;
+    ExtendedError: Windows.Foundation.HResult;
+    readonly HelpDetails: Windows.AI.Actions.ActionInvocationHelpDetails;
+    readonly InvokerAppUserModelId: string;
+    readonly InvokerWindowId: Windows.UI.WindowId;
+    Result: number;
+  }
+
+  class ActionInvocationHelpDetails implements Windows.AI.Actions.IActionInvocationHelpDetails, Windows.Foundation.IClosable {
+    Close(): void;
+    Description: string;
+    HelpUri: Windows.Foundation.Uri;
+    HelpUriDescription: string;
+    Kind: number;
+    Title: string;
+  }
+
+  class ActionRuntime implements Windows.AI.Actions.IActionRuntime, Windows.AI.Actions.IActionRuntime2, Windows.AI.Actions.IActionRuntime3, Windows.Foundation.IClosable {
+    Close(): void;
+    CreateActionFeedback(feedbackKind: number): Windows.AI.Actions.ActionFeedback;
+    CreateInvocationContext(actionId: string): Windows.AI.Actions.ActionInvocationContext;
+    CreateInvocationContextWithWindowId(actionId: string, invokerWindowId: Windows.UI.WindowId): Windows.AI.Actions.ActionInvocationContext;
+    GetActionAvailability(actionId: string): boolean;
+    GetActionEntityById(entityId: string): Windows.AI.Actions.ActionEntity;
+    SetActionAvailability(actionId: string, isAvailable: boolean): void;
+    readonly ActionCatalog: Windows.AI.Actions.Hosting.ActionCatalog;
+    readonly EntityFactory: Windows.AI.Actions.ActionEntityFactory;
+    readonly LatestSupportedSchemaVersion: number;
+  }
+
+  class ContactActionEntity extends Windows.AI.Actions.ActionEntity implements Windows.AI.Actions.IContactActionEntity {
+    Close(): void;
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+  }
+
+  class DocumentActionEntity extends Windows.AI.Actions.ActionEntity implements Windows.AI.Actions.IDocumentActionEntity {
+    Close(): void;
+    readonly FullPath: string;
+  }
+
+  class FileActionEntity extends Windows.AI.Actions.ActionEntity implements Windows.AI.Actions.IFileActionEntity {
+    Close(): void;
+    readonly FullPath: string;
+  }
+
+  class NamedActionEntity implements Windows.AI.Actions.INamedActionEntity, Windows.Foundation.IClosable {
+    Close(): void;
+    Entity: Windows.AI.Actions.ActionEntity;
+    Name: string;
+  }
+
+  class PhotoActionEntity extends Windows.AI.Actions.ActionEntity implements Windows.AI.Actions.IPhotoActionEntity {
+    Close(): void;
+    readonly FullPath: string;
+  }
+
+  class RemoteFileActionEntity extends Windows.AI.Actions.ActionEntity implements Windows.AI.Actions.IRemoteFileActionEntity {
+    Close(): void;
+    readonly AccountId: string;
+    readonly ContentType: string;
+    readonly DriveId: string;
+    readonly Extension: string;
+    readonly FileId: string;
+    readonly FileKind: number;
+    readonly SourceId: string;
+    readonly SourceUri: Windows.Foundation.Uri;
+  }
+
+  class StreamingTextActionEntity extends Windows.AI.Actions.ActionEntity implements Windows.AI.Actions.IStreamingTextActionEntity {
+    Close(): void;
+    GetText(): string;
+    readonly IsComplete: boolean;
+    readonly TextFormat: number;
+    TextChanged: Windows.Foundation.TypedEventHandler<Windows.AI.Actions.StreamingTextActionEntity, Windows.AI.Actions.StreamingTextActionEntityTextChangedArgs> | null;
+  }
+
+  class StreamingTextActionEntityTextChangedArgs implements Windows.AI.Actions.IStreamingTextActionEntityTextChangedArgs {
+    readonly IsComplete: boolean;
+    readonly Text: string;
+  }
+
+  class StreamingTextActionEntityWriter implements Windows.AI.Actions.IStreamingTextActionEntityWriter, Windows.Foundation.IClosable {
+    Close(): void;
+    SetText(text: string): void;
+    readonly ReaderEntity: Windows.AI.Actions.StreamingTextActionEntity;
+    readonly TextFormat: number;
+  }
+
+  class TableActionEntity extends Windows.AI.Actions.ActionEntity implements Windows.AI.Actions.ITableActionEntity {
+    Close(): void;
+    GetTextContent(): string[];
+    readonly ColumnCount: number;
+    readonly RowCount: number;
+  }
+
+  class TextActionEntity extends Windows.AI.Actions.ActionEntity implements Windows.AI.Actions.ITextActionEntity, Windows.AI.Actions.ITextActionEntity2 {
+    Close(): void;
+    readonly Text: string;
+    readonly TextFormat: number;
+  }
+
+  enum ActionEntityKind {
+    None = 0,
+    Document = 1,
+    File = 2,
+    Photo = 3,
+    Text = 4,
+    StreamingText = 5,
+    RemoteFile = 6,
+    Table = 7,
+    Contact = 8,
+  }
+
+  enum ActionEntityTextFormat {
+    Plain = 0,
+    Markdown = 1,
+  }
+
+  enum ActionFeedbackKind {
+    Positive = 0,
+    Negative = 1,
+  }
+
+  enum ActionInvocationHelpKind {
+    None = 0,
+    Error = 1,
+    Warning = 2,
+  }
+
+  enum ActionInvocationResult {
+    Success = 0,
+    UserCanceled = 1,
+    Unsupported = 2,
+    Unavailable = 3,
+  }
+
+  enum RemoteFileKind {
+    Document = 0,
+    Photo = 1,
+    File = 2,
+  }
+
+  interface ActionsContract {
+  }
+  var ActionsContract: {
+    new(fields: {  }): ActionsContract;
+  };
+
+  interface IActionEntity {
+    readonly DisplayInfo: Windows.AI.Actions.ActionEntityDisplayInfo;
+    readonly Kind: number;
+  }
+  var IActionEntity: abstract new (...args: any[]) => IActionEntity;
+
+  interface IActionEntity2 {
+    readonly Id: string;
+  }
+  var IActionEntity2: abstract new (...args: any[]) => IActionEntity2;
+
+  interface IActionEntityDisplayInfo {
+    readonly Title: string;
+  }
+  var IActionEntityDisplayInfo: abstract new (...args: any[]) => IActionEntityDisplayInfo;
+
+  interface IActionEntityFactory {
+  }
+  var IActionEntityFactory: abstract new (...args: any[]) => IActionEntityFactory;
+
+  interface IActionEntityFactory2 {
+    CreateDocumentEntity(path: string): Windows.AI.Actions.DocumentActionEntity;
+    CreateFileEntity(path: string): Windows.AI.Actions.FileActionEntity;
+    CreatePhotoEntity(path: string): Windows.AI.Actions.PhotoActionEntity;
+    CreateTextEntity(text: string): Windows.AI.Actions.TextActionEntity;
+  }
+  var IActionEntityFactory2: abstract new (...args: any[]) => IActionEntityFactory2;
+
+  interface IActionEntityFactory3 {
+    CreateRemoteFileEntity(sourceId: string, fileKind: number, sourceUri: Windows.Foundation.Uri, fileId: string, contentType: string, driveId: string, accountId: string, extension: string): Windows.AI.Actions.RemoteFileActionEntity;
+    CreateStreamingTextActionEntityWriter(textFormat: number): Windows.AI.Actions.StreamingTextActionEntityWriter;
+    CreateTextEntity(text: string, textFormat: number): Windows.AI.Actions.TextActionEntity;
+  }
+  var IActionEntityFactory3: abstract new (...args: any[]) => IActionEntityFactory3;
+
+  interface IActionEntityFactory4 {
+    CreateContactEntity(contact: Windows.ApplicationModel.Contacts.Contact): Windows.AI.Actions.ContactActionEntity;
+    CreateTableEntity(data: string[], columnCount: number): Windows.AI.Actions.TableActionEntity;
+  }
+  var IActionEntityFactory4: abstract new (...args: any[]) => IActionEntityFactory4;
+
+  interface IActionEntityFactoryFactory {
+  }
+  var IActionEntityFactoryFactory: abstract new (...args: any[]) => IActionEntityFactoryFactory;
+
+  interface IActionFeedback {
+    readonly FeedbackKind: number;
+  }
+  var IActionFeedback: abstract new (...args: any[]) => IActionFeedback;
+
+  interface IActionInvocationContext {
+    GetInputEntities(): Windows.AI.Actions.NamedActionEntity[];
+    GetOutputEntities(): Windows.AI.Actions.NamedActionEntity[];
+    SetInputEntity(inputName: string, inputValue: Windows.AI.Actions.ActionEntity): void;
+    SetOutputEntity(outputName: string, outputValue: Windows.AI.Actions.ActionEntity): void;
+    readonly EntityFactory: Windows.AI.Actions.ActionEntityFactory;
+    ExtendedError: Windows.Foundation.HResult;
+    Result: number;
+  }
+  var IActionInvocationContext: abstract new (...args: any[]) => IActionInvocationContext;
+
+  interface IActionInvocationContext2 {
+    readonly ActionId: string;
+    readonly HelpDetails: Windows.AI.Actions.ActionInvocationHelpDetails;
+    readonly InvokerAppUserModelId: string;
+    readonly InvokerWindowId: Windows.UI.WindowId;
+  }
+  var IActionInvocationContext2: abstract new (...args: any[]) => IActionInvocationContext2;
+
+  interface IActionInvocationHelpDetails {
+    Description: string;
+    HelpUri: Windows.Foundation.Uri;
+    HelpUriDescription: string;
+    Kind: number;
+    Title: string;
+  }
+  var IActionInvocationHelpDetails: abstract new (...args: any[]) => IActionInvocationHelpDetails;
+
+  interface IActionRuntime {
+    CreateInvocationContext(actionId: string): Windows.AI.Actions.ActionInvocationContext;
+    readonly ActionCatalog: Windows.AI.Actions.Hosting.ActionCatalog;
+    readonly EntityFactory: Windows.AI.Actions.ActionEntityFactory;
+  }
+  var IActionRuntime: abstract new (...args: any[]) => IActionRuntime;
+
+  interface IActionRuntime2 {
+    CreateActionFeedback(feedbackKind: number): Windows.AI.Actions.ActionFeedback;
+    GetActionAvailability(actionId: string): boolean;
+    SetActionAvailability(actionId: string, isAvailable: boolean): void;
+  }
+  var IActionRuntime2: abstract new (...args: any[]) => IActionRuntime2;
+
+  interface IActionRuntime3 {
+    CreateInvocationContextWithWindowId(actionId: string, invokerWindowId: Windows.UI.WindowId): Windows.AI.Actions.ActionInvocationContext;
+    GetActionEntityById(entityId: string): Windows.AI.Actions.ActionEntity;
+    readonly LatestSupportedSchemaVersion: number;
+  }
+  var IActionRuntime3: abstract new (...args: any[]) => IActionRuntime3;
+
+  interface IActionRuntimeFactory {
+  }
+  var IActionRuntimeFactory: abstract new (...args: any[]) => IActionRuntimeFactory;
+
+  interface IContactActionEntity {
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+  }
+  var IContactActionEntity: abstract new (...args: any[]) => IContactActionEntity;
+
+  interface IDocumentActionEntity {
+    readonly FullPath: string;
+  }
+  var IDocumentActionEntity: abstract new (...args: any[]) => IDocumentActionEntity;
+
+  interface IFileActionEntity {
+    readonly FullPath: string;
+  }
+  var IFileActionEntity: abstract new (...args: any[]) => IFileActionEntity;
+
+  interface INamedActionEntity {
+    Entity: Windows.AI.Actions.ActionEntity;
+    Name: string;
+  }
+  var INamedActionEntity: abstract new (...args: any[]) => INamedActionEntity;
+
+  interface IPhotoActionEntity {
+    readonly FullPath: string;
+  }
+  var IPhotoActionEntity: abstract new (...args: any[]) => IPhotoActionEntity;
+
+  interface IRemoteFileActionEntity {
+    readonly AccountId: string;
+    readonly ContentType: string;
+    readonly DriveId: string;
+    readonly Extension: string;
+    readonly FileId: string;
+    readonly FileKind: number;
+    readonly SourceId: string;
+    readonly SourceUri: Windows.Foundation.Uri;
+  }
+  var IRemoteFileActionEntity: abstract new (...args: any[]) => IRemoteFileActionEntity;
+
+  interface IStreamingTextActionEntity {
+    GetText(): string;
+    readonly IsComplete: boolean;
+    readonly TextFormat: number;
+    TextChanged: Windows.Foundation.TypedEventHandler<Windows.AI.Actions.StreamingTextActionEntity, Windows.AI.Actions.StreamingTextActionEntityTextChangedArgs> | null;
+  }
+  var IStreamingTextActionEntity: abstract new (...args: any[]) => IStreamingTextActionEntity;
+
+  interface IStreamingTextActionEntityTextChangedArgs {
+    readonly IsComplete: boolean;
+    readonly Text: string;
+  }
+  var IStreamingTextActionEntityTextChangedArgs: abstract new (...args: any[]) => IStreamingTextActionEntityTextChangedArgs;
+
+  interface IStreamingTextActionEntityWriter {
+    SetText(text: string): void;
+    readonly ReaderEntity: Windows.AI.Actions.StreamingTextActionEntity;
+    readonly TextFormat: number;
+  }
+  var IStreamingTextActionEntityWriter: abstract new (...args: any[]) => IStreamingTextActionEntityWriter;
+
+  interface ITableActionEntity {
+    GetTextContent(): string[];
+    readonly ColumnCount: number;
+    readonly RowCount: number;
+  }
+  var ITableActionEntity: abstract new (...args: any[]) => ITableActionEntity;
+
+  interface ITextActionEntity {
+    readonly Text: string;
+  }
+  var ITextActionEntity: abstract new (...args: any[]) => ITextActionEntity;
+
+  interface ITextActionEntity2 {
+    readonly TextFormat: number;
+  }
+  var ITextActionEntity2: abstract new (...args: any[]) => ITextActionEntity2;
+
+}
+
+declare namespace Windows.AI.Actions.Hosting {
+  class ActionCatalog implements Windows.AI.Actions.Hosting.IActionCatalog, Windows.AI.Actions.Hosting.IActionCatalog2, Windows.Foundation.IClosable {
+    Close(): void;
+    GetActionsForInputs(inputEntities: Windows.AI.Actions.ActionEntity[]): Windows.AI.Actions.Hosting.ActionInstance[];
+    GetActionsForInputs(inputEntities: Windows.AI.Actions.ActionEntity[], invokerWindowId: Windows.UI.WindowId): Windows.AI.Actions.Hosting.ActionInstance[];
+    GetAllActions(): Windows.AI.Actions.Hosting.ActionDefinition[];
+    Changed: Windows.Foundation.TypedEventHandler<Windows.AI.Actions.Hosting.ActionCatalog, Object> | null;
+  }
+
+  class ActionDefinition implements Windows.AI.Actions.Hosting.IActionDefinition, Windows.AI.Actions.Hosting.IActionDefinition2, Windows.AI.Actions.Hosting.IActionDefinition3, Windows.Foundation.IClosable {
+    Close(): void;
+    GetInputs(): Windows.AI.Actions.Hosting.ActionEntityRegistrationInfo[];
+    GetOutputs(): Windows.AI.Actions.Hosting.ActionEntityRegistrationInfo[];
+    GetOverloads(): Windows.AI.Actions.Hosting.ActionOverload[];
+    readonly Description: string;
+    readonly DisplaysUI: boolean;
+    readonly IconFullPath: string;
+    readonly Id: string;
+    readonly PackageFamilyName: string;
+    readonly PackageRelativeApplicationId: string;
+    readonly SchemaVersion: number;
+    readonly UsesGenerativeAI: boolean;
+  }
+
+  class ActionEntityRegistrationInfo implements Windows.AI.Actions.Hosting.IActionEntityRegistrationInfo, Windows.Foundation.IClosable {
+    Close(): void;
+    Kind: number;
+    Name: string;
+  }
+
+  class ActionInstance implements Windows.AI.Actions.Hosting.IActionInstance {
+    InvokeAsync(): Windows.Foundation.IAsyncAction;
+    readonly Context: Windows.AI.Actions.ActionInvocationContext;
+    readonly Definition: Windows.AI.Actions.Hosting.ActionDefinition;
+    readonly DisplayInfo: Windows.AI.Actions.Hosting.ActionInstanceDisplayInfo;
+  }
+
+  class ActionInstanceDisplayInfo implements Windows.AI.Actions.Hosting.IActionInstanceDisplayInfo {
+    readonly Description: string;
+  }
+
+  class ActionOverload implements Windows.AI.Actions.Hosting.IActionOverload, Windows.AI.Actions.Hosting.IActionOverload2, Windows.Foundation.IClosable {
+    Close(): void;
+    GetInputs(): Windows.AI.Actions.Hosting.ActionEntityRegistrationInfo[];
+    GetSupportsFeedback(): boolean;
+    InvokeAsync(context: Windows.AI.Actions.ActionInvocationContext): Windows.Foundation.IAsyncAction;
+    InvokeFeedbackAsync(context: Windows.AI.Actions.ActionInvocationContext, feedback: Windows.AI.Actions.ActionFeedback): Windows.Foundation.IAsyncAction;
+    readonly DescriptionTemplate: string;
+  }
+
+  interface IActionCatalog {
+    GetAllActions(): Windows.AI.Actions.Hosting.ActionDefinition[];
+    Changed: Windows.Foundation.TypedEventHandler<Windows.AI.Actions.Hosting.ActionCatalog, Object> | null;
+  }
+  var IActionCatalog: abstract new (...args: any[]) => IActionCatalog;
+
+  interface IActionCatalog2 {
+    GetActionsForInputs(inputEntities: Windows.AI.Actions.ActionEntity[]): Windows.AI.Actions.Hosting.ActionInstance[];
+    GetActionsForInputs(inputEntities: Windows.AI.Actions.ActionEntity[], invokerWindowId: Windows.UI.WindowId): Windows.AI.Actions.Hosting.ActionInstance[];
+  }
+  var IActionCatalog2: abstract new (...args: any[]) => IActionCatalog2;
+
+  interface IActionDefinition {
+    GetInputs(): Windows.AI.Actions.Hosting.ActionEntityRegistrationInfo[];
+    GetOutputs(): Windows.AI.Actions.Hosting.ActionEntityRegistrationInfo[];
+    GetOverloads(): Windows.AI.Actions.Hosting.ActionOverload[];
+    readonly Description: string;
+    readonly IconFullPath: string;
+    readonly Id: string;
+    readonly PackageFamilyName: string;
+  }
+  var IActionDefinition: abstract new (...args: any[]) => IActionDefinition;
+
+  interface IActionDefinition2 {
+    readonly DisplaysUI: boolean;
+    readonly SchemaVersion: number;
+    readonly UsesGenerativeAI: boolean;
+  }
+  var IActionDefinition2: abstract new (...args: any[]) => IActionDefinition2;
+
+  interface IActionDefinition3 {
+    readonly PackageRelativeApplicationId: string;
+  }
+  var IActionDefinition3: abstract new (...args: any[]) => IActionDefinition3;
+
+  interface IActionEntityRegistrationInfo {
+    Kind: number;
+    Name: string;
+  }
+  var IActionEntityRegistrationInfo: abstract new (...args: any[]) => IActionEntityRegistrationInfo;
+
+  interface IActionInstance {
+    InvokeAsync(): Windows.Foundation.IAsyncAction;
+    readonly Context: Windows.AI.Actions.ActionInvocationContext;
+    readonly Definition: Windows.AI.Actions.Hosting.ActionDefinition;
+    readonly DisplayInfo: Windows.AI.Actions.Hosting.ActionInstanceDisplayInfo;
+  }
+  var IActionInstance: abstract new (...args: any[]) => IActionInstance;
+
+  interface IActionInstanceDisplayInfo {
+    readonly Description: string;
+  }
+  var IActionInstanceDisplayInfo: abstract new (...args: any[]) => IActionInstanceDisplayInfo;
+
+  interface IActionOverload {
+    GetInputs(): Windows.AI.Actions.Hosting.ActionEntityRegistrationInfo[];
+    InvokeAsync(context: Windows.AI.Actions.ActionInvocationContext): Windows.Foundation.IAsyncAction;
+    readonly DescriptionTemplate: string;
+  }
+  var IActionOverload: abstract new (...args: any[]) => IActionOverload;
+
+  interface IActionOverload2 {
+    GetSupportsFeedback(): boolean;
+    InvokeFeedbackAsync(context: Windows.AI.Actions.ActionInvocationContext, feedback: Windows.AI.Actions.ActionFeedback): Windows.Foundation.IAsyncAction;
+  }
+  var IActionOverload2: abstract new (...args: any[]) => IActionOverload2;
+
+}
+
+declare namespace Windows.AI.Actions.Provider {
+  interface IActionFeedbackHandler {
+    ProcessFeedbackAsync(context: Windows.AI.Actions.ActionInvocationContext, feedback: Windows.AI.Actions.ActionFeedback): Windows.Foundation.IAsyncAction;
+  }
+  var IActionFeedbackHandler: abstract new (...args: any[]) => IActionFeedbackHandler;
+
+  interface IActionProvider {
+    InvokeAsync(context: Windows.AI.Actions.ActionInvocationContext): Windows.Foundation.IAsyncAction;
+  }
+  var IActionProvider: abstract new (...args: any[]) => IActionProvider;
+
+}
+
+declare namespace Windows.AI.MachineLearning {
+  class ImageFeatureDescriptor implements Windows.AI.MachineLearning.IImageFeatureDescriptor, Windows.AI.MachineLearning.IImageFeatureDescriptor2, Windows.AI.MachineLearning.ILearningModelFeatureDescriptor {
+    readonly BitmapAlphaMode: number;
+    readonly BitmapPixelFormat: number;
+    readonly Description: string;
+    readonly Height: number;
+    readonly IsRequired: boolean;
+    readonly Kind: number;
+    readonly Name: string;
+    readonly PixelRange: number;
+    readonly Width: number;
+  }
+
+  class ImageFeatureValue implements Windows.AI.MachineLearning.IImageFeatureValue, Windows.AI.MachineLearning.ILearningModelFeatureValue {
+    static CreateFromVideoFrame(image: Windows.Media.VideoFrame): Windows.AI.MachineLearning.ImageFeatureValue;
+    readonly Kind: number;
+    readonly VideoFrame: Windows.Media.VideoFrame;
+  }
+
+  class LearningModel implements Windows.AI.MachineLearning.ILearningModel, Windows.Foundation.IClosable {
+    Close(): void;
+    static LoadFromFilePath(filePath: string): Windows.AI.MachineLearning.LearningModel;
+    static LoadFromFilePath(filePath: string, operatorProvider: Windows.AI.MachineLearning.ILearningModelOperatorProvider): Windows.AI.MachineLearning.LearningModel;
+    static LoadFromStorageFileAsync(modelFile: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.LearningModel>;
+    static LoadFromStorageFileAsync(modelFile: Windows.Storage.IStorageFile, operatorProvider: Windows.AI.MachineLearning.ILearningModelOperatorProvider): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.LearningModel>;
+    static LoadFromStream(modelStream: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.AI.MachineLearning.LearningModel;
+    static LoadFromStream(modelStream: Windows.Storage.Streams.IRandomAccessStreamReference, operatorProvider: Windows.AI.MachineLearning.ILearningModelOperatorProvider): Windows.AI.MachineLearning.LearningModel;
+    static LoadFromStreamAsync(modelStream: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.LearningModel>;
+    static LoadFromStreamAsync(modelStream: Windows.Storage.Streams.IRandomAccessStreamReference, operatorProvider: Windows.AI.MachineLearning.ILearningModelOperatorProvider): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.LearningModel>;
+    readonly Author: string;
+    readonly Description: string;
+    readonly Domain: string;
+    readonly InputFeatures: Windows.Foundation.Collections.IVectorView<Windows.AI.MachineLearning.ILearningModelFeatureDescriptor> | Windows.AI.MachineLearning.ILearningModelFeatureDescriptor[];
+    readonly Metadata: Windows.Foundation.Collections.IMapView<string, string>;
+    readonly Name: string;
+    readonly OutputFeatures: Windows.Foundation.Collections.IVectorView<Windows.AI.MachineLearning.ILearningModelFeatureDescriptor> | Windows.AI.MachineLearning.ILearningModelFeatureDescriptor[];
+    readonly Version: number | bigint;
+  }
+
+  class LearningModelBinding implements Windows.AI.MachineLearning.ILearningModelBinding {
+    constructor(session: Windows.AI.MachineLearning.LearningModelSession);
+    Bind(name: string, value: Object): void;
+    Bind(name: string, value: Object, props: Windows.Foundation.Collections.IPropertySet): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, Object>>;
+    HasKey(key: string): boolean;
+    Lookup(key: string): Object;
+    Split(first: Windows.Foundation.Collections.IMapView<string, Object>, second: Windows.Foundation.Collections.IMapView<string, Object>): void;
+    readonly Size: number;
+  }
+
+  class LearningModelDevice implements Windows.AI.MachineLearning.ILearningModelDevice {
+    constructor(deviceKind: number);
+    static CreateFromDirect3D11Device(device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice): Windows.AI.MachineLearning.LearningModelDevice;
+    readonly AdapterId: Windows.Graphics.DisplayAdapterId;
+    readonly Direct3D11Device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice;
+  }
+
+  class LearningModelEvaluationResult implements Windows.AI.MachineLearning.ILearningModelEvaluationResult {
+    readonly CorrelationId: string;
+    readonly ErrorStatus: number;
+    readonly Outputs: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Succeeded: boolean;
+  }
+
+  class LearningModelSession implements Windows.AI.MachineLearning.ILearningModelSession, Windows.Foundation.IClosable {
+    constructor(model: Windows.AI.MachineLearning.LearningModel, deviceToRunOn: Windows.AI.MachineLearning.LearningModelDevice, learningModelSessionOptions: Windows.AI.MachineLearning.LearningModelSessionOptions);
+    constructor(model: Windows.AI.MachineLearning.LearningModel);
+    constructor(model: Windows.AI.MachineLearning.LearningModel, deviceToRunOn: Windows.AI.MachineLearning.LearningModelDevice);
+    Close(): void;
+    Evaluate(bindings: Windows.AI.MachineLearning.LearningModelBinding, correlationId: string): Windows.AI.MachineLearning.LearningModelEvaluationResult;
+    EvaluateAsync(bindings: Windows.AI.MachineLearning.LearningModelBinding, correlationId: string): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.LearningModelEvaluationResult>;
+    EvaluateFeatures(features: Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>, correlationId: string): Windows.AI.MachineLearning.LearningModelEvaluationResult;
+    EvaluateFeaturesAsync(features: Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>, correlationId: string): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.LearningModelEvaluationResult>;
+    readonly Device: Windows.AI.MachineLearning.LearningModelDevice;
+    readonly EvaluationProperties: Windows.Foundation.Collections.IPropertySet;
+    readonly Model: Windows.AI.MachineLearning.LearningModel;
+  }
+
+  class LearningModelSessionOptions implements Windows.AI.MachineLearning.ILearningModelSessionOptions, Windows.AI.MachineLearning.ILearningModelSessionOptions2, Windows.AI.MachineLearning.ILearningModelSessionOptions3 {
+    constructor();
+    OverrideNamedDimension(name: string, dimension: number): void;
+    BatchSizeOverride: number;
+    CloseModelOnSessionCreation: boolean;
+  }
+
+  class MapFeatureDescriptor implements Windows.AI.MachineLearning.ILearningModelFeatureDescriptor, Windows.AI.MachineLearning.IMapFeatureDescriptor {
+    readonly Description: string;
+    readonly IsRequired: boolean;
+    readonly KeyKind: number;
+    readonly Kind: number;
+    readonly Name: string;
+    readonly ValueDescriptor: Windows.AI.MachineLearning.ILearningModelFeatureDescriptor;
+  }
+
+  class SequenceFeatureDescriptor implements Windows.AI.MachineLearning.ILearningModelFeatureDescriptor, Windows.AI.MachineLearning.ISequenceFeatureDescriptor {
+    readonly Description: string;
+    readonly ElementDescriptor: Windows.AI.MachineLearning.ILearningModelFeatureDescriptor;
+    readonly IsRequired: boolean;
+    readonly Kind: number;
+    readonly Name: string;
+  }
+
+  class TensorBoolean implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorBoolean, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+    Close(): void;
+    static Create(): Windows.AI.MachineLearning.TensorBoolean;
+    static Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorBoolean;
+    static CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: boolean[]): Windows.AI.MachineLearning.TensorBoolean;
+    static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorBoolean;
+    static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<boolean> | boolean[]): Windows.AI.MachineLearning.TensorBoolean;
+    static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: boolean[]): Windows.AI.MachineLearning.TensorBoolean;
+    CreateReference(): Windows.Foundation.IMemoryBufferReference;
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<boolean> | boolean[];
+    readonly Kind: number;
+    readonly Shape: Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+    readonly TensorKind: number;
+  }
+
+  class TensorDouble implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorDouble, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+    Close(): void;
+    static Create(): Windows.AI.MachineLearning.TensorDouble;
+    static Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorDouble;
+    static CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorDouble;
+    static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorDouble;
+    static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.AI.MachineLearning.TensorDouble;
+    static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorDouble;
+    CreateReference(): Windows.Foundation.IMemoryBufferReference;
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Kind: number;
+    readonly Shape: Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+    readonly TensorKind: number;
+  }
+
+  class TensorFeatureDescriptor implements Windows.AI.MachineLearning.ILearningModelFeatureDescriptor, Windows.AI.MachineLearning.ITensorFeatureDescriptor {
+    readonly Description: string;
+    readonly IsRequired: boolean;
+    readonly Kind: number;
+    readonly Name: string;
+    readonly Shape: Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+    readonly TensorKind: number;
+  }
+
+  class TensorFloat implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorFloat, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+    Close(): void;
+    static Create(): Windows.AI.MachineLearning.TensorFloat;
+    static Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorFloat;
+    static CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorFloat;
+    static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorFloat;
+    static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.AI.MachineLearning.TensorFloat;
+    static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorFloat;
+    CreateReference(): Windows.Foundation.IMemoryBufferReference;
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Kind: number;
+    readonly Shape: Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+    readonly TensorKind: number;
+  }
+
+  class TensorFloat16Bit implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorFloat16Bit, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+    Close(): void;
+    static Create(): Windows.AI.MachineLearning.TensorFloat16Bit;
+    static Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorFloat16Bit;
+    static CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorFloat16Bit;
+    static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorFloat16Bit;
+    static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.AI.MachineLearning.TensorFloat16Bit;
+    static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorFloat16Bit;
+    CreateReference(): Windows.Foundation.IMemoryBufferReference;
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Kind: number;
+    readonly Shape: Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+    readonly TensorKind: number;
+  }
+
+  class TensorInt16Bit implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorInt16Bit, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+    Close(): void;
+    static Create(): Windows.AI.MachineLearning.TensorInt16Bit;
+    static Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorInt16Bit;
+    static CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt16Bit;
+    static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorInt16Bit;
+    static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.AI.MachineLearning.TensorInt16Bit;
+    static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt16Bit;
+    CreateReference(): Windows.Foundation.IMemoryBufferReference;
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Kind: number;
+    readonly Shape: Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+    readonly TensorKind: number;
+  }
+
+  class TensorInt32Bit implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorInt32Bit, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+    Close(): void;
+    static Create(): Windows.AI.MachineLearning.TensorInt32Bit;
+    static Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorInt32Bit;
+    static CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt32Bit;
+    static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorInt32Bit;
+    static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.AI.MachineLearning.TensorInt32Bit;
+    static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt32Bit;
+    CreateReference(): Windows.Foundation.IMemoryBufferReference;
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Kind: number;
+    readonly Shape: Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+    readonly TensorKind: number;
+  }
+
+  class TensorInt64Bit implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorInt64Bit, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+    Close(): void;
+    static Create(): Windows.AI.MachineLearning.TensorInt64Bit;
+    static Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorInt64Bit;
+    static CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number | bigint[]): Windows.AI.MachineLearning.TensorInt64Bit;
+    static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorInt64Bit;
+    static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorInt64Bit;
+    static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number | bigint[]): Windows.AI.MachineLearning.TensorInt64Bit;
+    CreateReference(): Windows.Foundation.IMemoryBufferReference;
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+    readonly Kind: number;
+    readonly Shape: Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+    readonly TensorKind: number;
+  }
+
+  class TensorInt8Bit implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorInt8Bit, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+    Close(): void;
+    static Create(): Windows.AI.MachineLearning.TensorInt8Bit;
+    static Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorInt8Bit;
+    static CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt8Bit;
+    static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorInt8Bit;
+    static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.AI.MachineLearning.TensorInt8Bit;
+    static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt8Bit;
+    CreateReference(): Windows.Foundation.IMemoryBufferReference;
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Kind: number;
+    readonly Shape: Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+    readonly TensorKind: number;
+  }
+
+  class TensorString implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorString, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+    Close(): void;
+    static Create(): Windows.AI.MachineLearning.TensorString;
+    static Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorString;
+    static CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: string[]): Windows.AI.MachineLearning.TensorString;
+    static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.AI.MachineLearning.TensorString;
+    static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: string[]): Windows.AI.MachineLearning.TensorString;
+    CreateReference(): Windows.Foundation.IMemoryBufferReference;
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Kind: number;
+    readonly Shape: Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+    readonly TensorKind: number;
+  }
+
+  class TensorUInt16Bit implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorUInt16Bit, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+    Close(): void;
+    static Create(): Windows.AI.MachineLearning.TensorUInt16Bit;
+    static Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorUInt16Bit;
+    static CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorUInt16Bit;
+    static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorUInt16Bit;
+    static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.AI.MachineLearning.TensorUInt16Bit;
+    static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorUInt16Bit;
+    CreateReference(): Windows.Foundation.IMemoryBufferReference;
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Kind: number;
+    readonly Shape: Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+    readonly TensorKind: number;
+  }
+
+  class TensorUInt32Bit implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorUInt32Bit, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+    Close(): void;
+    static Create(): Windows.AI.MachineLearning.TensorUInt32Bit;
+    static Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorUInt32Bit;
+    static CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorUInt32Bit;
+    static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorUInt32Bit;
+    static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.AI.MachineLearning.TensorUInt32Bit;
+    static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorUInt32Bit;
+    CreateReference(): Windows.Foundation.IMemoryBufferReference;
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Kind: number;
+    readonly Shape: Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+    readonly TensorKind: number;
+  }
+
+  class TensorUInt64Bit implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorUInt64Bit, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+    Close(): void;
+    static Create(): Windows.AI.MachineLearning.TensorUInt64Bit;
+    static Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorUInt64Bit;
+    static CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number | bigint[]): Windows.AI.MachineLearning.TensorUInt64Bit;
+    static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorUInt64Bit;
+    static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorUInt64Bit;
+    static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number | bigint[]): Windows.AI.MachineLearning.TensorUInt64Bit;
+    CreateReference(): Windows.Foundation.IMemoryBufferReference;
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+    readonly Kind: number;
+    readonly Shape: Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+    readonly TensorKind: number;
+  }
+
+  class TensorUInt8Bit implements Windows.AI.MachineLearning.ILearningModelFeatureValue, Windows.AI.MachineLearning.ITensor, Windows.AI.MachineLearning.ITensorUInt8Bit, Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+    Close(): void;
+    static Create(): Windows.AI.MachineLearning.TensorUInt8Bit;
+    static Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorUInt8Bit;
+    static CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorUInt8Bit;
+    static CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorUInt8Bit;
+    static CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.AI.MachineLearning.TensorUInt8Bit;
+    static CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorUInt8Bit;
+    CreateReference(): Windows.Foundation.IMemoryBufferReference;
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Kind: number;
+    readonly Shape: Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+    readonly TensorKind: number;
+  }
+
+  enum LearningModelDeviceKind {
+    Default = 0,
+    Cpu = 1,
+    DirectX = 2,
+    DirectXHighPerformance = 3,
+    DirectXMinPower = 4,
+  }
+
+  enum LearningModelFeatureKind {
+    Tensor = 0,
+    Sequence = 1,
+    Map = 2,
+    Image = 3,
+  }
+
+  enum LearningModelPixelRange {
+    ZeroTo255 = 0,
+    ZeroToOne = 1,
+    MinusOneToOne = 2,
+  }
+
+  enum TensorKind {
+    Undefined = 0,
+    Float = 1,
+    UInt8 = 2,
+    Int8 = 3,
+    UInt16 = 4,
+    Int16 = 5,
+    Int32 = 6,
+    Int64 = 7,
+    String = 8,
+    Boolean = 9,
+    Float16 = 10,
+    Double = 11,
+    UInt32 = 12,
+    UInt64 = 13,
+    Complex64 = 14,
+    Complex128 = 15,
+  }
+
+  interface IImageFeatureDescriptor {
+    readonly BitmapAlphaMode: number;
+    readonly BitmapPixelFormat: number;
+    readonly Height: number;
+    readonly Width: number;
+  }
+  var IImageFeatureDescriptor: abstract new (...args: any[]) => IImageFeatureDescriptor;
+
+  interface IImageFeatureDescriptor2 {
+    readonly PixelRange: number;
+  }
+  var IImageFeatureDescriptor2: abstract new (...args: any[]) => IImageFeatureDescriptor2;
+
+  interface IImageFeatureValue {
+    readonly VideoFrame: Windows.Media.VideoFrame;
+  }
+  var IImageFeatureValue: abstract new (...args: any[]) => IImageFeatureValue;
+
+  interface IImageFeatureValueStatics {
+    CreateFromVideoFrame(image: Windows.Media.VideoFrame): Windows.AI.MachineLearning.ImageFeatureValue;
+  }
+  var IImageFeatureValueStatics: abstract new (...args: any[]) => IImageFeatureValueStatics;
+
+  interface ILearningModel {
+    readonly Author: string;
+    readonly Description: string;
+    readonly Domain: string;
+    readonly InputFeatures: Windows.Foundation.Collections.IVectorView<Windows.AI.MachineLearning.ILearningModelFeatureDescriptor> | Windows.AI.MachineLearning.ILearningModelFeatureDescriptor[];
+    readonly Metadata: Windows.Foundation.Collections.IMapView<string, string>;
+    readonly Name: string;
+    readonly OutputFeatures: Windows.Foundation.Collections.IVectorView<Windows.AI.MachineLearning.ILearningModelFeatureDescriptor> | Windows.AI.MachineLearning.ILearningModelFeatureDescriptor[];
+    readonly Version: number | bigint;
+  }
+  var ILearningModel: abstract new (...args: any[]) => ILearningModel;
+
+  interface ILearningModelBinding {
+    Bind(name: string, value: Object): void;
+    Bind(name: string, value: Object, props: Windows.Foundation.Collections.IPropertySet): void;
+    Clear(): void;
+  }
+  var ILearningModelBinding: abstract new (...args: any[]) => ILearningModelBinding;
+
+  interface ILearningModelBindingFactory {
+    CreateFromSession(session: Windows.AI.MachineLearning.LearningModelSession): Windows.AI.MachineLearning.LearningModelBinding;
+  }
+  var ILearningModelBindingFactory: abstract new (...args: any[]) => ILearningModelBindingFactory;
+
+  interface ILearningModelDevice {
+    readonly AdapterId: Windows.Graphics.DisplayAdapterId;
+    readonly Direct3D11Device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice;
+  }
+  var ILearningModelDevice: abstract new (...args: any[]) => ILearningModelDevice;
+
+  interface ILearningModelDeviceFactory {
+    Create(deviceKind: number): Windows.AI.MachineLearning.LearningModelDevice;
+  }
+  var ILearningModelDeviceFactory: abstract new (...args: any[]) => ILearningModelDeviceFactory;
+
+  interface ILearningModelDeviceStatics {
+    CreateFromDirect3D11Device(device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice): Windows.AI.MachineLearning.LearningModelDevice;
+  }
+  var ILearningModelDeviceStatics: abstract new (...args: any[]) => ILearningModelDeviceStatics;
+
+  interface ILearningModelEvaluationResult {
+    readonly CorrelationId: string;
+    readonly ErrorStatus: number;
+    readonly Outputs: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Succeeded: boolean;
+  }
+  var ILearningModelEvaluationResult: abstract new (...args: any[]) => ILearningModelEvaluationResult;
+
+  interface ILearningModelFeatureDescriptor {
+    readonly Description: string;
+    readonly IsRequired: boolean;
+    readonly Kind: number;
+    readonly Name: string;
+  }
+  var ILearningModelFeatureDescriptor: abstract new (...args: any[]) => ILearningModelFeatureDescriptor;
+
+  interface ILearningModelFeatureValue {
+    readonly Kind: number;
+  }
+  var ILearningModelFeatureValue: abstract new (...args: any[]) => ILearningModelFeatureValue;
+
+  interface ILearningModelOperatorProvider {
+  }
+  var ILearningModelOperatorProvider: abstract new (...args: any[]) => ILearningModelOperatorProvider;
+
+  interface ILearningModelSession {
+    Evaluate(bindings: Windows.AI.MachineLearning.LearningModelBinding, correlationId: string): Windows.AI.MachineLearning.LearningModelEvaluationResult;
+    EvaluateAsync(bindings: Windows.AI.MachineLearning.LearningModelBinding, correlationId: string): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.LearningModelEvaluationResult>;
+    EvaluateFeatures(features: Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>, correlationId: string): Windows.AI.MachineLearning.LearningModelEvaluationResult;
+    EvaluateFeaturesAsync(features: Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>, correlationId: string): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.LearningModelEvaluationResult>;
+    readonly Device: Windows.AI.MachineLearning.LearningModelDevice;
+    readonly EvaluationProperties: Windows.Foundation.Collections.IPropertySet;
+    readonly Model: Windows.AI.MachineLearning.LearningModel;
+  }
+  var ILearningModelSession: abstract new (...args: any[]) => ILearningModelSession;
+
+  interface ILearningModelSessionFactory {
+    CreateFromModel(model: Windows.AI.MachineLearning.LearningModel): Windows.AI.MachineLearning.LearningModelSession;
+    CreateFromModelOnDevice(model: Windows.AI.MachineLearning.LearningModel, deviceToRunOn: Windows.AI.MachineLearning.LearningModelDevice): Windows.AI.MachineLearning.LearningModelSession;
+  }
+  var ILearningModelSessionFactory: abstract new (...args: any[]) => ILearningModelSessionFactory;
+
+  interface ILearningModelSessionFactory2 {
+    CreateFromModelOnDeviceWithSessionOptions(model: Windows.AI.MachineLearning.LearningModel, deviceToRunOn: Windows.AI.MachineLearning.LearningModelDevice, learningModelSessionOptions: Windows.AI.MachineLearning.LearningModelSessionOptions): Windows.AI.MachineLearning.LearningModelSession;
+  }
+  var ILearningModelSessionFactory2: abstract new (...args: any[]) => ILearningModelSessionFactory2;
+
+  interface ILearningModelSessionOptions {
+    BatchSizeOverride: number;
+  }
+  var ILearningModelSessionOptions: abstract new (...args: any[]) => ILearningModelSessionOptions;
+
+  interface ILearningModelSessionOptions2 {
+    CloseModelOnSessionCreation: boolean;
+  }
+  var ILearningModelSessionOptions2: abstract new (...args: any[]) => ILearningModelSessionOptions2;
+
+  interface ILearningModelSessionOptions3 {
+    OverrideNamedDimension(name: string, dimension: number): void;
+  }
+  var ILearningModelSessionOptions3: abstract new (...args: any[]) => ILearningModelSessionOptions3;
+
+  interface ILearningModelStatics {
+    LoadFromFilePath(filePath: string): Windows.AI.MachineLearning.LearningModel;
+    LoadFromFilePath(filePath: string, operatorProvider: Windows.AI.MachineLearning.ILearningModelOperatorProvider): Windows.AI.MachineLearning.LearningModel;
+    LoadFromStorageFileAsync(modelFile: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.LearningModel>;
+    LoadFromStorageFileAsync(modelFile: Windows.Storage.IStorageFile, operatorProvider: Windows.AI.MachineLearning.ILearningModelOperatorProvider): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.LearningModel>;
+    LoadFromStream(modelStream: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.AI.MachineLearning.LearningModel;
+    LoadFromStream(modelStream: Windows.Storage.Streams.IRandomAccessStreamReference, operatorProvider: Windows.AI.MachineLearning.ILearningModelOperatorProvider): Windows.AI.MachineLearning.LearningModel;
+    LoadFromStreamAsync(modelStream: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.LearningModel>;
+    LoadFromStreamAsync(modelStream: Windows.Storage.Streams.IRandomAccessStreamReference, operatorProvider: Windows.AI.MachineLearning.ILearningModelOperatorProvider): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.LearningModel>;
+  }
+  var ILearningModelStatics: abstract new (...args: any[]) => ILearningModelStatics;
+
+  interface IMapFeatureDescriptor {
+    readonly KeyKind: number;
+    readonly ValueDescriptor: Windows.AI.MachineLearning.ILearningModelFeatureDescriptor;
+  }
+  var IMapFeatureDescriptor: abstract new (...args: any[]) => IMapFeatureDescriptor;
+
+  interface ISequenceFeatureDescriptor {
+    readonly ElementDescriptor: Windows.AI.MachineLearning.ILearningModelFeatureDescriptor;
+  }
+  var ISequenceFeatureDescriptor: abstract new (...args: any[]) => ISequenceFeatureDescriptor;
+
+  interface ITensor extends Windows.AI.MachineLearning.ILearningModelFeatureValue {
+    readonly Shape: Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+    readonly TensorKind: number;
+  }
+  var ITensor: abstract new (...args: any[]) => ITensor;
+
+  interface ITensorBoolean {
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<boolean> | boolean[];
+  }
+  var ITensorBoolean: abstract new (...args: any[]) => ITensorBoolean;
+
+  interface ITensorBooleanStatics {
+    Create(): Windows.AI.MachineLearning.TensorBoolean;
+    Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorBoolean;
+    CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: boolean[]): Windows.AI.MachineLearning.TensorBoolean;
+    CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<boolean> | boolean[]): Windows.AI.MachineLearning.TensorBoolean;
+  }
+  var ITensorBooleanStatics: abstract new (...args: any[]) => ITensorBooleanStatics;
+
+  interface ITensorBooleanStatics2 {
+    CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorBoolean;
+    CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: boolean[]): Windows.AI.MachineLearning.TensorBoolean;
+  }
+  var ITensorBooleanStatics2: abstract new (...args: any[]) => ITensorBooleanStatics2;
+
+  interface ITensorDouble {
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var ITensorDouble: abstract new (...args: any[]) => ITensorDouble;
+
+  interface ITensorDoubleStatics {
+    Create(): Windows.AI.MachineLearning.TensorDouble;
+    Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorDouble;
+    CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorDouble;
+    CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.AI.MachineLearning.TensorDouble;
+  }
+  var ITensorDoubleStatics: abstract new (...args: any[]) => ITensorDoubleStatics;
+
+  interface ITensorDoubleStatics2 {
+    CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorDouble;
+    CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorDouble;
+  }
+  var ITensorDoubleStatics2: abstract new (...args: any[]) => ITensorDoubleStatics2;
+
+  interface ITensorFeatureDescriptor {
+    readonly Shape: Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+    readonly TensorKind: number;
+  }
+  var ITensorFeatureDescriptor: abstract new (...args: any[]) => ITensorFeatureDescriptor;
+
+  interface ITensorFloat {
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var ITensorFloat: abstract new (...args: any[]) => ITensorFloat;
+
+  interface ITensorFloat16Bit {
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var ITensorFloat16Bit: abstract new (...args: any[]) => ITensorFloat16Bit;
+
+  interface ITensorFloat16BitStatics {
+    Create(): Windows.AI.MachineLearning.TensorFloat16Bit;
+    Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorFloat16Bit;
+    CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorFloat16Bit;
+    CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.AI.MachineLearning.TensorFloat16Bit;
+  }
+  var ITensorFloat16BitStatics: abstract new (...args: any[]) => ITensorFloat16BitStatics;
+
+  interface ITensorFloat16BitStatics2 {
+    CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorFloat16Bit;
+    CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorFloat16Bit;
+  }
+  var ITensorFloat16BitStatics2: abstract new (...args: any[]) => ITensorFloat16BitStatics2;
+
+  interface ITensorFloatStatics {
+    Create(): Windows.AI.MachineLearning.TensorFloat;
+    Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorFloat;
+    CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorFloat;
+    CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.AI.MachineLearning.TensorFloat;
+  }
+  var ITensorFloatStatics: abstract new (...args: any[]) => ITensorFloatStatics;
+
+  interface ITensorFloatStatics2 {
+    CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorFloat;
+    CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorFloat;
+  }
+  var ITensorFloatStatics2: abstract new (...args: any[]) => ITensorFloatStatics2;
+
+  interface ITensorInt16Bit {
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var ITensorInt16Bit: abstract new (...args: any[]) => ITensorInt16Bit;
+
+  interface ITensorInt16BitStatics {
+    Create(): Windows.AI.MachineLearning.TensorInt16Bit;
+    Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorInt16Bit;
+    CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt16Bit;
+    CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.AI.MachineLearning.TensorInt16Bit;
+  }
+  var ITensorInt16BitStatics: abstract new (...args: any[]) => ITensorInt16BitStatics;
+
+  interface ITensorInt16BitStatics2 {
+    CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorInt16Bit;
+    CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt16Bit;
+  }
+  var ITensorInt16BitStatics2: abstract new (...args: any[]) => ITensorInt16BitStatics2;
+
+  interface ITensorInt32Bit {
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var ITensorInt32Bit: abstract new (...args: any[]) => ITensorInt32Bit;
+
+  interface ITensorInt32BitStatics {
+    Create(): Windows.AI.MachineLearning.TensorInt32Bit;
+    Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorInt32Bit;
+    CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt32Bit;
+    CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.AI.MachineLearning.TensorInt32Bit;
+  }
+  var ITensorInt32BitStatics: abstract new (...args: any[]) => ITensorInt32BitStatics;
+
+  interface ITensorInt32BitStatics2 {
+    CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorInt32Bit;
+    CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt32Bit;
+  }
+  var ITensorInt32BitStatics2: abstract new (...args: any[]) => ITensorInt32BitStatics2;
+
+  interface ITensorInt64Bit {
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+  }
+  var ITensorInt64Bit: abstract new (...args: any[]) => ITensorInt64Bit;
+
+  interface ITensorInt64BitStatics {
+    Create(): Windows.AI.MachineLearning.TensorInt64Bit;
+    Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorInt64Bit;
+    CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number | bigint[]): Windows.AI.MachineLearning.TensorInt64Bit;
+    CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorInt64Bit;
+  }
+  var ITensorInt64BitStatics: abstract new (...args: any[]) => ITensorInt64BitStatics;
+
+  interface ITensorInt64BitStatics2 {
+    CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorInt64Bit;
+    CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number | bigint[]): Windows.AI.MachineLearning.TensorInt64Bit;
+  }
+  var ITensorInt64BitStatics2: abstract new (...args: any[]) => ITensorInt64BitStatics2;
+
+  interface ITensorInt8Bit {
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var ITensorInt8Bit: abstract new (...args: any[]) => ITensorInt8Bit;
+
+  interface ITensorInt8BitStatics {
+    Create(): Windows.AI.MachineLearning.TensorInt8Bit;
+    Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorInt8Bit;
+    CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt8Bit;
+    CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.AI.MachineLearning.TensorInt8Bit;
+  }
+  var ITensorInt8BitStatics: abstract new (...args: any[]) => ITensorInt8BitStatics;
+
+  interface ITensorInt8BitStatics2 {
+    CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorInt8Bit;
+    CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorInt8Bit;
+  }
+  var ITensorInt8BitStatics2: abstract new (...args: any[]) => ITensorInt8BitStatics2;
+
+  interface ITensorString {
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var ITensorString: abstract new (...args: any[]) => ITensorString;
+
+  interface ITensorStringStatics {
+    Create(): Windows.AI.MachineLearning.TensorString;
+    Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorString;
+    CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: string[]): Windows.AI.MachineLearning.TensorString;
+    CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.AI.MachineLearning.TensorString;
+  }
+  var ITensorStringStatics: abstract new (...args: any[]) => ITensorStringStatics;
+
+  interface ITensorStringStatics2 {
+    CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: string[]): Windows.AI.MachineLearning.TensorString;
+  }
+  var ITensorStringStatics2: abstract new (...args: any[]) => ITensorStringStatics2;
+
+  interface ITensorUInt16Bit {
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var ITensorUInt16Bit: abstract new (...args: any[]) => ITensorUInt16Bit;
+
+  interface ITensorUInt16BitStatics {
+    Create(): Windows.AI.MachineLearning.TensorUInt16Bit;
+    Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorUInt16Bit;
+    CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorUInt16Bit;
+    CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.AI.MachineLearning.TensorUInt16Bit;
+  }
+  var ITensorUInt16BitStatics: abstract new (...args: any[]) => ITensorUInt16BitStatics;
+
+  interface ITensorUInt16BitStatics2 {
+    CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorUInt16Bit;
+    CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorUInt16Bit;
+  }
+  var ITensorUInt16BitStatics2: abstract new (...args: any[]) => ITensorUInt16BitStatics2;
+
+  interface ITensorUInt32Bit {
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var ITensorUInt32Bit: abstract new (...args: any[]) => ITensorUInt32Bit;
+
+  interface ITensorUInt32BitStatics {
+    Create(): Windows.AI.MachineLearning.TensorUInt32Bit;
+    Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorUInt32Bit;
+    CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorUInt32Bit;
+    CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.AI.MachineLearning.TensorUInt32Bit;
+  }
+  var ITensorUInt32BitStatics: abstract new (...args: any[]) => ITensorUInt32BitStatics;
+
+  interface ITensorUInt32BitStatics2 {
+    CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorUInt32Bit;
+    CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorUInt32Bit;
+  }
+  var ITensorUInt32BitStatics2: abstract new (...args: any[]) => ITensorUInt32BitStatics2;
+
+  interface ITensorUInt64Bit {
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number | bigint> | number | bigint[];
+  }
+  var ITensorUInt64Bit: abstract new (...args: any[]) => ITensorUInt64Bit;
+
+  interface ITensorUInt64BitStatics {
+    Create(): Windows.AI.MachineLearning.TensorUInt64Bit;
+    Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorUInt64Bit;
+    CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number | bigint[]): Windows.AI.MachineLearning.TensorUInt64Bit;
+    CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorUInt64Bit;
+  }
+  var ITensorUInt64BitStatics: abstract new (...args: any[]) => ITensorUInt64BitStatics;
+
+  interface ITensorUInt64BitStatics2 {
+    CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorUInt64Bit;
+    CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number | bigint[]): Windows.AI.MachineLearning.TensorUInt64Bit;
+  }
+  var ITensorUInt64BitStatics2: abstract new (...args: any[]) => ITensorUInt64BitStatics2;
+
+  interface ITensorUInt8Bit {
+    GetAsVectorView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var ITensorUInt8Bit: abstract new (...args: any[]) => ITensorUInt8Bit;
+
+  interface ITensorUInt8BitStatics {
+    Create(): Windows.AI.MachineLearning.TensorUInt8Bit;
+    Create(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[]): Windows.AI.MachineLearning.TensorUInt8Bit;
+    CreateFromArray(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorUInt8Bit;
+    CreateFromIterable(shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[], data: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.AI.MachineLearning.TensorUInt8Bit;
+  }
+  var ITensorUInt8BitStatics: abstract new (...args: any[]) => ITensorUInt8BitStatics;
+
+  interface ITensorUInt8BitStatics2 {
+    CreateFromBuffer(shape: number | bigint[], buffer: Windows.Storage.Streams.IBuffer): Windows.AI.MachineLearning.TensorUInt8Bit;
+    CreateFromShapeArrayAndDataArray(shape: number | bigint[], data: number[]): Windows.AI.MachineLearning.TensorUInt8Bit;
+  }
+  var ITensorUInt8BitStatics2: abstract new (...args: any[]) => ITensorUInt8BitStatics2;
+
+  interface MachineLearningContract {
+  }
+  var MachineLearningContract: {
+    new(fields: {  }): MachineLearningContract;
+  };
+
+}
+
+declare namespace Windows.AI.MachineLearning.Preview {
+  class ImageVariableDescriptorPreview implements Windows.AI.MachineLearning.Preview.IImageVariableDescriptorPreview, Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview {
+    readonly BitmapPixelFormat: number;
+    readonly Description: string;
+    readonly Height: number;
+    readonly IsRequired: boolean;
+    readonly ModelFeatureKind: number;
+    readonly Name: string;
+    readonly Width: number;
+  }
+
+  class InferencingOptionsPreview implements Windows.AI.MachineLearning.Preview.IInferencingOptionsPreview {
+    IsTracingEnabled: boolean;
+    MaxBatchSize: number;
+    MinimizeMemoryAllocation: boolean;
+    PreferredDeviceKind: number;
+    ReclaimMemoryAfterEvaluation: boolean;
+  }
+
+  class LearningModelBindingPreview implements Windows.AI.MachineLearning.Preview.ILearningModelBindingPreview {
+    constructor(model: Windows.AI.MachineLearning.Preview.LearningModelPreview);
+    Bind(name: string, value: Object): void;
+    Bind(name: string, value: Object, metadata: Windows.Foundation.Collections.IPropertySet): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, Object>>;
+    HasKey(key: string): boolean;
+    Lookup(key: string): Object;
+    Split(first: Windows.Foundation.Collections.IMapView<string, Object>, second: Windows.Foundation.Collections.IMapView<string, Object>): void;
+    readonly Size: number;
+  }
+
+  class LearningModelDescriptionPreview implements Windows.AI.MachineLearning.Preview.ILearningModelDescriptionPreview {
+    readonly Author: string;
+    readonly Description: string;
+    readonly Domain: string;
+    readonly InputFeatures: Windows.Foundation.Collections.IIterable<Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview> | Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview[];
+    readonly Metadata: Windows.Foundation.Collections.IMapView<string, string>;
+    readonly Name: string;
+    readonly OutputFeatures: Windows.Foundation.Collections.IIterable<Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview> | Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview[];
+    readonly Version: number | bigint;
+  }
+
+  class LearningModelEvaluationResultPreview implements Windows.AI.MachineLearning.Preview.ILearningModelEvaluationResultPreview {
+    readonly CorrelationId: string;
+    readonly Outputs: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+
+  class LearningModelPreview implements Windows.AI.MachineLearning.Preview.ILearningModelPreview {
+    EvaluateAsync(binding: Windows.AI.MachineLearning.Preview.LearningModelBindingPreview, correlationId: string): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.Preview.LearningModelEvaluationResultPreview>;
+    EvaluateFeaturesAsync(features: Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>, correlationId: string): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.Preview.LearningModelEvaluationResultPreview>;
+    static LoadModelFromStorageFileAsync(modelFile: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.Preview.LearningModelPreview>;
+    static LoadModelFromStreamAsync(modelStream: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.Preview.LearningModelPreview>;
+    readonly Description: Windows.AI.MachineLearning.Preview.LearningModelDescriptionPreview;
+    InferencingOptions: Windows.AI.MachineLearning.Preview.InferencingOptionsPreview;
+  }
+
+  class LearningModelVariableDescriptorPreview implements Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview {
+    readonly Description: string;
+    readonly IsRequired: boolean;
+    readonly ModelFeatureKind: number;
+    readonly Name: string;
+  }
+
+  class MapVariableDescriptorPreview implements Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview, Windows.AI.MachineLearning.Preview.IMapVariableDescriptorPreview {
+    readonly Description: string;
+    readonly Fields: Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview;
+    readonly IsRequired: boolean;
+    readonly KeyKind: number;
+    readonly ModelFeatureKind: number;
+    readonly Name: string;
+    readonly ValidIntegerKeys: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[];
+    readonly ValidStringKeys: Windows.Foundation.Collections.IIterable<string> | string[];
+  }
+
+  class SequenceVariableDescriptorPreview implements Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview, Windows.AI.MachineLearning.Preview.ISequenceVariableDescriptorPreview {
+    readonly Description: string;
+    readonly ElementType: Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview;
+    readonly IsRequired: boolean;
+    readonly ModelFeatureKind: number;
+    readonly Name: string;
+  }
+
+  class TensorVariableDescriptorPreview implements Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview, Windows.AI.MachineLearning.Preview.ITensorVariableDescriptorPreview {
+    readonly DataType: number;
+    readonly Description: string;
+    readonly IsRequired: boolean;
+    readonly ModelFeatureKind: number;
+    readonly Name: string;
+    readonly Shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[];
+  }
+
+  enum FeatureElementKindPreview {
+    Undefined = 0,
+    Float = 1,
+    UInt8 = 2,
+    Int8 = 3,
+    UInt16 = 4,
+    Int16 = 5,
+    Int32 = 6,
+    Int64 = 7,
+    String = 8,
+    Boolean = 9,
+    Float16 = 10,
+    Double = 11,
+    UInt32 = 12,
+    UInt64 = 13,
+    Complex64 = 14,
+    Complex128 = 15,
+  }
+
+  enum LearningModelDeviceKindPreview {
+    LearningDeviceAny = 0,
+    LearningDeviceCpu = 1,
+    LearningDeviceGpu = 2,
+    LearningDeviceNpu = 3,
+    LearningDeviceDsp = 4,
+    LearningDeviceFpga = 5,
+  }
+
+  enum LearningModelFeatureKindPreview {
+    Undefined = 0,
+    Tensor = 1,
+    Sequence = 2,
+    Map = 3,
+    Image = 4,
+  }
+
+  interface IImageVariableDescriptorPreview extends Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview {
+    readonly BitmapPixelFormat: number;
+    readonly Height: number;
+    readonly Width: number;
+  }
+  var IImageVariableDescriptorPreview: abstract new (...args: any[]) => IImageVariableDescriptorPreview;
+
+  interface IInferencingOptionsPreview {
+    IsTracingEnabled: boolean;
+    MaxBatchSize: number;
+    MinimizeMemoryAllocation: boolean;
+    PreferredDeviceKind: number;
+    ReclaimMemoryAfterEvaluation: boolean;
+  }
+  var IInferencingOptionsPreview: abstract new (...args: any[]) => IInferencingOptionsPreview;
+
+  interface ILearningModelBindingPreview {
+    Bind(name: string, value: Object): void;
+    Bind(name: string, value: Object, metadata: Windows.Foundation.Collections.IPropertySet): void;
+    Clear(): void;
+  }
+  var ILearningModelBindingPreview: abstract new (...args: any[]) => ILearningModelBindingPreview;
+
+  interface ILearningModelBindingPreviewFactory {
+    CreateFromModel(model: Windows.AI.MachineLearning.Preview.LearningModelPreview): Windows.AI.MachineLearning.Preview.LearningModelBindingPreview;
+  }
+  var ILearningModelBindingPreviewFactory: abstract new (...args: any[]) => ILearningModelBindingPreviewFactory;
+
+  interface ILearningModelDescriptionPreview {
+    readonly Author: string;
+    readonly Description: string;
+    readonly Domain: string;
+    readonly InputFeatures: Windows.Foundation.Collections.IIterable<Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview> | Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview[];
+    readonly Metadata: Windows.Foundation.Collections.IMapView<string, string>;
+    readonly Name: string;
+    readonly OutputFeatures: Windows.Foundation.Collections.IIterable<Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview> | Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview[];
+    readonly Version: number | bigint;
+  }
+  var ILearningModelDescriptionPreview: abstract new (...args: any[]) => ILearningModelDescriptionPreview;
+
+  interface ILearningModelEvaluationResultPreview {
+    readonly CorrelationId: string;
+    readonly Outputs: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+  var ILearningModelEvaluationResultPreview: abstract new (...args: any[]) => ILearningModelEvaluationResultPreview;
+
+  interface ILearningModelPreview {
+    EvaluateAsync(binding: Windows.AI.MachineLearning.Preview.LearningModelBindingPreview, correlationId: string): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.Preview.LearningModelEvaluationResultPreview>;
+    EvaluateFeaturesAsync(features: Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>, correlationId: string): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.Preview.LearningModelEvaluationResultPreview>;
+    readonly Description: Windows.AI.MachineLearning.Preview.LearningModelDescriptionPreview;
+    InferencingOptions: Windows.AI.MachineLearning.Preview.InferencingOptionsPreview;
+  }
+  var ILearningModelPreview: abstract new (...args: any[]) => ILearningModelPreview;
+
+  interface ILearningModelPreviewStatics {
+    LoadModelFromStorageFileAsync(modelFile: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.Preview.LearningModelPreview>;
+    LoadModelFromStreamAsync(modelStream: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.AI.MachineLearning.Preview.LearningModelPreview>;
+  }
+  var ILearningModelPreviewStatics: abstract new (...args: any[]) => ILearningModelPreviewStatics;
+
+  interface ILearningModelVariableDescriptorPreview {
+    readonly Description: string;
+    readonly IsRequired: boolean;
+    readonly ModelFeatureKind: number;
+    readonly Name: string;
+  }
+  var ILearningModelVariableDescriptorPreview: abstract new (...args: any[]) => ILearningModelVariableDescriptorPreview;
+
+  interface IMapVariableDescriptorPreview extends Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview {
+    readonly Fields: Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview;
+    readonly KeyKind: number;
+    readonly ValidIntegerKeys: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[];
+    readonly ValidStringKeys: Windows.Foundation.Collections.IIterable<string> | string[];
+  }
+  var IMapVariableDescriptorPreview: abstract new (...args: any[]) => IMapVariableDescriptorPreview;
+
+  interface ISequenceVariableDescriptorPreview extends Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview {
+    readonly ElementType: Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview;
+  }
+  var ISequenceVariableDescriptorPreview: abstract new (...args: any[]) => ISequenceVariableDescriptorPreview;
+
+  interface ITensorVariableDescriptorPreview extends Windows.AI.MachineLearning.Preview.ILearningModelVariableDescriptorPreview {
+    readonly DataType: number;
+    readonly Shape: Windows.Foundation.Collections.IIterable<number | bigint> | number | bigint[];
+  }
+  var ITensorVariableDescriptorPreview: abstract new (...args: any[]) => ITensorVariableDescriptorPreview;
+
+  interface MachineLearningPreviewContract {
+  }
+  var MachineLearningPreviewContract: {
+    new(fields: {  }): MachineLearningPreviewContract;
+  };
+
+}
+
+declare namespace Windows.AI.ModelContextProtocol {
+  class ModelContextProtocolClientContext implements Windows.AI.ModelContextProtocol.IModelContextProtocolClientContext {
+    OwnerWindowId: Windows.UI.WindowId;
+  }
+
+  class ModelContextProtocolServerCatalog implements Windows.AI.ModelContextProtocol.IModelContextProtocolServerCatalog {
+    ActivateServer(serverId: Guid, client: Windows.AI.ModelContextProtocol.ModelContextProtocolClientContext): Windows.AI.ModelContextProtocol.IModelContextProtocolServer;
+    CreateClientContext(): Windows.AI.ModelContextProtocol.ModelContextProtocolClientContext;
+    GetServerInfos(): Windows.AI.ModelContextProtocol.ModelContextProtocolServerInfo[];
+  }
+
+  class ModelContextProtocolServerInfo implements Windows.AI.ModelContextProtocol.IModelContextProtocolServerInfo {
+    GetPackage(): Windows.ApplicationModel.Package;
+    readonly Description: string;
+    readonly Id: Guid;
+    readonly Name: string;
+  }
+
+  interface IModelContextProtocolClientContext {
+    OwnerWindowId: Windows.UI.WindowId;
+  }
+  var IModelContextProtocolClientContext: abstract new (...args: any[]) => IModelContextProtocolClientContext;
+
+  interface IModelContextProtocolClientContextFactory {
+  }
+  var IModelContextProtocolClientContextFactory: abstract new (...args: any[]) => IModelContextProtocolClientContextFactory;
+
+  interface IModelContextProtocolServer extends Windows.Foundation.IClosable {
+    Close(): void;
+    GetCommandArguments(): string[];
+    readonly Command: string;
+    readonly Info: Windows.AI.ModelContextProtocol.ModelContextProtocolServerInfo;
+  }
+  var IModelContextProtocolServer: abstract new (...args: any[]) => IModelContextProtocolServer;
+
+  interface IModelContextProtocolServerCatalog {
+    ActivateServer(serverId: Guid, client: Windows.AI.ModelContextProtocol.ModelContextProtocolClientContext): Windows.AI.ModelContextProtocol.IModelContextProtocolServer;
+    CreateClientContext(): Windows.AI.ModelContextProtocol.ModelContextProtocolClientContext;
+    GetServerInfos(): Windows.AI.ModelContextProtocol.ModelContextProtocolServerInfo[];
+  }
+  var IModelContextProtocolServerCatalog: abstract new (...args: any[]) => IModelContextProtocolServerCatalog;
+
+  interface IModelContextProtocolServerCatalogFactory {
+  }
+  var IModelContextProtocolServerCatalogFactory: abstract new (...args: any[]) => IModelContextProtocolServerCatalogFactory;
+
+  interface IModelContextProtocolServerInfo {
+    GetPackage(): Windows.ApplicationModel.Package;
+    readonly Description: string;
+    readonly Id: Guid;
+    readonly Name: string;
+  }
+  var IModelContextProtocolServerInfo: abstract new (...args: any[]) => IModelContextProtocolServerInfo;
+
+  interface IModelContextProtocolServerInfoFactory {
+  }
+  var IModelContextProtocolServerInfoFactory: abstract new (...args: any[]) => IModelContextProtocolServerInfoFactory;
+
+  interface ModelContextProtocolContract {
+  }
+  var ModelContextProtocolContract: {
+    new(fields: {  }): ModelContextProtocolContract;
+  };
+
+}
+
+declare namespace Windows.ApplicationModel {
+  class AppDisplayInfo implements Windows.ApplicationModel.IAppDisplayInfo {
+    GetLogo(size: Windows.Foundation.Size): Windows.Storage.Streams.RandomAccessStreamReference;
+    readonly Description: string;
+    readonly DisplayName: string;
+  }
+
+  class AppInfo implements Windows.ApplicationModel.IAppInfo, Windows.ApplicationModel.IAppInfo2, Windows.ApplicationModel.IAppInfo3, Windows.ApplicationModel.IAppInfo4 {
+    static GetFromAppUserModelId(appUserModelId: string): Windows.ApplicationModel.AppInfo;
+    static GetFromAppUserModelIdForUser(user: Windows.System.User, appUserModelId: string): Windows.ApplicationModel.AppInfo;
+    readonly AppUserModelId: string;
+    static readonly Current: Windows.ApplicationModel.AppInfo;
+    readonly DisplayInfo: Windows.ApplicationModel.AppDisplayInfo;
+    readonly ExecutionContext: number;
+    readonly Id: string;
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly PackageFamilyName: string;
+    readonly SupportedFileExtensions: string[];
+  }
+
+  class AppInstallerInfo implements Windows.ApplicationModel.IAppInstallerInfo, Windows.ApplicationModel.IAppInstallerInfo2 {
+    readonly AutomaticBackgroundTask: boolean;
+    readonly DependencyPackageUris: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly ForceUpdateFromAnyVersion: boolean;
+    readonly HoursBetweenUpdateChecks: number;
+    readonly IsAutoRepairEnabled: boolean;
+    readonly LastChecked: Windows.Foundation.DateTime;
+    readonly OnLaunch: boolean;
+    readonly OptionalPackageUris: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly PausedUntil: Windows.Foundation.DateTime | null;
+    readonly PolicySource: number;
+    readonly RepairUris: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly ShowPrompt: boolean;
+    readonly UpdateBlocksActivation: boolean;
+    readonly UpdateUris: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly Uri: Windows.Foundation.Uri;
+    readonly Version: Windows.ApplicationModel.PackageVersion;
+  }
+
+  class AppInstance implements Windows.ApplicationModel.IAppInstance {
+    static FindOrRegisterInstanceForKey(key: string): Windows.ApplicationModel.AppInstance;
+    static GetActivatedEventArgs(): Windows.ApplicationModel.Activation.IActivatedEventArgs;
+    static GetInstances(): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.AppInstance> | Windows.ApplicationModel.AppInstance[];
+    RedirectActivationTo(): void;
+    static Unregister(): void;
+    readonly IsCurrentInstance: boolean;
+    readonly Key: string;
+    static readonly RecommendedInstance: Windows.ApplicationModel.AppInstance;
+  }
+
+  class DesignMode {
+    static readonly DesignMode2Enabled: boolean;
+    static readonly DesignModeEnabled: boolean;
+  }
+
+  class EnteredBackgroundEventArgs implements Windows.ApplicationModel.IEnteredBackgroundEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+
+  class FindRelatedPackagesOptions implements Windows.ApplicationModel.IFindRelatedPackagesOptions {
+    constructor(Relationship: number);
+    IncludeFrameworks: boolean;
+    IncludeHostRuntimes: boolean;
+    IncludeOptionals: boolean;
+    IncludeResources: boolean;
+    Relationship: number;
+  }
+
+  class FullTrustProcessLaunchResult implements Windows.ApplicationModel.IFullTrustProcessLaunchResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly LaunchResult: number;
+  }
+
+  class FullTrustProcessLauncher {
+    static LaunchFullTrustProcessForAppAsync(fullTrustPackageRelativeAppId: string): Windows.Foundation.IAsyncAction;
+    static LaunchFullTrustProcessForAppAsync(fullTrustPackageRelativeAppId: string, parameterGroupId: string): Windows.Foundation.IAsyncAction;
+    static LaunchFullTrustProcessForAppWithArgumentsAsync(fullTrustPackageRelativeAppId: string, commandLine: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.FullTrustProcessLaunchResult>;
+    static LaunchFullTrustProcessForCurrentAppAsync(): Windows.Foundation.IAsyncAction;
+    static LaunchFullTrustProcessForCurrentAppAsync(parameterGroupId: string): Windows.Foundation.IAsyncAction;
+    static LaunchFullTrustProcessForCurrentAppWithArgumentsAsync(commandLine: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.FullTrustProcessLaunchResult>;
+  }
+
+  class LeavingBackgroundEventArgs implements Windows.ApplicationModel.ILeavingBackgroundEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+
+  class LimitedAccessFeatureRequestResult implements Windows.ApplicationModel.ILimitedAccessFeatureRequestResult {
+    readonly EstimatedRemovalDate: Windows.Foundation.DateTime | null;
+    readonly FeatureId: string;
+    readonly Status: number;
+  }
+
+  class LimitedAccessFeatures {
+    static TryUnlockFeature(featureId: string, token: string, attestation: string): Windows.ApplicationModel.LimitedAccessFeatureRequestResult;
+  }
+
+  class Package implements Windows.ApplicationModel.IPackage, Windows.ApplicationModel.IPackage2, Windows.ApplicationModel.IPackage3, Windows.ApplicationModel.IPackage4, Windows.ApplicationModel.IPackage5, Windows.ApplicationModel.IPackage6, Windows.ApplicationModel.IPackage7, Windows.ApplicationModel.IPackage8, Windows.ApplicationModel.IPackage9, Windows.ApplicationModel.IPackageWithMetadata {
+    CheckUpdateAvailabilityAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.PackageUpdateAvailabilityResult>;
+    FindRelatedPackages(options: Windows.ApplicationModel.FindRelatedPackagesOptions): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    GetAppInstallerInfo(): Windows.ApplicationModel.AppInstallerInfo;
+    GetAppListEntries(): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Core.AppListEntry> | Windows.ApplicationModel.Core.AppListEntry[];
+    GetAppListEntriesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Core.AppListEntry> | Windows.ApplicationModel.Core.AppListEntry[]>;
+    GetContentGroupAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.PackageContentGroup>;
+    GetContentGroupsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.ApplicationModel.PackageContentGroup> | Windows.ApplicationModel.PackageContentGroup[]>;
+    GetLogoAsRandomAccessStreamReference(size: Windows.Foundation.Size): Windows.Storage.Streams.RandomAccessStreamReference;
+    GetThumbnailToken(): string;
+    Launch(parameters: string): void;
+    SetInUseAsync(inUse: boolean): Windows.Foundation.IAsyncOperation<boolean>;
+    StageContentGroupsAsync(names: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.ApplicationModel.PackageContentGroup> | Windows.ApplicationModel.PackageContentGroup[]>;
+    StageContentGroupsAsync(names: Windows.Foundation.Collections.IIterable<string> | string[], moveToHeadOfQueue: boolean): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.ApplicationModel.PackageContentGroup> | Windows.ApplicationModel.PackageContentGroup[]>;
+    VerifyContentIntegrityAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    static readonly Current: Windows.ApplicationModel.Package;
+    readonly Dependencies: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    readonly Description: string;
+    readonly DisplayName: string;
+    readonly EffectiveExternalLocation: Windows.Storage.StorageFolder;
+    readonly EffectiveExternalPath: string;
+    readonly EffectiveLocation: Windows.Storage.StorageFolder;
+    readonly EffectivePath: string;
+    readonly Id: Windows.ApplicationModel.PackageId;
+    readonly InstallDate: Windows.Foundation.DateTime;
+    readonly InstalledDate: Windows.Foundation.DateTime;
+    readonly InstalledLocation: Windows.Storage.StorageFolder;
+    readonly InstalledPath: string;
+    readonly IsBundle: boolean;
+    readonly IsDevelopmentMode: boolean;
+    readonly IsFramework: boolean;
+    readonly IsOptional: boolean;
+    readonly IsResourcePackage: boolean;
+    readonly IsStub: boolean;
+    readonly Logo: Windows.Foundation.Uri;
+    readonly MachineExternalLocation: Windows.Storage.StorageFolder;
+    readonly MachineExternalPath: string;
+    readonly MutableLocation: Windows.Storage.StorageFolder;
+    readonly MutablePath: string;
+    readonly PublisherDisplayName: string;
+    readonly SignatureKind: number;
+    readonly SourceUriSchemeName: string;
+    readonly Status: Windows.ApplicationModel.PackageStatus;
+    readonly UserExternalLocation: Windows.Storage.StorageFolder;
+    readonly UserExternalPath: string;
+  }
+
+  class PackageCatalog implements Windows.ApplicationModel.IPackageCatalog, Windows.ApplicationModel.IPackageCatalog2, Windows.ApplicationModel.IPackageCatalog3, Windows.ApplicationModel.IPackageCatalog4 {
+    AddOptionalPackageAsync(optionalPackageFamilyName: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.PackageCatalogAddOptionalPackageResult>;
+    AddResourcePackageAsync(resourcePackageFamilyName: string, resourceID: string, options: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.ApplicationModel.PackageCatalogAddResourcePackageResult, Windows.ApplicationModel.PackageInstallProgress>;
+    static OpenForCurrentPackage(): Windows.ApplicationModel.PackageCatalog;
+    static OpenForCurrentUser(): Windows.ApplicationModel.PackageCatalog;
+    static OpenForPackage(package_: Windows.ApplicationModel.Package): Windows.ApplicationModel.PackageCatalog;
+    RemoveOptionalPackagesAsync(optionalPackageFamilyNames: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.PackageCatalogRemoveOptionalPackagesResult>;
+    RemoveResourcePackagesAsync(resourcePackages: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[]): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.PackageCatalogRemoveResourcePackagesResult>;
+    PackageInstalling: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageCatalog, Windows.ApplicationModel.PackageInstallingEventArgs> | null;
+    PackageStaging: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageCatalog, Windows.ApplicationModel.PackageStagingEventArgs> | null;
+    PackageStatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageCatalog, Windows.ApplicationModel.PackageStatusChangedEventArgs> | null;
+    PackageUninstalling: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageCatalog, Windows.ApplicationModel.PackageUninstallingEventArgs> | null;
+    PackageUpdating: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageCatalog, Windows.ApplicationModel.PackageUpdatingEventArgs> | null;
+    PackageContentGroupStaging: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageCatalog, Windows.ApplicationModel.PackageContentGroupStagingEventArgs> | null;
+  }
+
+  class PackageCatalogAddOptionalPackageResult implements Windows.ApplicationModel.IPackageCatalogAddOptionalPackageResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+
+  class PackageCatalogAddResourcePackageResult implements Windows.ApplicationModel.IPackageCatalogAddResourcePackageResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly IsComplete: boolean;
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+
+  class PackageCatalogRemoveOptionalPackagesResult implements Windows.ApplicationModel.IPackageCatalogRemoveOptionalPackagesResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly PackagesRemoved: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+  }
+
+  class PackageCatalogRemoveResourcePackagesResult implements Windows.ApplicationModel.IPackageCatalogRemoveResourcePackagesResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly PackagesRemoved: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+  }
+
+  class PackageContentGroup implements Windows.ApplicationModel.IPackageContentGroup {
+    readonly IsRequired: boolean;
+    readonly Name: string;
+    readonly Package: Windows.ApplicationModel.Package;
+    static readonly RequiredGroupName: string;
+    readonly State: number;
+  }
+
+  class PackageContentGroupStagingEventArgs implements Windows.ApplicationModel.IPackageContentGroupStagingEventArgs {
+    readonly ActivityId: Guid;
+    readonly ContentGroupName: string;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly IsComplete: boolean;
+    readonly IsContentGroupRequired: boolean;
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly Progress: number;
+  }
+
+  class PackageId implements Windows.ApplicationModel.IPackageId, Windows.ApplicationModel.IPackageIdWithMetadata {
+    readonly Architecture: number;
+    readonly Author: string;
+    readonly FamilyName: string;
+    readonly FullName: string;
+    readonly Name: string;
+    readonly ProductId: string;
+    readonly Publisher: string;
+    readonly PublisherId: string;
+    readonly ResourceId: string;
+    readonly Version: Windows.ApplicationModel.PackageVersion;
+  }
+
+  class PackageInstallingEventArgs implements Windows.ApplicationModel.IPackageInstallingEventArgs {
+    readonly ActivityId: Guid;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly IsComplete: boolean;
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly Progress: number;
+  }
+
+  class PackageStagingEventArgs implements Windows.ApplicationModel.IPackageStagingEventArgs {
+    readonly ActivityId: Guid;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly IsComplete: boolean;
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly Progress: number;
+  }
+
+  class PackageStatus implements Windows.ApplicationModel.IPackageStatus, Windows.ApplicationModel.IPackageStatus2 {
+    VerifyIsOK(): boolean;
+    readonly DataOffline: boolean;
+    readonly DependencyIssue: boolean;
+    readonly DeploymentInProgress: boolean;
+    readonly Disabled: boolean;
+    readonly IsPartiallyStaged: boolean;
+    readonly LicenseIssue: boolean;
+    readonly Modified: boolean;
+    readonly NeedsRemediation: boolean;
+    readonly NotAvailable: boolean;
+    readonly PackageOffline: boolean;
+    readonly Servicing: boolean;
+    readonly Tampered: boolean;
+  }
+
+  class PackageStatusChangedEventArgs implements Windows.ApplicationModel.IPackageStatusChangedEventArgs {
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+
+  class PackageUninstallingEventArgs implements Windows.ApplicationModel.IPackageUninstallingEventArgs {
+    readonly ActivityId: Guid;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly IsComplete: boolean;
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly Progress: number;
+  }
+
+  class PackageUpdateAvailabilityResult implements Windows.ApplicationModel.IPackageUpdateAvailabilityResult {
+    readonly Availability: number;
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+
+  class PackageUpdatingEventArgs implements Windows.ApplicationModel.IPackageUpdatingEventArgs {
+    readonly ActivityId: Guid;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly IsComplete: boolean;
+    readonly Progress: number;
+    readonly SourcePackage: Windows.ApplicationModel.Package;
+    readonly TargetPackage: Windows.ApplicationModel.Package;
+  }
+
+  class StartupTask implements Windows.ApplicationModel.IStartupTask {
+    Disable(): void;
+    static GetAsync(taskId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.StartupTask>;
+    static GetForCurrentPackageAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.StartupTask> | Windows.ApplicationModel.StartupTask[]>;
+    RequestEnableAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly State: number;
+    readonly TaskId: string;
+  }
+
+  class SuspendingDeferral implements Windows.ApplicationModel.ISuspendingDeferral {
+    Complete(): void;
+  }
+
+  class SuspendingEventArgs implements Windows.ApplicationModel.ISuspendingEventArgs {
+    readonly SuspendingOperation: Windows.ApplicationModel.SuspendingOperation;
+  }
+
+  class SuspendingOperation implements Windows.ApplicationModel.ISuspendingOperation {
+    GetDeferral(): Windows.ApplicationModel.SuspendingDeferral;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+
+  enum AddResourcePackageOptions {
+    None = 0,
+    ForceTargetAppShutdown = 1,
+    ApplyUpdateIfAvailable = 2,
+  }
+
+  enum AppExecutionContext {
+    Unknown = 0,
+    Host = 1,
+    Guest = 2,
+  }
+
+  enum AppInstallerPolicySource {
+    Default = 0,
+    System = 1,
+  }
+
+  enum FullTrustLaunchResult {
+    Success = 0,
+    AccessDenied = 1,
+    FileNotFound = 2,
+    Unknown = 3,
+  }
+
+  enum LimitedAccessFeatureStatus {
+    Unavailable = 0,
+    Available = 1,
+    AvailableWithoutToken = 2,
+    Unknown = 3,
+  }
+
+  enum PackageContentGroupState {
+    NotStaged = 0,
+    Queued = 1,
+    Staging = 2,
+    Staged = 3,
+  }
+
+  enum PackageRelationship {
+    Dependencies = 0,
+    Dependents = 1,
+    All = 2,
+  }
+
+  enum PackageSignatureKind {
+    None = 0,
+    Developer = 1,
+    Enterprise = 2,
+    Store = 3,
+    System = 4,
+  }
+
+  enum PackageUpdateAvailability {
+    Unknown = 0,
+    NoUpdates = 1,
+    Available = 2,
+    Required = 3,
+    Error = 4,
+  }
+
+  enum StartupTaskState {
+    Disabled = 0,
+    DisabledByUser = 1,
+    Enabled = 2,
+    DisabledByPolicy = 3,
+    EnabledByPolicy = 4,
+  }
+
+  interface FullTrustAppContract {
+  }
+  var FullTrustAppContract: {
+    new(fields: {  }): FullTrustAppContract;
+  };
+
+  interface IAppDisplayInfo {
+    GetLogo(size: Windows.Foundation.Size): Windows.Storage.Streams.RandomAccessStreamReference;
+    readonly Description: string;
+    readonly DisplayName: string;
+  }
+  var IAppDisplayInfo: abstract new (...args: any[]) => IAppDisplayInfo;
+
+  interface IAppInfo {
+    readonly AppUserModelId: string;
+    readonly DisplayInfo: Windows.ApplicationModel.AppDisplayInfo;
+    readonly Id: string;
+    readonly PackageFamilyName: string;
+  }
+  var IAppInfo: abstract new (...args: any[]) => IAppInfo;
+
+  interface IAppInfo2 {
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+  var IAppInfo2: abstract new (...args: any[]) => IAppInfo2;
+
+  interface IAppInfo3 {
+    readonly ExecutionContext: number;
+  }
+  var IAppInfo3: abstract new (...args: any[]) => IAppInfo3;
+
+  interface IAppInfo4 {
+    readonly SupportedFileExtensions: string[];
+  }
+  var IAppInfo4: abstract new (...args: any[]) => IAppInfo4;
+
+  interface IAppInfoStatics {
+    GetFromAppUserModelId(appUserModelId: string): Windows.ApplicationModel.AppInfo;
+    GetFromAppUserModelIdForUser(user: Windows.System.User, appUserModelId: string): Windows.ApplicationModel.AppInfo;
+    readonly Current: Windows.ApplicationModel.AppInfo;
+  }
+  var IAppInfoStatics: abstract new (...args: any[]) => IAppInfoStatics;
+
+  interface IAppInstallerInfo {
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IAppInstallerInfo: abstract new (...args: any[]) => IAppInstallerInfo;
+
+  interface IAppInstallerInfo2 {
+    readonly AutomaticBackgroundTask: boolean;
+    readonly DependencyPackageUris: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly ForceUpdateFromAnyVersion: boolean;
+    readonly HoursBetweenUpdateChecks: number;
+    readonly IsAutoRepairEnabled: boolean;
+    readonly LastChecked: Windows.Foundation.DateTime;
+    readonly OnLaunch: boolean;
+    readonly OptionalPackageUris: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly PausedUntil: Windows.Foundation.DateTime | null;
+    readonly PolicySource: number;
+    readonly RepairUris: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly ShowPrompt: boolean;
+    readonly UpdateBlocksActivation: boolean;
+    readonly UpdateUris: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly Version: Windows.ApplicationModel.PackageVersion;
+  }
+  var IAppInstallerInfo2: abstract new (...args: any[]) => IAppInstallerInfo2;
+
+  interface IAppInstance {
+    RedirectActivationTo(): void;
+    readonly IsCurrentInstance: boolean;
+    readonly Key: string;
+  }
+  var IAppInstance: abstract new (...args: any[]) => IAppInstance;
+
+  interface IAppInstanceStatics {
+    FindOrRegisterInstanceForKey(key: string): Windows.ApplicationModel.AppInstance;
+    GetActivatedEventArgs(): Windows.ApplicationModel.Activation.IActivatedEventArgs;
+    GetInstances(): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.AppInstance> | Windows.ApplicationModel.AppInstance[];
+    Unregister(): void;
+    readonly RecommendedInstance: Windows.ApplicationModel.AppInstance;
+  }
+  var IAppInstanceStatics: abstract new (...args: any[]) => IAppInstanceStatics;
+
+  interface IDesignModeStatics {
+    readonly DesignModeEnabled: boolean;
+  }
+  var IDesignModeStatics: abstract new (...args: any[]) => IDesignModeStatics;
+
+  interface IDesignModeStatics2 {
+    readonly DesignMode2Enabled: boolean;
+  }
+  var IDesignModeStatics2: abstract new (...args: any[]) => IDesignModeStatics2;
+
+  interface IEnteredBackgroundEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+  var IEnteredBackgroundEventArgs: abstract new (...args: any[]) => IEnteredBackgroundEventArgs;
+
+  interface IFindRelatedPackagesOptions {
+    IncludeFrameworks: boolean;
+    IncludeHostRuntimes: boolean;
+    IncludeOptionals: boolean;
+    IncludeResources: boolean;
+    Relationship: number;
+  }
+  var IFindRelatedPackagesOptions: abstract new (...args: any[]) => IFindRelatedPackagesOptions;
+
+  interface IFindRelatedPackagesOptionsFactory {
+    CreateInstance(Relationship: number): Windows.ApplicationModel.FindRelatedPackagesOptions;
+  }
+  var IFindRelatedPackagesOptionsFactory: abstract new (...args: any[]) => IFindRelatedPackagesOptionsFactory;
+
+  interface IFullTrustProcessLaunchResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly LaunchResult: number;
+  }
+  var IFullTrustProcessLaunchResult: abstract new (...args: any[]) => IFullTrustProcessLaunchResult;
+
+  interface IFullTrustProcessLauncherStatics {
+    LaunchFullTrustProcessForAppAsync(fullTrustPackageRelativeAppId: string): Windows.Foundation.IAsyncAction;
+    LaunchFullTrustProcessForAppAsync(fullTrustPackageRelativeAppId: string, parameterGroupId: string): Windows.Foundation.IAsyncAction;
+    LaunchFullTrustProcessForCurrentAppAsync(): Windows.Foundation.IAsyncAction;
+    LaunchFullTrustProcessForCurrentAppAsync(parameterGroupId: string): Windows.Foundation.IAsyncAction;
+  }
+  var IFullTrustProcessLauncherStatics: abstract new (...args: any[]) => IFullTrustProcessLauncherStatics;
+
+  interface IFullTrustProcessLauncherStatics2 {
+    LaunchFullTrustProcessForAppWithArgumentsAsync(fullTrustPackageRelativeAppId: string, commandLine: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.FullTrustProcessLaunchResult>;
+    LaunchFullTrustProcessForCurrentAppWithArgumentsAsync(commandLine: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.FullTrustProcessLaunchResult>;
+  }
+  var IFullTrustProcessLauncherStatics2: abstract new (...args: any[]) => IFullTrustProcessLauncherStatics2;
+
+  interface ILeavingBackgroundEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+  var ILeavingBackgroundEventArgs: abstract new (...args: any[]) => ILeavingBackgroundEventArgs;
+
+  interface ILimitedAccessFeatureRequestResult {
+    readonly EstimatedRemovalDate: Windows.Foundation.DateTime | null;
+    readonly FeatureId: string;
+    readonly Status: number;
+  }
+  var ILimitedAccessFeatureRequestResult: abstract new (...args: any[]) => ILimitedAccessFeatureRequestResult;
+
+  interface ILimitedAccessFeaturesStatics {
+    TryUnlockFeature(featureId: string, token: string, attestation: string): Windows.ApplicationModel.LimitedAccessFeatureRequestResult;
+  }
+  var ILimitedAccessFeaturesStatics: abstract new (...args: any[]) => ILimitedAccessFeaturesStatics;
+
+  interface IPackage {
+    readonly Dependencies: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    readonly Id: Windows.ApplicationModel.PackageId;
+    readonly InstalledLocation: Windows.Storage.StorageFolder;
+    readonly IsFramework: boolean;
+  }
+  var IPackage: abstract new (...args: any[]) => IPackage;
+
+  interface IPackage2 {
+    readonly Description: string;
+    readonly DisplayName: string;
+    readonly IsBundle: boolean;
+    readonly IsDevelopmentMode: boolean;
+    readonly IsResourcePackage: boolean;
+    readonly Logo: Windows.Foundation.Uri;
+    readonly PublisherDisplayName: string;
+  }
+  var IPackage2: abstract new (...args: any[]) => IPackage2;
+
+  interface IPackage3 {
+    GetAppListEntriesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Core.AppListEntry> | Windows.ApplicationModel.Core.AppListEntry[]>;
+    readonly InstalledDate: Windows.Foundation.DateTime;
+    readonly Status: Windows.ApplicationModel.PackageStatus;
+  }
+  var IPackage3: abstract new (...args: any[]) => IPackage3;
+
+  interface IPackage4 {
+    VerifyContentIntegrityAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly IsOptional: boolean;
+    readonly SignatureKind: number;
+  }
+  var IPackage4: abstract new (...args: any[]) => IPackage4;
+
+  interface IPackage5 {
+    GetContentGroupAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.PackageContentGroup>;
+    GetContentGroupsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.ApplicationModel.PackageContentGroup> | Windows.ApplicationModel.PackageContentGroup[]>;
+    SetInUseAsync(inUse: boolean): Windows.Foundation.IAsyncOperation<boolean>;
+    StageContentGroupsAsync(names: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.ApplicationModel.PackageContentGroup> | Windows.ApplicationModel.PackageContentGroup[]>;
+    StageContentGroupsAsync(names: Windows.Foundation.Collections.IIterable<string> | string[], moveToHeadOfQueue: boolean): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.ApplicationModel.PackageContentGroup> | Windows.ApplicationModel.PackageContentGroup[]>;
+  }
+  var IPackage5: abstract new (...args: any[]) => IPackage5;
+
+  interface IPackage6 {
+    CheckUpdateAvailabilityAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.PackageUpdateAvailabilityResult>;
+    GetAppInstallerInfo(): Windows.ApplicationModel.AppInstallerInfo;
+  }
+  var IPackage6: abstract new (...args: any[]) => IPackage6;
+
+  interface IPackage7 {
+    readonly EffectiveLocation: Windows.Storage.StorageFolder;
+    readonly MutableLocation: Windows.Storage.StorageFolder;
+  }
+  var IPackage7: abstract new (...args: any[]) => IPackage7;
+
+  interface IPackage8 {
+    GetAppListEntries(): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Core.AppListEntry> | Windows.ApplicationModel.Core.AppListEntry[];
+    GetLogoAsRandomAccessStreamReference(size: Windows.Foundation.Size): Windows.Storage.Streams.RandomAccessStreamReference;
+    readonly EffectiveExternalLocation: Windows.Storage.StorageFolder;
+    readonly EffectiveExternalPath: string;
+    readonly EffectivePath: string;
+    readonly InstalledPath: string;
+    readonly IsStub: boolean;
+    readonly MachineExternalLocation: Windows.Storage.StorageFolder;
+    readonly MachineExternalPath: string;
+    readonly MutablePath: string;
+    readonly UserExternalLocation: Windows.Storage.StorageFolder;
+    readonly UserExternalPath: string;
+  }
+  var IPackage8: abstract new (...args: any[]) => IPackage8;
+
+  interface IPackage9 {
+    FindRelatedPackages(options: Windows.ApplicationModel.FindRelatedPackagesOptions): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    readonly SourceUriSchemeName: string;
+  }
+  var IPackage9: abstract new (...args: any[]) => IPackage9;
+
+  interface IPackageCatalog {
+    PackageInstalling: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageCatalog, Windows.ApplicationModel.PackageInstallingEventArgs> | null;
+    PackageStaging: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageCatalog, Windows.ApplicationModel.PackageStagingEventArgs> | null;
+    PackageStatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageCatalog, Windows.ApplicationModel.PackageStatusChangedEventArgs> | null;
+    PackageUninstalling: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageCatalog, Windows.ApplicationModel.PackageUninstallingEventArgs> | null;
+    PackageUpdating: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageCatalog, Windows.ApplicationModel.PackageUpdatingEventArgs> | null;
+  }
+  var IPackageCatalog: abstract new (...args: any[]) => IPackageCatalog;
+
+  interface IPackageCatalog2 {
+    AddOptionalPackageAsync(optionalPackageFamilyName: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.PackageCatalogAddOptionalPackageResult>;
+    PackageContentGroupStaging: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageCatalog, Windows.ApplicationModel.PackageContentGroupStagingEventArgs> | null;
+  }
+  var IPackageCatalog2: abstract new (...args: any[]) => IPackageCatalog2;
+
+  interface IPackageCatalog3 {
+    RemoveOptionalPackagesAsync(optionalPackageFamilyNames: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.PackageCatalogRemoveOptionalPackagesResult>;
+  }
+  var IPackageCatalog3: abstract new (...args: any[]) => IPackageCatalog3;
+
+  interface IPackageCatalog4 {
+    AddResourcePackageAsync(resourcePackageFamilyName: string, resourceID: string, options: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.ApplicationModel.PackageCatalogAddResourcePackageResult, Windows.ApplicationModel.PackageInstallProgress>;
+    RemoveResourcePackagesAsync(resourcePackages: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[]): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.PackageCatalogRemoveResourcePackagesResult>;
+  }
+  var IPackageCatalog4: abstract new (...args: any[]) => IPackageCatalog4;
+
+  interface IPackageCatalogAddOptionalPackageResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+  var IPackageCatalogAddOptionalPackageResult: abstract new (...args: any[]) => IPackageCatalogAddOptionalPackageResult;
+
+  interface IPackageCatalogAddResourcePackageResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly IsComplete: boolean;
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+  var IPackageCatalogAddResourcePackageResult: abstract new (...args: any[]) => IPackageCatalogAddResourcePackageResult;
+
+  interface IPackageCatalogRemoveOptionalPackagesResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly PackagesRemoved: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+  }
+  var IPackageCatalogRemoveOptionalPackagesResult: abstract new (...args: any[]) => IPackageCatalogRemoveOptionalPackagesResult;
+
+  interface IPackageCatalogRemoveResourcePackagesResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly PackagesRemoved: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+  }
+  var IPackageCatalogRemoveResourcePackagesResult: abstract new (...args: any[]) => IPackageCatalogRemoveResourcePackagesResult;
+
+  interface IPackageCatalogStatics {
+    OpenForCurrentPackage(): Windows.ApplicationModel.PackageCatalog;
+    OpenForCurrentUser(): Windows.ApplicationModel.PackageCatalog;
+  }
+  var IPackageCatalogStatics: abstract new (...args: any[]) => IPackageCatalogStatics;
+
+  interface IPackageCatalogStatics2 {
+    OpenForPackage(package_: Windows.ApplicationModel.Package): Windows.ApplicationModel.PackageCatalog;
+  }
+  var IPackageCatalogStatics2: abstract new (...args: any[]) => IPackageCatalogStatics2;
+
+  interface IPackageContentGroup {
+    readonly IsRequired: boolean;
+    readonly Name: string;
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly State: number;
+  }
+  var IPackageContentGroup: abstract new (...args: any[]) => IPackageContentGroup;
+
+  interface IPackageContentGroupStagingEventArgs {
+    readonly ActivityId: Guid;
+    readonly ContentGroupName: string;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly IsComplete: boolean;
+    readonly IsContentGroupRequired: boolean;
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly Progress: number;
+  }
+  var IPackageContentGroupStagingEventArgs: abstract new (...args: any[]) => IPackageContentGroupStagingEventArgs;
+
+  interface IPackageContentGroupStatics {
+    readonly RequiredGroupName: string;
+  }
+  var IPackageContentGroupStatics: abstract new (...args: any[]) => IPackageContentGroupStatics;
+
+  interface IPackageId {
+    readonly Architecture: number;
+    readonly FamilyName: string;
+    readonly FullName: string;
+    readonly Name: string;
+    readonly Publisher: string;
+    readonly PublisherId: string;
+    readonly ResourceId: string;
+    readonly Version: Windows.ApplicationModel.PackageVersion;
+  }
+  var IPackageId: abstract new (...args: any[]) => IPackageId;
+
+  interface IPackageIdWithMetadata {
+    readonly Author: string;
+    readonly ProductId: string;
+  }
+  var IPackageIdWithMetadata: abstract new (...args: any[]) => IPackageIdWithMetadata;
+
+  interface IPackageInstallingEventArgs {
+    readonly ActivityId: Guid;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly IsComplete: boolean;
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly Progress: number;
+  }
+  var IPackageInstallingEventArgs: abstract new (...args: any[]) => IPackageInstallingEventArgs;
+
+  interface IPackageStagingEventArgs {
+    readonly ActivityId: Guid;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly IsComplete: boolean;
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly Progress: number;
+  }
+  var IPackageStagingEventArgs: abstract new (...args: any[]) => IPackageStagingEventArgs;
+
+  interface IPackageStatics {
+    readonly Current: Windows.ApplicationModel.Package;
+  }
+  var IPackageStatics: abstract new (...args: any[]) => IPackageStatics;
+
+  interface IPackageStatus {
+    VerifyIsOK(): boolean;
+    readonly DataOffline: boolean;
+    readonly DependencyIssue: boolean;
+    readonly DeploymentInProgress: boolean;
+    readonly Disabled: boolean;
+    readonly LicenseIssue: boolean;
+    readonly Modified: boolean;
+    readonly NeedsRemediation: boolean;
+    readonly NotAvailable: boolean;
+    readonly PackageOffline: boolean;
+    readonly Servicing: boolean;
+    readonly Tampered: boolean;
+  }
+  var IPackageStatus: abstract new (...args: any[]) => IPackageStatus;
+
+  interface IPackageStatus2 {
+    readonly IsPartiallyStaged: boolean;
+  }
+  var IPackageStatus2: abstract new (...args: any[]) => IPackageStatus2;
+
+  interface IPackageStatusChangedEventArgs {
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+  var IPackageStatusChangedEventArgs: abstract new (...args: any[]) => IPackageStatusChangedEventArgs;
+
+  interface IPackageUninstallingEventArgs {
+    readonly ActivityId: Guid;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly IsComplete: boolean;
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly Progress: number;
+  }
+  var IPackageUninstallingEventArgs: abstract new (...args: any[]) => IPackageUninstallingEventArgs;
+
+  interface IPackageUpdateAvailabilityResult {
+    readonly Availability: number;
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+  var IPackageUpdateAvailabilityResult: abstract new (...args: any[]) => IPackageUpdateAvailabilityResult;
+
+  interface IPackageUpdatingEventArgs {
+    readonly ActivityId: Guid;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly IsComplete: boolean;
+    readonly Progress: number;
+    readonly SourcePackage: Windows.ApplicationModel.Package;
+    readonly TargetPackage: Windows.ApplicationModel.Package;
+  }
+  var IPackageUpdatingEventArgs: abstract new (...args: any[]) => IPackageUpdatingEventArgs;
+
+  interface IPackageWithMetadata {
+    GetThumbnailToken(): string;
+    Launch(parameters: string): void;
+    readonly InstallDate: Windows.Foundation.DateTime;
+  }
+  var IPackageWithMetadata: abstract new (...args: any[]) => IPackageWithMetadata;
+
+  interface IStartupTask {
+    Disable(): void;
+    RequestEnableAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly State: number;
+    readonly TaskId: string;
+  }
+  var IStartupTask: abstract new (...args: any[]) => IStartupTask;
+
+  interface IStartupTaskStatics {
+    GetAsync(taskId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.StartupTask>;
+    GetForCurrentPackageAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.StartupTask> | Windows.ApplicationModel.StartupTask[]>;
+  }
+  var IStartupTaskStatics: abstract new (...args: any[]) => IStartupTaskStatics;
+
+  interface ISuspendingDeferral {
+    Complete(): void;
+  }
+  var ISuspendingDeferral: abstract new (...args: any[]) => ISuspendingDeferral;
+
+  interface ISuspendingEventArgs {
+    readonly SuspendingOperation: Windows.ApplicationModel.SuspendingOperation;
+  }
+  var ISuspendingEventArgs: abstract new (...args: any[]) => ISuspendingEventArgs;
+
+  interface ISuspendingOperation {
+    GetDeferral(): Windows.ApplicationModel.SuspendingDeferral;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+  var ISuspendingOperation: abstract new (...args: any[]) => ISuspendingOperation;
+
+  interface PackageInstallProgress {
+    PercentComplete: number;
+  }
+  var PackageInstallProgress: {
+    new(percentComplete: number): PackageInstallProgress;
+    new(fields: { PercentComplete?: number }): PackageInstallProgress;
+  };
+
+  interface PackageVersion {
+    Major: number;
+    Minor: number;
+    Build: number;
+    Revision: number;
+  }
+  var PackageVersion: {
+    new(major: number, minor: number, build: number, revision: number): PackageVersion;
+    new(fields: { Major?: number; Minor?: number; Build?: number; Revision?: number }): PackageVersion;
+  };
+
+  interface StartupTaskContract {
+  }
+  var StartupTaskContract: {
+    new(fields: {  }): StartupTaskContract;
+  };
+
+}
+
+declare namespace Windows.ApplicationModel.Activation {
+  class AppointmentsProviderAddAppointmentActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IAppointmentsProviderActivatedEventArgs, Windows.ApplicationModel.Activation.IAppointmentsProviderAddAppointmentActivatedEventArgs {
+    readonly AddAppointmentOperation: Windows.ApplicationModel.Appointments.AppointmentsProvider.AddAppointmentOperation;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+    readonly Verb: string;
+  }
+
+  class AppointmentsProviderRemoveAppointmentActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IAppointmentsProviderActivatedEventArgs, Windows.ApplicationModel.Activation.IAppointmentsProviderRemoveAppointmentActivatedEventArgs {
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly RemoveAppointmentOperation: Windows.ApplicationModel.Appointments.AppointmentsProvider.RemoveAppointmentOperation;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+    readonly Verb: string;
+  }
+
+  class AppointmentsProviderReplaceAppointmentActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IAppointmentsProviderActivatedEventArgs, Windows.ApplicationModel.Activation.IAppointmentsProviderReplaceAppointmentActivatedEventArgs {
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly ReplaceAppointmentOperation: Windows.ApplicationModel.Appointments.AppointmentsProvider.ReplaceAppointmentOperation;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+    readonly Verb: string;
+  }
+
+  class AppointmentsProviderShowAppointmentDetailsActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IAppointmentsProviderActivatedEventArgs, Windows.ApplicationModel.Activation.IAppointmentsProviderShowAppointmentDetailsActivatedEventArgs {
+    readonly InstanceStartDate: Windows.Foundation.DateTime | null;
+    readonly Kind: number;
+    readonly LocalId: string;
+    readonly PreviousExecutionState: number;
+    readonly RoamingId: string;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+    readonly Verb: string;
+  }
+
+  class AppointmentsProviderShowTimeFrameActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IAppointmentsProviderActivatedEventArgs, Windows.ApplicationModel.Activation.IAppointmentsProviderShowTimeFrameActivatedEventArgs {
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly TimeToShow: Windows.Foundation.DateTime;
+    readonly User: Windows.System.User;
+    readonly Verb: string;
+  }
+
+  class BackgroundActivatedEventArgs implements Windows.ApplicationModel.Activation.IBackgroundActivatedEventArgs {
+    readonly TaskInstance: Windows.ApplicationModel.Background.IBackgroundTaskInstance;
+  }
+
+  class BarcodeScannerPreviewActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IBarcodeScannerPreviewActivatedEventArgs {
+    readonly ConnectionId: string;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class CachedFileUpdaterActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.ICachedFileUpdaterActivatedEventArgs {
+    readonly CachedFileUpdaterUI: Windows.Storage.Provider.CachedFileUpdaterUI;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class CameraSettingsActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.ICameraSettingsActivatedEventArgs {
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly VideoDeviceController: Object;
+    readonly VideoDeviceExtension: Object;
+  }
+
+  class CommandLineActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.ICommandLineActivatedEventArgs {
+    readonly Kind: number;
+    readonly Operation: Windows.ApplicationModel.Activation.CommandLineActivationOperation;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class CommandLineActivationOperation implements Windows.ApplicationModel.Activation.ICommandLineActivationOperation {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Arguments: string;
+    readonly CurrentDirectoryPath: string;
+    ExitCode: number;
+  }
+
+  class ContactCallActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContactActivatedEventArgs, Windows.ApplicationModel.Activation.IContactCallActivatedEventArgs {
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly ServiceId: string;
+    readonly ServiceUserId: string;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly Verb: string;
+  }
+
+  class ContactMapActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContactActivatedEventArgs, Windows.ApplicationModel.Activation.IContactMapActivatedEventArgs {
+    readonly Address: Windows.ApplicationModel.Contacts.ContactAddress;
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly Verb: string;
+  }
+
+  class ContactMessageActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContactActivatedEventArgs, Windows.ApplicationModel.Activation.IContactMessageActivatedEventArgs {
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly ServiceId: string;
+    readonly ServiceUserId: string;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly Verb: string;
+  }
+
+  class ContactPanelActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IContactPanelActivatedEventArgs {
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+    readonly ContactPanel: Windows.ApplicationModel.Contacts.ContactPanel;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class ContactPickerActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContactPickerActivatedEventArgs {
+    readonly ContactPickerUI: Windows.ApplicationModel.Contacts.Provider.ContactPickerUI;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+  }
+
+  class ContactPostActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContactActivatedEventArgs, Windows.ApplicationModel.Activation.IContactPostActivatedEventArgs {
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly ServiceId: string;
+    readonly ServiceUserId: string;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly Verb: string;
+  }
+
+  class ContactVideoCallActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContactActivatedEventArgs, Windows.ApplicationModel.Activation.IContactVideoCallActivatedEventArgs {
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly ServiceId: string;
+    readonly ServiceUserId: string;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly Verb: string;
+  }
+
+  class DeviceActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs, Windows.ApplicationModel.Activation.IDeviceActivatedEventArgs, Windows.ApplicationModel.Activation.IViewSwitcherProvider {
+    readonly CurrentlyShownApplicationViewId: number;
+    readonly DeviceInformationId: string;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+    readonly Verb: string;
+    readonly ViewSwitcher: Windows.UI.ViewManagement.ActivationViewSwitcher;
+  }
+
+  class DevicePairingActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IDevicePairingActivatedEventArgs {
+    readonly DeviceInformation: Windows.Devices.Enumeration.DeviceInformation;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class DialReceiverActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs, Windows.ApplicationModel.Activation.IDialReceiverActivatedEventArgs, Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs, Windows.ApplicationModel.Activation.IViewSwitcherProvider {
+    readonly AppName: string;
+    readonly Arguments: string;
+    readonly CurrentlyShownApplicationViewId: number;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly TileId: string;
+    readonly User: Windows.System.User;
+    readonly ViewSwitcher: Windows.UI.ViewManagement.ActivationViewSwitcher;
+  }
+
+  class FileActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs, Windows.ApplicationModel.Activation.IFileActivatedEventArgs, Windows.ApplicationModel.Activation.IFileActivatedEventArgsWithCallerPackageFamilyName, Windows.ApplicationModel.Activation.IFileActivatedEventArgsWithNeighboringFiles, Windows.ApplicationModel.Activation.IViewSwitcherProvider {
+    readonly CallerPackageFamilyName: string;
+    readonly CurrentlyShownApplicationViewId: number;
+    readonly Files: Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[];
+    readonly Kind: number;
+    readonly NeighboringFilesQuery: Windows.Storage.Search.StorageFileQueryResult;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+    readonly Verb: string;
+    readonly ViewSwitcher: Windows.UI.ViewManagement.ActivationViewSwitcher;
+  }
+
+  class FileOpenPickerActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IFileOpenPickerActivatedEventArgs, Windows.ApplicationModel.Activation.IFileOpenPickerActivatedEventArgs2 {
+    readonly CallerPackageFamilyName: string;
+    readonly FileOpenPickerUI: Windows.Storage.Pickers.Provider.FileOpenPickerUI;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class FileOpenPickerContinuationEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IContinuationActivatedEventArgs, Windows.ApplicationModel.Activation.IFileOpenPickerContinuationEventArgs {
+    readonly ContinuationData: Windows.Foundation.Collections.ValueSet;
+    readonly Files: Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[];
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class FileSavePickerActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IFileSavePickerActivatedEventArgs, Windows.ApplicationModel.Activation.IFileSavePickerActivatedEventArgs2 {
+    readonly CallerPackageFamilyName: string;
+    readonly EnterpriseId: string;
+    readonly FileSavePickerUI: Windows.Storage.Pickers.Provider.FileSavePickerUI;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class FileSavePickerContinuationEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IContinuationActivatedEventArgs, Windows.ApplicationModel.Activation.IFileSavePickerContinuationEventArgs {
+    readonly ContinuationData: Windows.Foundation.Collections.ValueSet;
+    readonly File: Windows.Storage.StorageFile;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class FolderPickerContinuationEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IContinuationActivatedEventArgs, Windows.ApplicationModel.Activation.IFolderPickerContinuationEventArgs {
+    readonly ContinuationData: Windows.Foundation.Collections.ValueSet;
+    readonly Folder: Windows.Storage.StorageFolder;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class LaunchActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs, Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs, Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs2, Windows.ApplicationModel.Activation.IPrelaunchActivatedEventArgs, Windows.ApplicationModel.Activation.IViewSwitcherProvider {
+    readonly Arguments: string;
+    readonly CurrentlyShownApplicationViewId: number;
+    readonly Kind: number;
+    readonly PrelaunchActivated: boolean;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly TileActivatedInfo: Windows.ApplicationModel.Activation.TileActivatedInfo;
+    readonly TileId: string;
+    readonly User: Windows.System.User;
+    readonly ViewSwitcher: Windows.UI.ViewManagement.ActivationViewSwitcher;
+  }
+
+  class LockScreenActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.ILockScreenActivatedEventArgs {
+    readonly Info: Object;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class LockScreenCallActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs, Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs, Windows.ApplicationModel.Activation.ILockScreenCallActivatedEventArgs, Windows.ApplicationModel.Activation.IViewSwitcherProvider {
+    readonly Arguments: string;
+    readonly CallUI: Windows.ApplicationModel.Calls.LockScreenCallUI;
+    readonly CurrentlyShownApplicationViewId: number;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly TileId: string;
+    readonly ViewSwitcher: Windows.UI.ViewManagement.ActivationViewSwitcher;
+  }
+
+  class LockScreenComponentActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+  }
+
+  class PhoneCallActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IPhoneCallActivatedEventArgs {
+    readonly Kind: number;
+    readonly LineId: Guid;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class PickerReturnedActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IPickerReturnedActivatedEventArgs {
+    readonly Kind: number;
+    readonly PickerOperationId: string;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+  }
+
+  class Print3DWorkflowActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IPrint3DWorkflowActivatedEventArgs {
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly Workflow: Windows.Devices.Printers.Extensions.Print3DWorkflow;
+  }
+
+  class PrintTaskSettingsActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IPrintTaskSettingsActivatedEventArgs {
+    readonly Configuration: Windows.Devices.Printers.Extensions.PrintTaskConfiguration;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+  }
+
+  class ProtocolActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs, Windows.ApplicationModel.Activation.IProtocolActivatedEventArgs, Windows.ApplicationModel.Activation.IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData, Windows.ApplicationModel.Activation.IViewSwitcherProvider {
+    readonly CallerPackageFamilyName: string;
+    readonly CurrentlyShownApplicationViewId: number;
+    readonly Data: Windows.Foundation.Collections.ValueSet;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly Uri: Windows.Foundation.Uri;
+    readonly User: Windows.System.User;
+    readonly ViewSwitcher: Windows.UI.ViewManagement.ActivationViewSwitcher;
+  }
+
+  class ProtocolForResultsActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs, Windows.ApplicationModel.Activation.IProtocolActivatedEventArgs, Windows.ApplicationModel.Activation.IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData, Windows.ApplicationModel.Activation.IProtocolForResultsActivatedEventArgs, Windows.ApplicationModel.Activation.IViewSwitcherProvider {
+    readonly CallerPackageFamilyName: string;
+    readonly CurrentlyShownApplicationViewId: number;
+    readonly Data: Windows.Foundation.Collections.ValueSet;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly ProtocolForResultsOperation: Windows.System.ProtocolForResultsOperation;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly Uri: Windows.Foundation.Uri;
+    readonly User: Windows.System.User;
+    readonly ViewSwitcher: Windows.UI.ViewManagement.ActivationViewSwitcher;
+  }
+
+  class RestrictedLaunchActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IRestrictedLaunchActivatedEventArgs {
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SharedContext: Object;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class SearchActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs, Windows.ApplicationModel.Activation.ISearchActivatedEventArgs, Windows.ApplicationModel.Activation.ISearchActivatedEventArgsWithLinguisticDetails, Windows.ApplicationModel.Activation.IViewSwitcherProvider {
+    readonly CurrentlyShownApplicationViewId: number;
+    readonly Kind: number;
+    readonly Language: string;
+    readonly LinguisticDetails: Windows.ApplicationModel.Search.SearchPaneQueryLinguisticDetails;
+    readonly PreviousExecutionState: number;
+    readonly QueryText: string;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+    readonly ViewSwitcher: Windows.UI.ViewManagement.ActivationViewSwitcher;
+  }
+
+  class ShareTargetActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IShareTargetActivatedEventArgs {
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly ShareOperation: Windows.ApplicationModel.DataTransfer.ShareTarget.ShareOperation;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class SplashScreen implements Windows.ApplicationModel.Activation.ISplashScreen {
+    readonly ImageLocation: Windows.Foundation.Rect;
+    Dismissed: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Activation.SplashScreen, Object> | null;
+  }
+
+  class StartupTaskActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IStartupTaskActivatedEventArgs {
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly TaskId: string;
+    readonly User: Windows.System.User;
+  }
+
+  class TileActivatedInfo implements Windows.ApplicationModel.Activation.ITileActivatedInfo {
+    readonly RecentlyShownNotifications: Windows.Foundation.Collections.IVectorView<Windows.UI.Notifications.ShownTileNotification> | Windows.UI.Notifications.ShownTileNotification[];
+  }
+
+  class ToastNotificationActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs, Windows.ApplicationModel.Activation.IToastNotificationActivatedEventArgs {
+    readonly Argument: string;
+    readonly CurrentlyShownApplicationViewId: number;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+    readonly UserInput: Windows.Foundation.Collections.ValueSet;
+  }
+
+  class UserDataAccountProviderActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IUserDataAccountProviderActivatedEventArgs {
+    readonly Kind: number;
+    readonly Operation: Windows.ApplicationModel.UserDataAccounts.Provider.IUserDataAccountProviderOperation;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+  }
+
+  class VoiceCommandActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IVoiceCommandActivatedEventArgs {
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly Result: Windows.Media.SpeechRecognition.SpeechRecognitionResult;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class WalletActionActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IWalletActionActivatedEventArgs {
+    readonly ActionId: string;
+    readonly ActionKind: number;
+    readonly ItemId: string;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+  }
+
+  class WebAccountProviderActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IWebAccountProviderActivatedEventArgs {
+    readonly Kind: number;
+    readonly Operation: Windows.Security.Authentication.Web.Provider.IWebAccountProviderOperation;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class WebAuthenticationBrokerContinuationEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContinuationActivatedEventArgs, Windows.ApplicationModel.Activation.IWebAuthenticationBrokerContinuationEventArgs {
+    readonly ContinuationData: Windows.Foundation.Collections.ValueSet;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly WebAuthenticationResult: Windows.Security.Authentication.Web.WebAuthenticationResult;
+  }
+
+  enum ActivationKind {
+    Launch = 0,
+    Search = 1,
+    ShareTarget = 2,
+    File = 3,
+    Protocol = 4,
+    FileOpenPicker = 5,
+    FileSavePicker = 6,
+    CachedFileUpdater = 7,
+    ContactPicker = 8,
+    Device = 9,
+    PrintTaskSettings = 10,
+    CameraSettings = 11,
+    RestrictedLaunch = 12,
+    AppointmentsProvider = 13,
+    Contact = 14,
+    LockScreenCall = 15,
+    VoiceCommand = 16,
+    LockScreen = 17,
+    PickerReturned = 1000,
+    WalletAction = 1001,
+    PickFileContinuation = 1002,
+    PickSaveFileContinuation = 1003,
+    PickFolderContinuation = 1004,
+    WebAuthenticationBrokerContinuation = 1005,
+    WebAccountProvider = 1006,
+    ComponentUI = 1007,
+    ProtocolForResults = 1009,
+    ToastNotification = 1010,
+    Print3DWorkflow = 1011,
+    DialReceiver = 1012,
+    DevicePairing = 1013,
+    UserDataAccountsProvider = 1014,
+    FilePickerExperience = 1015,
+    LockScreenComponent = 1016,
+    ContactPanel = 1017,
+    PrintWorkflowForegroundTask = 1018,
+    GameUIProvider = 1019,
+    StartupTask = 1020,
+    CommandLineLaunch = 1021,
+    BarcodeScannerProvider = 1022,
+    PrintSupportJobUI = 1023,
+    PrintSupportSettingsUI = 1024,
+    PhoneCallActivation = 1025,
+    VpnForeground = 1026,
+  }
+
+  enum ApplicationExecutionState {
+    NotRunning = 0,
+    Running = 1,
+    Suspended = 2,
+    Terminated = 3,
+    ClosedByUser = 4,
+  }
+
+  interface ActivatedEventsContract {
+  }
+  var ActivatedEventsContract: {
+    new(fields: {  }): ActivatedEventsContract;
+  };
+
+  interface ActivationCameraSettingsContract {
+  }
+  var ActivationCameraSettingsContract: {
+    new(fields: {  }): ActivationCameraSettingsContract;
+  };
+
+  interface ContactActivatedEventsContract {
+  }
+  var ContactActivatedEventsContract: {
+    new(fields: {  }): ContactActivatedEventsContract;
+  };
+
+  interface IActivatedEventArgs {
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+  }
+  var IActivatedEventArgs: abstract new (...args: any[]) => IActivatedEventArgs;
+
+  interface IActivatedEventArgsWithUser extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly User: Windows.System.User;
+  }
+  var IActivatedEventArgsWithUser: abstract new (...args: any[]) => IActivatedEventArgsWithUser;
+
+  interface IApplicationViewActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly CurrentlyShownApplicationViewId: number;
+  }
+  var IApplicationViewActivatedEventArgs: abstract new (...args: any[]) => IApplicationViewActivatedEventArgs;
+
+  interface IAppointmentsProviderActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly Verb: string;
+  }
+  var IAppointmentsProviderActivatedEventArgs: abstract new (...args: any[]) => IAppointmentsProviderActivatedEventArgs;
+
+  interface IAppointmentsProviderAddAppointmentActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IAppointmentsProviderActivatedEventArgs {
+    readonly AddAppointmentOperation: Windows.ApplicationModel.Appointments.AppointmentsProvider.AddAppointmentOperation;
+  }
+  var IAppointmentsProviderAddAppointmentActivatedEventArgs: abstract new (...args: any[]) => IAppointmentsProviderAddAppointmentActivatedEventArgs;
+
+  interface IAppointmentsProviderRemoveAppointmentActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IAppointmentsProviderActivatedEventArgs {
+    readonly RemoveAppointmentOperation: Windows.ApplicationModel.Appointments.AppointmentsProvider.RemoveAppointmentOperation;
+  }
+  var IAppointmentsProviderRemoveAppointmentActivatedEventArgs: abstract new (...args: any[]) => IAppointmentsProviderRemoveAppointmentActivatedEventArgs;
+
+  interface IAppointmentsProviderReplaceAppointmentActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IAppointmentsProviderActivatedEventArgs {
+    readonly ReplaceAppointmentOperation: Windows.ApplicationModel.Appointments.AppointmentsProvider.ReplaceAppointmentOperation;
+  }
+  var IAppointmentsProviderReplaceAppointmentActivatedEventArgs: abstract new (...args: any[]) => IAppointmentsProviderReplaceAppointmentActivatedEventArgs;
+
+  interface IAppointmentsProviderShowAppointmentDetailsActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IAppointmentsProviderActivatedEventArgs {
+    readonly InstanceStartDate: Windows.Foundation.DateTime | null;
+    readonly LocalId: string;
+    readonly RoamingId: string;
+  }
+  var IAppointmentsProviderShowAppointmentDetailsActivatedEventArgs: abstract new (...args: any[]) => IAppointmentsProviderShowAppointmentDetailsActivatedEventArgs;
+
+  interface IAppointmentsProviderShowTimeFrameActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IAppointmentsProviderActivatedEventArgs {
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly TimeToShow: Windows.Foundation.DateTime;
+  }
+  var IAppointmentsProviderShowTimeFrameActivatedEventArgs: abstract new (...args: any[]) => IAppointmentsProviderShowTimeFrameActivatedEventArgs;
+
+  interface IBackgroundActivatedEventArgs {
+    readonly TaskInstance: Windows.ApplicationModel.Background.IBackgroundTaskInstance;
+  }
+  var IBackgroundActivatedEventArgs: abstract new (...args: any[]) => IBackgroundActivatedEventArgs;
+
+  interface IBarcodeScannerPreviewActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly ConnectionId: string;
+  }
+  var IBarcodeScannerPreviewActivatedEventArgs: abstract new (...args: any[]) => IBarcodeScannerPreviewActivatedEventArgs;
+
+  interface ICachedFileUpdaterActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly CachedFileUpdaterUI: Windows.Storage.Provider.CachedFileUpdaterUI;
+  }
+  var ICachedFileUpdaterActivatedEventArgs: abstract new (...args: any[]) => ICachedFileUpdaterActivatedEventArgs;
+
+  interface ICameraSettingsActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly VideoDeviceController: Object;
+    readonly VideoDeviceExtension: Object;
+  }
+  var ICameraSettingsActivatedEventArgs: abstract new (...args: any[]) => ICameraSettingsActivatedEventArgs;
+
+  interface ICommandLineActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly Operation: Windows.ApplicationModel.Activation.CommandLineActivationOperation;
+  }
+  var ICommandLineActivatedEventArgs: abstract new (...args: any[]) => ICommandLineActivatedEventArgs;
+
+  interface ICommandLineActivationOperation {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Arguments: string;
+    readonly CurrentDirectoryPath: string;
+    ExitCode: number;
+  }
+  var ICommandLineActivationOperation: abstract new (...args: any[]) => ICommandLineActivationOperation;
+
+  interface IContactActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly Verb: string;
+  }
+  var IContactActivatedEventArgs: abstract new (...args: any[]) => IContactActivatedEventArgs;
+
+  interface IContactCallActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContactActivatedEventArgs {
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+    readonly ServiceId: string;
+    readonly ServiceUserId: string;
+  }
+  var IContactCallActivatedEventArgs: abstract new (...args: any[]) => IContactCallActivatedEventArgs;
+
+  interface IContactMapActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContactActivatedEventArgs {
+    readonly Address: Windows.ApplicationModel.Contacts.ContactAddress;
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+  }
+  var IContactMapActivatedEventArgs: abstract new (...args: any[]) => IContactMapActivatedEventArgs;
+
+  interface IContactMessageActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContactActivatedEventArgs {
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+    readonly ServiceId: string;
+    readonly ServiceUserId: string;
+  }
+  var IContactMessageActivatedEventArgs: abstract new (...args: any[]) => IContactMessageActivatedEventArgs;
+
+  interface IContactPanelActivatedEventArgs {
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+    readonly ContactPanel: Windows.ApplicationModel.Contacts.ContactPanel;
+  }
+  var IContactPanelActivatedEventArgs: abstract new (...args: any[]) => IContactPanelActivatedEventArgs;
+
+  interface IContactPickerActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly ContactPickerUI: Windows.ApplicationModel.Contacts.Provider.ContactPickerUI;
+  }
+  var IContactPickerActivatedEventArgs: abstract new (...args: any[]) => IContactPickerActivatedEventArgs;
+
+  interface IContactPostActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContactActivatedEventArgs {
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+    readonly ServiceId: string;
+    readonly ServiceUserId: string;
+  }
+  var IContactPostActivatedEventArgs: abstract new (...args: any[]) => IContactPostActivatedEventArgs;
+
+  interface IContactVideoCallActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContactActivatedEventArgs {
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+    readonly ServiceId: string;
+    readonly ServiceUserId: string;
+  }
+  var IContactVideoCallActivatedEventArgs: abstract new (...args: any[]) => IContactVideoCallActivatedEventArgs;
+
+  interface IContactsProviderActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly Verb: string;
+  }
+  var IContactsProviderActivatedEventArgs: abstract new (...args: any[]) => IContactsProviderActivatedEventArgs;
+
+  interface IContinuationActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly ContinuationData: Windows.Foundation.Collections.ValueSet;
+  }
+  var IContinuationActivatedEventArgs: abstract new (...args: any[]) => IContinuationActivatedEventArgs;
+
+  interface IDeviceActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly DeviceInformationId: string;
+    readonly Verb: string;
+  }
+  var IDeviceActivatedEventArgs: abstract new (...args: any[]) => IDeviceActivatedEventArgs;
+
+  interface IDevicePairingActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly DeviceInformation: Windows.Devices.Enumeration.DeviceInformation;
+  }
+  var IDevicePairingActivatedEventArgs: abstract new (...args: any[]) => IDevicePairingActivatedEventArgs;
+
+  interface IDialReceiverActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs {
+    readonly AppName: string;
+  }
+  var IDialReceiverActivatedEventArgs: abstract new (...args: any[]) => IDialReceiverActivatedEventArgs;
+
+  interface IFileActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly Files: Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[];
+    readonly Verb: string;
+  }
+  var IFileActivatedEventArgs: abstract new (...args: any[]) => IFileActivatedEventArgs;
+
+  interface IFileActivatedEventArgsWithCallerPackageFamilyName extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly CallerPackageFamilyName: string;
+  }
+  var IFileActivatedEventArgsWithCallerPackageFamilyName: abstract new (...args: any[]) => IFileActivatedEventArgsWithCallerPackageFamilyName;
+
+  interface IFileActivatedEventArgsWithNeighboringFiles extends Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IFileActivatedEventArgs {
+    readonly NeighboringFilesQuery: Windows.Storage.Search.StorageFileQueryResult;
+  }
+  var IFileActivatedEventArgsWithNeighboringFiles: abstract new (...args: any[]) => IFileActivatedEventArgsWithNeighboringFiles;
+
+  interface IFileOpenPickerActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly FileOpenPickerUI: Windows.Storage.Pickers.Provider.FileOpenPickerUI;
+  }
+  var IFileOpenPickerActivatedEventArgs: abstract new (...args: any[]) => IFileOpenPickerActivatedEventArgs;
+
+  interface IFileOpenPickerActivatedEventArgs2 {
+    readonly CallerPackageFamilyName: string;
+  }
+  var IFileOpenPickerActivatedEventArgs2: abstract new (...args: any[]) => IFileOpenPickerActivatedEventArgs2;
+
+  interface IFileOpenPickerContinuationEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContinuationActivatedEventArgs {
+    readonly Files: Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[];
+  }
+  var IFileOpenPickerContinuationEventArgs: abstract new (...args: any[]) => IFileOpenPickerContinuationEventArgs;
+
+  interface IFileSavePickerActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly FileSavePickerUI: Windows.Storage.Pickers.Provider.FileSavePickerUI;
+  }
+  var IFileSavePickerActivatedEventArgs: abstract new (...args: any[]) => IFileSavePickerActivatedEventArgs;
+
+  interface IFileSavePickerActivatedEventArgs2 {
+    readonly CallerPackageFamilyName: string;
+    readonly EnterpriseId: string;
+  }
+  var IFileSavePickerActivatedEventArgs2: abstract new (...args: any[]) => IFileSavePickerActivatedEventArgs2;
+
+  interface IFileSavePickerContinuationEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContinuationActivatedEventArgs {
+    readonly File: Windows.Storage.StorageFile;
+  }
+  var IFileSavePickerContinuationEventArgs: abstract new (...args: any[]) => IFileSavePickerContinuationEventArgs;
+
+  interface IFolderPickerContinuationEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContinuationActivatedEventArgs {
+    readonly Folder: Windows.Storage.StorageFolder;
+  }
+  var IFolderPickerContinuationEventArgs: abstract new (...args: any[]) => IFolderPickerContinuationEventArgs;
+
+  interface ILaunchActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly Arguments: string;
+    readonly TileId: string;
+  }
+  var ILaunchActivatedEventArgs: abstract new (...args: any[]) => ILaunchActivatedEventArgs;
+
+  interface ILaunchActivatedEventArgs2 extends Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs {
+    readonly TileActivatedInfo: Windows.ApplicationModel.Activation.TileActivatedInfo;
+  }
+  var ILaunchActivatedEventArgs2: abstract new (...args: any[]) => ILaunchActivatedEventArgs2;
+
+  interface ILockScreenActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly Info: Object;
+  }
+  var ILockScreenActivatedEventArgs: abstract new (...args: any[]) => ILockScreenActivatedEventArgs;
+
+  interface ILockScreenCallActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs {
+    readonly CallUI: Windows.ApplicationModel.Calls.LockScreenCallUI;
+  }
+  var ILockScreenCallActivatedEventArgs: abstract new (...args: any[]) => ILockScreenCallActivatedEventArgs;
+
+  interface IPhoneCallActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly LineId: Guid;
+  }
+  var IPhoneCallActivatedEventArgs: abstract new (...args: any[]) => IPhoneCallActivatedEventArgs;
+
+  interface IPickerReturnedActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly PickerOperationId: string;
+  }
+  var IPickerReturnedActivatedEventArgs: abstract new (...args: any[]) => IPickerReturnedActivatedEventArgs;
+
+  interface IPrelaunchActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly PrelaunchActivated: boolean;
+  }
+  var IPrelaunchActivatedEventArgs: abstract new (...args: any[]) => IPrelaunchActivatedEventArgs;
+
+  interface IPrint3DWorkflowActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly Workflow: Windows.Devices.Printers.Extensions.Print3DWorkflow;
+  }
+  var IPrint3DWorkflowActivatedEventArgs: abstract new (...args: any[]) => IPrint3DWorkflowActivatedEventArgs;
+
+  interface IPrintTaskSettingsActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly Configuration: Windows.Devices.Printers.Extensions.PrintTaskConfiguration;
+  }
+  var IPrintTaskSettingsActivatedEventArgs: abstract new (...args: any[]) => IPrintTaskSettingsActivatedEventArgs;
+
+  interface IProtocolActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IProtocolActivatedEventArgs: abstract new (...args: any[]) => IProtocolActivatedEventArgs;
+
+  interface IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly CallerPackageFamilyName: string;
+    readonly Data: Windows.Foundation.Collections.ValueSet;
+  }
+  var IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData: abstract new (...args: any[]) => IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData;
+
+  interface IProtocolForResultsActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly ProtocolForResultsOperation: Windows.System.ProtocolForResultsOperation;
+  }
+  var IProtocolForResultsActivatedEventArgs: abstract new (...args: any[]) => IProtocolForResultsActivatedEventArgs;
+
+  interface IRestrictedLaunchActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly SharedContext: Object;
+  }
+  var IRestrictedLaunchActivatedEventArgs: abstract new (...args: any[]) => IRestrictedLaunchActivatedEventArgs;
+
+  interface ISearchActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly Language: string;
+    readonly QueryText: string;
+  }
+  var ISearchActivatedEventArgs: abstract new (...args: any[]) => ISearchActivatedEventArgs;
+
+  interface ISearchActivatedEventArgsWithLinguisticDetails {
+    readonly LinguisticDetails: Windows.ApplicationModel.Search.SearchPaneQueryLinguisticDetails;
+  }
+  var ISearchActivatedEventArgsWithLinguisticDetails: abstract new (...args: any[]) => ISearchActivatedEventArgsWithLinguisticDetails;
+
+  interface IShareTargetActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly ShareOperation: Windows.ApplicationModel.DataTransfer.ShareTarget.ShareOperation;
+  }
+  var IShareTargetActivatedEventArgs: abstract new (...args: any[]) => IShareTargetActivatedEventArgs;
+
+  interface ISplashScreen {
+    readonly ImageLocation: Windows.Foundation.Rect;
+    Dismissed: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Activation.SplashScreen, Object> | null;
+  }
+  var ISplashScreen: abstract new (...args: any[]) => ISplashScreen;
+
+  interface IStartupTaskActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly TaskId: string;
+  }
+  var IStartupTaskActivatedEventArgs: abstract new (...args: any[]) => IStartupTaskActivatedEventArgs;
+
+  interface ITileActivatedInfo {
+    readonly RecentlyShownNotifications: Windows.Foundation.Collections.IVectorView<Windows.UI.Notifications.ShownTileNotification> | Windows.UI.Notifications.ShownTileNotification[];
+  }
+  var ITileActivatedInfo: abstract new (...args: any[]) => ITileActivatedInfo;
+
+  interface IToastNotificationActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly Argument: string;
+    readonly UserInput: Windows.Foundation.Collections.ValueSet;
+  }
+  var IToastNotificationActivatedEventArgs: abstract new (...args: any[]) => IToastNotificationActivatedEventArgs;
+
+  interface IUserDataAccountProviderActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly Operation: Windows.ApplicationModel.UserDataAccounts.Provider.IUserDataAccountProviderOperation;
+  }
+  var IUserDataAccountProviderActivatedEventArgs: abstract new (...args: any[]) => IUserDataAccountProviderActivatedEventArgs;
+
+  interface IViewSwitcherProvider extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly ViewSwitcher: Windows.UI.ViewManagement.ActivationViewSwitcher;
+  }
+  var IViewSwitcherProvider: abstract new (...args: any[]) => IViewSwitcherProvider;
+
+  interface IVoiceCommandActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly Result: Windows.Media.SpeechRecognition.SpeechRecognitionResult;
+  }
+  var IVoiceCommandActivatedEventArgs: abstract new (...args: any[]) => IVoiceCommandActivatedEventArgs;
+
+  interface IWalletActionActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly ActionId: string;
+    readonly ActionKind: number;
+    readonly ItemId: string;
+  }
+  var IWalletActionActivatedEventArgs: abstract new (...args: any[]) => IWalletActionActivatedEventArgs;
+
+  interface IWebAccountProviderActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    readonly Operation: Windows.Security.Authentication.Web.Provider.IWebAccountProviderOperation;
+  }
+  var IWebAccountProviderActivatedEventArgs: abstract new (...args: any[]) => IWebAccountProviderActivatedEventArgs;
+
+  interface IWebAuthenticationBrokerContinuationEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContinuationActivatedEventArgs {
+    readonly WebAuthenticationResult: Windows.Security.Authentication.Web.WebAuthenticationResult;
+  }
+  var IWebAuthenticationBrokerContinuationEventArgs: abstract new (...args: any[]) => IWebAuthenticationBrokerContinuationEventArgs;
+
+  interface WebUISearchActivatedEventsContract {
+  }
+  var WebUISearchActivatedEventsContract: {
+    new(fields: {  }): WebUISearchActivatedEventsContract;
+  };
+
+}
+
+declare namespace Windows.ApplicationModel.AppExtensions {
+  class AppExtension implements Windows.ApplicationModel.AppExtensions.IAppExtension, Windows.ApplicationModel.AppExtensions.IAppExtension2, Windows.ApplicationModel.AppExtensions.IAppExtension3 {
+    GetExtensionProperties(): Windows.Foundation.Collections.IPropertySet;
+    GetExtensionPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IPropertySet>;
+    GetPublicFolder(): Windows.Storage.StorageFolder;
+    GetPublicFolderAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetPublicPath(): string;
+    readonly AppInfo: Windows.ApplicationModel.AppInfo;
+    readonly AppUserModelId: string;
+    readonly Description: string;
+    readonly DisplayName: string;
+    readonly Id: string;
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+
+  class AppExtensionCatalog implements Windows.ApplicationModel.AppExtensions.IAppExtensionCatalog, Windows.ApplicationModel.AppExtensions.IAppExtensionCatalog2 {
+    FindAll(): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.AppExtensions.AppExtension> | Windows.ApplicationModel.AppExtensions.AppExtension[];
+    FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.AppExtensions.AppExtension> | Windows.ApplicationModel.AppExtensions.AppExtension[]>;
+    static Open(appExtensionName: string): Windows.ApplicationModel.AppExtensions.AppExtensionCatalog;
+    RequestRemovePackageAsync(packageFullName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    PackageInstalled: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.AppExtensions.AppExtensionCatalog, Windows.ApplicationModel.AppExtensions.AppExtensionPackageInstalledEventArgs> | null;
+    PackageStatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.AppExtensions.AppExtensionCatalog, Windows.ApplicationModel.AppExtensions.AppExtensionPackageStatusChangedEventArgs> | null;
+    PackageUninstalling: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.AppExtensions.AppExtensionCatalog, Windows.ApplicationModel.AppExtensions.AppExtensionPackageUninstallingEventArgs> | null;
+    PackageUpdated: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.AppExtensions.AppExtensionCatalog, Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatedEventArgs> | null;
+    PackageUpdating: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.AppExtensions.AppExtensionCatalog, Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatingEventArgs> | null;
+  }
+
+  class AppExtensionPackageInstalledEventArgs implements Windows.ApplicationModel.AppExtensions.IAppExtensionPackageInstalledEventArgs {
+    readonly AppExtensionName: string;
+    readonly Extensions: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.AppExtensions.AppExtension> | Windows.ApplicationModel.AppExtensions.AppExtension[];
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+
+  class AppExtensionPackageStatusChangedEventArgs implements Windows.ApplicationModel.AppExtensions.IAppExtensionPackageStatusChangedEventArgs {
+    readonly AppExtensionName: string;
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+
+  class AppExtensionPackageUninstallingEventArgs implements Windows.ApplicationModel.AppExtensions.IAppExtensionPackageUninstallingEventArgs {
+    readonly AppExtensionName: string;
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+
+  class AppExtensionPackageUpdatedEventArgs implements Windows.ApplicationModel.AppExtensions.IAppExtensionPackageUpdatedEventArgs {
+    readonly AppExtensionName: string;
+    readonly Extensions: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.AppExtensions.AppExtension> | Windows.ApplicationModel.AppExtensions.AppExtension[];
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+
+  class AppExtensionPackageUpdatingEventArgs implements Windows.ApplicationModel.AppExtensions.IAppExtensionPackageUpdatingEventArgs {
+    readonly AppExtensionName: string;
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+
+  interface IAppExtension {
+    GetExtensionPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IPropertySet>;
+    GetPublicFolderAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    readonly AppInfo: Windows.ApplicationModel.AppInfo;
+    readonly Description: string;
+    readonly DisplayName: string;
+    readonly Id: string;
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+  var IAppExtension: abstract new (...args: any[]) => IAppExtension;
+
+  interface IAppExtension2 {
+    readonly AppUserModelId: string;
+  }
+  var IAppExtension2: abstract new (...args: any[]) => IAppExtension2;
+
+  interface IAppExtension3 {
+    GetExtensionProperties(): Windows.Foundation.Collections.IPropertySet;
+    GetPublicFolder(): Windows.Storage.StorageFolder;
+    GetPublicPath(): string;
+  }
+  var IAppExtension3: abstract new (...args: any[]) => IAppExtension3;
+
+  interface IAppExtensionCatalog {
+    FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.AppExtensions.AppExtension> | Windows.ApplicationModel.AppExtensions.AppExtension[]>;
+    RequestRemovePackageAsync(packageFullName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    PackageInstalled: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.AppExtensions.AppExtensionCatalog, Windows.ApplicationModel.AppExtensions.AppExtensionPackageInstalledEventArgs> | null;
+    PackageStatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.AppExtensions.AppExtensionCatalog, Windows.ApplicationModel.AppExtensions.AppExtensionPackageStatusChangedEventArgs> | null;
+    PackageUninstalling: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.AppExtensions.AppExtensionCatalog, Windows.ApplicationModel.AppExtensions.AppExtensionPackageUninstallingEventArgs> | null;
+    PackageUpdated: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.AppExtensions.AppExtensionCatalog, Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatedEventArgs> | null;
+    PackageUpdating: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.AppExtensions.AppExtensionCatalog, Windows.ApplicationModel.AppExtensions.AppExtensionPackageUpdatingEventArgs> | null;
+  }
+  var IAppExtensionCatalog: abstract new (...args: any[]) => IAppExtensionCatalog;
+
+  interface IAppExtensionCatalog2 {
+    FindAll(): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.AppExtensions.AppExtension> | Windows.ApplicationModel.AppExtensions.AppExtension[];
+  }
+  var IAppExtensionCatalog2: abstract new (...args: any[]) => IAppExtensionCatalog2;
+
+  interface IAppExtensionCatalogStatics {
+    Open(appExtensionName: string): Windows.ApplicationModel.AppExtensions.AppExtensionCatalog;
+  }
+  var IAppExtensionCatalogStatics: abstract new (...args: any[]) => IAppExtensionCatalogStatics;
+
+  interface IAppExtensionPackageInstalledEventArgs {
+    readonly AppExtensionName: string;
+    readonly Extensions: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.AppExtensions.AppExtension> | Windows.ApplicationModel.AppExtensions.AppExtension[];
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+  var IAppExtensionPackageInstalledEventArgs: abstract new (...args: any[]) => IAppExtensionPackageInstalledEventArgs;
+
+  interface IAppExtensionPackageStatusChangedEventArgs {
+    readonly AppExtensionName: string;
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+  var IAppExtensionPackageStatusChangedEventArgs: abstract new (...args: any[]) => IAppExtensionPackageStatusChangedEventArgs;
+
+  interface IAppExtensionPackageUninstallingEventArgs {
+    readonly AppExtensionName: string;
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+  var IAppExtensionPackageUninstallingEventArgs: abstract new (...args: any[]) => IAppExtensionPackageUninstallingEventArgs;
+
+  interface IAppExtensionPackageUpdatedEventArgs {
+    readonly AppExtensionName: string;
+    readonly Extensions: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.AppExtensions.AppExtension> | Windows.ApplicationModel.AppExtensions.AppExtension[];
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+  var IAppExtensionPackageUpdatedEventArgs: abstract new (...args: any[]) => IAppExtensionPackageUpdatedEventArgs;
+
+  interface IAppExtensionPackageUpdatingEventArgs {
+    readonly AppExtensionName: string;
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+  var IAppExtensionPackageUpdatingEventArgs: abstract new (...args: any[]) => IAppExtensionPackageUpdatingEventArgs;
+
+}
+
+declare namespace Windows.ApplicationModel.AppService {
+  class AppServiceCatalog {
+    static FindAppServiceProvidersAsync(appServiceName: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.AppInfo> | Windows.ApplicationModel.AppInfo[]>;
+  }
+
+  class AppServiceClosedEventArgs implements Windows.ApplicationModel.AppService.IAppServiceClosedEventArgs {
+    readonly Status: number;
+  }
+
+  class AppServiceConnection implements Windows.ApplicationModel.AppService.IAppServiceConnection, Windows.ApplicationModel.AppService.IAppServiceConnection2, Windows.Foundation.IClosable {
+    constructor();
+    Close(): void;
+    OpenAsync(): Windows.Foundation.IAsyncOperation<number>;
+    OpenRemoteAsync(remoteSystemConnectionRequest: Windows.System.RemoteSystems.RemoteSystemConnectionRequest): Windows.Foundation.IAsyncOperation<number>;
+    SendMessageAsync(message: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.AppService.AppServiceResponse>;
+    static SendStatelessMessageAsync(connection: Windows.ApplicationModel.AppService.AppServiceConnection, connectionRequest: Windows.System.RemoteSystems.RemoteSystemConnectionRequest, message: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.AppService.StatelessAppServiceResponse>;
+    AppServiceName: string;
+    PackageFamilyName: string;
+    User: Windows.System.User;
+    RequestReceived: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.AppService.AppServiceConnection, Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs> | null;
+    ServiceClosed: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.AppService.AppServiceConnection, Windows.ApplicationModel.AppService.AppServiceClosedEventArgs> | null;
+  }
+
+  class AppServiceDeferral implements Windows.ApplicationModel.AppService.IAppServiceDeferral {
+    Complete(): void;
+  }
+
+  class AppServiceRequest implements Windows.ApplicationModel.AppService.IAppServiceRequest {
+    SendResponseAsync(message: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<number>;
+    readonly Message: Windows.Foundation.Collections.ValueSet;
+  }
+
+  class AppServiceRequestReceivedEventArgs implements Windows.ApplicationModel.AppService.IAppServiceRequestReceivedEventArgs {
+    GetDeferral(): Windows.ApplicationModel.AppService.AppServiceDeferral;
+    readonly Request: Windows.ApplicationModel.AppService.AppServiceRequest;
+  }
+
+  class AppServiceResponse implements Windows.ApplicationModel.AppService.IAppServiceResponse {
+    readonly Message: Windows.Foundation.Collections.ValueSet;
+    readonly Status: number;
+  }
+
+  class AppServiceTriggerDetails implements Windows.ApplicationModel.AppService.IAppServiceTriggerDetails, Windows.ApplicationModel.AppService.IAppServiceTriggerDetails2, Windows.ApplicationModel.AppService.IAppServiceTriggerDetails3, Windows.ApplicationModel.AppService.IAppServiceTriggerDetails4 {
+    CheckCallerForCapabilityAsync(capabilityName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly AppServiceConnection: Windows.ApplicationModel.AppService.AppServiceConnection;
+    readonly CallerPackageFamilyName: string;
+    readonly CallerRemoteConnectionToken: string;
+    readonly IsRemoteSystemConnection: boolean;
+    readonly Name: string;
+  }
+
+  class StatelessAppServiceResponse implements Windows.ApplicationModel.AppService.IStatelessAppServiceResponse {
+    readonly Message: Windows.Foundation.Collections.ValueSet;
+    readonly Status: number;
+  }
+
+  enum AppServiceClosedStatus {
+    Completed = 0,
+    Canceled = 1,
+    ResourceLimitsExceeded = 2,
+    Unknown = 3,
+  }
+
+  enum AppServiceConnectionStatus {
+    Success = 0,
+    AppNotInstalled = 1,
+    AppUnavailable = 2,
+    AppServiceUnavailable = 3,
+    Unknown = 4,
+    RemoteSystemUnavailable = 5,
+    RemoteSystemNotSupportedByApp = 6,
+    NotAuthorized = 7,
+    AuthenticationError = 8,
+    NetworkNotAvailable = 9,
+    DisabledByPolicy = 10,
+    WebServiceUnavailable = 11,
+  }
+
+  enum AppServiceResponseStatus {
+    Success = 0,
+    Failure = 1,
+    ResourceLimitsExceeded = 2,
+    Unknown = 3,
+    RemoteSystemUnavailable = 4,
+    MessageSizeTooLarge = 5,
+    AppUnavailable = 6,
+    AuthenticationError = 7,
+    NetworkNotAvailable = 8,
+    DisabledByPolicy = 9,
+    WebServiceUnavailable = 10,
+  }
+
+  enum StatelessAppServiceResponseStatus {
+    Success = 0,
+    AppNotInstalled = 1,
+    AppUnavailable = 2,
+    AppServiceUnavailable = 3,
+    RemoteSystemUnavailable = 4,
+    RemoteSystemNotSupportedByApp = 5,
+    NotAuthorized = 6,
+    ResourceLimitsExceeded = 7,
+    MessageSizeTooLarge = 8,
+    Failure = 9,
+    Unknown = 10,
+    AuthenticationError = 11,
+    NetworkNotAvailable = 12,
+    DisabledByPolicy = 13,
+    WebServiceUnavailable = 14,
+  }
+
+  interface IAppServiceCatalogStatics {
+    FindAppServiceProvidersAsync(appServiceName: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.AppInfo> | Windows.ApplicationModel.AppInfo[]>;
+  }
+  var IAppServiceCatalogStatics: abstract new (...args: any[]) => IAppServiceCatalogStatics;
+
+  interface IAppServiceClosedEventArgs {
+    readonly Status: number;
+  }
+  var IAppServiceClosedEventArgs: abstract new (...args: any[]) => IAppServiceClosedEventArgs;
+
+  interface IAppServiceConnection {
+    OpenAsync(): Windows.Foundation.IAsyncOperation<number>;
+    SendMessageAsync(message: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.AppService.AppServiceResponse>;
+    AppServiceName: string;
+    PackageFamilyName: string;
+    RequestReceived: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.AppService.AppServiceConnection, Windows.ApplicationModel.AppService.AppServiceRequestReceivedEventArgs> | null;
+    ServiceClosed: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.AppService.AppServiceConnection, Windows.ApplicationModel.AppService.AppServiceClosedEventArgs> | null;
+  }
+  var IAppServiceConnection: abstract new (...args: any[]) => IAppServiceConnection;
+
+  interface IAppServiceConnection2 {
+    OpenRemoteAsync(remoteSystemConnectionRequest: Windows.System.RemoteSystems.RemoteSystemConnectionRequest): Windows.Foundation.IAsyncOperation<number>;
+    User: Windows.System.User;
+  }
+  var IAppServiceConnection2: abstract new (...args: any[]) => IAppServiceConnection2;
+
+  interface IAppServiceConnectionStatics {
+    SendStatelessMessageAsync(connection: Windows.ApplicationModel.AppService.AppServiceConnection, connectionRequest: Windows.System.RemoteSystems.RemoteSystemConnectionRequest, message: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.AppService.StatelessAppServiceResponse>;
+  }
+  var IAppServiceConnectionStatics: abstract new (...args: any[]) => IAppServiceConnectionStatics;
+
+  interface IAppServiceDeferral {
+    Complete(): void;
+  }
+  var IAppServiceDeferral: abstract new (...args: any[]) => IAppServiceDeferral;
+
+  interface IAppServiceRequest {
+    SendResponseAsync(message: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<number>;
+    readonly Message: Windows.Foundation.Collections.ValueSet;
+  }
+  var IAppServiceRequest: abstract new (...args: any[]) => IAppServiceRequest;
+
+  interface IAppServiceRequestReceivedEventArgs {
+    GetDeferral(): Windows.ApplicationModel.AppService.AppServiceDeferral;
+    readonly Request: Windows.ApplicationModel.AppService.AppServiceRequest;
+  }
+  var IAppServiceRequestReceivedEventArgs: abstract new (...args: any[]) => IAppServiceRequestReceivedEventArgs;
+
+  interface IAppServiceResponse {
+    readonly Message: Windows.Foundation.Collections.ValueSet;
+    readonly Status: number;
+  }
+  var IAppServiceResponse: abstract new (...args: any[]) => IAppServiceResponse;
+
+  interface IAppServiceTriggerDetails {
+    readonly AppServiceConnection: Windows.ApplicationModel.AppService.AppServiceConnection;
+    readonly CallerPackageFamilyName: string;
+    readonly Name: string;
+  }
+  var IAppServiceTriggerDetails: abstract new (...args: any[]) => IAppServiceTriggerDetails;
+
+  interface IAppServiceTriggerDetails2 {
+    readonly IsRemoteSystemConnection: boolean;
+  }
+  var IAppServiceTriggerDetails2: abstract new (...args: any[]) => IAppServiceTriggerDetails2;
+
+  interface IAppServiceTriggerDetails3 {
+    CheckCallerForCapabilityAsync(capabilityName: string): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IAppServiceTriggerDetails3: abstract new (...args: any[]) => IAppServiceTriggerDetails3;
+
+  interface IAppServiceTriggerDetails4 {
+    readonly CallerRemoteConnectionToken: string;
+  }
+  var IAppServiceTriggerDetails4: abstract new (...args: any[]) => IAppServiceTriggerDetails4;
+
+  interface IStatelessAppServiceResponse {
+    readonly Message: Windows.Foundation.Collections.ValueSet;
+    readonly Status: number;
+  }
+  var IStatelessAppServiceResponse: abstract new (...args: any[]) => IStatelessAppServiceResponse;
+
+}
+
+declare namespace Windows.ApplicationModel.Appointments {
+  class Appointment implements Windows.ApplicationModel.Appointments.IAppointment, Windows.ApplicationModel.Appointments.IAppointment2, Windows.ApplicationModel.Appointments.IAppointment3 {
+    constructor();
+    AllDay: boolean;
+    AllowNewTimeProposal: boolean;
+    BusyStatus: number;
+    readonly CalendarId: string;
+    readonly ChangeNumber: number | bigint;
+    Details: string;
+    DetailsKind: number;
+    Duration: Windows.Foundation.TimeSpan;
+    readonly HasInvitees: boolean;
+    readonly Invitees: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Appointments.AppointmentInvitee> | Windows.ApplicationModel.Appointments.AppointmentInvitee[];
+    IsCanceledMeeting: boolean;
+    IsOrganizedByUser: boolean;
+    IsResponseRequested: boolean;
+    readonly LocalId: string;
+    Location: string;
+    OnlineMeetingLink: string;
+    Organizer: Windows.ApplicationModel.Appointments.AppointmentOrganizer;
+    readonly OriginalStartTime: Windows.Foundation.DateTime | null;
+    Recurrence: Windows.ApplicationModel.Appointments.AppointmentRecurrence;
+    Reminder: Windows.Foundation.TimeSpan | null;
+    RemoteChangeNumber: number | bigint;
+    ReplyTime: Windows.Foundation.DateTime | null;
+    RoamingId: string;
+    Sensitivity: number;
+    StartTime: Windows.Foundation.DateTime;
+    Subject: string;
+    Uri: Windows.Foundation.Uri;
+    UserResponse: number;
+  }
+
+  class AppointmentCalendar implements Windows.ApplicationModel.Appointments.IAppointmentCalendar, Windows.ApplicationModel.Appointments.IAppointmentCalendar2, Windows.ApplicationModel.Appointments.IAppointmentCalendar3 {
+    DeleteAppointmentAsync(localId: string): Windows.Foundation.IAsyncAction;
+    DeleteAppointmentInstanceAsync(localId: string, instanceStartTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncAction;
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    FindAllInstancesAsync(masterLocalId: string, rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindAllInstancesAsync(masterLocalId: string, rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan, pOptions: Windows.ApplicationModel.Appointments.FindAppointmentsOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindAppointmentsAsync(rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindAppointmentsAsync(rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan, options: Windows.ApplicationModel.Appointments.FindAppointmentsOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindExceptionsFromMasterAsync(masterLocalId: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.AppointmentException> | Windows.ApplicationModel.Appointments.AppointmentException[]>;
+    FindUnexpandedAppointmentsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindUnexpandedAppointmentsAsync(options: Windows.ApplicationModel.Appointments.FindAppointmentsOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    GetAppointmentAsync(localId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.Appointment>;
+    GetAppointmentInstanceAsync(localId: string, instanceStartTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.Appointment>;
+    RegisterSyncManagerAsync(): Windows.Foundation.IAsyncAction;
+    SaveAppointmentAsync(pAppointment: Windows.ApplicationModel.Appointments.Appointment): Windows.Foundation.IAsyncAction;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    TryCancelMeetingAsync(meeting: Windows.ApplicationModel.Appointments.Appointment, subject: string, comment: string, notifyInvitees: boolean): Windows.Foundation.IAsyncOperation<boolean>;
+    TryCreateOrUpdateAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment, notifyInvitees: boolean): Windows.Foundation.IAsyncOperation<boolean>;
+    TryForwardMeetingAsync(meeting: Windows.ApplicationModel.Appointments.Appointment, invitees: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Appointments.AppointmentInvitee> | Windows.ApplicationModel.Appointments.AppointmentInvitee[], subject: string, forwardHeader: string, comment: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryProposeNewTimeForMeetingAsync(meeting: Windows.ApplicationModel.Appointments.Appointment, newStartTime: Windows.Foundation.DateTime, newDuration: Windows.Foundation.TimeSpan, subject: string, comment: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryUpdateMeetingResponseAsync(meeting: Windows.ApplicationModel.Appointments.Appointment, response: number, subject: string, comment: string, sendUpdate: boolean): Windows.Foundation.IAsyncOperation<boolean>;
+    CanCancelMeetings: boolean;
+    CanCreateOrUpdateAppointments: boolean;
+    CanForwardMeetings: boolean;
+    CanNotifyInvitees: boolean;
+    CanProposeNewTimeForMeetings: boolean;
+    CanUpdateMeetingResponses: boolean;
+    DisplayColor: Windows.UI.Color;
+    DisplayName: string;
+    IsHidden: boolean;
+    readonly LocalId: string;
+    MustNofityInvitees: boolean;
+    OtherAppReadAccess: number;
+    OtherAppWriteAccess: number;
+    RemoteId: string;
+    readonly SourceDisplayName: string;
+    SummaryCardView: number;
+    readonly SyncManager: Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager;
+    readonly UserDataAccountId: string;
+  }
+
+  class AppointmentCalendarSyncManager implements Windows.ApplicationModel.Appointments.IAppointmentCalendarSyncManager, Windows.ApplicationModel.Appointments.IAppointmentCalendarSyncManager2 {
+    SyncAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    LastAttemptedSyncTime: Windows.Foundation.DateTime;
+    LastSuccessfulSyncTime: Windows.Foundation.DateTime;
+    Status: number;
+    SyncStatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager, Object> | null;
+  }
+
+  class AppointmentConflictResult implements Windows.ApplicationModel.Appointments.IAppointmentConflictResult {
+    readonly Date: Windows.Foundation.DateTime;
+    readonly Type: number;
+  }
+
+  class AppointmentException implements Windows.ApplicationModel.Appointments.IAppointmentException {
+    readonly Appointment: Windows.ApplicationModel.Appointments.Appointment;
+    readonly ExceptionProperties: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly IsDeleted: boolean;
+  }
+
+  class AppointmentInvitee implements Windows.ApplicationModel.Appointments.IAppointmentInvitee, Windows.ApplicationModel.Appointments.IAppointmentParticipant {
+    constructor();
+    Address: string;
+    DisplayName: string;
+    Response: number;
+    Role: number;
+  }
+
+  class AppointmentManager {
+    static GetForUser(user: Windows.System.User): Windows.ApplicationModel.Appointments.AppointmentManagerForUser;
+    static RequestStoreAsync(options: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.AppointmentStore>;
+    static ShowAddAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<string>;
+    static ShowAddAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<string>;
+    static ShowAppointmentDetailsAsync(appointmentId: string): Windows.Foundation.IAsyncAction;
+    static ShowAppointmentDetailsAsync(appointmentId: string, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncAction;
+    static ShowEditNewAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment): Windows.Foundation.IAsyncOperation<string>;
+    static ShowRemoveAppointmentAsync(appointmentId: string, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<boolean>;
+    static ShowRemoveAppointmentAsync(appointmentId: string, selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<boolean>;
+    static ShowRemoveAppointmentAsync(appointmentId: string, selection: Windows.Foundation.Rect, preferredPlacement: number, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<boolean>;
+    static ShowReplaceAppointmentAsync(appointmentId: string, appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<string>;
+    static ShowReplaceAppointmentAsync(appointmentId: string, appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<string>;
+    static ShowReplaceAppointmentAsync(appointmentId: string, appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect, preferredPlacement: number, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<string>;
+    static ShowTimeFrameAsync(timeToShow: Windows.Foundation.DateTime, duration: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncAction;
+  }
+
+  class AppointmentManagerForUser implements Windows.ApplicationModel.Appointments.IAppointmentManagerForUser {
+    RequestStoreAsync(options: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.AppointmentStore>;
+    ShowAddAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<string>;
+    ShowAddAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<string>;
+    ShowAppointmentDetailsAsync(appointmentId: string): Windows.Foundation.IAsyncAction;
+    ShowAppointmentDetailsAsync(appointmentId: string, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncAction;
+    ShowEditNewAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment): Windows.Foundation.IAsyncOperation<string>;
+    ShowRemoveAppointmentAsync(appointmentId: string, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowRemoveAppointmentAsync(appointmentId: string, selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowRemoveAppointmentAsync(appointmentId: string, selection: Windows.Foundation.Rect, preferredPlacement: number, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowReplaceAppointmentAsync(appointmentId: string, appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<string>;
+    ShowReplaceAppointmentAsync(appointmentId: string, appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<string>;
+    ShowReplaceAppointmentAsync(appointmentId: string, appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect, preferredPlacement: number, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<string>;
+    ShowTimeFrameAsync(timeToShow: Windows.Foundation.DateTime, duration: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncAction;
+    readonly User: Windows.System.User;
+  }
+
+  class AppointmentOrganizer implements Windows.ApplicationModel.Appointments.IAppointmentParticipant {
+    constructor();
+    Address: string;
+    DisplayName: string;
+  }
+
+  class AppointmentProperties {
+    static readonly AllDay: string;
+    static readonly AllowNewTimeProposal: string;
+    static readonly BusyStatus: string;
+    static readonly ChangeNumber: string;
+    static readonly DefaultProperties: Windows.Foundation.Collections.IVector<string> | string[];
+    static readonly Details: string;
+    static readonly DetailsKind: string;
+    static readonly Duration: string;
+    static readonly HasInvitees: string;
+    static readonly Invitees: string;
+    static readonly IsCanceledMeeting: string;
+    static readonly IsOrganizedByUser: string;
+    static readonly IsResponseRequested: string;
+    static readonly Location: string;
+    static readonly OnlineMeetingLink: string;
+    static readonly Organizer: string;
+    static readonly OriginalStartTime: string;
+    static readonly Recurrence: string;
+    static readonly Reminder: string;
+    static readonly RemoteChangeNumber: string;
+    static readonly ReplyTime: string;
+    static readonly Sensitivity: string;
+    static readonly StartTime: string;
+    static readonly Subject: string;
+    static readonly Uri: string;
+    static readonly UserResponse: string;
+  }
+
+  class AppointmentRecurrence implements Windows.ApplicationModel.Appointments.IAppointmentRecurrence, Windows.ApplicationModel.Appointments.IAppointmentRecurrence2, Windows.ApplicationModel.Appointments.IAppointmentRecurrence3 {
+    constructor();
+    readonly CalendarIdentifier: string;
+    Day: number;
+    DaysOfWeek: number;
+    Interval: number;
+    Month: number;
+    Occurrences: number | null;
+    readonly RecurrenceType: number;
+    TimeZone: string;
+    Unit: number;
+    Until: Windows.Foundation.DateTime | null;
+    WeekOfMonth: number;
+  }
+
+  class AppointmentStore implements Windows.ApplicationModel.Appointments.IAppointmentStore, Windows.ApplicationModel.Appointments.IAppointmentStore2, Windows.ApplicationModel.Appointments.IAppointmentStore3 {
+    CreateAppointmentCalendarAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.AppointmentCalendar>;
+    CreateAppointmentCalendarAsync(name: string, userDataAccountId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.AppointmentCalendar>;
+    FindAppointmentCalendarsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.AppointmentCalendar> | Windows.ApplicationModel.Appointments.AppointmentCalendar[]>;
+    FindAppointmentCalendarsAsync(options: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.AppointmentCalendar> | Windows.ApplicationModel.Appointments.AppointmentCalendar[]>;
+    FindAppointmentsAsync(rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindAppointmentsAsync(rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan, options: Windows.ApplicationModel.Appointments.FindAppointmentsOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindConflictAsync(appointment: Windows.ApplicationModel.Appointments.Appointment): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.AppointmentConflictResult>;
+    FindConflictAsync(appointment: Windows.ApplicationModel.Appointments.Appointment, instanceStartTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.AppointmentConflictResult>;
+    FindLocalIdsFromRoamingIdAsync(roamingId: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    GetAppointmentAsync(localId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.Appointment>;
+    GetAppointmentCalendarAsync(calendarId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.AppointmentCalendar>;
+    GetAppointmentInstanceAsync(localId: string, instanceStartTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.Appointment>;
+    GetChangeTracker(identity: string): Windows.ApplicationModel.Appointments.AppointmentStoreChangeTracker;
+    MoveAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment, destinationCalendar: Windows.ApplicationModel.Appointments.AppointmentCalendar): Windows.Foundation.IAsyncAction;
+    ShowAddAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<string>;
+    ShowAppointmentDetailsAsync(localId: string): Windows.Foundation.IAsyncAction;
+    ShowAppointmentDetailsAsync(localId: string, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncAction;
+    ShowEditNewAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment): Windows.Foundation.IAsyncOperation<string>;
+    ShowRemoveAppointmentAsync(localId: string, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowRemoveAppointmentAsync(localId: string, selection: Windows.Foundation.Rect, preferredPlacement: number, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowReplaceAppointmentAsync(localId: string, appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<string>;
+    ShowReplaceAppointmentAsync(localId: string, appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect, preferredPlacement: number, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<string>;
+    readonly ChangeTracker: Windows.ApplicationModel.Appointments.AppointmentStoreChangeTracker;
+    StoreChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Appointments.AppointmentStore, Windows.ApplicationModel.Appointments.AppointmentStoreChangedEventArgs> | null;
+  }
+
+  class AppointmentStoreChange implements Windows.ApplicationModel.Appointments.IAppointmentStoreChange, Windows.ApplicationModel.Appointments.IAppointmentStoreChange2 {
+    readonly Appointment: Windows.ApplicationModel.Appointments.Appointment;
+    readonly AppointmentCalendar: Windows.ApplicationModel.Appointments.AppointmentCalendar;
+    readonly ChangeType: number;
+  }
+
+  class AppointmentStoreChangeReader implements Windows.ApplicationModel.Appointments.IAppointmentStoreChangeReader {
+    AcceptChanges(): void;
+    AcceptChangesThrough(lastChangeToAccept: Windows.ApplicationModel.Appointments.AppointmentStoreChange): void;
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.AppointmentStoreChange> | Windows.ApplicationModel.Appointments.AppointmentStoreChange[]>;
+  }
+
+  class AppointmentStoreChangeTracker implements Windows.ApplicationModel.Appointments.IAppointmentStoreChangeTracker, Windows.ApplicationModel.Appointments.IAppointmentStoreChangeTracker2 {
+    Enable(): void;
+    GetChangeReader(): Windows.ApplicationModel.Appointments.AppointmentStoreChangeReader;
+    Reset(): void;
+    readonly IsTracking: boolean;
+  }
+
+  class AppointmentStoreChangedDeferral implements Windows.ApplicationModel.Appointments.IAppointmentStoreChangedDeferral {
+    Complete(): void;
+  }
+
+  class AppointmentStoreChangedEventArgs implements Windows.ApplicationModel.Appointments.IAppointmentStoreChangedEventArgs {
+    GetDeferral(): Windows.ApplicationModel.Appointments.AppointmentStoreChangedDeferral;
+  }
+
+  class AppointmentStoreNotificationTriggerDetails implements Windows.ApplicationModel.Appointments.IAppointmentStoreNotificationTriggerDetails {
+  }
+
+  class FindAppointmentsOptions implements Windows.ApplicationModel.Appointments.IFindAppointmentsOptions {
+    constructor();
+    readonly CalendarIds: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly FetchProperties: Windows.Foundation.Collections.IVector<string> | string[];
+    IncludeHidden: boolean;
+    MaxCount: number;
+  }
+
+  enum AppointmentBusyStatus {
+    Busy = 0,
+    Tentative = 1,
+    Free = 2,
+    OutOfOffice = 3,
+    WorkingElsewhere = 4,
+  }
+
+  enum AppointmentCalendarOtherAppReadAccess {
+    SystemOnly = 0,
+    Limited = 1,
+    Full = 2,
+    None = 3,
+  }
+
+  enum AppointmentCalendarOtherAppWriteAccess {
+    None = 0,
+    SystemOnly = 1,
+    Limited = 2,
+  }
+
+  enum AppointmentCalendarSyncStatus {
+    Idle = 0,
+    Syncing = 1,
+    UpToDate = 2,
+    AuthenticationError = 3,
+    PolicyError = 4,
+    UnknownError = 5,
+    ManualAccountRemovalRequired = 6,
+  }
+
+  enum AppointmentConflictType {
+    None = 0,
+    Adjacent = 1,
+    Overlap = 2,
+  }
+
+  enum AppointmentDaysOfWeek {
+    None = 0,
+    Sunday = 1,
+    Monday = 2,
+    Tuesday = 4,
+    Wednesday = 8,
+    Thursday = 16,
+    Friday = 32,
+    Saturday = 64,
+  }
+
+  enum AppointmentDetailsKind {
+    PlainText = 0,
+    Html = 1,
+  }
+
+  enum AppointmentParticipantResponse {
+    None = 0,
+    Tentative = 1,
+    Accepted = 2,
+    Declined = 3,
+    Unknown = 4,
+  }
+
+  enum AppointmentParticipantRole {
+    RequiredAttendee = 0,
+    OptionalAttendee = 1,
+    Resource = 2,
+  }
+
+  enum AppointmentRecurrenceUnit {
+    Daily = 0,
+    Weekly = 1,
+    Monthly = 2,
+    MonthlyOnDay = 3,
+    Yearly = 4,
+    YearlyOnDay = 5,
+  }
+
+  enum AppointmentSensitivity {
+    Public = 0,
+    Private = 1,
+  }
+
+  enum AppointmentStoreAccessType {
+    AppCalendarsReadWrite = 0,
+    AllCalendarsReadOnly = 1,
+    AllCalendarsReadWrite = 2,
+  }
+
+  enum AppointmentStoreChangeType {
+    AppointmentCreated = 0,
+    AppointmentModified = 1,
+    AppointmentDeleted = 2,
+    ChangeTrackingLost = 3,
+    CalendarCreated = 4,
+    CalendarModified = 5,
+    CalendarDeleted = 6,
+  }
+
+  enum AppointmentSummaryCardView {
+    System = 0,
+    App = 1,
+  }
+
+  enum AppointmentWeekOfMonth {
+    First = 0,
+    Second = 1,
+    Third = 2,
+    Fourth = 3,
+    Last = 4,
+  }
+
+  enum FindAppointmentCalendarsOptions {
+    None = 0,
+    IncludeHidden = 1,
+  }
+
+  enum RecurrenceType {
+    Master = 0,
+    Instance = 1,
+    ExceptionInstance = 2,
+  }
+
+  interface IAppointment {
+    AllDay: boolean;
+    BusyStatus: number;
+    Details: string;
+    Duration: Windows.Foundation.TimeSpan;
+    readonly Invitees: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Appointments.AppointmentInvitee> | Windows.ApplicationModel.Appointments.AppointmentInvitee[];
+    Location: string;
+    Organizer: Windows.ApplicationModel.Appointments.AppointmentOrganizer;
+    Recurrence: Windows.ApplicationModel.Appointments.AppointmentRecurrence;
+    Reminder: Windows.Foundation.TimeSpan | null;
+    Sensitivity: number;
+    StartTime: Windows.Foundation.DateTime;
+    Subject: string;
+    Uri: Windows.Foundation.Uri;
+  }
+  var IAppointment: abstract new (...args: any[]) => IAppointment;
+
+  interface IAppointment2 extends Windows.ApplicationModel.Appointments.IAppointment {
+    AllowNewTimeProposal: boolean;
+    readonly CalendarId: string;
+    readonly HasInvitees: boolean;
+    IsCanceledMeeting: boolean;
+    IsOrganizedByUser: boolean;
+    IsResponseRequested: boolean;
+    readonly LocalId: string;
+    OnlineMeetingLink: string;
+    readonly OriginalStartTime: Windows.Foundation.DateTime | null;
+    ReplyTime: Windows.Foundation.DateTime | null;
+    RoamingId: string;
+    UserResponse: number;
+  }
+  var IAppointment2: abstract new (...args: any[]) => IAppointment2;
+
+  interface IAppointment3 extends Windows.ApplicationModel.Appointments.IAppointment, Windows.ApplicationModel.Appointments.IAppointment2 {
+    readonly ChangeNumber: number | bigint;
+    DetailsKind: number;
+    RemoteChangeNumber: number | bigint;
+  }
+  var IAppointment3: abstract new (...args: any[]) => IAppointment3;
+
+  interface IAppointmentCalendar {
+    DeleteAppointmentAsync(localId: string): Windows.Foundation.IAsyncAction;
+    DeleteAppointmentInstanceAsync(localId: string, instanceStartTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncAction;
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    FindAllInstancesAsync(masterLocalId: string, rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindAllInstancesAsync(masterLocalId: string, rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan, pOptions: Windows.ApplicationModel.Appointments.FindAppointmentsOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindAppointmentsAsync(rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindAppointmentsAsync(rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan, options: Windows.ApplicationModel.Appointments.FindAppointmentsOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindExceptionsFromMasterAsync(masterLocalId: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.AppointmentException> | Windows.ApplicationModel.Appointments.AppointmentException[]>;
+    FindUnexpandedAppointmentsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindUnexpandedAppointmentsAsync(options: Windows.ApplicationModel.Appointments.FindAppointmentsOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    GetAppointmentAsync(localId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.Appointment>;
+    GetAppointmentInstanceAsync(localId: string, instanceStartTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.Appointment>;
+    SaveAppointmentAsync(pAppointment: Windows.ApplicationModel.Appointments.Appointment): Windows.Foundation.IAsyncAction;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    readonly DisplayColor: Windows.UI.Color;
+    DisplayName: string;
+    readonly IsHidden: boolean;
+    readonly LocalId: string;
+    OtherAppReadAccess: number;
+    OtherAppWriteAccess: number;
+    readonly SourceDisplayName: string;
+    SummaryCardView: number;
+  }
+  var IAppointmentCalendar: abstract new (...args: any[]) => IAppointmentCalendar;
+
+  interface IAppointmentCalendar2 extends Windows.ApplicationModel.Appointments.IAppointmentCalendar {
+    DeleteAppointmentAsync(localId: string): Windows.Foundation.IAsyncAction;
+    DeleteAppointmentInstanceAsync(localId: string, instanceStartTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncAction;
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    FindAllInstancesAsync(masterLocalId: string, rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindAllInstancesAsync(masterLocalId: string, rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan, pOptions: Windows.ApplicationModel.Appointments.FindAppointmentsOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindAppointmentsAsync(rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindAppointmentsAsync(rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan, options: Windows.ApplicationModel.Appointments.FindAppointmentsOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindExceptionsFromMasterAsync(masterLocalId: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.AppointmentException> | Windows.ApplicationModel.Appointments.AppointmentException[]>;
+    FindUnexpandedAppointmentsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindUnexpandedAppointmentsAsync(options: Windows.ApplicationModel.Appointments.FindAppointmentsOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    GetAppointmentAsync(localId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.Appointment>;
+    GetAppointmentInstanceAsync(localId: string, instanceStartTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.Appointment>;
+    SaveAppointmentAsync(pAppointment: Windows.ApplicationModel.Appointments.Appointment): Windows.Foundation.IAsyncAction;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    TryCancelMeetingAsync(meeting: Windows.ApplicationModel.Appointments.Appointment, subject: string, comment: string, notifyInvitees: boolean): Windows.Foundation.IAsyncOperation<boolean>;
+    TryCreateOrUpdateAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment, notifyInvitees: boolean): Windows.Foundation.IAsyncOperation<boolean>;
+    TryForwardMeetingAsync(meeting: Windows.ApplicationModel.Appointments.Appointment, invitees: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Appointments.AppointmentInvitee> | Windows.ApplicationModel.Appointments.AppointmentInvitee[], subject: string, forwardHeader: string, comment: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryProposeNewTimeForMeetingAsync(meeting: Windows.ApplicationModel.Appointments.Appointment, newStartTime: Windows.Foundation.DateTime, newDuration: Windows.Foundation.TimeSpan, subject: string, comment: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryUpdateMeetingResponseAsync(meeting: Windows.ApplicationModel.Appointments.Appointment, response: number, subject: string, comment: string, sendUpdate: boolean): Windows.Foundation.IAsyncOperation<boolean>;
+    CanCancelMeetings: boolean;
+    CanCreateOrUpdateAppointments: boolean;
+    CanForwardMeetings: boolean;
+    CanNotifyInvitees: boolean;
+    CanProposeNewTimeForMeetings: boolean;
+    CanUpdateMeetingResponses: boolean;
+    DisplayColor: Object;
+    IsHidden: Object;
+    MustNofityInvitees: boolean;
+    RemoteId: string;
+    readonly SyncManager: Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager;
+    readonly UserDataAccountId: string;
+  }
+  var IAppointmentCalendar2: abstract new (...args: any[]) => IAppointmentCalendar2;
+
+  interface IAppointmentCalendar3 {
+    RegisterSyncManagerAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var IAppointmentCalendar3: abstract new (...args: any[]) => IAppointmentCalendar3;
+
+  interface IAppointmentCalendarSyncManager {
+    SyncAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly LastAttemptedSyncTime: Windows.Foundation.DateTime;
+    readonly LastSuccessfulSyncTime: Windows.Foundation.DateTime;
+    readonly Status: number;
+    SyncStatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Appointments.AppointmentCalendarSyncManager, Object> | null;
+  }
+  var IAppointmentCalendarSyncManager: abstract new (...args: any[]) => IAppointmentCalendarSyncManager;
+
+  interface IAppointmentCalendarSyncManager2 {
+    LastAttemptedSyncTime: Object;
+    LastSuccessfulSyncTime: Object;
+    Status: Object;
+  }
+  var IAppointmentCalendarSyncManager2: abstract new (...args: any[]) => IAppointmentCalendarSyncManager2;
+
+  interface IAppointmentConflictResult {
+    readonly Date: Windows.Foundation.DateTime;
+    readonly Type: number;
+  }
+  var IAppointmentConflictResult: abstract new (...args: any[]) => IAppointmentConflictResult;
+
+  interface IAppointmentException {
+    readonly Appointment: Windows.ApplicationModel.Appointments.Appointment;
+    readonly ExceptionProperties: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly IsDeleted: boolean;
+  }
+  var IAppointmentException: abstract new (...args: any[]) => IAppointmentException;
+
+  interface IAppointmentInvitee extends Windows.ApplicationModel.Appointments.IAppointmentParticipant {
+    Response: number;
+    Role: number;
+  }
+  var IAppointmentInvitee: abstract new (...args: any[]) => IAppointmentInvitee;
+
+  interface IAppointmentManagerForUser {
+    RequestStoreAsync(options: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.AppointmentStore>;
+    ShowAddAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<string>;
+    ShowAddAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<string>;
+    ShowAppointmentDetailsAsync(appointmentId: string): Windows.Foundation.IAsyncAction;
+    ShowAppointmentDetailsAsync(appointmentId: string, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncAction;
+    ShowEditNewAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment): Windows.Foundation.IAsyncOperation<string>;
+    ShowRemoveAppointmentAsync(appointmentId: string, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowRemoveAppointmentAsync(appointmentId: string, selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowRemoveAppointmentAsync(appointmentId: string, selection: Windows.Foundation.Rect, preferredPlacement: number, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowReplaceAppointmentAsync(appointmentId: string, appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<string>;
+    ShowReplaceAppointmentAsync(appointmentId: string, appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<string>;
+    ShowReplaceAppointmentAsync(appointmentId: string, appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect, preferredPlacement: number, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<string>;
+    ShowTimeFrameAsync(timeToShow: Windows.Foundation.DateTime, duration: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncAction;
+    readonly User: Windows.System.User;
+  }
+  var IAppointmentManagerForUser: abstract new (...args: any[]) => IAppointmentManagerForUser;
+
+  interface IAppointmentManagerStatics {
+    ShowAddAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<string>;
+    ShowAddAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<string>;
+    ShowRemoveAppointmentAsync(appointmentId: string, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowRemoveAppointmentAsync(appointmentId: string, selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowRemoveAppointmentAsync(appointmentId: string, selection: Windows.Foundation.Rect, preferredPlacement: number, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowReplaceAppointmentAsync(appointmentId: string, appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<string>;
+    ShowReplaceAppointmentAsync(appointmentId: string, appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<string>;
+    ShowReplaceAppointmentAsync(appointmentId: string, appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect, preferredPlacement: number, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<string>;
+    ShowTimeFrameAsync(timeToShow: Windows.Foundation.DateTime, duration: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncAction;
+  }
+  var IAppointmentManagerStatics: abstract new (...args: any[]) => IAppointmentManagerStatics;
+
+  interface IAppointmentManagerStatics2 {
+    RequestStoreAsync(options: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.AppointmentStore>;
+    ShowAppointmentDetailsAsync(appointmentId: string): Windows.Foundation.IAsyncAction;
+    ShowAppointmentDetailsAsync(appointmentId: string, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncAction;
+    ShowEditNewAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment): Windows.Foundation.IAsyncOperation<string>;
+  }
+  var IAppointmentManagerStatics2: abstract new (...args: any[]) => IAppointmentManagerStatics2;
+
+  interface IAppointmentManagerStatics3 {
+    GetForUser(user: Windows.System.User): Windows.ApplicationModel.Appointments.AppointmentManagerForUser;
+  }
+  var IAppointmentManagerStatics3: abstract new (...args: any[]) => IAppointmentManagerStatics3;
+
+  interface IAppointmentParticipant {
+    Address: string;
+    DisplayName: string;
+  }
+  var IAppointmentParticipant: abstract new (...args: any[]) => IAppointmentParticipant;
+
+  interface IAppointmentPropertiesStatics {
+    readonly AllDay: string;
+    readonly AllowNewTimeProposal: string;
+    readonly BusyStatus: string;
+    readonly DefaultProperties: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Details: string;
+    readonly Duration: string;
+    readonly HasInvitees: string;
+    readonly Invitees: string;
+    readonly IsCanceledMeeting: string;
+    readonly IsOrganizedByUser: string;
+    readonly IsResponseRequested: string;
+    readonly Location: string;
+    readonly OnlineMeetingLink: string;
+    readonly Organizer: string;
+    readonly OriginalStartTime: string;
+    readonly Recurrence: string;
+    readonly Reminder: string;
+    readonly ReplyTime: string;
+    readonly Sensitivity: string;
+    readonly StartTime: string;
+    readonly Subject: string;
+    readonly Uri: string;
+    readonly UserResponse: string;
+  }
+  var IAppointmentPropertiesStatics: abstract new (...args: any[]) => IAppointmentPropertiesStatics;
+
+  interface IAppointmentPropertiesStatics2 extends Windows.ApplicationModel.Appointments.IAppointmentPropertiesStatics {
+    readonly ChangeNumber: string;
+    readonly DetailsKind: string;
+    readonly RemoteChangeNumber: string;
+  }
+  var IAppointmentPropertiesStatics2: abstract new (...args: any[]) => IAppointmentPropertiesStatics2;
+
+  interface IAppointmentRecurrence {
+    Day: number;
+    DaysOfWeek: number;
+    Interval: number;
+    Month: number;
+    Occurrences: number | null;
+    Unit: number;
+    Until: Windows.Foundation.DateTime | null;
+    WeekOfMonth: number;
+  }
+  var IAppointmentRecurrence: abstract new (...args: any[]) => IAppointmentRecurrence;
+
+  interface IAppointmentRecurrence2 extends Windows.ApplicationModel.Appointments.IAppointmentRecurrence {
+    readonly RecurrenceType: number;
+    TimeZone: string;
+  }
+  var IAppointmentRecurrence2: abstract new (...args: any[]) => IAppointmentRecurrence2;
+
+  interface IAppointmentRecurrence3 extends Windows.ApplicationModel.Appointments.IAppointmentRecurrence, Windows.ApplicationModel.Appointments.IAppointmentRecurrence2 {
+    readonly CalendarIdentifier: string;
+  }
+  var IAppointmentRecurrence3: abstract new (...args: any[]) => IAppointmentRecurrence3;
+
+  interface IAppointmentStore {
+    CreateAppointmentCalendarAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.AppointmentCalendar>;
+    FindAppointmentCalendarsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.AppointmentCalendar> | Windows.ApplicationModel.Appointments.AppointmentCalendar[]>;
+    FindAppointmentCalendarsAsync(options: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.AppointmentCalendar> | Windows.ApplicationModel.Appointments.AppointmentCalendar[]>;
+    FindAppointmentsAsync(rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindAppointmentsAsync(rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan, options: Windows.ApplicationModel.Appointments.FindAppointmentsOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindConflictAsync(appointment: Windows.ApplicationModel.Appointments.Appointment): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.AppointmentConflictResult>;
+    FindConflictAsync(appointment: Windows.ApplicationModel.Appointments.Appointment, instanceStartTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.AppointmentConflictResult>;
+    FindLocalIdsFromRoamingIdAsync(roamingId: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    GetAppointmentAsync(localId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.Appointment>;
+    GetAppointmentCalendarAsync(calendarId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.AppointmentCalendar>;
+    GetAppointmentInstanceAsync(localId: string, instanceStartTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.Appointment>;
+    MoveAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment, destinationCalendar: Windows.ApplicationModel.Appointments.AppointmentCalendar): Windows.Foundation.IAsyncAction;
+    ShowAddAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<string>;
+    ShowAppointmentDetailsAsync(localId: string): Windows.Foundation.IAsyncAction;
+    ShowAppointmentDetailsAsync(localId: string, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncAction;
+    ShowEditNewAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment): Windows.Foundation.IAsyncOperation<string>;
+    ShowRemoveAppointmentAsync(localId: string, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowRemoveAppointmentAsync(localId: string, selection: Windows.Foundation.Rect, preferredPlacement: number, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowReplaceAppointmentAsync(localId: string, appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<string>;
+    ShowReplaceAppointmentAsync(localId: string, appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect, preferredPlacement: number, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<string>;
+    readonly ChangeTracker: Windows.ApplicationModel.Appointments.AppointmentStoreChangeTracker;
+  }
+  var IAppointmentStore: abstract new (...args: any[]) => IAppointmentStore;
+
+  interface IAppointmentStore2 extends Windows.ApplicationModel.Appointments.IAppointmentStore {
+    CreateAppointmentCalendarAsync(name: string, userDataAccountId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.AppointmentCalendar>;
+    CreateAppointmentCalendarAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.AppointmentCalendar>;
+    FindAppointmentCalendarsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.AppointmentCalendar> | Windows.ApplicationModel.Appointments.AppointmentCalendar[]>;
+    FindAppointmentCalendarsAsync(options: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.AppointmentCalendar> | Windows.ApplicationModel.Appointments.AppointmentCalendar[]>;
+    FindAppointmentsAsync(rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindAppointmentsAsync(rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan, options: Windows.ApplicationModel.Appointments.FindAppointmentsOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.Appointment> | Windows.ApplicationModel.Appointments.Appointment[]>;
+    FindConflictAsync(appointment: Windows.ApplicationModel.Appointments.Appointment): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.AppointmentConflictResult>;
+    FindConflictAsync(appointment: Windows.ApplicationModel.Appointments.Appointment, instanceStartTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.AppointmentConflictResult>;
+    FindLocalIdsFromRoamingIdAsync(roamingId: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    GetAppointmentAsync(localId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.Appointment>;
+    GetAppointmentCalendarAsync(calendarId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.AppointmentCalendar>;
+    GetAppointmentInstanceAsync(localId: string, instanceStartTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Appointments.Appointment>;
+    MoveAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment, destinationCalendar: Windows.ApplicationModel.Appointments.AppointmentCalendar): Windows.Foundation.IAsyncAction;
+    ShowAddAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<string>;
+    ShowAppointmentDetailsAsync(localId: string): Windows.Foundation.IAsyncAction;
+    ShowAppointmentDetailsAsync(localId: string, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncAction;
+    ShowEditNewAppointmentAsync(appointment: Windows.ApplicationModel.Appointments.Appointment): Windows.Foundation.IAsyncOperation<string>;
+    ShowRemoveAppointmentAsync(localId: string, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowRemoveAppointmentAsync(localId: string, selection: Windows.Foundation.Rect, preferredPlacement: number, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowReplaceAppointmentAsync(localId: string, appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<string>;
+    ShowReplaceAppointmentAsync(localId: string, appointment: Windows.ApplicationModel.Appointments.Appointment, selection: Windows.Foundation.Rect, preferredPlacement: number, instanceStartDate: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<string>;
+    StoreChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Appointments.AppointmentStore, Windows.ApplicationModel.Appointments.AppointmentStoreChangedEventArgs> | null;
+  }
+  var IAppointmentStore2: abstract new (...args: any[]) => IAppointmentStore2;
+
+  interface IAppointmentStore3 {
+    GetChangeTracker(identity: string): Windows.ApplicationModel.Appointments.AppointmentStoreChangeTracker;
+  }
+  var IAppointmentStore3: abstract new (...args: any[]) => IAppointmentStore3;
+
+  interface IAppointmentStoreChange {
+    readonly Appointment: Windows.ApplicationModel.Appointments.Appointment;
+    readonly ChangeType: number;
+  }
+  var IAppointmentStoreChange: abstract new (...args: any[]) => IAppointmentStoreChange;
+
+  interface IAppointmentStoreChange2 extends Windows.ApplicationModel.Appointments.IAppointmentStoreChange {
+    readonly AppointmentCalendar: Windows.ApplicationModel.Appointments.AppointmentCalendar;
+  }
+  var IAppointmentStoreChange2: abstract new (...args: any[]) => IAppointmentStoreChange2;
+
+  interface IAppointmentStoreChangeReader {
+    AcceptChanges(): void;
+    AcceptChangesThrough(lastChangeToAccept: Windows.ApplicationModel.Appointments.AppointmentStoreChange): void;
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.AppointmentStoreChange> | Windows.ApplicationModel.Appointments.AppointmentStoreChange[]>;
+  }
+  var IAppointmentStoreChangeReader: abstract new (...args: any[]) => IAppointmentStoreChangeReader;
+
+  interface IAppointmentStoreChangeTracker {
+    Enable(): void;
+    GetChangeReader(): Windows.ApplicationModel.Appointments.AppointmentStoreChangeReader;
+    Reset(): void;
+  }
+  var IAppointmentStoreChangeTracker: abstract new (...args: any[]) => IAppointmentStoreChangeTracker;
+
+  interface IAppointmentStoreChangeTracker2 {
+    readonly IsTracking: boolean;
+  }
+  var IAppointmentStoreChangeTracker2: abstract new (...args: any[]) => IAppointmentStoreChangeTracker2;
+
+  interface IAppointmentStoreChangedDeferral {
+    Complete(): void;
+  }
+  var IAppointmentStoreChangedDeferral: abstract new (...args: any[]) => IAppointmentStoreChangedDeferral;
+
+  interface IAppointmentStoreChangedEventArgs {
+    GetDeferral(): Windows.ApplicationModel.Appointments.AppointmentStoreChangedDeferral;
+  }
+  var IAppointmentStoreChangedEventArgs: abstract new (...args: any[]) => IAppointmentStoreChangedEventArgs;
+
+  interface IAppointmentStoreNotificationTriggerDetails {
+  }
+  var IAppointmentStoreNotificationTriggerDetails: abstract new (...args: any[]) => IAppointmentStoreNotificationTriggerDetails;
+
+  interface IFindAppointmentsOptions {
+    readonly CalendarIds: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly FetchProperties: Windows.Foundation.Collections.IVector<string> | string[];
+    IncludeHidden: boolean;
+    MaxCount: number;
+  }
+  var IFindAppointmentsOptions: abstract new (...args: any[]) => IFindAppointmentsOptions;
+
+}
+
+declare namespace Windows.ApplicationModel.Appointments.AppointmentsProvider {
+  class AddAppointmentOperation implements Windows.ApplicationModel.Appointments.AppointmentsProvider.IAddAppointmentOperation {
+    DismissUI(): void;
+    ReportCanceled(): void;
+    ReportCompleted(itemId: string): void;
+    ReportError(value: string): void;
+    readonly AppointmentInformation: Windows.ApplicationModel.Appointments.Appointment;
+    readonly SourcePackageFamilyName: string;
+  }
+
+  class AppointmentsProviderLaunchActionVerbs {
+    static readonly AddAppointment: string;
+    static readonly RemoveAppointment: string;
+    static readonly ReplaceAppointment: string;
+    static readonly ShowAppointmentDetails: string;
+    static readonly ShowTimeFrame: string;
+  }
+
+  class RemoveAppointmentOperation implements Windows.ApplicationModel.Appointments.AppointmentsProvider.IRemoveAppointmentOperation {
+    DismissUI(): void;
+    ReportCanceled(): void;
+    ReportCompleted(): void;
+    ReportError(value: string): void;
+    readonly AppointmentId: string;
+    readonly InstanceStartDate: Windows.Foundation.DateTime | null;
+    readonly SourcePackageFamilyName: string;
+  }
+
+  class ReplaceAppointmentOperation implements Windows.ApplicationModel.Appointments.AppointmentsProvider.IReplaceAppointmentOperation {
+    DismissUI(): void;
+    ReportCanceled(): void;
+    ReportCompleted(itemId: string): void;
+    ReportError(value: string): void;
+    readonly AppointmentId: string;
+    readonly AppointmentInformation: Windows.ApplicationModel.Appointments.Appointment;
+    readonly InstanceStartDate: Windows.Foundation.DateTime | null;
+    readonly SourcePackageFamilyName: string;
+  }
+
+  interface IAddAppointmentOperation {
+    DismissUI(): void;
+    ReportCanceled(): void;
+    ReportCompleted(itemId: string): void;
+    ReportError(value: string): void;
+    readonly AppointmentInformation: Windows.ApplicationModel.Appointments.Appointment;
+    readonly SourcePackageFamilyName: string;
+  }
+  var IAddAppointmentOperation: abstract new (...args: any[]) => IAddAppointmentOperation;
+
+  interface IAppointmentsProviderLaunchActionVerbsStatics {
+    readonly AddAppointment: string;
+    readonly RemoveAppointment: string;
+    readonly ReplaceAppointment: string;
+    readonly ShowTimeFrame: string;
+  }
+  var IAppointmentsProviderLaunchActionVerbsStatics: abstract new (...args: any[]) => IAppointmentsProviderLaunchActionVerbsStatics;
+
+  interface IAppointmentsProviderLaunchActionVerbsStatics2 {
+    readonly ShowAppointmentDetails: string;
+  }
+  var IAppointmentsProviderLaunchActionVerbsStatics2: abstract new (...args: any[]) => IAppointmentsProviderLaunchActionVerbsStatics2;
+
+  interface IRemoveAppointmentOperation {
+    DismissUI(): void;
+    ReportCanceled(): void;
+    ReportCompleted(): void;
+    ReportError(value: string): void;
+    readonly AppointmentId: string;
+    readonly InstanceStartDate: Windows.Foundation.DateTime | null;
+    readonly SourcePackageFamilyName: string;
+  }
+  var IRemoveAppointmentOperation: abstract new (...args: any[]) => IRemoveAppointmentOperation;
+
+  interface IReplaceAppointmentOperation {
+    DismissUI(): void;
+    ReportCanceled(): void;
+    ReportCompleted(itemId: string): void;
+    ReportError(value: string): void;
+    readonly AppointmentId: string;
+    readonly AppointmentInformation: Windows.ApplicationModel.Appointments.Appointment;
+    readonly InstanceStartDate: Windows.Foundation.DateTime | null;
+    readonly SourcePackageFamilyName: string;
+  }
+  var IReplaceAppointmentOperation: abstract new (...args: any[]) => IReplaceAppointmentOperation;
+
+}
+
+declare namespace Windows.ApplicationModel.Appointments.DataProvider {
+  class AppointmentCalendarCancelMeetingRequest implements Windows.ApplicationModel.Appointments.DataProvider.IAppointmentCalendarCancelMeetingRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly AppointmentCalendarLocalId: string;
+    readonly AppointmentLocalId: string;
+    readonly AppointmentOriginalStartTime: Windows.Foundation.DateTime | null;
+    readonly Comment: string;
+    readonly NotifyInvitees: boolean;
+    readonly Subject: string;
+  }
+
+  class AppointmentCalendarCancelMeetingRequestEventArgs implements Windows.ApplicationModel.Appointments.DataProvider.IAppointmentCalendarCancelMeetingRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequest;
+  }
+
+  class AppointmentCalendarCreateOrUpdateAppointmentRequest implements Windows.ApplicationModel.Appointments.DataProvider.IAppointmentCalendarCreateOrUpdateAppointmentRequest {
+    ReportCompletedAsync(createdOrUpdatedAppointment: Windows.ApplicationModel.Appointments.Appointment): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly Appointment: Windows.ApplicationModel.Appointments.Appointment;
+    readonly AppointmentCalendarLocalId: string;
+    readonly ChangedProperties: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly NotifyInvitees: boolean;
+  }
+
+  class AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs implements Windows.ApplicationModel.Appointments.DataProvider.IAppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequest;
+  }
+
+  class AppointmentCalendarForwardMeetingRequest implements Windows.ApplicationModel.Appointments.DataProvider.IAppointmentCalendarForwardMeetingRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly AppointmentCalendarLocalId: string;
+    readonly AppointmentLocalId: string;
+    readonly AppointmentOriginalStartTime: Windows.Foundation.DateTime | null;
+    readonly Comment: string;
+    readonly ForwardHeader: string;
+    readonly Invitees: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.AppointmentInvitee> | Windows.ApplicationModel.Appointments.AppointmentInvitee[];
+    readonly Subject: string;
+  }
+
+  class AppointmentCalendarForwardMeetingRequestEventArgs implements Windows.ApplicationModel.Appointments.DataProvider.IAppointmentCalendarForwardMeetingRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequest;
+  }
+
+  class AppointmentCalendarProposeNewTimeForMeetingRequest implements Windows.ApplicationModel.Appointments.DataProvider.IAppointmentCalendarProposeNewTimeForMeetingRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly AppointmentCalendarLocalId: string;
+    readonly AppointmentLocalId: string;
+    readonly AppointmentOriginalStartTime: Windows.Foundation.DateTime | null;
+    readonly Comment: string;
+    readonly NewDuration: Windows.Foundation.TimeSpan;
+    readonly NewStartTime: Windows.Foundation.DateTime;
+    readonly Subject: string;
+  }
+
+  class AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs implements Windows.ApplicationModel.Appointments.DataProvider.IAppointmentCalendarProposeNewTimeForMeetingRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequest;
+  }
+
+  class AppointmentCalendarSyncManagerSyncRequest implements Windows.ApplicationModel.Appointments.DataProvider.IAppointmentCalendarSyncManagerSyncRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly AppointmentCalendarLocalId: string;
+  }
+
+  class AppointmentCalendarSyncManagerSyncRequestEventArgs implements Windows.ApplicationModel.Appointments.DataProvider.IAppointmentCalendarSyncManagerSyncRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequest;
+  }
+
+  class AppointmentCalendarUpdateMeetingResponseRequest implements Windows.ApplicationModel.Appointments.DataProvider.IAppointmentCalendarUpdateMeetingResponseRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly AppointmentCalendarLocalId: string;
+    readonly AppointmentLocalId: string;
+    readonly AppointmentOriginalStartTime: Windows.Foundation.DateTime | null;
+    readonly Comment: string;
+    readonly Response: number;
+    readonly SendUpdate: boolean;
+    readonly Subject: string;
+  }
+
+  class AppointmentCalendarUpdateMeetingResponseRequestEventArgs implements Windows.ApplicationModel.Appointments.DataProvider.IAppointmentCalendarUpdateMeetingResponseRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequest;
+  }
+
+  class AppointmentDataProviderConnection implements Windows.ApplicationModel.Appointments.DataProvider.IAppointmentDataProviderConnection {
+    Start(): void;
+    CancelMeetingRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection, Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs> | null;
+    CreateOrUpdateAppointmentRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection, Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs> | null;
+    ForwardMeetingRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection, Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs> | null;
+    ProposeNewTimeForMeetingRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection, Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs> | null;
+    SyncRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection, Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs> | null;
+    UpdateMeetingResponseRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection, Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs> | null;
+  }
+
+  class AppointmentDataProviderTriggerDetails implements Windows.ApplicationModel.Appointments.DataProvider.IAppointmentDataProviderTriggerDetails {
+    readonly Connection: Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection;
+  }
+
+  interface IAppointmentCalendarCancelMeetingRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly AppointmentCalendarLocalId: string;
+    readonly AppointmentLocalId: string;
+    readonly AppointmentOriginalStartTime: Windows.Foundation.DateTime | null;
+    readonly Comment: string;
+    readonly NotifyInvitees: boolean;
+    readonly Subject: string;
+  }
+  var IAppointmentCalendarCancelMeetingRequest: abstract new (...args: any[]) => IAppointmentCalendarCancelMeetingRequest;
+
+  interface IAppointmentCalendarCancelMeetingRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequest;
+  }
+  var IAppointmentCalendarCancelMeetingRequestEventArgs: abstract new (...args: any[]) => IAppointmentCalendarCancelMeetingRequestEventArgs;
+
+  interface IAppointmentCalendarCreateOrUpdateAppointmentRequest {
+    ReportCompletedAsync(createdOrUpdatedAppointment: Windows.ApplicationModel.Appointments.Appointment): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly Appointment: Windows.ApplicationModel.Appointments.Appointment;
+    readonly AppointmentCalendarLocalId: string;
+    readonly ChangedProperties: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly NotifyInvitees: boolean;
+  }
+  var IAppointmentCalendarCreateOrUpdateAppointmentRequest: abstract new (...args: any[]) => IAppointmentCalendarCreateOrUpdateAppointmentRequest;
+
+  interface IAppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequest;
+  }
+  var IAppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs: abstract new (...args: any[]) => IAppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs;
+
+  interface IAppointmentCalendarForwardMeetingRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly AppointmentCalendarLocalId: string;
+    readonly AppointmentLocalId: string;
+    readonly AppointmentOriginalStartTime: Windows.Foundation.DateTime | null;
+    readonly Comment: string;
+    readonly ForwardHeader: string;
+    readonly Invitees: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.AppointmentInvitee> | Windows.ApplicationModel.Appointments.AppointmentInvitee[];
+    readonly Subject: string;
+  }
+  var IAppointmentCalendarForwardMeetingRequest: abstract new (...args: any[]) => IAppointmentCalendarForwardMeetingRequest;
+
+  interface IAppointmentCalendarForwardMeetingRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequest;
+  }
+  var IAppointmentCalendarForwardMeetingRequestEventArgs: abstract new (...args: any[]) => IAppointmentCalendarForwardMeetingRequestEventArgs;
+
+  interface IAppointmentCalendarProposeNewTimeForMeetingRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly AppointmentCalendarLocalId: string;
+    readonly AppointmentLocalId: string;
+    readonly AppointmentOriginalStartTime: Windows.Foundation.DateTime | null;
+    readonly Comment: string;
+    readonly NewDuration: Windows.Foundation.TimeSpan;
+    readonly NewStartTime: Windows.Foundation.DateTime;
+    readonly Subject: string;
+  }
+  var IAppointmentCalendarProposeNewTimeForMeetingRequest: abstract new (...args: any[]) => IAppointmentCalendarProposeNewTimeForMeetingRequest;
+
+  interface IAppointmentCalendarProposeNewTimeForMeetingRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequest;
+  }
+  var IAppointmentCalendarProposeNewTimeForMeetingRequestEventArgs: abstract new (...args: any[]) => IAppointmentCalendarProposeNewTimeForMeetingRequestEventArgs;
+
+  interface IAppointmentCalendarSyncManagerSyncRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly AppointmentCalendarLocalId: string;
+  }
+  var IAppointmentCalendarSyncManagerSyncRequest: abstract new (...args: any[]) => IAppointmentCalendarSyncManagerSyncRequest;
+
+  interface IAppointmentCalendarSyncManagerSyncRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequest;
+  }
+  var IAppointmentCalendarSyncManagerSyncRequestEventArgs: abstract new (...args: any[]) => IAppointmentCalendarSyncManagerSyncRequestEventArgs;
+
+  interface IAppointmentCalendarUpdateMeetingResponseRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly AppointmentCalendarLocalId: string;
+    readonly AppointmentLocalId: string;
+    readonly AppointmentOriginalStartTime: Windows.Foundation.DateTime | null;
+    readonly Comment: string;
+    readonly Response: number;
+    readonly SendUpdate: boolean;
+    readonly Subject: string;
+  }
+  var IAppointmentCalendarUpdateMeetingResponseRequest: abstract new (...args: any[]) => IAppointmentCalendarUpdateMeetingResponseRequest;
+
+  interface IAppointmentCalendarUpdateMeetingResponseRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequest;
+  }
+  var IAppointmentCalendarUpdateMeetingResponseRequestEventArgs: abstract new (...args: any[]) => IAppointmentCalendarUpdateMeetingResponseRequestEventArgs;
+
+  interface IAppointmentDataProviderConnection {
+    Start(): void;
+    CancelMeetingRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection, Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCancelMeetingRequestEventArgs> | null;
+    CreateOrUpdateAppointmentRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection, Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarCreateOrUpdateAppointmentRequestEventArgs> | null;
+    ForwardMeetingRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection, Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarForwardMeetingRequestEventArgs> | null;
+    ProposeNewTimeForMeetingRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection, Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarProposeNewTimeForMeetingRequestEventArgs> | null;
+    SyncRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection, Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarSyncManagerSyncRequestEventArgs> | null;
+    UpdateMeetingResponseRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection, Windows.ApplicationModel.Appointments.DataProvider.AppointmentCalendarUpdateMeetingResponseRequestEventArgs> | null;
+  }
+  var IAppointmentDataProviderConnection: abstract new (...args: any[]) => IAppointmentDataProviderConnection;
+
+  interface IAppointmentDataProviderTriggerDetails {
+    readonly Connection: Windows.ApplicationModel.Appointments.DataProvider.AppointmentDataProviderConnection;
+  }
+  var IAppointmentDataProviderTriggerDetails: abstract new (...args: any[]) => IAppointmentDataProviderTriggerDetails;
+
+}
+
+declare namespace Windows.ApplicationModel.Background {
+  class ActivitySensorTrigger implements Windows.ApplicationModel.Background.IActivitySensorTrigger, Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor(reportIntervalInMilliseconds: number);
+    readonly MinimumReportInterval: number;
+    readonly ReportInterval: number;
+    readonly SubscribedActivities: Windows.Foundation.Collections.IVector<number> | number[];
+    readonly SupportedActivities: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class AlarmApplicationManager {
+    static GetAccessStatus(): number;
+    static RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+
+  class AppBroadcastTrigger implements Windows.ApplicationModel.Background.IAppBroadcastTrigger, Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor(providerKey: string);
+    ProviderInfo: Windows.ApplicationModel.Background.AppBroadcastTriggerProviderInfo;
+  }
+
+  class AppBroadcastTriggerProviderInfo implements Windows.ApplicationModel.Background.IAppBroadcastTriggerProviderInfo {
+    DisplayNameResource: string;
+    LogoResource: string;
+    MaxVideoBitrate: number;
+    MaxVideoHeight: number;
+    MaxVideoWidth: number;
+    VideoKeyFrameInterval: Windows.Foundation.TimeSpan;
+  }
+
+  class ApplicationTrigger implements Windows.ApplicationModel.Background.IApplicationTrigger, Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor();
+    RequestAsync(): Windows.Foundation.IAsyncOperation<number>;
+    RequestAsync(arguments_: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<number>;
+  }
+
+  class ApplicationTriggerDetails implements Windows.ApplicationModel.Background.IApplicationTriggerDetails {
+    readonly Arguments: Windows.Foundation.Collections.ValueSet;
+  }
+
+  class AppointmentStoreNotificationTrigger implements Windows.ApplicationModel.Background.IAppointmentStoreNotificationTrigger, Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor();
+  }
+
+  class BackgroundExecutionManager {
+    static GetAccessStatus(): number;
+    static GetAccessStatus(applicationId: string): number;
+    static GetAccessStatusForModernStandby(): number;
+    static GetAccessStatusForModernStandby(applicationId: string): number;
+    static RemoveAccess(): void;
+    static RemoveAccess(applicationId: string): void;
+    static RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    static RequestAccessAsync(applicationId: string): Windows.Foundation.IAsyncOperation<number>;
+    static RequestAccessKindAsync(requestedAccess: number, reason: string): Windows.Foundation.IAsyncOperation<boolean>;
+    static RequestAccessKindForModernStandbyAsync(requestedAccess: number, reason: string): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+
+  class BackgroundTaskBuilder implements Windows.ApplicationModel.Background.IBackgroundTaskBuilder, Windows.ApplicationModel.Background.IBackgroundTaskBuilder2, Windows.ApplicationModel.Background.IBackgroundTaskBuilder3, Windows.ApplicationModel.Background.IBackgroundTaskBuilder4, Windows.ApplicationModel.Background.IBackgroundTaskBuilder5, Windows.ApplicationModel.Background.IBackgroundTaskBuilder6 {
+    constructor();
+    AddCondition(condition: Windows.ApplicationModel.Background.IBackgroundCondition): void;
+    Register(): Windows.ApplicationModel.Background.BackgroundTaskRegistration;
+    Register(taskName: string): Windows.ApplicationModel.Background.BackgroundTaskRegistration;
+    SetTaskEntryPointClsid(TaskEntryPoint: Guid): void;
+    SetTrigger(trigger: Windows.ApplicationModel.Background.IBackgroundTrigger): void;
+    Validate(): boolean;
+    AllowRunningTaskInStandby: boolean;
+    CancelOnConditionLoss: boolean;
+    IsNetworkRequested: boolean;
+    static readonly IsRunningTaskInStandbySupported: boolean;
+    Name: string;
+    TaskEntryPoint: string;
+    TaskGroup: Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup;
+  }
+
+  class BackgroundTaskCompletedEventArgs implements Windows.ApplicationModel.Background.IBackgroundTaskCompletedEventArgs {
+    CheckResult(): void;
+    readonly InstanceId: Guid;
+  }
+
+  class BackgroundTaskDeferral implements Windows.ApplicationModel.Background.IBackgroundTaskDeferral {
+    Complete(): void;
+  }
+
+  class BackgroundTaskProgressEventArgs implements Windows.ApplicationModel.Background.IBackgroundTaskProgressEventArgs {
+    readonly InstanceId: Guid;
+    readonly Progress: number;
+  }
+
+  class BackgroundTaskRegistration implements Windows.ApplicationModel.Background.IBackgroundTaskRegistration, Windows.ApplicationModel.Background.IBackgroundTaskRegistration2, Windows.ApplicationModel.Background.IBackgroundTaskRegistration3, Windows.ApplicationModel.Background.IBackgroundTaskRegistration4 {
+    static GetTaskGroup(groupId: string): Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup;
+    Unregister(cancelTask: boolean): void;
+    static readonly AllTaskGroups: Windows.Foundation.Collections.IMapView<string, Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup>;
+    static readonly AllTasks: Windows.Foundation.Collections.IMapView<Guid, Windows.ApplicationModel.Background.IBackgroundTaskRegistration>;
+    readonly AppEnergyUsePredictionContribution: number;
+    readonly Name: string;
+    readonly TaskGroup: Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup;
+    readonly TaskId: Guid;
+    readonly TaskLastThrottledInStandbyTimestamp: Windows.Foundation.DateTime;
+    readonly Trigger: Windows.ApplicationModel.Background.IBackgroundTrigger;
+    Completed: Windows.ApplicationModel.Background.BackgroundTaskCompletedEventHandler | null;
+    Progress: Windows.ApplicationModel.Background.BackgroundTaskProgressEventHandler | null;
+  }
+
+  class BackgroundTaskRegistrationGroup implements Windows.ApplicationModel.Background.IBackgroundTaskRegistrationGroup {
+    constructor(id: string);
+    constructor(id: string, name: string);
+    readonly AllTasks: Windows.Foundation.Collections.IMapView<Guid, Windows.ApplicationModel.Background.BackgroundTaskRegistration>;
+    readonly Id: string;
+    readonly Name: string;
+    BackgroundActivated: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup, Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs> | null;
+  }
+
+  class BackgroundWorkCost {
+    static readonly AppEnergyUseLevel: number;
+    static readonly AppEnergyUsePrediction: number;
+    static readonly AppLastThrottledInStandbyTimestamp: Windows.Foundation.DateTime;
+    static readonly CurrentBackgroundWorkCost: number;
+  }
+
+  class BluetoothLEAdvertisementPublisherTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IBluetoothLEAdvertisementPublisherTrigger, Windows.ApplicationModel.Background.IBluetoothLEAdvertisementPublisherTrigger2, Windows.ApplicationModel.Background.IBluetoothLEAdvertisementPublisherTrigger3 {
+    constructor();
+    readonly Advertisement: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisement;
+    IncludeTransmitPowerLevel: boolean;
+    IsAnonymous: boolean;
+    PreferredTransmitPowerLevelInDBm: number | null;
+    PrimaryPhy: number;
+    SecondaryPhy: number;
+    UseExtendedFormat: boolean;
+  }
+
+  class BluetoothLEAdvertisementWatcherTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IBluetoothLEAdvertisementWatcherTrigger, Windows.ApplicationModel.Background.IBluetoothLEAdvertisementWatcherTrigger2, Windows.ApplicationModel.Background.IBluetoothLEAdvertisementWatcherTrigger3 {
+    constructor();
+    AdvertisementFilter: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementFilter;
+    AllowExtendedAdvertisements: boolean;
+    readonly MaxOutOfRangeTimeout: Windows.Foundation.TimeSpan;
+    readonly MaxSamplingInterval: Windows.Foundation.TimeSpan;
+    readonly MinOutOfRangeTimeout: Windows.Foundation.TimeSpan;
+    readonly MinSamplingInterval: Windows.Foundation.TimeSpan;
+    ScanParameters: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementScanParameters;
+    SignalStrengthFilter: Windows.Devices.Bluetooth.BluetoothSignalStrengthFilter;
+    UseCodedPhy: boolean;
+    UseUncoded1MPhy: boolean;
+  }
+
+  class CachedFileUpdaterTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.ICachedFileUpdaterTrigger {
+    constructor();
+  }
+
+  class CachedFileUpdaterTriggerDetails implements Windows.ApplicationModel.Background.ICachedFileUpdaterTriggerDetails {
+    readonly CanRequestUserInput: boolean;
+    readonly UpdateRequest: Windows.Storage.Provider.FileUpdateRequest;
+    readonly UpdateTarget: number;
+  }
+
+  class ChatMessageNotificationTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IChatMessageNotificationTrigger {
+    constructor();
+  }
+
+  class ChatMessageReceivedNotificationTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IChatMessageReceivedNotificationTrigger {
+    constructor();
+  }
+
+  class CommunicationBlockingAppSetAsActiveTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.ICommunicationBlockingAppSetAsActiveTrigger {
+    constructor();
+  }
+
+  class ContactStoreNotificationTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IContactStoreNotificationTrigger {
+    constructor();
+  }
+
+  class ContentPrefetchTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IContentPrefetchTrigger {
+    constructor(waitInterval: Windows.Foundation.TimeSpan);
+    constructor();
+    readonly WaitInterval: Windows.Foundation.TimeSpan;
+  }
+
+  class ConversationalAgentTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor();
+  }
+
+  class CustomSystemEventTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.ICustomSystemEventTrigger {
+    constructor(triggerId: string, recurrence: number);
+    readonly Recurrence: number;
+    readonly TriggerId: string;
+  }
+
+  class DeviceConnectionChangeTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IDeviceConnectionChangeTrigger {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Background.DeviceConnectionChangeTrigger>;
+    readonly CanMaintainConnection: boolean;
+    readonly DeviceId: string;
+    MaintainConnection: boolean;
+  }
+
+  class DeviceManufacturerNotificationTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IDeviceManufacturerNotificationTrigger {
+    constructor(triggerQualifier: string, oneShot: boolean);
+    readonly OneShot: boolean;
+    readonly TriggerQualifier: string;
+  }
+
+  class DeviceServicingTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IDeviceServicingTrigger {
+    constructor();
+    RequestAsync(deviceId: string, expectedDuration: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<number>;
+    RequestAsync(deviceId: string, expectedDuration: Windows.Foundation.TimeSpan, arguments_: string): Windows.Foundation.IAsyncOperation<number>;
+  }
+
+  class DeviceUseTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IDeviceUseTrigger {
+    constructor();
+    RequestAsync(deviceId: string): Windows.Foundation.IAsyncOperation<number>;
+    RequestAsync(deviceId: string, arguments_: string): Windows.Foundation.IAsyncOperation<number>;
+  }
+
+  class DeviceWatcherTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IDeviceWatcherTrigger {
+  }
+
+  class EmailStoreNotificationTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IEmailStoreNotificationTrigger {
+    constructor();
+  }
+
+  class GattCharacteristicNotificationTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IGattCharacteristicNotificationTrigger, Windows.ApplicationModel.Background.IGattCharacteristicNotificationTrigger2 {
+    constructor(characteristic: Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic, eventTriggeringMode: number);
+    constructor(characteristic: Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic);
+    readonly Characteristic: Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic;
+    readonly EventTriggeringMode: number;
+  }
+
+  class GattServiceProviderTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IGattServiceProviderTrigger {
+    static CreateAsync(triggerId: string, serviceUuid: Guid): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Background.GattServiceProviderTriggerResult>;
+    AdvertisingParameters: Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisingParameters;
+    readonly Service: Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalService;
+    readonly TriggerId: string;
+  }
+
+  class GattServiceProviderTriggerResult implements Windows.ApplicationModel.Background.IGattServiceProviderTriggerResult {
+    readonly Error: number;
+    readonly Trigger: Windows.ApplicationModel.Background.GattServiceProviderTrigger;
+  }
+
+  class GeovisitTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IGeovisitTrigger {
+    constructor();
+    MonitoringScope: number;
+  }
+
+  class LocationTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.ILocationTrigger {
+    constructor(triggerType: number);
+    readonly TriggerType: number;
+  }
+
+  class MaintenanceTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IMaintenanceTrigger {
+    constructor(freshnessTime: number, oneShot: boolean);
+    readonly FreshnessTime: number;
+    readonly OneShot: boolean;
+  }
+
+  class MediaProcessingTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IMediaProcessingTrigger {
+    constructor();
+    RequestAsync(): Windows.Foundation.IAsyncOperation<number>;
+    RequestAsync(arguments_: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<number>;
+  }
+
+  class MobileBroadbandDeviceServiceNotificationTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor();
+  }
+
+  class MobileBroadbandPcoDataChangeTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor();
+  }
+
+  class MobileBroadbandPinLockStateChangeTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor();
+  }
+
+  class MobileBroadbandRadioStateChangeTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor();
+  }
+
+  class MobileBroadbandRegistrationStateChangeTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor();
+  }
+
+  class NetworkOperatorDataUsageTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor();
+  }
+
+  class NetworkOperatorHotspotAuthenticationTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.INetworkOperatorHotspotAuthenticationTrigger {
+    constructor();
+  }
+
+  class NetworkOperatorNotificationTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.INetworkOperatorNotificationTrigger {
+    constructor(networkAccountId: string);
+    readonly NetworkAccountId: string;
+  }
+
+  class PaymentAppCanMakePaymentTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor();
+  }
+
+  class PhoneTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IPhoneTrigger {
+    constructor(type: number, oneShot: boolean);
+    readonly OneShot: boolean;
+    readonly TriggerType: number;
+  }
+
+  class PushNotificationTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor(applicationId: string);
+    constructor();
+  }
+
+  class RcsEndUserMessageAvailableTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IRcsEndUserMessageAvailableTrigger {
+    constructor();
+  }
+
+  class RfcommConnectionTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IRfcommConnectionTrigger {
+    constructor();
+    AllowMultipleConnections: boolean;
+    readonly InboundConnection: Windows.Devices.Bluetooth.Background.RfcommInboundConnectionInformation;
+    readonly OutboundConnection: Windows.Devices.Bluetooth.Background.RfcommOutboundConnectionInformation;
+    ProtectionLevel: number;
+    RemoteHostName: Windows.Networking.HostName;
+  }
+
+  class SecondaryAuthenticationFactorAuthenticationTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.ISecondaryAuthenticationFactorAuthenticationTrigger {
+    constructor();
+  }
+
+  class SensorDataThresholdTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.ISensorDataThresholdTrigger {
+    constructor(threshold: Windows.Devices.Sensors.ISensorDataThreshold);
+  }
+
+  class SmartCardTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.ISmartCardTrigger {
+    constructor(triggerType: number);
+    readonly TriggerType: number;
+  }
+
+  class SmsMessageReceivedTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor(filterRules: Windows.Devices.Sms.SmsFilterRules);
+  }
+
+  class SocketActivityTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.ISocketActivityTrigger {
+    constructor();
+    readonly IsWakeFromLowPowerSupported: boolean;
+  }
+
+  class StorageLibraryChangeTrackerTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor(tracker: Windows.Storage.StorageLibraryChangeTracker);
+  }
+
+  class StorageLibraryContentChangedTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.IStorageLibraryContentChangedTrigger {
+    static Create(storageLibrary: Windows.Storage.StorageLibrary): Windows.ApplicationModel.Background.StorageLibraryContentChangedTrigger;
+    static CreateFromLibraries(storageLibraries: Windows.Foundation.Collections.IIterable<Windows.Storage.StorageLibrary> | Windows.Storage.StorageLibrary[]): Windows.ApplicationModel.Background.StorageLibraryContentChangedTrigger;
+  }
+
+  class SystemCondition implements Windows.ApplicationModel.Background.IBackgroundCondition, Windows.ApplicationModel.Background.ISystemCondition {
+    constructor(conditionType: number);
+    readonly ConditionType: number;
+  }
+
+  class SystemTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.ISystemTrigger {
+    constructor(triggerType: number, oneShot: boolean);
+    readonly OneShot: boolean;
+    readonly TriggerType: number;
+  }
+
+  class TetheringEntitlementCheckTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor();
+  }
+
+  class TimeTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger, Windows.ApplicationModel.Background.ITimeTrigger {
+    constructor(freshnessTime: number, oneShot: boolean);
+    readonly FreshnessTime: number;
+    readonly OneShot: boolean;
+  }
+
+  class ToastNotificationActionTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor(applicationId: string);
+    constructor();
+  }
+
+  class ToastNotificationHistoryChangedTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor(applicationId: string);
+    constructor();
+  }
+
+  class UserNotificationChangedTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor(notificationKinds: number);
+  }
+
+  class WiFiOnDemandHotspotConnectTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor();
+  }
+
+  class WiFiOnDemandHotspotUpdateMetadataTrigger implements Windows.ApplicationModel.Background.IBackgroundTrigger {
+    constructor();
+  }
+
+  enum AlarmAccessStatus {
+    Unspecified = 0,
+    AllowedWithWakeupCapability = 1,
+    AllowedWithoutWakeupCapability = 2,
+    Denied = 3,
+  }
+
+  enum ApplicationTriggerResult {
+    Allowed = 0,
+    CurrentlyRunning = 1,
+    DisabledByPolicy = 2,
+    UnknownError = 3,
+  }
+
+  enum BackgroundAccessRequestKind {
+    AlwaysAllowed = 0,
+    AllowedSubjectToSystemPolicy = 1,
+  }
+
+  enum BackgroundAccessStatus {
+    Unspecified = 0,
+    AllowedWithAlwaysOnRealTimeConnectivity = 1,
+    AllowedMayUseActiveRealTimeConnectivity = 2,
+    Denied = 3,
+    AlwaysAllowed = 4,
+    AllowedSubjectToSystemPolicy = 5,
+    DeniedBySystemPolicy = 6,
+    DeniedByUser = 7,
+  }
+
+  enum BackgroundTaskCancellationReason {
+    Abort = 0,
+    Terminating = 1,
+    LoggingOff = 2,
+    ServicingUpdate = 3,
+    IdleTask = 4,
+    Uninstall = 5,
+    ConditionLoss = 6,
+    SystemPolicy = 7,
+    QuietHoursEntered = 8,
+    ExecutionTimeExceeded = 9,
+    ResourceRevocation = 10,
+    EnergySaver = 11,
+  }
+
+  enum BackgroundTaskThrottleCounter {
+    All = 0,
+    Cpu = 1,
+    Network = 2,
+  }
+
+  enum BackgroundWorkCostValue {
+    Low = 0,
+    Medium = 1,
+    High = 2,
+  }
+
+  enum CustomSystemEventTriggerRecurrence {
+    Once = 0,
+    Always = 1,
+  }
+
+  enum DeviceTriggerResult {
+    Allowed = 0,
+    DeniedByUser = 1,
+    DeniedBySystem = 2,
+    LowBattery = 3,
+  }
+
+  enum EnergyUseLevel {
+    Unknown = 0,
+    UnderHalfOfBudget = 1,
+    OverHalfOfBudget = 2,
+    OverBudget = 3,
+  }
+
+  enum LocationTriggerType {
+    Geofence = 0,
+  }
+
+  enum MediaProcessingTriggerResult {
+    Allowed = 0,
+    CurrentlyRunning = 1,
+    DisabledByPolicy = 2,
+    UnknownError = 3,
+  }
+
+  enum SystemConditionType {
+    Invalid = 0,
+    UserPresent = 1,
+    UserNotPresent = 2,
+    InternetAvailable = 3,
+    InternetNotAvailable = 4,
+    SessionConnected = 5,
+    SessionDisconnected = 6,
+    FreeNetworkAvailable = 7,
+    BackgroundWorkCostNotHigh = 8,
+  }
+
+  enum SystemTriggerType {
+    Invalid = 0,
+    SmsReceived = 1,
+    UserPresent = 2,
+    UserAway = 3,
+    NetworkStateChange = 4,
+    ControlChannelReset = 5,
+    InternetAvailable = 6,
+    SessionConnected = 7,
+    ServicingComplete = 8,
+    LockScreenApplicationAdded = 9,
+    LockScreenApplicationRemoved = 10,
+    TimeZoneChange = 11,
+    OnlineIdConnectedStateChange = 12,
+    BackgroundWorkCostChange = 13,
+    PowerStateChange = 14,
+    DefaultSignInAccountChange = 15,
+  }
+
+  interface BackgroundAlarmApplicationContract {
+  }
+  var BackgroundAlarmApplicationContract: {
+    new(fields: {  }): BackgroundAlarmApplicationContract;
+  };
+
+  interface BackgroundTaskCanceledEventHandler {
+    (sender: Windows.ApplicationModel.Background.IBackgroundTaskInstance, reason: number): void;
+  }
+  var BackgroundTaskCanceledEventHandler: {
+    new(callback: (sender: Windows.ApplicationModel.Background.IBackgroundTaskInstance, reason: number) => void): BackgroundTaskCanceledEventHandler;
+  };
+
+  interface BackgroundTaskCompletedEventHandler {
+    (sender: Windows.ApplicationModel.Background.BackgroundTaskRegistration, args: Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs): void;
+  }
+  var BackgroundTaskCompletedEventHandler: {
+    new(callback: (sender: Windows.ApplicationModel.Background.BackgroundTaskRegistration, args: Windows.ApplicationModel.Background.BackgroundTaskCompletedEventArgs) => void): BackgroundTaskCompletedEventHandler;
+  };
+
+  interface BackgroundTaskProgressEventHandler {
+    (sender: Windows.ApplicationModel.Background.BackgroundTaskRegistration, args: Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs): void;
+  }
+  var BackgroundTaskProgressEventHandler: {
+    new(callback: (sender: Windows.ApplicationModel.Background.BackgroundTaskRegistration, args: Windows.ApplicationModel.Background.BackgroundTaskProgressEventArgs) => void): BackgroundTaskProgressEventHandler;
+  };
+
+  interface IActivitySensorTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    readonly MinimumReportInterval: number;
+    readonly ReportInterval: number;
+    readonly SubscribedActivities: Windows.Foundation.Collections.IVector<number> | number[];
+    readonly SupportedActivities: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IActivitySensorTrigger: abstract new (...args: any[]) => IActivitySensorTrigger;
+
+  interface IActivitySensorTriggerFactory {
+    Create(reportIntervalInMilliseconds: number): Windows.ApplicationModel.Background.ActivitySensorTrigger;
+  }
+  var IActivitySensorTriggerFactory: abstract new (...args: any[]) => IActivitySensorTriggerFactory;
+
+  interface IAlarmApplicationManagerStatics {
+    GetAccessStatus(): number;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IAlarmApplicationManagerStatics: abstract new (...args: any[]) => IAlarmApplicationManagerStatics;
+
+  interface IAppBroadcastTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    ProviderInfo: Windows.ApplicationModel.Background.AppBroadcastTriggerProviderInfo;
+  }
+  var IAppBroadcastTrigger: abstract new (...args: any[]) => IAppBroadcastTrigger;
+
+  interface IAppBroadcastTriggerFactory {
+    CreateAppBroadcastTrigger(providerKey: string): Windows.ApplicationModel.Background.AppBroadcastTrigger;
+  }
+  var IAppBroadcastTriggerFactory: abstract new (...args: any[]) => IAppBroadcastTriggerFactory;
+
+  interface IAppBroadcastTriggerProviderInfo {
+    DisplayNameResource: string;
+    LogoResource: string;
+    MaxVideoBitrate: number;
+    MaxVideoHeight: number;
+    MaxVideoWidth: number;
+    VideoKeyFrameInterval: Windows.Foundation.TimeSpan;
+  }
+  var IAppBroadcastTriggerProviderInfo: abstract new (...args: any[]) => IAppBroadcastTriggerProviderInfo;
+
+  interface IApplicationTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    RequestAsync(): Windows.Foundation.IAsyncOperation<number>;
+    RequestAsync(arguments_: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IApplicationTrigger: abstract new (...args: any[]) => IApplicationTrigger;
+
+  interface IApplicationTriggerDetails {
+    readonly Arguments: Windows.Foundation.Collections.ValueSet;
+  }
+  var IApplicationTriggerDetails: abstract new (...args: any[]) => IApplicationTriggerDetails;
+
+  interface IAppointmentStoreNotificationTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+  }
+  var IAppointmentStoreNotificationTrigger: abstract new (...args: any[]) => IAppointmentStoreNotificationTrigger;
+
+  interface IBackgroundCondition {
+  }
+  var IBackgroundCondition: abstract new (...args: any[]) => IBackgroundCondition;
+
+  interface IBackgroundExecutionManagerStatics {
+    GetAccessStatus(): number;
+    GetAccessStatus(applicationId: string): number;
+    RemoveAccess(): void;
+    RemoveAccess(applicationId: string): void;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    RequestAccessAsync(applicationId: string): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IBackgroundExecutionManagerStatics: abstract new (...args: any[]) => IBackgroundExecutionManagerStatics;
+
+  interface IBackgroundExecutionManagerStatics2 {
+    RequestAccessKindAsync(requestedAccess: number, reason: string): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IBackgroundExecutionManagerStatics2: abstract new (...args: any[]) => IBackgroundExecutionManagerStatics2;
+
+  interface IBackgroundExecutionManagerStatics3 {
+    GetAccessStatusForModernStandby(): number;
+    GetAccessStatusForModernStandby(applicationId: string): number;
+    RequestAccessKindForModernStandbyAsync(requestedAccess: number, reason: string): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IBackgroundExecutionManagerStatics3: abstract new (...args: any[]) => IBackgroundExecutionManagerStatics3;
+
+  interface IBackgroundTask {
+    Run(taskInstance: Windows.ApplicationModel.Background.IBackgroundTaskInstance): void;
+  }
+  var IBackgroundTask: abstract new (...args: any[]) => IBackgroundTask;
+
+  interface IBackgroundTaskBuilder {
+    AddCondition(condition: Windows.ApplicationModel.Background.IBackgroundCondition): void;
+    Register(): Windows.ApplicationModel.Background.BackgroundTaskRegistration;
+    SetTrigger(trigger: Windows.ApplicationModel.Background.IBackgroundTrigger): void;
+    Name: string;
+    TaskEntryPoint: string;
+  }
+  var IBackgroundTaskBuilder: abstract new (...args: any[]) => IBackgroundTaskBuilder;
+
+  interface IBackgroundTaskBuilder2 {
+    CancelOnConditionLoss: boolean;
+  }
+  var IBackgroundTaskBuilder2: abstract new (...args: any[]) => IBackgroundTaskBuilder2;
+
+  interface IBackgroundTaskBuilder3 {
+    IsNetworkRequested: boolean;
+  }
+  var IBackgroundTaskBuilder3: abstract new (...args: any[]) => IBackgroundTaskBuilder3;
+
+  interface IBackgroundTaskBuilder4 {
+    TaskGroup: Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup;
+  }
+  var IBackgroundTaskBuilder4: abstract new (...args: any[]) => IBackgroundTaskBuilder4;
+
+  interface IBackgroundTaskBuilder5 {
+    SetTaskEntryPointClsid(TaskEntryPoint: Guid): void;
+  }
+  var IBackgroundTaskBuilder5: abstract new (...args: any[]) => IBackgroundTaskBuilder5;
+
+  interface IBackgroundTaskBuilder6 {
+    Register(taskName: string): Windows.ApplicationModel.Background.BackgroundTaskRegistration;
+    Validate(): boolean;
+    AllowRunningTaskInStandby: boolean;
+  }
+  var IBackgroundTaskBuilder6: abstract new (...args: any[]) => IBackgroundTaskBuilder6;
+
+  interface IBackgroundTaskBuilderStatics {
+    readonly IsRunningTaskInStandbySupported: boolean;
+  }
+  var IBackgroundTaskBuilderStatics: abstract new (...args: any[]) => IBackgroundTaskBuilderStatics;
+
+  interface IBackgroundTaskCompletedEventArgs {
+    CheckResult(): void;
+    readonly InstanceId: Guid;
+  }
+  var IBackgroundTaskCompletedEventArgs: abstract new (...args: any[]) => IBackgroundTaskCompletedEventArgs;
+
+  interface IBackgroundTaskDeferral {
+    Complete(): void;
+  }
+  var IBackgroundTaskDeferral: abstract new (...args: any[]) => IBackgroundTaskDeferral;
+
+  interface IBackgroundTaskInstance {
+    GetDeferral(): Windows.ApplicationModel.Background.BackgroundTaskDeferral;
+    readonly InstanceId: Guid;
+    Progress: number;
+    readonly SuspendedCount: number;
+    readonly Task: Windows.ApplicationModel.Background.BackgroundTaskRegistration;
+    readonly TriggerDetails: Object;
+    Canceled: Windows.ApplicationModel.Background.BackgroundTaskCanceledEventHandler | null;
+  }
+  var IBackgroundTaskInstance: abstract new (...args: any[]) => IBackgroundTaskInstance;
+
+  interface IBackgroundTaskInstance2 extends Windows.ApplicationModel.Background.IBackgroundTaskInstance {
+    GetDeferral(): Windows.ApplicationModel.Background.BackgroundTaskDeferral;
+    GetThrottleCount(counter: number): number;
+  }
+  var IBackgroundTaskInstance2: abstract new (...args: any[]) => IBackgroundTaskInstance2;
+
+  interface IBackgroundTaskInstance4 extends Windows.ApplicationModel.Background.IBackgroundTaskInstance {
+    GetDeferral(): Windows.ApplicationModel.Background.BackgroundTaskDeferral;
+    readonly User: Windows.System.User;
+  }
+  var IBackgroundTaskInstance4: abstract new (...args: any[]) => IBackgroundTaskInstance4;
+
+  interface IBackgroundTaskProgressEventArgs {
+    readonly InstanceId: Guid;
+    readonly Progress: number;
+  }
+  var IBackgroundTaskProgressEventArgs: abstract new (...args: any[]) => IBackgroundTaskProgressEventArgs;
+
+  interface IBackgroundTaskRegistration {
+    Unregister(cancelTask: boolean): void;
+    readonly Name: string;
+    readonly TaskId: Guid;
+    Completed: Windows.ApplicationModel.Background.BackgroundTaskCompletedEventHandler | null;
+    Progress: Windows.ApplicationModel.Background.BackgroundTaskProgressEventHandler | null;
+  }
+  var IBackgroundTaskRegistration: abstract new (...args: any[]) => IBackgroundTaskRegistration;
+
+  interface IBackgroundTaskRegistration2 extends Windows.ApplicationModel.Background.IBackgroundTaskRegistration {
+    Unregister(cancelTask: boolean): void;
+    readonly Trigger: Windows.ApplicationModel.Background.IBackgroundTrigger;
+  }
+  var IBackgroundTaskRegistration2: abstract new (...args: any[]) => IBackgroundTaskRegistration2;
+
+  interface IBackgroundTaskRegistration3 extends Windows.ApplicationModel.Background.IBackgroundTaskRegistration {
+    Unregister(cancelTask: boolean): void;
+    readonly TaskGroup: Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup;
+  }
+  var IBackgroundTaskRegistration3: abstract new (...args: any[]) => IBackgroundTaskRegistration3;
+
+  interface IBackgroundTaskRegistration4 {
+    readonly AppEnergyUsePredictionContribution: number;
+    readonly TaskLastThrottledInStandbyTimestamp: Windows.Foundation.DateTime;
+  }
+  var IBackgroundTaskRegistration4: abstract new (...args: any[]) => IBackgroundTaskRegistration4;
+
+  interface IBackgroundTaskRegistrationGroup {
+    readonly AllTasks: Windows.Foundation.Collections.IMapView<Guid, Windows.ApplicationModel.Background.BackgroundTaskRegistration>;
+    readonly Id: string;
+    readonly Name: string;
+    BackgroundActivated: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup, Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs> | null;
+  }
+  var IBackgroundTaskRegistrationGroup: abstract new (...args: any[]) => IBackgroundTaskRegistrationGroup;
+
+  interface IBackgroundTaskRegistrationGroupFactory {
+    Create(id: string): Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup;
+    CreateWithName(id: string, name: string): Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup;
+  }
+  var IBackgroundTaskRegistrationGroupFactory: abstract new (...args: any[]) => IBackgroundTaskRegistrationGroupFactory;
+
+  interface IBackgroundTaskRegistrationStatics {
+    readonly AllTasks: Windows.Foundation.Collections.IMapView<Guid, Windows.ApplicationModel.Background.IBackgroundTaskRegistration>;
+  }
+  var IBackgroundTaskRegistrationStatics: abstract new (...args: any[]) => IBackgroundTaskRegistrationStatics;
+
+  interface IBackgroundTaskRegistrationStatics2 {
+    GetTaskGroup(groupId: string): Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup;
+    readonly AllTaskGroups: Windows.Foundation.Collections.IMapView<string, Windows.ApplicationModel.Background.BackgroundTaskRegistrationGroup>;
+  }
+  var IBackgroundTaskRegistrationStatics2: abstract new (...args: any[]) => IBackgroundTaskRegistrationStatics2;
+
+  interface IBackgroundTrigger {
+  }
+  var IBackgroundTrigger: abstract new (...args: any[]) => IBackgroundTrigger;
+
+  interface IBackgroundWorkCostStatics {
+    readonly CurrentBackgroundWorkCost: number;
+  }
+  var IBackgroundWorkCostStatics: abstract new (...args: any[]) => IBackgroundWorkCostStatics;
+
+  interface IBackgroundWorkCostStatics2 {
+    readonly AppEnergyUseLevel: number;
+    readonly AppEnergyUsePrediction: number;
+    readonly AppLastThrottledInStandbyTimestamp: Windows.Foundation.DateTime;
+  }
+  var IBackgroundWorkCostStatics2: abstract new (...args: any[]) => IBackgroundWorkCostStatics2;
+
+  interface IBluetoothLEAdvertisementPublisherTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    readonly Advertisement: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisement;
+  }
+  var IBluetoothLEAdvertisementPublisherTrigger: abstract new (...args: any[]) => IBluetoothLEAdvertisementPublisherTrigger;
+
+  interface IBluetoothLEAdvertisementPublisherTrigger2 {
+    IncludeTransmitPowerLevel: boolean;
+    IsAnonymous: boolean;
+    PreferredTransmitPowerLevelInDBm: number | null;
+    UseExtendedFormat: boolean;
+  }
+  var IBluetoothLEAdvertisementPublisherTrigger2: abstract new (...args: any[]) => IBluetoothLEAdvertisementPublisherTrigger2;
+
+  interface IBluetoothLEAdvertisementPublisherTrigger3 {
+    PrimaryPhy: number;
+    SecondaryPhy: number;
+  }
+  var IBluetoothLEAdvertisementPublisherTrigger3: abstract new (...args: any[]) => IBluetoothLEAdvertisementPublisherTrigger3;
+
+  interface IBluetoothLEAdvertisementWatcherTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    AdvertisementFilter: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementFilter;
+    readonly MaxOutOfRangeTimeout: Windows.Foundation.TimeSpan;
+    readonly MaxSamplingInterval: Windows.Foundation.TimeSpan;
+    readonly MinOutOfRangeTimeout: Windows.Foundation.TimeSpan;
+    readonly MinSamplingInterval: Windows.Foundation.TimeSpan;
+    SignalStrengthFilter: Windows.Devices.Bluetooth.BluetoothSignalStrengthFilter;
+  }
+  var IBluetoothLEAdvertisementWatcherTrigger: abstract new (...args: any[]) => IBluetoothLEAdvertisementWatcherTrigger;
+
+  interface IBluetoothLEAdvertisementWatcherTrigger2 {
+    AllowExtendedAdvertisements: boolean;
+  }
+  var IBluetoothLEAdvertisementWatcherTrigger2: abstract new (...args: any[]) => IBluetoothLEAdvertisementWatcherTrigger2;
+
+  interface IBluetoothLEAdvertisementWatcherTrigger3 {
+    ScanParameters: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementScanParameters;
+    UseCodedPhy: boolean;
+    UseUncoded1MPhy: boolean;
+  }
+  var IBluetoothLEAdvertisementWatcherTrigger3: abstract new (...args: any[]) => IBluetoothLEAdvertisementWatcherTrigger3;
+
+  interface ICachedFileUpdaterTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+  }
+  var ICachedFileUpdaterTrigger: abstract new (...args: any[]) => ICachedFileUpdaterTrigger;
+
+  interface ICachedFileUpdaterTriggerDetails {
+    readonly CanRequestUserInput: boolean;
+    readonly UpdateRequest: Windows.Storage.Provider.FileUpdateRequest;
+    readonly UpdateTarget: number;
+  }
+  var ICachedFileUpdaterTriggerDetails: abstract new (...args: any[]) => ICachedFileUpdaterTriggerDetails;
+
+  interface IChatMessageNotificationTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+  }
+  var IChatMessageNotificationTrigger: abstract new (...args: any[]) => IChatMessageNotificationTrigger;
+
+  interface IChatMessageReceivedNotificationTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+  }
+  var IChatMessageReceivedNotificationTrigger: abstract new (...args: any[]) => IChatMessageReceivedNotificationTrigger;
+
+  interface ICommunicationBlockingAppSetAsActiveTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+  }
+  var ICommunicationBlockingAppSetAsActiveTrigger: abstract new (...args: any[]) => ICommunicationBlockingAppSetAsActiveTrigger;
+
+  interface IContactStoreNotificationTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+  }
+  var IContactStoreNotificationTrigger: abstract new (...args: any[]) => IContactStoreNotificationTrigger;
+
+  interface IContentPrefetchTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    readonly WaitInterval: Windows.Foundation.TimeSpan;
+  }
+  var IContentPrefetchTrigger: abstract new (...args: any[]) => IContentPrefetchTrigger;
+
+  interface IContentPrefetchTriggerFactory {
+    Create(waitInterval: Windows.Foundation.TimeSpan): Windows.ApplicationModel.Background.ContentPrefetchTrigger;
+  }
+  var IContentPrefetchTriggerFactory: abstract new (...args: any[]) => IContentPrefetchTriggerFactory;
+
+  interface ICustomSystemEventTrigger {
+    readonly Recurrence: number;
+    readonly TriggerId: string;
+  }
+  var ICustomSystemEventTrigger: abstract new (...args: any[]) => ICustomSystemEventTrigger;
+
+  interface ICustomSystemEventTriggerFactory {
+    Create(triggerId: string, recurrence: number): Windows.ApplicationModel.Background.CustomSystemEventTrigger;
+  }
+  var ICustomSystemEventTriggerFactory: abstract new (...args: any[]) => ICustomSystemEventTriggerFactory;
+
+  interface IDeviceConnectionChangeTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    readonly CanMaintainConnection: boolean;
+    readonly DeviceId: string;
+    MaintainConnection: boolean;
+  }
+  var IDeviceConnectionChangeTrigger: abstract new (...args: any[]) => IDeviceConnectionChangeTrigger;
+
+  interface IDeviceConnectionChangeTriggerStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Background.DeviceConnectionChangeTrigger>;
+  }
+  var IDeviceConnectionChangeTriggerStatics: abstract new (...args: any[]) => IDeviceConnectionChangeTriggerStatics;
+
+  interface IDeviceManufacturerNotificationTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    readonly OneShot: boolean;
+    readonly TriggerQualifier: string;
+  }
+  var IDeviceManufacturerNotificationTrigger: abstract new (...args: any[]) => IDeviceManufacturerNotificationTrigger;
+
+  interface IDeviceManufacturerNotificationTriggerFactory {
+    Create(triggerQualifier: string, oneShot: boolean): Windows.ApplicationModel.Background.DeviceManufacturerNotificationTrigger;
+  }
+  var IDeviceManufacturerNotificationTriggerFactory: abstract new (...args: any[]) => IDeviceManufacturerNotificationTriggerFactory;
+
+  interface IDeviceServicingTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    RequestAsync(deviceId: string, expectedDuration: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<number>;
+    RequestAsync(deviceId: string, expectedDuration: Windows.Foundation.TimeSpan, arguments_: string): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IDeviceServicingTrigger: abstract new (...args: any[]) => IDeviceServicingTrigger;
+
+  interface IDeviceUseTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    RequestAsync(deviceId: string): Windows.Foundation.IAsyncOperation<number>;
+    RequestAsync(deviceId: string, arguments_: string): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IDeviceUseTrigger: abstract new (...args: any[]) => IDeviceUseTrigger;
+
+  interface IDeviceWatcherTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+  }
+  var IDeviceWatcherTrigger: abstract new (...args: any[]) => IDeviceWatcherTrigger;
+
+  interface IEmailStoreNotificationTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+  }
+  var IEmailStoreNotificationTrigger: abstract new (...args: any[]) => IEmailStoreNotificationTrigger;
+
+  interface IGattCharacteristicNotificationTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    readonly Characteristic: Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic;
+  }
+  var IGattCharacteristicNotificationTrigger: abstract new (...args: any[]) => IGattCharacteristicNotificationTrigger;
+
+  interface IGattCharacteristicNotificationTrigger2 {
+    readonly EventTriggeringMode: number;
+  }
+  var IGattCharacteristicNotificationTrigger2: abstract new (...args: any[]) => IGattCharacteristicNotificationTrigger2;
+
+  interface IGattCharacteristicNotificationTriggerFactory {
+    Create(characteristic: Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic): Windows.ApplicationModel.Background.GattCharacteristicNotificationTrigger;
+  }
+  var IGattCharacteristicNotificationTriggerFactory: abstract new (...args: any[]) => IGattCharacteristicNotificationTriggerFactory;
+
+  interface IGattCharacteristicNotificationTriggerFactory2 {
+    Create(characteristic: Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic, eventTriggeringMode: number): Windows.ApplicationModel.Background.GattCharacteristicNotificationTrigger;
+  }
+  var IGattCharacteristicNotificationTriggerFactory2: abstract new (...args: any[]) => IGattCharacteristicNotificationTriggerFactory2;
+
+  interface IGattServiceProviderTrigger {
+    AdvertisingParameters: Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisingParameters;
+    readonly Service: Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalService;
+    readonly TriggerId: string;
+  }
+  var IGattServiceProviderTrigger: abstract new (...args: any[]) => IGattServiceProviderTrigger;
+
+  interface IGattServiceProviderTriggerResult {
+    readonly Error: number;
+    readonly Trigger: Windows.ApplicationModel.Background.GattServiceProviderTrigger;
+  }
+  var IGattServiceProviderTriggerResult: abstract new (...args: any[]) => IGattServiceProviderTriggerResult;
+
+  interface IGattServiceProviderTriggerStatics {
+    CreateAsync(triggerId: string, serviceUuid: Guid): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Background.GattServiceProviderTriggerResult>;
+  }
+  var IGattServiceProviderTriggerStatics: abstract new (...args: any[]) => IGattServiceProviderTriggerStatics;
+
+  interface IGeovisitTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    MonitoringScope: number;
+  }
+  var IGeovisitTrigger: abstract new (...args: any[]) => IGeovisitTrigger;
+
+  interface ILocationTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    readonly TriggerType: number;
+  }
+  var ILocationTrigger: abstract new (...args: any[]) => ILocationTrigger;
+
+  interface ILocationTriggerFactory {
+    Create(triggerType: number): Windows.ApplicationModel.Background.LocationTrigger;
+  }
+  var ILocationTriggerFactory: abstract new (...args: any[]) => ILocationTriggerFactory;
+
+  interface IMaintenanceTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    readonly FreshnessTime: number;
+    readonly OneShot: boolean;
+  }
+  var IMaintenanceTrigger: abstract new (...args: any[]) => IMaintenanceTrigger;
+
+  interface IMaintenanceTriggerFactory {
+    Create(freshnessTime: number, oneShot: boolean): Windows.ApplicationModel.Background.MaintenanceTrigger;
+  }
+  var IMaintenanceTriggerFactory: abstract new (...args: any[]) => IMaintenanceTriggerFactory;
+
+  interface IMediaProcessingTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    RequestAsync(): Windows.Foundation.IAsyncOperation<number>;
+    RequestAsync(arguments_: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IMediaProcessingTrigger: abstract new (...args: any[]) => IMediaProcessingTrigger;
+
+  interface INetworkOperatorHotspotAuthenticationTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+  }
+  var INetworkOperatorHotspotAuthenticationTrigger: abstract new (...args: any[]) => INetworkOperatorHotspotAuthenticationTrigger;
+
+  interface INetworkOperatorNotificationTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    readonly NetworkAccountId: string;
+  }
+  var INetworkOperatorNotificationTrigger: abstract new (...args: any[]) => INetworkOperatorNotificationTrigger;
+
+  interface INetworkOperatorNotificationTriggerFactory {
+    Create(networkAccountId: string): Windows.ApplicationModel.Background.NetworkOperatorNotificationTrigger;
+  }
+  var INetworkOperatorNotificationTriggerFactory: abstract new (...args: any[]) => INetworkOperatorNotificationTriggerFactory;
+
+  interface IPhoneTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    readonly OneShot: boolean;
+    readonly TriggerType: number;
+  }
+  var IPhoneTrigger: abstract new (...args: any[]) => IPhoneTrigger;
+
+  interface IPhoneTriggerFactory {
+    Create(type: number, oneShot: boolean): Windows.ApplicationModel.Background.PhoneTrigger;
+  }
+  var IPhoneTriggerFactory: abstract new (...args: any[]) => IPhoneTriggerFactory;
+
+  interface IPushNotificationTriggerFactory {
+    Create(applicationId: string): Windows.ApplicationModel.Background.PushNotificationTrigger;
+  }
+  var IPushNotificationTriggerFactory: abstract new (...args: any[]) => IPushNotificationTriggerFactory;
+
+  interface IRcsEndUserMessageAvailableTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+  }
+  var IRcsEndUserMessageAvailableTrigger: abstract new (...args: any[]) => IRcsEndUserMessageAvailableTrigger;
+
+  interface IRfcommConnectionTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    AllowMultipleConnections: boolean;
+    readonly InboundConnection: Windows.Devices.Bluetooth.Background.RfcommInboundConnectionInformation;
+    readonly OutboundConnection: Windows.Devices.Bluetooth.Background.RfcommOutboundConnectionInformation;
+    ProtectionLevel: number;
+    RemoteHostName: Windows.Networking.HostName;
+  }
+  var IRfcommConnectionTrigger: abstract new (...args: any[]) => IRfcommConnectionTrigger;
+
+  interface ISecondaryAuthenticationFactorAuthenticationTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+  }
+  var ISecondaryAuthenticationFactorAuthenticationTrigger: abstract new (...args: any[]) => ISecondaryAuthenticationFactorAuthenticationTrigger;
+
+  interface ISensorDataThresholdTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+  }
+  var ISensorDataThresholdTrigger: abstract new (...args: any[]) => ISensorDataThresholdTrigger;
+
+  interface ISensorDataThresholdTriggerFactory {
+    Create(threshold: Windows.Devices.Sensors.ISensorDataThreshold): Windows.ApplicationModel.Background.SensorDataThresholdTrigger;
+  }
+  var ISensorDataThresholdTriggerFactory: abstract new (...args: any[]) => ISensorDataThresholdTriggerFactory;
+
+  interface ISmartCardTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    readonly TriggerType: number;
+  }
+  var ISmartCardTrigger: abstract new (...args: any[]) => ISmartCardTrigger;
+
+  interface ISmartCardTriggerFactory {
+    Create(triggerType: number): Windows.ApplicationModel.Background.SmartCardTrigger;
+  }
+  var ISmartCardTriggerFactory: abstract new (...args: any[]) => ISmartCardTriggerFactory;
+
+  interface ISmsMessageReceivedTriggerFactory {
+    Create(filterRules: Windows.Devices.Sms.SmsFilterRules): Windows.ApplicationModel.Background.SmsMessageReceivedTrigger;
+  }
+  var ISmsMessageReceivedTriggerFactory: abstract new (...args: any[]) => ISmsMessageReceivedTriggerFactory;
+
+  interface ISocketActivityTrigger {
+    readonly IsWakeFromLowPowerSupported: boolean;
+  }
+  var ISocketActivityTrigger: abstract new (...args: any[]) => ISocketActivityTrigger;
+
+  interface IStorageLibraryChangeTrackerTriggerFactory {
+    Create(tracker: Windows.Storage.StorageLibraryChangeTracker): Windows.ApplicationModel.Background.StorageLibraryChangeTrackerTrigger;
+  }
+  var IStorageLibraryChangeTrackerTriggerFactory: abstract new (...args: any[]) => IStorageLibraryChangeTrackerTriggerFactory;
+
+  interface IStorageLibraryContentChangedTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+  }
+  var IStorageLibraryContentChangedTrigger: abstract new (...args: any[]) => IStorageLibraryContentChangedTrigger;
+
+  interface IStorageLibraryContentChangedTriggerStatics {
+    Create(storageLibrary: Windows.Storage.StorageLibrary): Windows.ApplicationModel.Background.StorageLibraryContentChangedTrigger;
+    CreateFromLibraries(storageLibraries: Windows.Foundation.Collections.IIterable<Windows.Storage.StorageLibrary> | Windows.Storage.StorageLibrary[]): Windows.ApplicationModel.Background.StorageLibraryContentChangedTrigger;
+  }
+  var IStorageLibraryContentChangedTriggerStatics: abstract new (...args: any[]) => IStorageLibraryContentChangedTriggerStatics;
+
+  interface ISystemCondition extends Windows.ApplicationModel.Background.IBackgroundCondition {
+    readonly ConditionType: number;
+  }
+  var ISystemCondition: abstract new (...args: any[]) => ISystemCondition;
+
+  interface ISystemConditionFactory {
+    Create(conditionType: number): Windows.ApplicationModel.Background.SystemCondition;
+  }
+  var ISystemConditionFactory: abstract new (...args: any[]) => ISystemConditionFactory;
+
+  interface ISystemTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    readonly OneShot: boolean;
+    readonly TriggerType: number;
+  }
+  var ISystemTrigger: abstract new (...args: any[]) => ISystemTrigger;
+
+  interface ISystemTriggerFactory {
+    Create(triggerType: number, oneShot: boolean): Windows.ApplicationModel.Background.SystemTrigger;
+  }
+  var ISystemTriggerFactory: abstract new (...args: any[]) => ISystemTriggerFactory;
+
+  interface ITimeTrigger extends Windows.ApplicationModel.Background.IBackgroundTrigger {
+    readonly FreshnessTime: number;
+    readonly OneShot: boolean;
+  }
+  var ITimeTrigger: abstract new (...args: any[]) => ITimeTrigger;
+
+  interface ITimeTriggerFactory {
+    Create(freshnessTime: number, oneShot: boolean): Windows.ApplicationModel.Background.TimeTrigger;
+  }
+  var ITimeTriggerFactory: abstract new (...args: any[]) => ITimeTriggerFactory;
+
+  interface IToastNotificationActionTriggerFactory {
+    Create(applicationId: string): Windows.ApplicationModel.Background.ToastNotificationActionTrigger;
+  }
+  var IToastNotificationActionTriggerFactory: abstract new (...args: any[]) => IToastNotificationActionTriggerFactory;
+
+  interface IToastNotificationHistoryChangedTriggerFactory {
+    Create(applicationId: string): Windows.ApplicationModel.Background.ToastNotificationHistoryChangedTrigger;
+  }
+  var IToastNotificationHistoryChangedTriggerFactory: abstract new (...args: any[]) => IToastNotificationHistoryChangedTriggerFactory;
+
+  interface IUserNotificationChangedTriggerFactory {
+    Create(notificationKinds: number): Windows.ApplicationModel.Background.UserNotificationChangedTrigger;
+  }
+  var IUserNotificationChangedTriggerFactory: abstract new (...args: any[]) => IUserNotificationChangedTriggerFactory;
+
+}
+
+declare namespace Windows.ApplicationModel.Calls {
+  class AcceptedVoipPhoneCallOptions implements Windows.ApplicationModel.Calls.IAcceptedVoipPhoneCallOptions {
+    constructor(associatedDeviceIds: Windows.Foundation.Collections.IIterable<string> | string[]);
+    constructor();
+    readonly AssociatedDeviceIds: Windows.Foundation.Collections.IVector<string> | string[];
+    ContactName: string;
+    ContactNumber: string;
+    Context: string;
+    Media: number;
+    ServiceName: string;
+  }
+
+  class AppInitiatedVoipPhoneCallOptions implements Windows.ApplicationModel.Calls.IAppInitiatedVoipPhoneCallOptions {
+    constructor(associatedDeviceIds: Windows.Foundation.Collections.IIterable<string> | string[]);
+    constructor();
+    readonly AssociatedDeviceIds: Windows.Foundation.Collections.IVector<string> | string[];
+    ContactName: string;
+    ContactNumber: string;
+    Context: string;
+    Media: number;
+    ServiceName: string;
+  }
+
+  class CallAnswerEventArgs implements Windows.ApplicationModel.Calls.ICallAnswerEventArgs, Windows.ApplicationModel.Calls.ICallAnswerEventArgs2 {
+    readonly AcceptedMedia: number;
+    readonly SourceDeviceId: string;
+  }
+
+  class CallRejectEventArgs implements Windows.ApplicationModel.Calls.ICallRejectEventArgs {
+    readonly RejectReason: number;
+  }
+
+  class CallStateChangeEventArgs implements Windows.ApplicationModel.Calls.ICallStateChangeEventArgs {
+    readonly State: number;
+  }
+
+  class IncomingVoipPhoneCallOptions implements Windows.ApplicationModel.Calls.IIncomingVoipPhoneCallOptions {
+    constructor(associatedDeviceIds: Windows.Foundation.Collections.IIterable<string> | string[]);
+    constructor();
+    readonly AssociatedDeviceIds: Windows.Foundation.Collections.IVector<string> | string[];
+    BrandingImage: Windows.Foundation.Uri;
+    CallDetails: string;
+    ContactImage: Windows.Foundation.Uri;
+    ContactName: string;
+    ContactNumber: string;
+    ContactRemoteId: string;
+    Context: string;
+    Media: number;
+    RingTimeout: Windows.Foundation.TimeSpan;
+    Ringtone: Windows.Foundation.Uri;
+    ServiceName: string;
+  }
+
+  class LockScreenCallEndCallDeferral implements Windows.ApplicationModel.Calls.ILockScreenCallEndCallDeferral {
+    Complete(): void;
+  }
+
+  class LockScreenCallEndRequestedEventArgs implements Windows.ApplicationModel.Calls.ILockScreenCallEndRequestedEventArgs {
+    GetDeferral(): Windows.ApplicationModel.Calls.LockScreenCallEndCallDeferral;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+
+  class LockScreenCallUI implements Windows.ApplicationModel.Calls.ILockScreenCallUI {
+    Dismiss(): void;
+    CallTitle: string;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.LockScreenCallUI, Object> | null;
+    EndRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.LockScreenCallUI, Windows.ApplicationModel.Calls.LockScreenCallEndRequestedEventArgs> | null;
+  }
+
+  class MuteChangeEventArgs implements Windows.ApplicationModel.Calls.IMuteChangeEventArgs {
+    readonly Muted: boolean;
+  }
+
+  class OutgoingVoipPhoneCallOptions implements Windows.ApplicationModel.Calls.IOutgoingVoipPhoneCallOptions {
+    constructor(associatedDeviceIds: Windows.Foundation.Collections.IIterable<string> | string[]);
+    constructor();
+    readonly AssociatedDeviceIds: Windows.Foundation.Collections.IVector<string> | string[];
+    ContactName: string;
+    Context: string;
+    Media: number;
+    ServiceName: string;
+  }
+
+  class PhoneCall implements Windows.ApplicationModel.Calls.IPhoneCall {
+    AcceptIncoming(): number;
+    AcceptIncomingAsync(): Windows.Foundation.IAsyncOperation<number>;
+    ChangeAudioDevice(endpoint: number): number;
+    ChangeAudioDeviceAsync(endpoint: number): Windows.Foundation.IAsyncOperation<number>;
+    End(): number;
+    EndAsync(): Windows.Foundation.IAsyncOperation<number>;
+    static GetFromId(callId: string): Windows.ApplicationModel.Calls.PhoneCall;
+    GetPhoneCallInfo(): Windows.ApplicationModel.Calls.PhoneCallInfo;
+    GetPhoneCallInfoAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Calls.PhoneCallInfo>;
+    Hold(): number;
+    HoldAsync(): Windows.Foundation.IAsyncOperation<number>;
+    Mute(): number;
+    MuteAsync(): Windows.Foundation.IAsyncOperation<number>;
+    RejectIncoming(): number;
+    RejectIncomingAsync(): Windows.Foundation.IAsyncOperation<number>;
+    ResumeFromHold(): number;
+    ResumeFromHoldAsync(): Windows.Foundation.IAsyncOperation<number>;
+    SendDtmfKey(key: number, dtmfToneAudioPlayback: number): number;
+    SendDtmfKeyAsync(key: number, dtmfToneAudioPlayback: number): Windows.Foundation.IAsyncOperation<number>;
+    Unmute(): number;
+    UnmuteAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly AudioDevice: number;
+    readonly CallId: string;
+    readonly IsMuted: boolean;
+    readonly Status: number;
+    AudioDeviceChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneCall, Object> | null;
+    IsMutedChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneCall, Object> | null;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneCall, Object> | null;
+  }
+
+  class PhoneCallBlocking {
+    static SetCallBlockingListAsync(phoneNumberList: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<boolean>;
+    static BlockPrivateNumbers: boolean;
+    static BlockUnknownNumbers: boolean;
+  }
+
+  class PhoneCallHistoryEntry implements Windows.ApplicationModel.Calls.IPhoneCallHistoryEntry {
+    constructor();
+    Address: Windows.ApplicationModel.Calls.PhoneCallHistoryEntryAddress;
+    Duration: Windows.Foundation.TimeSpan | null;
+    readonly Id: string;
+    IsCallerIdBlocked: boolean;
+    IsEmergency: boolean;
+    IsIncoming: boolean;
+    IsMissed: boolean;
+    IsRinging: boolean;
+    IsSeen: boolean;
+    IsSuppressed: boolean;
+    IsVoicemail: boolean;
+    Media: number;
+    OtherAppReadAccess: number;
+    RemoteId: string;
+    readonly SourceDisplayName: string;
+    SourceId: string;
+    SourceIdKind: number;
+    StartTime: Windows.Foundation.DateTime;
+  }
+
+  class PhoneCallHistoryEntryAddress implements Windows.ApplicationModel.Calls.IPhoneCallHistoryEntryAddress {
+    constructor(rawAddress: string, rawAddressKind: number);
+    constructor();
+    ContactId: string;
+    DisplayName: string;
+    RawAddress: string;
+    RawAddressKind: number;
+  }
+
+  class PhoneCallHistoryEntryQueryOptions implements Windows.ApplicationModel.Calls.IPhoneCallHistoryEntryQueryOptions {
+    constructor();
+    DesiredMedia: number;
+    readonly SourceIds: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+
+  class PhoneCallHistoryEntryReader implements Windows.ApplicationModel.Calls.IPhoneCallHistoryEntryReader {
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Calls.PhoneCallHistoryEntry> | Windows.ApplicationModel.Calls.PhoneCallHistoryEntry[]>;
+  }
+
+  class PhoneCallHistoryManager {
+    static GetForUser(user: Windows.System.User): Windows.ApplicationModel.Calls.PhoneCallHistoryManagerForUser;
+    static RequestStoreAsync(accessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Calls.PhoneCallHistoryStore>;
+  }
+
+  class PhoneCallHistoryManagerForUser implements Windows.ApplicationModel.Calls.IPhoneCallHistoryManagerForUser {
+    RequestStoreAsync(accessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Calls.PhoneCallHistoryStore>;
+    readonly User: Windows.System.User;
+  }
+
+  class PhoneCallHistoryStore implements Windows.ApplicationModel.Calls.IPhoneCallHistoryStore {
+    DeleteEntriesAsync(callHistoryEntries: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Calls.PhoneCallHistoryEntry> | Windows.ApplicationModel.Calls.PhoneCallHistoryEntry[]): Windows.Foundation.IAsyncAction;
+    DeleteEntryAsync(callHistoryEntry: Windows.ApplicationModel.Calls.PhoneCallHistoryEntry): Windows.Foundation.IAsyncAction;
+    GetEntryAsync(callHistoryEntryId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Calls.PhoneCallHistoryEntry>;
+    GetEntryReader(): Windows.ApplicationModel.Calls.PhoneCallHistoryEntryReader;
+    GetEntryReader(queryOptions: Windows.ApplicationModel.Calls.PhoneCallHistoryEntryQueryOptions): Windows.ApplicationModel.Calls.PhoneCallHistoryEntryReader;
+    GetSourcesUnseenCountAsync(sourceIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<number>;
+    GetUnseenCountAsync(): Windows.Foundation.IAsyncOperation<number>;
+    MarkAllAsSeenAsync(): Windows.Foundation.IAsyncAction;
+    MarkEntriesAsSeenAsync(callHistoryEntries: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Calls.PhoneCallHistoryEntry> | Windows.ApplicationModel.Calls.PhoneCallHistoryEntry[]): Windows.Foundation.IAsyncAction;
+    MarkEntryAsSeenAsync(callHistoryEntry: Windows.ApplicationModel.Calls.PhoneCallHistoryEntry): Windows.Foundation.IAsyncAction;
+    MarkSourcesAsSeenAsync(sourceIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    SaveEntryAsync(callHistoryEntry: Windows.ApplicationModel.Calls.PhoneCallHistoryEntry): Windows.Foundation.IAsyncAction;
+  }
+
+  class PhoneCallInfo implements Windows.ApplicationModel.Calls.IPhoneCallInfo {
+    readonly CallDirection: number;
+    readonly DisplayName: string;
+    readonly IsHoldSupported: boolean;
+    readonly LineId: Guid;
+    readonly PhoneNumber: string;
+    readonly StartTime: Windows.Foundation.DateTime;
+  }
+
+  class PhoneCallManager {
+    static RequestStoreAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Calls.PhoneCallStore>;
+    static ShowPhoneCallSettingsUI(): void;
+    static ShowPhoneCallUI(phoneNumber: string, displayName: string): void;
+    static readonly IsCallActive: boolean;
+    static readonly IsCallIncoming: boolean;
+    static CallStateChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class PhoneCallStore implements Windows.ApplicationModel.Calls.IPhoneCallStore {
+    GetDefaultLineAsync(): Windows.Foundation.IAsyncOperation<Guid>;
+    IsEmergencyPhoneNumberAsync(number: string): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestLineWatcher(): Windows.ApplicationModel.Calls.PhoneLineWatcher;
+  }
+
+  class PhoneCallVideoCapabilities implements Windows.ApplicationModel.Calls.IPhoneCallVideoCapabilities {
+    readonly IsVideoCallingCapable: boolean;
+  }
+
+  class PhoneCallVideoCapabilitiesManager {
+    static GetCapabilitiesAsync(phoneNumber: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Calls.PhoneCallVideoCapabilities>;
+  }
+
+  class PhoneCallsResult implements Windows.ApplicationModel.Calls.IPhoneCallsResult {
+    readonly AllActivePhoneCalls: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Calls.PhoneCall> | Windows.ApplicationModel.Calls.PhoneCall[];
+    readonly OperationStatus: number;
+  }
+
+  class PhoneDialOptions implements Windows.ApplicationModel.Calls.IPhoneDialOptions {
+    constructor();
+    AudioEndpoint: number;
+    Contact: Windows.ApplicationModel.Contacts.Contact;
+    ContactPhone: Windows.ApplicationModel.Contacts.ContactPhone;
+    DisplayName: string;
+    Media: number;
+    Number: string;
+  }
+
+  class PhoneLine implements Windows.ApplicationModel.Calls.IPhoneLine, Windows.ApplicationModel.Calls.IPhoneLine2, Windows.ApplicationModel.Calls.IPhoneLine3 {
+    Dial(number: string, displayName: string): void;
+    DialWithOptions(options: Windows.ApplicationModel.Calls.PhoneDialOptions): void;
+    DialWithResult(number: string, displayName: string): Windows.ApplicationModel.Calls.PhoneLineDialResult;
+    DialWithResultAsync(number: string, displayName: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Calls.PhoneLineDialResult>;
+    EnableTextReply(value: boolean): void;
+    static FromIdAsync(lineId: Guid): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Calls.PhoneLine>;
+    GetAllActivePhoneCalls(): Windows.ApplicationModel.Calls.PhoneCallsResult;
+    GetAllActivePhoneCallsAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Calls.PhoneCallsResult>;
+    IsImmediateDialNumberAsync(number: string): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly CanDial: boolean;
+    readonly CellularDetails: Windows.ApplicationModel.Calls.PhoneLineCellularDetails;
+    readonly DisplayColor: Windows.UI.Color;
+    readonly DisplayName: string;
+    readonly Id: Guid;
+    readonly LineConfiguration: Windows.ApplicationModel.Calls.PhoneLineConfiguration;
+    readonly NetworkName: string;
+    readonly NetworkState: number;
+    readonly SupportsTile: boolean;
+    readonly Transport: number;
+    readonly TransportDeviceId: string;
+    readonly VideoCallingCapabilities: Windows.ApplicationModel.Calls.PhoneCallVideoCapabilities;
+    readonly Voicemail: Windows.ApplicationModel.Calls.PhoneVoicemail;
+    LineChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneLine, Object> | null;
+  }
+
+  class PhoneLineCellularDetails implements Windows.ApplicationModel.Calls.IPhoneLineCellularDetails {
+    GetNetworkOperatorDisplayText(location: number): string;
+    readonly IsModemOn: boolean;
+    readonly RegistrationRejectCode: number;
+    readonly SimSlotIndex: number;
+    readonly SimState: number;
+  }
+
+  class PhoneLineConfiguration implements Windows.ApplicationModel.Calls.IPhoneLineConfiguration {
+    readonly ExtendedProperties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly IsVideoCallingEnabled: boolean;
+  }
+
+  class PhoneLineDialResult implements Windows.ApplicationModel.Calls.IPhoneLineDialResult {
+    readonly DialCallStatus: number;
+    readonly DialedCall: Windows.ApplicationModel.Calls.PhoneCall;
+  }
+
+  class PhoneLineTransportDevice implements Windows.ApplicationModel.Calls.IPhoneLineTransportDevice, Windows.ApplicationModel.Calls.IPhoneLineTransportDevice2 {
+    Connect(): boolean;
+    ConnectAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    static FromId(id: string): Windows.ApplicationModel.Calls.PhoneLineTransportDevice;
+    static GetDeviceSelector(): string;
+    static GetDeviceSelector(transport: number): string;
+    IsRegistered(): boolean;
+    RegisterApp(): void;
+    RegisterAppForUser(user: Windows.System.User): void;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    UnregisterApp(): void;
+    UnregisterAppForUser(user: Windows.System.User): void;
+    readonly AudioRoutingStatus: number;
+    readonly DeviceId: string;
+    readonly InBandRingingEnabled: boolean;
+    readonly Transport: number;
+    AudioRoutingStatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneLineTransportDevice, Object> | null;
+    InBandRingingEnabledChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneLineTransportDevice, Object> | null;
+  }
+
+  class PhoneLineWatcher implements Windows.ApplicationModel.Calls.IPhoneLineWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneLineWatcher, Object> | null;
+    LineAdded: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneLineWatcher, Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs> | null;
+    LineRemoved: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneLineWatcher, Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs> | null;
+    LineUpdated: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneLineWatcher, Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneLineWatcher, Object> | null;
+  }
+
+  class PhoneLineWatcherEventArgs implements Windows.ApplicationModel.Calls.IPhoneLineWatcherEventArgs {
+    readonly LineId: Guid;
+  }
+
+  class PhoneVoicemail implements Windows.ApplicationModel.Calls.IPhoneVoicemail {
+    DialVoicemailAsync(): Windows.Foundation.IAsyncAction;
+    readonly MessageCount: number;
+    readonly Number: string;
+    readonly Type: number;
+  }
+
+  class VoipCallCoordinator implements Windows.ApplicationModel.Calls.IVoipCallCoordinator, Windows.ApplicationModel.Calls.IVoipCallCoordinator2, Windows.ApplicationModel.Calls.IVoipCallCoordinator3, Windows.ApplicationModel.Calls.IVoipCallCoordinator4, Windows.ApplicationModel.Calls.IVoipCallCoordinator5 {
+    CancelUpgrade(callUpgradeGuid: Guid): void;
+    static GetDefault(): Windows.ApplicationModel.Calls.VoipCallCoordinator;
+    static GetDeviceSelectorForCallControl(): string;
+    static IsCallControlDeviceKindSupportedForAssociation(kind: number): boolean;
+    NotifyMuted(): void;
+    NotifyUnmuted(): void;
+    RequestIncomingUpgradeToVideoCall(context: string, contactName: string, contactNumber: string, contactImage: Windows.Foundation.Uri, serviceName: string, brandingImage: Windows.Foundation.Uri, callDetails: string, ringtone: Windows.Foundation.Uri, ringTimeout: Windows.Foundation.TimeSpan): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestNewAppInitiatedCall(context: string, contactName: string, contactNumber: string, serviceName: string, media: number): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestNewAppInitiatedCallWithOptions(callOptions: Windows.ApplicationModel.Calls.AppInitiatedVoipPhoneCallOptions): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestNewIncomingCall(context: string, contactName: string, contactNumber: string, contactImage: Windows.Foundation.Uri, serviceName: string, brandingImage: Windows.Foundation.Uri, callDetails: string, ringtone: Windows.Foundation.Uri, media: number, ringTimeout: Windows.Foundation.TimeSpan): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestNewIncomingCall(context: string, contactName: string, contactNumber: string, contactImage: Windows.Foundation.Uri, serviceName: string, brandingImage: Windows.Foundation.Uri, callDetails: string, ringtone: Windows.Foundation.Uri, media: number, ringTimeout: Windows.Foundation.TimeSpan, contactRemoteId: string): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestNewIncomingCallWithOptions(callOptions: Windows.ApplicationModel.Calls.IncomingVoipPhoneCallOptions): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestNewOutgoingCall(context: string, contactName: string, serviceName: string, media: number): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestNewOutgoingCallWithOptions(callOptions: Windows.ApplicationModel.Calls.OutgoingVoipPhoneCallOptions): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestOutgoingUpgradeToVideoCall(callUpgradeGuid: Guid, context: string, contactName: string, serviceName: string): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    ReserveCallResourcesAsync(taskEntryPoint: string): Windows.Foundation.IAsyncOperation<number>;
+    ReserveCallResourcesAsync(): Windows.Foundation.IAsyncOperation<number>;
+    SetupNewAcceptedCall(context: string, contactName: string, contactNumber: string, serviceName: string, media: number): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    SetupNewAcceptedCallWithOptions(callOptions: Windows.ApplicationModel.Calls.AcceptedVoipPhoneCallOptions): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    TerminateCellularCall(callUpgradeGuid: Guid): void;
+    MuteStateChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.VoipCallCoordinator, Windows.ApplicationModel.Calls.MuteChangeEventArgs> | null;
+  }
+
+  class VoipPhoneCall implements Windows.ApplicationModel.Calls.IVoipPhoneCall, Windows.ApplicationModel.Calls.IVoipPhoneCall2, Windows.ApplicationModel.Calls.IVoipPhoneCall3, Windows.ApplicationModel.Calls.IVoipPhoneCall4 {
+    AddAssociatedCallControlDevice(deviceId: string): void;
+    GetAssociatedCallControlDevices(): Windows.Foundation.Collections.IVectorView<string> | string[];
+    NotifyCallAccepted(media: number): void;
+    NotifyCallActive(): void;
+    NotifyCallActive(associatedDeviceIds: Windows.Foundation.Collections.IIterable<string> | string[]): void;
+    NotifyCallEnded(): void;
+    NotifyCallHeld(): void;
+    NotifyCallReady(): void;
+    RemoveAssociatedCallControlDevice(deviceId: string): void;
+    SetAssociatedCallControlDevices(associatedDeviceIds: Windows.Foundation.Collections.IIterable<string> | string[]): void;
+    TryShowAppUI(): void;
+    CallMedia: number;
+    ContactName: string;
+    readonly IsUsingAssociatedDevicesList: boolean;
+    StartTime: Windows.Foundation.DateTime;
+    AnswerRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.VoipPhoneCall, Windows.ApplicationModel.Calls.CallAnswerEventArgs> | null;
+    EndRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.VoipPhoneCall, Windows.ApplicationModel.Calls.CallStateChangeEventArgs> | null;
+    HoldRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.VoipPhoneCall, Windows.ApplicationModel.Calls.CallStateChangeEventArgs> | null;
+    RejectRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.VoipPhoneCall, Windows.ApplicationModel.Calls.CallRejectEventArgs> | null;
+    ResumeRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.VoipPhoneCall, Windows.ApplicationModel.Calls.CallStateChangeEventArgs> | null;
+  }
+
+  enum CellularDtmfMode {
+    Continuous = 0,
+    Burst = 1,
+  }
+
+  enum DtmfKey {
+    D0 = 0,
+    D1 = 1,
+    D2 = 2,
+    D3 = 3,
+    D4 = 4,
+    D5 = 5,
+    D6 = 6,
+    D7 = 7,
+    D8 = 8,
+    D9 = 9,
+    Star = 10,
+    Pound = 11,
+  }
+
+  enum DtmfToneAudioPlayback {
+    Play = 0,
+    DoNotPlay = 1,
+  }
+
+  enum PhoneAudioRoutingEndpoint {
+    Default = 0,
+    Bluetooth = 1,
+    Speakerphone = 2,
+  }
+
+  enum PhoneCallAudioDevice {
+    Unknown = 0,
+    LocalDevice = 1,
+    RemoteDevice = 2,
+  }
+
+  enum PhoneCallDirection {
+    Unknown = 0,
+    Incoming = 1,
+    Outgoing = 2,
+  }
+
+  enum PhoneCallHistoryEntryMedia {
+    Audio = 0,
+    Video = 1,
+  }
+
+  enum PhoneCallHistoryEntryOtherAppReadAccess {
+    Full = 0,
+    SystemOnly = 1,
+  }
+
+  enum PhoneCallHistoryEntryQueryDesiredMedia {
+    None = 0,
+    Audio = 1,
+    Video = 2,
+    All = 4294967295,
+  }
+
+  enum PhoneCallHistoryEntryRawAddressKind {
+    PhoneNumber = 0,
+    Custom = 1,
+  }
+
+  enum PhoneCallHistorySourceIdKind {
+    CellularPhoneLineId = 0,
+    PackageFamilyName = 1,
+  }
+
+  enum PhoneCallHistoryStoreAccessType {
+    AppEntriesReadWrite = 0,
+    AllEntriesLimitedReadWrite = 1,
+    AllEntriesReadWrite = 2,
+  }
+
+  enum PhoneCallMedia {
+    Audio = 0,
+    AudioAndVideo = 1,
+    AudioAndRealTimeText = 2,
+  }
+
+  enum PhoneCallOperationStatus {
+    Succeeded = 0,
+    OtherFailure = 1,
+    TimedOut = 2,
+    ConnectionLost = 3,
+    InvalidCallState = 4,
+  }
+
+  enum PhoneCallStatus {
+    Lost = 0,
+    Incoming = 1,
+    Dialing = 2,
+    Talking = 3,
+    Held = 4,
+    Ended = 5,
+  }
+
+  enum PhoneLineNetworkOperatorDisplayTextLocation {
+    Default = 0,
+    Tile = 1,
+    Dialer = 2,
+    InCallUI = 3,
+  }
+
+  enum PhoneLineOperationStatus {
+    Succeeded = 0,
+    OtherFailure = 1,
+    TimedOut = 2,
+    ConnectionLost = 3,
+    InvalidCallState = 4,
+  }
+
+  enum PhoneLineTransport {
+    Cellular = 0,
+    VoipApp = 1,
+    Bluetooth = 2,
+  }
+
+  enum PhoneLineWatcherStatus {
+    Created = 0,
+    Started = 1,
+    EnumerationCompleted = 2,
+    Stopped = 3,
+  }
+
+  enum PhoneNetworkState {
+    Unknown = 0,
+    NoSignal = 1,
+    Deregistered = 2,
+    Denied = 3,
+    Searching = 4,
+    Home = 5,
+    RoamingInternational = 6,
+    RoamingDomestic = 7,
+  }
+
+  enum PhoneSimState {
+    Unknown = 0,
+    PinNotRequired = 1,
+    PinUnlocked = 2,
+    PinLocked = 3,
+    PukLocked = 4,
+    NotInserted = 5,
+    Invalid = 6,
+    Disabled = 7,
+  }
+
+  enum PhoneVoicemailType {
+    None = 0,
+    Traditional = 1,
+    Visual = 2,
+  }
+
+  enum TransportDeviceAudioRoutingStatus {
+    Unknown = 0,
+    CanRouteToLocalDevice = 1,
+    CannotRouteToLocalDevice = 2,
+  }
+
+  enum VoipCallControlDeviceKind {
+    Bluetooth = 0,
+    Usb = 1,
+  }
+
+  enum VoipPhoneCallMedia {
+    None = 0,
+    Audio = 1,
+    Video = 2,
+  }
+
+  enum VoipPhoneCallRejectReason {
+    UserIgnored = 0,
+    TimedOut = 1,
+    OtherIncomingCall = 2,
+    EmergencyCallExists = 3,
+    InvalidCallState = 4,
+  }
+
+  enum VoipPhoneCallResourceReservationStatus {
+    Success = 0,
+    ResourcesNotAvailable = 1,
+  }
+
+  enum VoipPhoneCallState {
+    Ended = 0,
+    Held = 1,
+    Active = 2,
+    Incoming = 3,
+    Outgoing = 4,
+  }
+
+  interface CallsPhoneContract {
+  }
+  var CallsPhoneContract: {
+    new(fields: {  }): CallsPhoneContract;
+  };
+
+  interface CallsVoipContract {
+  }
+  var CallsVoipContract: {
+    new(fields: {  }): CallsVoipContract;
+  };
+
+  interface IAcceptedVoipPhoneCallOptions {
+    readonly AssociatedDeviceIds: Windows.Foundation.Collections.IVector<string> | string[];
+    ContactName: string;
+    ContactNumber: string;
+    Context: string;
+    Media: number;
+    ServiceName: string;
+  }
+  var IAcceptedVoipPhoneCallOptions: abstract new (...args: any[]) => IAcceptedVoipPhoneCallOptions;
+
+  interface IAcceptedVoipPhoneCallOptionsFactory {
+    CreateInstance(associatedDeviceIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.ApplicationModel.Calls.AcceptedVoipPhoneCallOptions;
+  }
+  var IAcceptedVoipPhoneCallOptionsFactory: abstract new (...args: any[]) => IAcceptedVoipPhoneCallOptionsFactory;
+
+  interface IAppInitiatedVoipPhoneCallOptions {
+    readonly AssociatedDeviceIds: Windows.Foundation.Collections.IVector<string> | string[];
+    ContactName: string;
+    ContactNumber: string;
+    Context: string;
+    Media: number;
+    ServiceName: string;
+  }
+  var IAppInitiatedVoipPhoneCallOptions: abstract new (...args: any[]) => IAppInitiatedVoipPhoneCallOptions;
+
+  interface IAppInitiatedVoipPhoneCallOptionsFactory {
+    CreateInstance(associatedDeviceIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.ApplicationModel.Calls.AppInitiatedVoipPhoneCallOptions;
+  }
+  var IAppInitiatedVoipPhoneCallOptionsFactory: abstract new (...args: any[]) => IAppInitiatedVoipPhoneCallOptionsFactory;
+
+  interface ICallAnswerEventArgs {
+    readonly AcceptedMedia: number;
+  }
+  var ICallAnswerEventArgs: abstract new (...args: any[]) => ICallAnswerEventArgs;
+
+  interface ICallAnswerEventArgs2 {
+    readonly SourceDeviceId: string;
+  }
+  var ICallAnswerEventArgs2: abstract new (...args: any[]) => ICallAnswerEventArgs2;
+
+  interface ICallRejectEventArgs {
+    readonly RejectReason: number;
+  }
+  var ICallRejectEventArgs: abstract new (...args: any[]) => ICallRejectEventArgs;
+
+  interface ICallStateChangeEventArgs {
+    readonly State: number;
+  }
+  var ICallStateChangeEventArgs: abstract new (...args: any[]) => ICallStateChangeEventArgs;
+
+  interface IIncomingVoipPhoneCallOptions {
+    readonly AssociatedDeviceIds: Windows.Foundation.Collections.IVector<string> | string[];
+    BrandingImage: Windows.Foundation.Uri;
+    CallDetails: string;
+    ContactImage: Windows.Foundation.Uri;
+    ContactName: string;
+    ContactNumber: string;
+    ContactRemoteId: string;
+    Context: string;
+    Media: number;
+    RingTimeout: Windows.Foundation.TimeSpan;
+    Ringtone: Windows.Foundation.Uri;
+    ServiceName: string;
+  }
+  var IIncomingVoipPhoneCallOptions: abstract new (...args: any[]) => IIncomingVoipPhoneCallOptions;
+
+  interface IIncomingVoipPhoneCallOptionsFactory {
+    CreateInstance(associatedDeviceIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.ApplicationModel.Calls.IncomingVoipPhoneCallOptions;
+  }
+  var IIncomingVoipPhoneCallOptionsFactory: abstract new (...args: any[]) => IIncomingVoipPhoneCallOptionsFactory;
+
+  interface ILockScreenCallEndCallDeferral {
+    Complete(): void;
+  }
+  var ILockScreenCallEndCallDeferral: abstract new (...args: any[]) => ILockScreenCallEndCallDeferral;
+
+  interface ILockScreenCallEndRequestedEventArgs {
+    GetDeferral(): Windows.ApplicationModel.Calls.LockScreenCallEndCallDeferral;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+  var ILockScreenCallEndRequestedEventArgs: abstract new (...args: any[]) => ILockScreenCallEndRequestedEventArgs;
+
+  interface ILockScreenCallUI {
+    Dismiss(): void;
+    CallTitle: string;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.LockScreenCallUI, Object> | null;
+    EndRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.LockScreenCallUI, Windows.ApplicationModel.Calls.LockScreenCallEndRequestedEventArgs> | null;
+  }
+  var ILockScreenCallUI: abstract new (...args: any[]) => ILockScreenCallUI;
+
+  interface IMuteChangeEventArgs {
+    readonly Muted: boolean;
+  }
+  var IMuteChangeEventArgs: abstract new (...args: any[]) => IMuteChangeEventArgs;
+
+  interface IOutgoingVoipPhoneCallOptions {
+    readonly AssociatedDeviceIds: Windows.Foundation.Collections.IVector<string> | string[];
+    ContactName: string;
+    Context: string;
+    Media: number;
+    ServiceName: string;
+  }
+  var IOutgoingVoipPhoneCallOptions: abstract new (...args: any[]) => IOutgoingVoipPhoneCallOptions;
+
+  interface IOutgoingVoipPhoneCallOptionsFactory {
+    CreateInstance(associatedDeviceIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.ApplicationModel.Calls.OutgoingVoipPhoneCallOptions;
+  }
+  var IOutgoingVoipPhoneCallOptionsFactory: abstract new (...args: any[]) => IOutgoingVoipPhoneCallOptionsFactory;
+
+  interface IPhoneCall {
+    AcceptIncoming(): number;
+    AcceptIncomingAsync(): Windows.Foundation.IAsyncOperation<number>;
+    ChangeAudioDevice(endpoint: number): number;
+    ChangeAudioDeviceAsync(endpoint: number): Windows.Foundation.IAsyncOperation<number>;
+    End(): number;
+    EndAsync(): Windows.Foundation.IAsyncOperation<number>;
+    GetPhoneCallInfo(): Windows.ApplicationModel.Calls.PhoneCallInfo;
+    GetPhoneCallInfoAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Calls.PhoneCallInfo>;
+    Hold(): number;
+    HoldAsync(): Windows.Foundation.IAsyncOperation<number>;
+    Mute(): number;
+    MuteAsync(): Windows.Foundation.IAsyncOperation<number>;
+    RejectIncoming(): number;
+    RejectIncomingAsync(): Windows.Foundation.IAsyncOperation<number>;
+    ResumeFromHold(): number;
+    ResumeFromHoldAsync(): Windows.Foundation.IAsyncOperation<number>;
+    SendDtmfKey(key: number, dtmfToneAudioPlayback: number): number;
+    SendDtmfKeyAsync(key: number, dtmfToneAudioPlayback: number): Windows.Foundation.IAsyncOperation<number>;
+    Unmute(): number;
+    UnmuteAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly AudioDevice: number;
+    readonly CallId: string;
+    readonly IsMuted: boolean;
+    readonly Status: number;
+    AudioDeviceChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneCall, Object> | null;
+    IsMutedChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneCall, Object> | null;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneCall, Object> | null;
+  }
+  var IPhoneCall: abstract new (...args: any[]) => IPhoneCall;
+
+  interface IPhoneCallBlockingStatics {
+    SetCallBlockingListAsync(phoneNumberList: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<boolean>;
+    BlockPrivateNumbers: boolean;
+    BlockUnknownNumbers: boolean;
+  }
+  var IPhoneCallBlockingStatics: abstract new (...args: any[]) => IPhoneCallBlockingStatics;
+
+  interface IPhoneCallHistoryEntry {
+    Address: Windows.ApplicationModel.Calls.PhoneCallHistoryEntryAddress;
+    Duration: Windows.Foundation.TimeSpan | null;
+    readonly Id: string;
+    IsCallerIdBlocked: boolean;
+    IsEmergency: boolean;
+    IsIncoming: boolean;
+    IsMissed: boolean;
+    IsRinging: boolean;
+    IsSeen: boolean;
+    IsSuppressed: boolean;
+    IsVoicemail: boolean;
+    Media: number;
+    OtherAppReadAccess: number;
+    RemoteId: string;
+    readonly SourceDisplayName: string;
+    SourceId: string;
+    SourceIdKind: number;
+    StartTime: Windows.Foundation.DateTime;
+  }
+  var IPhoneCallHistoryEntry: abstract new (...args: any[]) => IPhoneCallHistoryEntry;
+
+  interface IPhoneCallHistoryEntryAddress {
+    ContactId: string;
+    DisplayName: string;
+    RawAddress: string;
+    RawAddressKind: number;
+  }
+  var IPhoneCallHistoryEntryAddress: abstract new (...args: any[]) => IPhoneCallHistoryEntryAddress;
+
+  interface IPhoneCallHistoryEntryAddressFactory {
+    Create(rawAddress: string, rawAddressKind: number): Windows.ApplicationModel.Calls.PhoneCallHistoryEntryAddress;
+  }
+  var IPhoneCallHistoryEntryAddressFactory: abstract new (...args: any[]) => IPhoneCallHistoryEntryAddressFactory;
+
+  interface IPhoneCallHistoryEntryQueryOptions {
+    DesiredMedia: number;
+    readonly SourceIds: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var IPhoneCallHistoryEntryQueryOptions: abstract new (...args: any[]) => IPhoneCallHistoryEntryQueryOptions;
+
+  interface IPhoneCallHistoryEntryReader {
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Calls.PhoneCallHistoryEntry> | Windows.ApplicationModel.Calls.PhoneCallHistoryEntry[]>;
+  }
+  var IPhoneCallHistoryEntryReader: abstract new (...args: any[]) => IPhoneCallHistoryEntryReader;
+
+  interface IPhoneCallHistoryManagerForUser {
+    RequestStoreAsync(accessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Calls.PhoneCallHistoryStore>;
+    readonly User: Windows.System.User;
+  }
+  var IPhoneCallHistoryManagerForUser: abstract new (...args: any[]) => IPhoneCallHistoryManagerForUser;
+
+  interface IPhoneCallHistoryManagerStatics {
+    RequestStoreAsync(accessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Calls.PhoneCallHistoryStore>;
+  }
+  var IPhoneCallHistoryManagerStatics: abstract new (...args: any[]) => IPhoneCallHistoryManagerStatics;
+
+  interface IPhoneCallHistoryManagerStatics2 {
+    GetForUser(user: Windows.System.User): Windows.ApplicationModel.Calls.PhoneCallHistoryManagerForUser;
+  }
+  var IPhoneCallHistoryManagerStatics2: abstract new (...args: any[]) => IPhoneCallHistoryManagerStatics2;
+
+  interface IPhoneCallHistoryStore {
+    DeleteEntriesAsync(callHistoryEntries: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Calls.PhoneCallHistoryEntry> | Windows.ApplicationModel.Calls.PhoneCallHistoryEntry[]): Windows.Foundation.IAsyncAction;
+    DeleteEntryAsync(callHistoryEntry: Windows.ApplicationModel.Calls.PhoneCallHistoryEntry): Windows.Foundation.IAsyncAction;
+    GetEntryAsync(callHistoryEntryId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Calls.PhoneCallHistoryEntry>;
+    GetEntryReader(): Windows.ApplicationModel.Calls.PhoneCallHistoryEntryReader;
+    GetEntryReader(queryOptions: Windows.ApplicationModel.Calls.PhoneCallHistoryEntryQueryOptions): Windows.ApplicationModel.Calls.PhoneCallHistoryEntryReader;
+    GetSourcesUnseenCountAsync(sourceIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<number>;
+    GetUnseenCountAsync(): Windows.Foundation.IAsyncOperation<number>;
+    MarkAllAsSeenAsync(): Windows.Foundation.IAsyncAction;
+    MarkEntriesAsSeenAsync(callHistoryEntries: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Calls.PhoneCallHistoryEntry> | Windows.ApplicationModel.Calls.PhoneCallHistoryEntry[]): Windows.Foundation.IAsyncAction;
+    MarkEntryAsSeenAsync(callHistoryEntry: Windows.ApplicationModel.Calls.PhoneCallHistoryEntry): Windows.Foundation.IAsyncAction;
+    MarkSourcesAsSeenAsync(sourceIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    SaveEntryAsync(callHistoryEntry: Windows.ApplicationModel.Calls.PhoneCallHistoryEntry): Windows.Foundation.IAsyncAction;
+  }
+  var IPhoneCallHistoryStore: abstract new (...args: any[]) => IPhoneCallHistoryStore;
+
+  interface IPhoneCallInfo {
+    readonly CallDirection: number;
+    readonly DisplayName: string;
+    readonly IsHoldSupported: boolean;
+    readonly LineId: Guid;
+    readonly PhoneNumber: string;
+    readonly StartTime: Windows.Foundation.DateTime;
+  }
+  var IPhoneCallInfo: abstract new (...args: any[]) => IPhoneCallInfo;
+
+  interface IPhoneCallManagerStatics {
+    ShowPhoneCallUI(phoneNumber: string, displayName: string): void;
+  }
+  var IPhoneCallManagerStatics: abstract new (...args: any[]) => IPhoneCallManagerStatics;
+
+  interface IPhoneCallManagerStatics2 {
+    RequestStoreAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Calls.PhoneCallStore>;
+    ShowPhoneCallSettingsUI(): void;
+    readonly IsCallActive: boolean;
+    readonly IsCallIncoming: boolean;
+    CallStateChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IPhoneCallManagerStatics2: abstract new (...args: any[]) => IPhoneCallManagerStatics2;
+
+  interface IPhoneCallStatics {
+    GetFromId(callId: string): Windows.ApplicationModel.Calls.PhoneCall;
+  }
+  var IPhoneCallStatics: abstract new (...args: any[]) => IPhoneCallStatics;
+
+  interface IPhoneCallStore {
+    GetDefaultLineAsync(): Windows.Foundation.IAsyncOperation<Guid>;
+    IsEmergencyPhoneNumberAsync(number: string): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestLineWatcher(): Windows.ApplicationModel.Calls.PhoneLineWatcher;
+  }
+  var IPhoneCallStore: abstract new (...args: any[]) => IPhoneCallStore;
+
+  interface IPhoneCallVideoCapabilities {
+    readonly IsVideoCallingCapable: boolean;
+  }
+  var IPhoneCallVideoCapabilities: abstract new (...args: any[]) => IPhoneCallVideoCapabilities;
+
+  interface IPhoneCallVideoCapabilitiesManagerStatics {
+    GetCapabilitiesAsync(phoneNumber: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Calls.PhoneCallVideoCapabilities>;
+  }
+  var IPhoneCallVideoCapabilitiesManagerStatics: abstract new (...args: any[]) => IPhoneCallVideoCapabilitiesManagerStatics;
+
+  interface IPhoneCallsResult {
+    readonly AllActivePhoneCalls: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Calls.PhoneCall> | Windows.ApplicationModel.Calls.PhoneCall[];
+    readonly OperationStatus: number;
+  }
+  var IPhoneCallsResult: abstract new (...args: any[]) => IPhoneCallsResult;
+
+  interface IPhoneDialOptions {
+    AudioEndpoint: number;
+    Contact: Windows.ApplicationModel.Contacts.Contact;
+    ContactPhone: Windows.ApplicationModel.Contacts.ContactPhone;
+    DisplayName: string;
+    Media: number;
+    Number: string;
+  }
+  var IPhoneDialOptions: abstract new (...args: any[]) => IPhoneDialOptions;
+
+  interface IPhoneLine {
+    Dial(number: string, displayName: string): void;
+    DialWithOptions(options: Windows.ApplicationModel.Calls.PhoneDialOptions): void;
+    IsImmediateDialNumberAsync(number: string): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly CanDial: boolean;
+    readonly CellularDetails: Windows.ApplicationModel.Calls.PhoneLineCellularDetails;
+    readonly DisplayColor: Windows.UI.Color;
+    readonly DisplayName: string;
+    readonly Id: Guid;
+    readonly LineConfiguration: Windows.ApplicationModel.Calls.PhoneLineConfiguration;
+    readonly NetworkName: string;
+    readonly NetworkState: number;
+    readonly SupportsTile: boolean;
+    readonly Transport: number;
+    readonly VideoCallingCapabilities: Windows.ApplicationModel.Calls.PhoneCallVideoCapabilities;
+    readonly Voicemail: Windows.ApplicationModel.Calls.PhoneVoicemail;
+    LineChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneLine, Object> | null;
+  }
+  var IPhoneLine: abstract new (...args: any[]) => IPhoneLine;
+
+  interface IPhoneLine2 {
+    EnableTextReply(value: boolean): void;
+    readonly TransportDeviceId: string;
+  }
+  var IPhoneLine2: abstract new (...args: any[]) => IPhoneLine2;
+
+  interface IPhoneLine3 {
+    DialWithResult(number: string, displayName: string): Windows.ApplicationModel.Calls.PhoneLineDialResult;
+    DialWithResultAsync(number: string, displayName: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Calls.PhoneLineDialResult>;
+    GetAllActivePhoneCalls(): Windows.ApplicationModel.Calls.PhoneCallsResult;
+    GetAllActivePhoneCallsAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Calls.PhoneCallsResult>;
+  }
+  var IPhoneLine3: abstract new (...args: any[]) => IPhoneLine3;
+
+  interface IPhoneLineCellularDetails {
+    GetNetworkOperatorDisplayText(location: number): string;
+    readonly IsModemOn: boolean;
+    readonly RegistrationRejectCode: number;
+    readonly SimSlotIndex: number;
+    readonly SimState: number;
+  }
+  var IPhoneLineCellularDetails: abstract new (...args: any[]) => IPhoneLineCellularDetails;
+
+  interface IPhoneLineConfiguration {
+    readonly ExtendedProperties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly IsVideoCallingEnabled: boolean;
+  }
+  var IPhoneLineConfiguration: abstract new (...args: any[]) => IPhoneLineConfiguration;
+
+  interface IPhoneLineDialResult {
+    readonly DialCallStatus: number;
+    readonly DialedCall: Windows.ApplicationModel.Calls.PhoneCall;
+  }
+  var IPhoneLineDialResult: abstract new (...args: any[]) => IPhoneLineDialResult;
+
+  interface IPhoneLineStatics {
+    FromIdAsync(lineId: Guid): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Calls.PhoneLine>;
+  }
+  var IPhoneLineStatics: abstract new (...args: any[]) => IPhoneLineStatics;
+
+  interface IPhoneLineTransportDevice {
+    Connect(): boolean;
+    ConnectAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    IsRegistered(): boolean;
+    RegisterApp(): void;
+    RegisterAppForUser(user: Windows.System.User): void;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    UnregisterApp(): void;
+    UnregisterAppForUser(user: Windows.System.User): void;
+    readonly DeviceId: string;
+    readonly Transport: number;
+  }
+  var IPhoneLineTransportDevice: abstract new (...args: any[]) => IPhoneLineTransportDevice;
+
+  interface IPhoneLineTransportDevice2 {
+    readonly AudioRoutingStatus: number;
+    readonly InBandRingingEnabled: boolean;
+    AudioRoutingStatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneLineTransportDevice, Object> | null;
+    InBandRingingEnabledChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneLineTransportDevice, Object> | null;
+  }
+  var IPhoneLineTransportDevice2: abstract new (...args: any[]) => IPhoneLineTransportDevice2;
+
+  interface IPhoneLineTransportDeviceStatics {
+    FromId(id: string): Windows.ApplicationModel.Calls.PhoneLineTransportDevice;
+    GetDeviceSelector(): string;
+    GetDeviceSelector(transport: number): string;
+  }
+  var IPhoneLineTransportDeviceStatics: abstract new (...args: any[]) => IPhoneLineTransportDeviceStatics;
+
+  interface IPhoneLineWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneLineWatcher, Object> | null;
+    LineAdded: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneLineWatcher, Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs> | null;
+    LineRemoved: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneLineWatcher, Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs> | null;
+    LineUpdated: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneLineWatcher, Windows.ApplicationModel.Calls.PhoneLineWatcherEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.PhoneLineWatcher, Object> | null;
+  }
+  var IPhoneLineWatcher: abstract new (...args: any[]) => IPhoneLineWatcher;
+
+  interface IPhoneLineWatcherEventArgs {
+    readonly LineId: Guid;
+  }
+  var IPhoneLineWatcherEventArgs: abstract new (...args: any[]) => IPhoneLineWatcherEventArgs;
+
+  interface IPhoneVoicemail {
+    DialVoicemailAsync(): Windows.Foundation.IAsyncAction;
+    readonly MessageCount: number;
+    readonly Number: string;
+    readonly Type: number;
+  }
+  var IPhoneVoicemail: abstract new (...args: any[]) => IPhoneVoicemail;
+
+  interface IVoipCallCoordinator {
+    CancelUpgrade(callUpgradeGuid: Guid): void;
+    NotifyMuted(): void;
+    NotifyUnmuted(): void;
+    RequestIncomingUpgradeToVideoCall(context: string, contactName: string, contactNumber: string, contactImage: Windows.Foundation.Uri, serviceName: string, brandingImage: Windows.Foundation.Uri, callDetails: string, ringtone: Windows.Foundation.Uri, ringTimeout: Windows.Foundation.TimeSpan): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestNewIncomingCall(context: string, contactName: string, contactNumber: string, contactImage: Windows.Foundation.Uri, serviceName: string, brandingImage: Windows.Foundation.Uri, callDetails: string, ringtone: Windows.Foundation.Uri, media: number, ringTimeout: Windows.Foundation.TimeSpan): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestNewOutgoingCall(context: string, contactName: string, serviceName: string, media: number): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestOutgoingUpgradeToVideoCall(callUpgradeGuid: Guid, context: string, contactName: string, serviceName: string): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    ReserveCallResourcesAsync(taskEntryPoint: string): Windows.Foundation.IAsyncOperation<number>;
+    TerminateCellularCall(callUpgradeGuid: Guid): void;
+    MuteStateChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.VoipCallCoordinator, Windows.ApplicationModel.Calls.MuteChangeEventArgs> | null;
+  }
+  var IVoipCallCoordinator: abstract new (...args: any[]) => IVoipCallCoordinator;
+
+  interface IVoipCallCoordinator2 extends Windows.ApplicationModel.Calls.IVoipCallCoordinator {
+    CancelUpgrade(callUpgradeGuid: Guid): void;
+    NotifyMuted(): void;
+    NotifyUnmuted(): void;
+    RequestIncomingUpgradeToVideoCall(context: string, contactName: string, contactNumber: string, contactImage: Windows.Foundation.Uri, serviceName: string, brandingImage: Windows.Foundation.Uri, callDetails: string, ringtone: Windows.Foundation.Uri, ringTimeout: Windows.Foundation.TimeSpan): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestNewIncomingCall(context: string, contactName: string, contactNumber: string, contactImage: Windows.Foundation.Uri, serviceName: string, brandingImage: Windows.Foundation.Uri, callDetails: string, ringtone: Windows.Foundation.Uri, media: number, ringTimeout: Windows.Foundation.TimeSpan): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestNewOutgoingCall(context: string, contactName: string, serviceName: string, media: number): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestOutgoingUpgradeToVideoCall(callUpgradeGuid: Guid, context: string, contactName: string, serviceName: string): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    ReserveCallResourcesAsync(taskEntryPoint: string): Windows.Foundation.IAsyncOperation<number>;
+    SetupNewAcceptedCall(context: string, contactName: string, contactNumber: string, serviceName: string, media: number): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    TerminateCellularCall(callUpgradeGuid: Guid): void;
+  }
+  var IVoipCallCoordinator2: abstract new (...args: any[]) => IVoipCallCoordinator2;
+
+  interface IVoipCallCoordinator3 extends Windows.ApplicationModel.Calls.IVoipCallCoordinator {
+    CancelUpgrade(callUpgradeGuid: Guid): void;
+    NotifyMuted(): void;
+    NotifyUnmuted(): void;
+    RequestIncomingUpgradeToVideoCall(context: string, contactName: string, contactNumber: string, contactImage: Windows.Foundation.Uri, serviceName: string, brandingImage: Windows.Foundation.Uri, callDetails: string, ringtone: Windows.Foundation.Uri, ringTimeout: Windows.Foundation.TimeSpan): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestNewAppInitiatedCall(context: string, contactName: string, contactNumber: string, serviceName: string, media: number): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestNewIncomingCall(context: string, contactName: string, contactNumber: string, contactImage: Windows.Foundation.Uri, serviceName: string, brandingImage: Windows.Foundation.Uri, callDetails: string, ringtone: Windows.Foundation.Uri, media: number, ringTimeout: Windows.Foundation.TimeSpan, contactRemoteId: string): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestNewIncomingCall(context: string, contactName: string, contactNumber: string, contactImage: Windows.Foundation.Uri, serviceName: string, brandingImage: Windows.Foundation.Uri, callDetails: string, ringtone: Windows.Foundation.Uri, media: number, ringTimeout: Windows.Foundation.TimeSpan): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestNewOutgoingCall(context: string, contactName: string, serviceName: string, media: number): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestOutgoingUpgradeToVideoCall(callUpgradeGuid: Guid, context: string, contactName: string, serviceName: string): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    ReserveCallResourcesAsync(taskEntryPoint: string): Windows.Foundation.IAsyncOperation<number>;
+    TerminateCellularCall(callUpgradeGuid: Guid): void;
+  }
+  var IVoipCallCoordinator3: abstract new (...args: any[]) => IVoipCallCoordinator3;
+
+  interface IVoipCallCoordinator4 extends Windows.ApplicationModel.Calls.IVoipCallCoordinator {
+    CancelUpgrade(callUpgradeGuid: Guid): void;
+    NotifyMuted(): void;
+    NotifyUnmuted(): void;
+    RequestIncomingUpgradeToVideoCall(context: string, contactName: string, contactNumber: string, contactImage: Windows.Foundation.Uri, serviceName: string, brandingImage: Windows.Foundation.Uri, callDetails: string, ringtone: Windows.Foundation.Uri, ringTimeout: Windows.Foundation.TimeSpan): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestNewIncomingCall(context: string, contactName: string, contactNumber: string, contactImage: Windows.Foundation.Uri, serviceName: string, brandingImage: Windows.Foundation.Uri, callDetails: string, ringtone: Windows.Foundation.Uri, media: number, ringTimeout: Windows.Foundation.TimeSpan): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestNewOutgoingCall(context: string, contactName: string, serviceName: string, media: number): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestOutgoingUpgradeToVideoCall(callUpgradeGuid: Guid, context: string, contactName: string, serviceName: string): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    ReserveCallResourcesAsync(): Windows.Foundation.IAsyncOperation<number>;
+    ReserveCallResourcesAsync(taskEntryPoint: string): Windows.Foundation.IAsyncOperation<number>;
+    TerminateCellularCall(callUpgradeGuid: Guid): void;
+  }
+  var IVoipCallCoordinator4: abstract new (...args: any[]) => IVoipCallCoordinator4;
+
+  interface IVoipCallCoordinator5 {
+    RequestNewAppInitiatedCallWithOptions(callOptions: Windows.ApplicationModel.Calls.AppInitiatedVoipPhoneCallOptions): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestNewIncomingCallWithOptions(callOptions: Windows.ApplicationModel.Calls.IncomingVoipPhoneCallOptions): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    RequestNewOutgoingCallWithOptions(callOptions: Windows.ApplicationModel.Calls.OutgoingVoipPhoneCallOptions): Windows.ApplicationModel.Calls.VoipPhoneCall;
+    SetupNewAcceptedCallWithOptions(callOptions: Windows.ApplicationModel.Calls.AcceptedVoipPhoneCallOptions): Windows.ApplicationModel.Calls.VoipPhoneCall;
+  }
+  var IVoipCallCoordinator5: abstract new (...args: any[]) => IVoipCallCoordinator5;
+
+  interface IVoipCallCoordinatorStatics {
+    GetDefault(): Windows.ApplicationModel.Calls.VoipCallCoordinator;
+  }
+  var IVoipCallCoordinatorStatics: abstract new (...args: any[]) => IVoipCallCoordinatorStatics;
+
+  interface IVoipCallCoordinatorStatics2 {
+    GetDeviceSelectorForCallControl(): string;
+    IsCallControlDeviceKindSupportedForAssociation(kind: number): boolean;
+  }
+  var IVoipCallCoordinatorStatics2: abstract new (...args: any[]) => IVoipCallCoordinatorStatics2;
+
+  interface IVoipPhoneCall {
+    NotifyCallActive(): void;
+    NotifyCallEnded(): void;
+    NotifyCallHeld(): void;
+    NotifyCallReady(): void;
+    CallMedia: number;
+    ContactName: string;
+    StartTime: Windows.Foundation.DateTime;
+    AnswerRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.VoipPhoneCall, Windows.ApplicationModel.Calls.CallAnswerEventArgs> | null;
+    EndRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.VoipPhoneCall, Windows.ApplicationModel.Calls.CallStateChangeEventArgs> | null;
+    HoldRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.VoipPhoneCall, Windows.ApplicationModel.Calls.CallStateChangeEventArgs> | null;
+    RejectRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.VoipPhoneCall, Windows.ApplicationModel.Calls.CallRejectEventArgs> | null;
+    ResumeRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Calls.VoipPhoneCall, Windows.ApplicationModel.Calls.CallStateChangeEventArgs> | null;
+  }
+  var IVoipPhoneCall: abstract new (...args: any[]) => IVoipPhoneCall;
+
+  interface IVoipPhoneCall2 extends Windows.ApplicationModel.Calls.IVoipPhoneCall {
+    NotifyCallActive(): void;
+    NotifyCallEnded(): void;
+    NotifyCallHeld(): void;
+    NotifyCallReady(): void;
+    TryShowAppUI(): void;
+  }
+  var IVoipPhoneCall2: abstract new (...args: any[]) => IVoipPhoneCall2;
+
+  interface IVoipPhoneCall3 extends Windows.ApplicationModel.Calls.IVoipPhoneCall, Windows.ApplicationModel.Calls.IVoipPhoneCall2 {
+    NotifyCallAccepted(media: number): void;
+    NotifyCallActive(): void;
+    NotifyCallEnded(): void;
+    NotifyCallHeld(): void;
+    NotifyCallReady(): void;
+    TryShowAppUI(): void;
+  }
+  var IVoipPhoneCall3: abstract new (...args: any[]) => IVoipPhoneCall3;
+
+  interface IVoipPhoneCall4 {
+    AddAssociatedCallControlDevice(deviceId: string): void;
+    GetAssociatedCallControlDevices(): Windows.Foundation.Collections.IVectorView<string> | string[];
+    NotifyCallActive(associatedDeviceIds: Windows.Foundation.Collections.IIterable<string> | string[]): void;
+    RemoveAssociatedCallControlDevice(deviceId: string): void;
+    SetAssociatedCallControlDevices(associatedDeviceIds: Windows.Foundation.Collections.IIterable<string> | string[]): void;
+    readonly IsUsingAssociatedDevicesList: boolean;
+  }
+  var IVoipPhoneCall4: abstract new (...args: any[]) => IVoipPhoneCall4;
+
+  interface LockScreenCallContract {
+  }
+  var LockScreenCallContract: {
+    new(fields: {  }): LockScreenCallContract;
+  };
+
+}
+
+declare namespace Windows.ApplicationModel.Calls.Background {
+  class PhoneCallBlockedTriggerDetails implements Windows.ApplicationModel.Calls.Background.IPhoneCallBlockedTriggerDetails {
+    readonly CallBlockedReason: number;
+    readonly LineId: Guid;
+    readonly PhoneNumber: string;
+  }
+
+  class PhoneCallOriginDataRequestTriggerDetails implements Windows.ApplicationModel.Calls.Background.IPhoneCallOriginDataRequestTriggerDetails {
+    readonly PhoneNumber: string;
+    readonly RequestId: Guid;
+  }
+
+  class PhoneIncomingCallDismissedTriggerDetails implements Windows.ApplicationModel.Calls.Background.IPhoneIncomingCallDismissedTriggerDetails {
+    readonly DismissalTime: Windows.Foundation.DateTime;
+    readonly DisplayName: string;
+    readonly LineId: Guid;
+    readonly PhoneNumber: string;
+    readonly Reason: number;
+    readonly TextReplyMessage: string;
+  }
+
+  class PhoneIncomingCallNotificationTriggerDetails implements Windows.ApplicationModel.Calls.Background.IPhoneIncomingCallNotificationTriggerDetails {
+    readonly CallId: string;
+    readonly LineId: Guid;
+  }
+
+  class PhoneLineChangedTriggerDetails implements Windows.ApplicationModel.Calls.Background.IPhoneLineChangedTriggerDetails {
+    HasLinePropertyChanged(lineProperty: number): boolean;
+    readonly ChangeType: number;
+    readonly LineId: Guid;
+  }
+
+  class PhoneNewVoicemailMessageTriggerDetails implements Windows.ApplicationModel.Calls.Background.IPhoneNewVoicemailMessageTriggerDetails {
+    readonly LineId: Guid;
+    readonly OperatorMessage: string;
+    readonly VoicemailCount: number;
+  }
+
+  enum PhoneCallBlockedReason {
+    InCallBlockingList = 0,
+    PrivateNumber = 1,
+    UnknownNumber = 2,
+  }
+
+  enum PhoneIncomingCallDismissedReason {
+    Unknown = 0,
+    CallRejected = 1,
+    TextReply = 2,
+    ConnectionLost = 3,
+  }
+
+  enum PhoneLineChangeKind {
+    Added = 0,
+    Removed = 1,
+    PropertiesChanged = 2,
+  }
+
+  enum PhoneLineProperties {
+    None = 0,
+    BrandingOptions = 1,
+    CanDial = 2,
+    CellularDetails = 4,
+    DisplayColor = 8,
+    DisplayName = 16,
+    NetworkName = 32,
+    NetworkState = 64,
+    Transport = 128,
+    Voicemail = 256,
+  }
+
+  enum PhoneTriggerType {
+    NewVoicemailMessage = 0,
+    CallHistoryChanged = 1,
+    LineChanged = 2,
+    AirplaneModeDisabledForEmergencyCall = 3,
+    CallOriginDataRequest = 4,
+    CallBlocked = 5,
+    IncomingCallDismissed = 6,
+    IncomingCallNotification = 7,
+  }
+
+  interface CallsBackgroundContract {
+  }
+  var CallsBackgroundContract: {
+    new(fields: {  }): CallsBackgroundContract;
+  };
+
+  interface IPhoneCallBlockedTriggerDetails {
+    readonly CallBlockedReason: number;
+    readonly LineId: Guid;
+    readonly PhoneNumber: string;
+  }
+  var IPhoneCallBlockedTriggerDetails: abstract new (...args: any[]) => IPhoneCallBlockedTriggerDetails;
+
+  interface IPhoneCallOriginDataRequestTriggerDetails {
+    readonly PhoneNumber: string;
+    readonly RequestId: Guid;
+  }
+  var IPhoneCallOriginDataRequestTriggerDetails: abstract new (...args: any[]) => IPhoneCallOriginDataRequestTriggerDetails;
+
+  interface IPhoneIncomingCallDismissedTriggerDetails {
+    readonly DismissalTime: Windows.Foundation.DateTime;
+    readonly DisplayName: string;
+    readonly LineId: Guid;
+    readonly PhoneNumber: string;
+    readonly Reason: number;
+    readonly TextReplyMessage: string;
+  }
+  var IPhoneIncomingCallDismissedTriggerDetails: abstract new (...args: any[]) => IPhoneIncomingCallDismissedTriggerDetails;
+
+  interface IPhoneIncomingCallNotificationTriggerDetails {
+    readonly CallId: string;
+    readonly LineId: Guid;
+  }
+  var IPhoneIncomingCallNotificationTriggerDetails: abstract new (...args: any[]) => IPhoneIncomingCallNotificationTriggerDetails;
+
+  interface IPhoneLineChangedTriggerDetails {
+    HasLinePropertyChanged(lineProperty: number): boolean;
+    readonly ChangeType: number;
+    readonly LineId: Guid;
+  }
+  var IPhoneLineChangedTriggerDetails: abstract new (...args: any[]) => IPhoneLineChangedTriggerDetails;
+
+  interface IPhoneNewVoicemailMessageTriggerDetails {
+    readonly LineId: Guid;
+    readonly OperatorMessage: string;
+    readonly VoicemailCount: number;
+  }
+  var IPhoneNewVoicemailMessageTriggerDetails: abstract new (...args: any[]) => IPhoneNewVoicemailMessageTriggerDetails;
+
+}
+
+declare namespace Windows.ApplicationModel.Calls.Provider {
+  class PhoneCallOrigin implements Windows.ApplicationModel.Calls.Provider.IPhoneCallOrigin, Windows.ApplicationModel.Calls.Provider.IPhoneCallOrigin2, Windows.ApplicationModel.Calls.Provider.IPhoneCallOrigin3 {
+    constructor();
+    Category: string;
+    CategoryDescription: string;
+    DisplayName: string;
+    DisplayPicture: Windows.Storage.StorageFile;
+    Location: string;
+  }
+
+  class PhoneCallOriginManager {
+    static RequestSetAsActiveCallOriginAppAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    static SetCallOrigin(requestId: Guid, callOrigin: Windows.ApplicationModel.Calls.Provider.PhoneCallOrigin): void;
+    static ShowPhoneCallOriginSettingsUI(): void;
+    static readonly IsCurrentAppActiveCallOriginApp: boolean;
+    static readonly IsSupported: boolean;
+  }
+
+  interface IPhoneCallOrigin {
+    Category: string;
+    CategoryDescription: string;
+    Location: string;
+  }
+  var IPhoneCallOrigin: abstract new (...args: any[]) => IPhoneCallOrigin;
+
+  interface IPhoneCallOrigin2 extends Windows.ApplicationModel.Calls.Provider.IPhoneCallOrigin {
+    DisplayName: string;
+  }
+  var IPhoneCallOrigin2: abstract new (...args: any[]) => IPhoneCallOrigin2;
+
+  interface IPhoneCallOrigin3 extends Windows.ApplicationModel.Calls.Provider.IPhoneCallOrigin, Windows.ApplicationModel.Calls.Provider.IPhoneCallOrigin2 {
+    DisplayPicture: Windows.Storage.StorageFile;
+  }
+  var IPhoneCallOrigin3: abstract new (...args: any[]) => IPhoneCallOrigin3;
+
+  interface IPhoneCallOriginManagerStatics {
+    SetCallOrigin(requestId: Guid, callOrigin: Windows.ApplicationModel.Calls.Provider.PhoneCallOrigin): void;
+    ShowPhoneCallOriginSettingsUI(): void;
+    readonly IsCurrentAppActiveCallOriginApp: boolean;
+  }
+  var IPhoneCallOriginManagerStatics: abstract new (...args: any[]) => IPhoneCallOriginManagerStatics;
+
+  interface IPhoneCallOriginManagerStatics2 extends Windows.ApplicationModel.Calls.Provider.IPhoneCallOriginManagerStatics {
+    RequestSetAsActiveCallOriginAppAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    SetCallOrigin(requestId: Guid, callOrigin: Windows.ApplicationModel.Calls.Provider.PhoneCallOrigin): void;
+    ShowPhoneCallOriginSettingsUI(): void;
+  }
+  var IPhoneCallOriginManagerStatics2: abstract new (...args: any[]) => IPhoneCallOriginManagerStatics2;
+
+  interface IPhoneCallOriginManagerStatics3 {
+    readonly IsSupported: boolean;
+  }
+  var IPhoneCallOriginManagerStatics3: abstract new (...args: any[]) => IPhoneCallOriginManagerStatics3;
+
+}
+
+declare namespace Windows.ApplicationModel.Chat {
+  class ChatCapabilities implements Windows.ApplicationModel.Chat.IChatCapabilities {
+    readonly IsChatCapable: boolean;
+    readonly IsFileTransferCapable: boolean;
+    readonly IsGeoLocationPushCapable: boolean;
+    readonly IsIntegratedMessagingCapable: boolean;
+    readonly IsOnline: boolean;
+  }
+
+  class ChatCapabilitiesManager {
+    static GetCachedCapabilitiesAsync(address: string, transportId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatCapabilities>;
+    static GetCachedCapabilitiesAsync(address: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatCapabilities>;
+    static GetCapabilitiesFromNetworkAsync(address: string, transportId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatCapabilities>;
+    static GetCapabilitiesFromNetworkAsync(address: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatCapabilities>;
+  }
+
+  class ChatConversation implements Windows.ApplicationModel.Chat.IChatConversation, Windows.ApplicationModel.Chat.IChatConversation2, Windows.ApplicationModel.Chat.IChatItem {
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    GetMessageReader(): Windows.ApplicationModel.Chat.ChatMessageReader;
+    MarkMessagesAsReadAsync(): Windows.Foundation.IAsyncAction;
+    MarkMessagesAsReadAsync(value: Windows.Foundation.DateTime): Windows.Foundation.IAsyncAction;
+    NotifyLocalParticipantComposing(transportId: string, participantAddress: string, isComposing: boolean): void;
+    NotifyRemoteParticipantComposing(transportId: string, participantAddress: string, isComposing: boolean): void;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    CanModifyParticipants: boolean;
+    readonly HasUnreadMessages: boolean;
+    readonly Id: string;
+    IsConversationMuted: boolean;
+    readonly ItemKind: number;
+    readonly MostRecentMessageId: string;
+    readonly Participants: Windows.Foundation.Collections.IVector<string> | string[];
+    Subject: string;
+    readonly ThreadingInfo: Windows.ApplicationModel.Chat.ChatConversationThreadingInfo;
+    RemoteParticipantComposingChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Chat.ChatConversation, Windows.ApplicationModel.Chat.RemoteParticipantComposingChangedEventArgs> | null;
+  }
+
+  class ChatConversationReader implements Windows.ApplicationModel.Chat.IChatConversationReader {
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.ChatConversation> | Windows.ApplicationModel.Chat.ChatConversation[]>;
+    ReadBatchAsync(count: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.ChatConversation> | Windows.ApplicationModel.Chat.ChatConversation[]>;
+  }
+
+  class ChatConversationThreadingInfo implements Windows.ApplicationModel.Chat.IChatConversationThreadingInfo {
+    constructor();
+    ContactId: string;
+    ConversationId: string;
+    Custom: string;
+    Kind: number;
+    readonly Participants: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+
+  class ChatMessage implements Windows.ApplicationModel.Chat.IChatItem, Windows.ApplicationModel.Chat.IChatMessage, Windows.ApplicationModel.Chat.IChatMessage2, Windows.ApplicationModel.Chat.IChatMessage3, Windows.ApplicationModel.Chat.IChatMessage4 {
+    constructor();
+    readonly Attachments: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Chat.ChatMessageAttachment> | Windows.ApplicationModel.Chat.ChatMessageAttachment[];
+    Body: string;
+    EstimatedDownloadSize: number | bigint;
+    From: string;
+    readonly Id: string;
+    IsAutoReply: boolean;
+    IsForwardingDisabled: boolean;
+    IsIncoming: boolean;
+    IsRead: boolean;
+    IsReceivedDuringQuietHours: boolean;
+    readonly IsReplyDisabled: boolean;
+    IsSeen: boolean;
+    readonly IsSimMessage: boolean;
+    readonly ItemKind: number;
+    LocalTimestamp: Windows.Foundation.DateTime;
+    MessageKind: number;
+    MessageOperatorKind: number;
+    NetworkTimestamp: Windows.Foundation.DateTime;
+    readonly RecipientSendStatuses: Windows.Foundation.Collections.IMapView<string, number>;
+    readonly Recipients: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly RecipientsDeliveryInfos: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Chat.ChatRecipientDeliveryInfo> | Windows.ApplicationModel.Chat.ChatRecipientDeliveryInfo[];
+    RemoteId: string;
+    ShouldSuppressNotification: boolean;
+    Status: number;
+    Subject: string;
+    SyncId: string;
+    ThreadingInfo: Windows.ApplicationModel.Chat.ChatConversationThreadingInfo;
+    readonly TransportFriendlyName: string;
+    TransportId: string;
+  }
+
+  class ChatMessageAttachment implements Windows.ApplicationModel.Chat.IChatMessageAttachment, Windows.ApplicationModel.Chat.IChatMessageAttachment2 {
+    constructor(mimeType: string, dataStreamReference: Windows.Storage.Streams.IRandomAccessStreamReference);
+    DataStreamReference: Windows.Storage.Streams.IRandomAccessStreamReference;
+    GroupId: number;
+    MimeType: string;
+    OriginalFileName: string;
+    Text: string;
+    Thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+    TransferProgress: number;
+  }
+
+  class ChatMessageBlocking {
+    static MarkMessageAsBlockedAsync(localChatMessageId: string, blocked: boolean): Windows.Foundation.IAsyncAction;
+  }
+
+  class ChatMessageChange implements Windows.ApplicationModel.Chat.IChatMessageChange {
+    readonly ChangeType: number;
+    readonly Message: Windows.ApplicationModel.Chat.ChatMessage;
+  }
+
+  class ChatMessageChangeReader implements Windows.ApplicationModel.Chat.IChatMessageChangeReader {
+    AcceptChanges(): void;
+    AcceptChangesThrough(lastChangeToAcknowledge: Windows.ApplicationModel.Chat.ChatMessageChange): void;
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.ChatMessageChange> | Windows.ApplicationModel.Chat.ChatMessageChange[]>;
+  }
+
+  class ChatMessageChangeTracker implements Windows.ApplicationModel.Chat.IChatMessageChangeTracker {
+    Enable(): void;
+    GetChangeReader(): Windows.ApplicationModel.Chat.ChatMessageChangeReader;
+    Reset(): void;
+  }
+
+  class ChatMessageChangedDeferral implements Windows.ApplicationModel.Chat.IChatMessageChangedDeferral {
+    Complete(): void;
+  }
+
+  class ChatMessageChangedEventArgs implements Windows.ApplicationModel.Chat.IChatMessageChangedEventArgs {
+    GetDeferral(): Windows.ApplicationModel.Chat.ChatMessageChangedDeferral;
+  }
+
+  class ChatMessageManager {
+    static GetTransportAsync(transportId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatMessageTransport>;
+    static GetTransportsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.ChatMessageTransport> | Windows.ApplicationModel.Chat.ChatMessageTransport[]>;
+    static RegisterTransportAsync(): Windows.Foundation.IAsyncOperation<string>;
+    static RequestStoreAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatMessageStore>;
+    static RequestSyncManagerAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatSyncManager>;
+    static ShowComposeSmsMessageAsync(message: Windows.ApplicationModel.Chat.ChatMessage): Windows.Foundation.IAsyncAction;
+    static ShowSmsSettings(): void;
+  }
+
+  class ChatMessageNotificationTriggerDetails implements Windows.ApplicationModel.Chat.IChatMessageNotificationTriggerDetails, Windows.ApplicationModel.Chat.IChatMessageNotificationTriggerDetails2 {
+    readonly ChatMessage: Windows.ApplicationModel.Chat.ChatMessage;
+    readonly ShouldDisplayToast: boolean;
+    readonly ShouldUpdateActionCenter: boolean;
+    readonly ShouldUpdateBadge: boolean;
+    readonly ShouldUpdateDetailText: boolean;
+  }
+
+  class ChatMessageReader implements Windows.ApplicationModel.Chat.IChatMessageReader, Windows.ApplicationModel.Chat.IChatMessageReader2 {
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.ChatMessage> | Windows.ApplicationModel.Chat.ChatMessage[]>;
+    ReadBatchAsync(count: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.ChatMessage> | Windows.ApplicationModel.Chat.ChatMessage[]>;
+  }
+
+  class ChatMessageStore implements Windows.ApplicationModel.Chat.IChatMessageStore, Windows.ApplicationModel.Chat.IChatMessageStore2, Windows.ApplicationModel.Chat.IChatMessageStore3 {
+    DeleteMessageAsync(localMessageId: string): Windows.Foundation.IAsyncAction;
+    DownloadMessageAsync(localChatMessageId: string): Windows.Foundation.IAsyncAction;
+    ForwardMessageAsync(localChatMessageId: string, addresses: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatMessage>;
+    GetConversationAsync(conversationId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatConversation>;
+    GetConversationAsync(conversationId: string, transportIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatConversation>;
+    GetConversationFromThreadingInfoAsync(threadingInfo: Windows.ApplicationModel.Chat.ChatConversationThreadingInfo): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatConversation>;
+    GetConversationReader(): Windows.ApplicationModel.Chat.ChatConversationReader;
+    GetConversationReader(transportIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.ApplicationModel.Chat.ChatConversationReader;
+    GetMessageAsync(localChatMessageId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatMessage>;
+    GetMessageByRemoteIdAsync(transportId: string, remoteId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatMessage>;
+    GetMessageBySyncIdAsync(syncId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatMessage>;
+    GetMessageReader(): Windows.ApplicationModel.Chat.ChatMessageReader;
+    GetMessageReader(recentTimeLimit: Windows.Foundation.TimeSpan): Windows.ApplicationModel.Chat.ChatMessageReader;
+    GetSearchReader(value: Windows.ApplicationModel.Chat.ChatQueryOptions): Windows.ApplicationModel.Chat.ChatSearchReader;
+    GetUnseenCountAsync(): Windows.Foundation.IAsyncOperation<number>;
+    GetUnseenCountAsync(transportIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<number>;
+    MarkAsSeenAsync(): Windows.Foundation.IAsyncAction;
+    MarkAsSeenAsync(transportIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    MarkMessageReadAsync(localChatMessageId: string): Windows.Foundation.IAsyncAction;
+    RetrySendMessageAsync(localChatMessageId: string): Windows.Foundation.IAsyncAction;
+    SaveMessageAsync(chatMessage: Windows.ApplicationModel.Chat.ChatMessage): Windows.Foundation.IAsyncAction;
+    SendMessageAsync(chatMessage: Windows.ApplicationModel.Chat.ChatMessage): Windows.Foundation.IAsyncAction;
+    TryCancelDownloadMessageAsync(localChatMessageId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryCancelSendMessageAsync(localChatMessageId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    ValidateMessage(chatMessage: Windows.ApplicationModel.Chat.ChatMessage): Windows.ApplicationModel.Chat.ChatMessageValidationResult;
+    readonly ChangeTracker: Windows.ApplicationModel.Chat.ChatMessageChangeTracker;
+    MessageChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Chat.ChatMessageStore, Windows.ApplicationModel.Chat.ChatMessageChangedEventArgs> | null;
+    StoreChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Chat.ChatMessageStore, Windows.ApplicationModel.Chat.ChatMessageStoreChangedEventArgs> | null;
+  }
+
+  class ChatMessageStoreChangedEventArgs implements Windows.ApplicationModel.Chat.IChatMessageStoreChangedEventArgs {
+    readonly Id: string;
+    readonly Kind: number;
+  }
+
+  class ChatMessageTransport implements Windows.ApplicationModel.Chat.IChatMessageTransport, Windows.ApplicationModel.Chat.IChatMessageTransport2 {
+    RequestSetAsNotificationProviderAsync(): Windows.Foundation.IAsyncAction;
+    readonly Configuration: Windows.ApplicationModel.Chat.ChatMessageTransportConfiguration;
+    readonly IsActive: boolean;
+    readonly IsAppSetAsNotificationProvider: boolean;
+    readonly TransportFriendlyName: string;
+    readonly TransportId: string;
+    readonly TransportKind: number;
+  }
+
+  class ChatMessageTransportConfiguration implements Windows.ApplicationModel.Chat.IChatMessageTransportConfiguration {
+    readonly ExtendedProperties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly MaxAttachmentCount: number;
+    readonly MaxMessageSizeInKilobytes: number;
+    readonly MaxRecipientCount: number;
+    readonly SupportedVideoFormat: Windows.Media.MediaProperties.MediaEncodingProfile;
+  }
+
+  class ChatMessageValidationResult implements Windows.ApplicationModel.Chat.IChatMessageValidationResult {
+    readonly MaxPartCount: number | null;
+    readonly PartCount: number | null;
+    readonly RemainingCharacterCountInPart: number | null;
+    readonly Status: number;
+  }
+
+  class ChatQueryOptions implements Windows.ApplicationModel.Chat.IChatQueryOptions {
+    constructor();
+    SearchString: string;
+  }
+
+  class ChatRecipientDeliveryInfo implements Windows.ApplicationModel.Chat.IChatRecipientDeliveryInfo {
+    constructor();
+    DeliveryTime: Windows.Foundation.DateTime | null;
+    readonly IsErrorPermanent: boolean;
+    ReadTime: Windows.Foundation.DateTime | null;
+    readonly Status: number;
+    TransportAddress: string;
+    readonly TransportErrorCode: number;
+    readonly TransportErrorCodeCategory: number;
+    readonly TransportInterpretedErrorCode: number;
+  }
+
+  class ChatSearchReader implements Windows.ApplicationModel.Chat.IChatSearchReader {
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.IChatItem> | Windows.ApplicationModel.Chat.IChatItem[]>;
+    ReadBatchAsync(count: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.IChatItem> | Windows.ApplicationModel.Chat.IChatItem[]>;
+  }
+
+  class ChatSyncConfiguration implements Windows.ApplicationModel.Chat.IChatSyncConfiguration {
+    IsSyncEnabled: boolean;
+    RestoreHistorySpan: number;
+  }
+
+  class ChatSyncManager implements Windows.ApplicationModel.Chat.IChatSyncManager {
+    AssociateAccountAsync(webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncAction;
+    IsAccountAssociated(webAccount: Windows.Security.Credentials.WebAccount): boolean;
+    SetConfigurationAsync(configuration: Windows.ApplicationModel.Chat.ChatSyncConfiguration): Windows.Foundation.IAsyncAction;
+    StartSync(): void;
+    UnassociateAccountAsync(): Windows.Foundation.IAsyncAction;
+    readonly Configuration: Windows.ApplicationModel.Chat.ChatSyncConfiguration;
+  }
+
+  class RcsEndUserMessage implements Windows.ApplicationModel.Chat.IRcsEndUserMessage {
+    SendResponseAsync(action: Windows.ApplicationModel.Chat.RcsEndUserMessageAction): Windows.Foundation.IAsyncAction;
+    SendResponseWithPinAsync(action: Windows.ApplicationModel.Chat.RcsEndUserMessageAction, pin: string): Windows.Foundation.IAsyncAction;
+    readonly Actions: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.RcsEndUserMessageAction> | Windows.ApplicationModel.Chat.RcsEndUserMessageAction[];
+    readonly IsPinRequired: boolean;
+    readonly Text: string;
+    readonly Title: string;
+    readonly TransportId: string;
+  }
+
+  class RcsEndUserMessageAction implements Windows.ApplicationModel.Chat.IRcsEndUserMessageAction {
+    readonly Label: string;
+  }
+
+  class RcsEndUserMessageAvailableEventArgs implements Windows.ApplicationModel.Chat.IRcsEndUserMessageAvailableEventArgs {
+    readonly IsMessageAvailable: boolean;
+    readonly Message: Windows.ApplicationModel.Chat.RcsEndUserMessage;
+  }
+
+  class RcsEndUserMessageAvailableTriggerDetails implements Windows.ApplicationModel.Chat.IRcsEndUserMessageAvailableTriggerDetails {
+    readonly Text: string;
+    readonly Title: string;
+  }
+
+  class RcsEndUserMessageManager implements Windows.ApplicationModel.Chat.IRcsEndUserMessageManager {
+    MessageAvailableChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Chat.RcsEndUserMessageManager, Windows.ApplicationModel.Chat.RcsEndUserMessageAvailableEventArgs> | null;
+  }
+
+  class RcsManager {
+    static GetEndUserMessageManager(): Windows.ApplicationModel.Chat.RcsEndUserMessageManager;
+    static GetTransportAsync(transportId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.RcsTransport>;
+    static GetTransportsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.RcsTransport> | Windows.ApplicationModel.Chat.RcsTransport[]>;
+    static LeaveConversationAsync(conversation: Windows.ApplicationModel.Chat.ChatConversation): Windows.Foundation.IAsyncAction;
+    static TransportListChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class RcsServiceKindSupportedChangedEventArgs implements Windows.ApplicationModel.Chat.IRcsServiceKindSupportedChangedEventArgs {
+    readonly ServiceKind: number;
+  }
+
+  class RcsTransport implements Windows.ApplicationModel.Chat.IRcsTransport {
+    IsServiceKindSupported(serviceKind: number): boolean;
+    IsStoreAndForwardEnabled(serviceKind: number): boolean;
+    readonly Configuration: Windows.ApplicationModel.Chat.RcsTransportConfiguration;
+    readonly ExtendedProperties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly IsActive: boolean;
+    readonly TransportFriendlyName: string;
+    readonly TransportId: string;
+    ServiceKindSupportedChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Chat.RcsTransport, Windows.ApplicationModel.Chat.RcsServiceKindSupportedChangedEventArgs> | null;
+  }
+
+  class RcsTransportConfiguration implements Windows.ApplicationModel.Chat.IRcsTransportConfiguration {
+    readonly MaxAttachmentCount: number;
+    readonly MaxFileSizeInKilobytes: number;
+    readonly MaxGroupMessageSizeInKilobytes: number;
+    readonly MaxMessageSizeInKilobytes: number;
+    readonly MaxRecipientCount: number;
+    readonly WarningFileSizeInKilobytes: number;
+  }
+
+  class RemoteParticipantComposingChangedEventArgs implements Windows.ApplicationModel.Chat.IRemoteParticipantComposingChangedEventArgs {
+    readonly IsComposing: boolean;
+    readonly ParticipantAddress: string;
+    readonly TransportId: string;
+  }
+
+  enum ChatConversationThreadingKind {
+    Participants = 0,
+    ContactId = 1,
+    ConversationId = 2,
+    Custom = 3,
+  }
+
+  enum ChatItemKind {
+    Message = 0,
+    Conversation = 1,
+  }
+
+  enum ChatMessageChangeType {
+    MessageCreated = 0,
+    MessageModified = 1,
+    MessageDeleted = 2,
+    ChangeTrackingLost = 3,
+  }
+
+  enum ChatMessageKind {
+    Standard = 0,
+    FileTransferRequest = 1,
+    TransportCustom = 2,
+    JoinedConversation = 3,
+    LeftConversation = 4,
+    OtherParticipantJoinedConversation = 5,
+    OtherParticipantLeftConversation = 6,
+  }
+
+  enum ChatMessageOperatorKind {
+    Unspecified = 0,
+    Sms = 1,
+    Mms = 2,
+    Rcs = 3,
+  }
+
+  enum ChatMessageStatus {
+    Draft = 0,
+    Sending = 1,
+    Sent = 2,
+    SendRetryNeeded = 3,
+    SendFailed = 4,
+    Received = 5,
+    ReceiveDownloadNeeded = 6,
+    ReceiveDownloadFailed = 7,
+    ReceiveDownloading = 8,
+    Deleted = 9,
+    Declined = 10,
+    Cancelled = 11,
+    Recalled = 12,
+    ReceiveRetryNeeded = 13,
+  }
+
+  enum ChatMessageTransportKind {
+    Text = 0,
+    Untriaged = 1,
+    Blocked = 2,
+    Custom = 3,
+  }
+
+  enum ChatMessageValidationStatus {
+    Valid = 0,
+    NoRecipients = 1,
+    InvalidData = 2,
+    MessageTooLarge = 3,
+    TooManyRecipients = 4,
+    TransportInactive = 5,
+    TransportNotFound = 6,
+    TooManyAttachments = 7,
+    InvalidRecipients = 8,
+    InvalidBody = 9,
+    InvalidOther = 10,
+    ValidWithLargeMessage = 11,
+    VoiceRoamingRestriction = 12,
+    DataRoamingRestriction = 13,
+  }
+
+  enum ChatRestoreHistorySpan {
+    LastMonth = 0,
+    LastYear = 1,
+    AnyTime = 2,
+  }
+
+  enum ChatStoreChangedEventKind {
+    NotificationsMissed = 0,
+    StoreModified = 1,
+    MessageCreated = 2,
+    MessageModified = 3,
+    MessageDeleted = 4,
+    ConversationModified = 5,
+    ConversationDeleted = 6,
+    ConversationTransportDeleted = 7,
+  }
+
+  enum ChatTransportErrorCodeCategory {
+    None = 0,
+    Http = 1,
+    Network = 2,
+    MmsServer = 3,
+  }
+
+  enum ChatTransportInterpretedErrorCode {
+    None = 0,
+    Unknown = 1,
+    InvalidRecipientAddress = 2,
+    NetworkConnectivity = 3,
+    ServiceDenied = 4,
+    Timeout = 5,
+  }
+
+  enum RcsServiceKind {
+    Chat = 0,
+    GroupChat = 1,
+    FileTransfer = 2,
+    Capability = 3,
+  }
+
+  interface IChatCapabilities {
+    readonly IsChatCapable: boolean;
+    readonly IsFileTransferCapable: boolean;
+    readonly IsGeoLocationPushCapable: boolean;
+    readonly IsIntegratedMessagingCapable: boolean;
+    readonly IsOnline: boolean;
+  }
+  var IChatCapabilities: abstract new (...args: any[]) => IChatCapabilities;
+
+  interface IChatCapabilitiesManagerStatics {
+    GetCachedCapabilitiesAsync(address: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatCapabilities>;
+    GetCapabilitiesFromNetworkAsync(address: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatCapabilities>;
+  }
+  var IChatCapabilitiesManagerStatics: abstract new (...args: any[]) => IChatCapabilitiesManagerStatics;
+
+  interface IChatCapabilitiesManagerStatics2 {
+    GetCachedCapabilitiesAsync(address: string, transportId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatCapabilities>;
+    GetCapabilitiesFromNetworkAsync(address: string, transportId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatCapabilities>;
+  }
+  var IChatCapabilitiesManagerStatics2: abstract new (...args: any[]) => IChatCapabilitiesManagerStatics2;
+
+  interface IChatConversation {
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    GetMessageReader(): Windows.ApplicationModel.Chat.ChatMessageReader;
+    MarkMessagesAsReadAsync(): Windows.Foundation.IAsyncAction;
+    MarkMessagesAsReadAsync(value: Windows.Foundation.DateTime): Windows.Foundation.IAsyncAction;
+    NotifyLocalParticipantComposing(transportId: string, participantAddress: string, isComposing: boolean): void;
+    NotifyRemoteParticipantComposing(transportId: string, participantAddress: string, isComposing: boolean): void;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    readonly HasUnreadMessages: boolean;
+    readonly Id: string;
+    IsConversationMuted: boolean;
+    readonly MostRecentMessageId: string;
+    readonly Participants: Windows.Foundation.Collections.IVector<string> | string[];
+    Subject: string;
+    readonly ThreadingInfo: Windows.ApplicationModel.Chat.ChatConversationThreadingInfo;
+    RemoteParticipantComposingChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Chat.ChatConversation, Windows.ApplicationModel.Chat.RemoteParticipantComposingChangedEventArgs> | null;
+  }
+  var IChatConversation: abstract new (...args: any[]) => IChatConversation;
+
+  interface IChatConversation2 {
+    CanModifyParticipants: boolean;
+  }
+  var IChatConversation2: abstract new (...args: any[]) => IChatConversation2;
+
+  interface IChatConversationReader {
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.ChatConversation> | Windows.ApplicationModel.Chat.ChatConversation[]>;
+    ReadBatchAsync(count: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.ChatConversation> | Windows.ApplicationModel.Chat.ChatConversation[]>;
+  }
+  var IChatConversationReader: abstract new (...args: any[]) => IChatConversationReader;
+
+  interface IChatConversationThreadingInfo {
+    ContactId: string;
+    ConversationId: string;
+    Custom: string;
+    Kind: number;
+    readonly Participants: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var IChatConversationThreadingInfo: abstract new (...args: any[]) => IChatConversationThreadingInfo;
+
+  interface IChatItem {
+    readonly ItemKind: number;
+  }
+  var IChatItem: abstract new (...args: any[]) => IChatItem;
+
+  interface IChatMessage {
+    readonly Attachments: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Chat.ChatMessageAttachment> | Windows.ApplicationModel.Chat.ChatMessageAttachment[];
+    Body: string;
+    readonly From: string;
+    readonly Id: string;
+    readonly IsForwardingDisabled: boolean;
+    readonly IsIncoming: boolean;
+    readonly IsRead: boolean;
+    readonly LocalTimestamp: Windows.Foundation.DateTime;
+    readonly NetworkTimestamp: Windows.Foundation.DateTime;
+    readonly RecipientSendStatuses: Windows.Foundation.Collections.IMapView<string, number>;
+    readonly Recipients: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Status: number;
+    readonly Subject: string;
+    readonly TransportFriendlyName: string;
+    TransportId: string;
+  }
+  var IChatMessage: abstract new (...args: any[]) => IChatMessage;
+
+  interface IChatMessage2 extends Windows.ApplicationModel.Chat.IChatMessage, Windows.ApplicationModel.Chat.IChatMessage3 {
+    EstimatedDownloadSize: number | bigint;
+    From: Object;
+    IsAutoReply: boolean;
+    IsForwardingDisabled: Object;
+    IsIncoming: Object;
+    IsRead: Object;
+    IsReceivedDuringQuietHours: boolean;
+    readonly IsReplyDisabled: boolean;
+    IsSeen: boolean;
+    readonly IsSimMessage: boolean;
+    LocalTimestamp: Object;
+    MessageKind: number;
+    MessageOperatorKind: number;
+    NetworkTimestamp: Object;
+    readonly RecipientsDeliveryInfos: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Chat.ChatRecipientDeliveryInfo> | Windows.ApplicationModel.Chat.ChatRecipientDeliveryInfo[];
+    RemoteId: Object;
+    ShouldSuppressNotification: boolean;
+    Status: Object;
+    Subject: Object;
+    ThreadingInfo: Windows.ApplicationModel.Chat.ChatConversationThreadingInfo;
+  }
+  var IChatMessage2: abstract new (...args: any[]) => IChatMessage2;
+
+  interface IChatMessage3 extends Windows.ApplicationModel.Chat.IChatMessage {
+    readonly RemoteId: string;
+  }
+  var IChatMessage3: abstract new (...args: any[]) => IChatMessage3;
+
+  interface IChatMessage4 extends Windows.ApplicationModel.Chat.IChatMessage {
+    SyncId: string;
+  }
+  var IChatMessage4: abstract new (...args: any[]) => IChatMessage4;
+
+  interface IChatMessageAttachment {
+    DataStreamReference: Windows.Storage.Streams.IRandomAccessStreamReference;
+    GroupId: number;
+    MimeType: string;
+    Text: string;
+  }
+  var IChatMessageAttachment: abstract new (...args: any[]) => IChatMessageAttachment;
+
+  interface IChatMessageAttachment2 extends Windows.ApplicationModel.Chat.IChatMessageAttachment {
+    OriginalFileName: string;
+    Thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+    TransferProgress: number;
+  }
+  var IChatMessageAttachment2: abstract new (...args: any[]) => IChatMessageAttachment2;
+
+  interface IChatMessageAttachmentFactory {
+    CreateChatMessageAttachment(mimeType: string, dataStreamReference: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.ApplicationModel.Chat.ChatMessageAttachment;
+  }
+  var IChatMessageAttachmentFactory: abstract new (...args: any[]) => IChatMessageAttachmentFactory;
+
+  interface IChatMessageBlockingStatic {
+    MarkMessageAsBlockedAsync(localChatMessageId: string, blocked: boolean): Windows.Foundation.IAsyncAction;
+  }
+  var IChatMessageBlockingStatic: abstract new (...args: any[]) => IChatMessageBlockingStatic;
+
+  interface IChatMessageChange {
+    readonly ChangeType: number;
+    readonly Message: Windows.ApplicationModel.Chat.ChatMessage;
+  }
+  var IChatMessageChange: abstract new (...args: any[]) => IChatMessageChange;
+
+  interface IChatMessageChangeReader {
+    AcceptChanges(): void;
+    AcceptChangesThrough(lastChangeToAcknowledge: Windows.ApplicationModel.Chat.ChatMessageChange): void;
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.ChatMessageChange> | Windows.ApplicationModel.Chat.ChatMessageChange[]>;
+  }
+  var IChatMessageChangeReader: abstract new (...args: any[]) => IChatMessageChangeReader;
+
+  interface IChatMessageChangeTracker {
+    Enable(): void;
+    GetChangeReader(): Windows.ApplicationModel.Chat.ChatMessageChangeReader;
+    Reset(): void;
+  }
+  var IChatMessageChangeTracker: abstract new (...args: any[]) => IChatMessageChangeTracker;
+
+  interface IChatMessageChangedDeferral {
+    Complete(): void;
+  }
+  var IChatMessageChangedDeferral: abstract new (...args: any[]) => IChatMessageChangedDeferral;
+
+  interface IChatMessageChangedEventArgs {
+    GetDeferral(): Windows.ApplicationModel.Chat.ChatMessageChangedDeferral;
+  }
+  var IChatMessageChangedEventArgs: abstract new (...args: any[]) => IChatMessageChangedEventArgs;
+
+  interface IChatMessageManager2Statics extends Windows.ApplicationModel.Chat.IChatMessageManagerStatic {
+    GetTransportAsync(transportId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatMessageTransport>;
+    GetTransportsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.ChatMessageTransport> | Windows.ApplicationModel.Chat.ChatMessageTransport[]>;
+    RegisterTransportAsync(): Windows.Foundation.IAsyncOperation<string>;
+    RequestStoreAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatMessageStore>;
+    ShowComposeSmsMessageAsync(message: Windows.ApplicationModel.Chat.ChatMessage): Windows.Foundation.IAsyncAction;
+    ShowSmsSettings(): void;
+  }
+  var IChatMessageManager2Statics: abstract new (...args: any[]) => IChatMessageManager2Statics;
+
+  interface IChatMessageManagerStatic {
+    GetTransportsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.ChatMessageTransport> | Windows.ApplicationModel.Chat.ChatMessageTransport[]>;
+    RequestStoreAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatMessageStore>;
+    ShowComposeSmsMessageAsync(message: Windows.ApplicationModel.Chat.ChatMessage): Windows.Foundation.IAsyncAction;
+    ShowSmsSettings(): void;
+  }
+  var IChatMessageManagerStatic: abstract new (...args: any[]) => IChatMessageManagerStatic;
+
+  interface IChatMessageManagerStatics3 extends Windows.ApplicationModel.Chat.IChatMessageManagerStatic {
+    GetTransportsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.ChatMessageTransport> | Windows.ApplicationModel.Chat.ChatMessageTransport[]>;
+    RequestStoreAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatMessageStore>;
+    RequestSyncManagerAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatSyncManager>;
+    ShowComposeSmsMessageAsync(message: Windows.ApplicationModel.Chat.ChatMessage): Windows.Foundation.IAsyncAction;
+    ShowSmsSettings(): void;
+  }
+  var IChatMessageManagerStatics3: abstract new (...args: any[]) => IChatMessageManagerStatics3;
+
+  interface IChatMessageNotificationTriggerDetails {
+    readonly ChatMessage: Windows.ApplicationModel.Chat.ChatMessage;
+  }
+  var IChatMessageNotificationTriggerDetails: abstract new (...args: any[]) => IChatMessageNotificationTriggerDetails;
+
+  interface IChatMessageNotificationTriggerDetails2 extends Windows.ApplicationModel.Chat.IChatMessageNotificationTriggerDetails {
+    readonly ShouldDisplayToast: boolean;
+    readonly ShouldUpdateActionCenter: boolean;
+    readonly ShouldUpdateBadge: boolean;
+    readonly ShouldUpdateDetailText: boolean;
+  }
+  var IChatMessageNotificationTriggerDetails2: abstract new (...args: any[]) => IChatMessageNotificationTriggerDetails2;
+
+  interface IChatMessageReader {
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.ChatMessage> | Windows.ApplicationModel.Chat.ChatMessage[]>;
+  }
+  var IChatMessageReader: abstract new (...args: any[]) => IChatMessageReader;
+
+  interface IChatMessageReader2 {
+    ReadBatchAsync(count: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.ChatMessage> | Windows.ApplicationModel.Chat.ChatMessage[]>;
+  }
+  var IChatMessageReader2: abstract new (...args: any[]) => IChatMessageReader2;
+
+  interface IChatMessageStore {
+    DeleteMessageAsync(localMessageId: string): Windows.Foundation.IAsyncAction;
+    DownloadMessageAsync(localChatMessageId: string): Windows.Foundation.IAsyncAction;
+    GetMessageAsync(localChatMessageId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatMessage>;
+    GetMessageReader(): Windows.ApplicationModel.Chat.ChatMessageReader;
+    GetMessageReader(recentTimeLimit: Windows.Foundation.TimeSpan): Windows.ApplicationModel.Chat.ChatMessageReader;
+    MarkMessageReadAsync(localChatMessageId: string): Windows.Foundation.IAsyncAction;
+    RetrySendMessageAsync(localChatMessageId: string): Windows.Foundation.IAsyncAction;
+    SendMessageAsync(chatMessage: Windows.ApplicationModel.Chat.ChatMessage): Windows.Foundation.IAsyncAction;
+    ValidateMessage(chatMessage: Windows.ApplicationModel.Chat.ChatMessage): Windows.ApplicationModel.Chat.ChatMessageValidationResult;
+    readonly ChangeTracker: Windows.ApplicationModel.Chat.ChatMessageChangeTracker;
+    MessageChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Chat.ChatMessageStore, Windows.ApplicationModel.Chat.ChatMessageChangedEventArgs> | null;
+  }
+  var IChatMessageStore: abstract new (...args: any[]) => IChatMessageStore;
+
+  interface IChatMessageStore2 extends Windows.ApplicationModel.Chat.IChatMessageStore {
+    DeleteMessageAsync(localMessageId: string): Windows.Foundation.IAsyncAction;
+    DownloadMessageAsync(localChatMessageId: string): Windows.Foundation.IAsyncAction;
+    ForwardMessageAsync(localChatMessageId: string, addresses: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatMessage>;
+    GetConversationAsync(conversationId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatConversation>;
+    GetConversationAsync(conversationId: string, transportIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatConversation>;
+    GetConversationFromThreadingInfoAsync(threadingInfo: Windows.ApplicationModel.Chat.ChatConversationThreadingInfo): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatConversation>;
+    GetConversationReader(): Windows.ApplicationModel.Chat.ChatConversationReader;
+    GetConversationReader(transportIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.ApplicationModel.Chat.ChatConversationReader;
+    GetMessageAsync(localChatMessageId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatMessage>;
+    GetMessageByRemoteIdAsync(transportId: string, remoteId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatMessage>;
+    GetMessageReader(): Windows.ApplicationModel.Chat.ChatMessageReader;
+    GetMessageReader(recentTimeLimit: Windows.Foundation.TimeSpan): Windows.ApplicationModel.Chat.ChatMessageReader;
+    GetSearchReader(value: Windows.ApplicationModel.Chat.ChatQueryOptions): Windows.ApplicationModel.Chat.ChatSearchReader;
+    GetUnseenCountAsync(): Windows.Foundation.IAsyncOperation<number>;
+    GetUnseenCountAsync(transportIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<number>;
+    MarkAsSeenAsync(): Windows.Foundation.IAsyncAction;
+    MarkAsSeenAsync(transportIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    MarkMessageReadAsync(localChatMessageId: string): Windows.Foundation.IAsyncAction;
+    RetrySendMessageAsync(localChatMessageId: string): Windows.Foundation.IAsyncAction;
+    SaveMessageAsync(chatMessage: Windows.ApplicationModel.Chat.ChatMessage): Windows.Foundation.IAsyncAction;
+    SendMessageAsync(chatMessage: Windows.ApplicationModel.Chat.ChatMessage): Windows.Foundation.IAsyncAction;
+    TryCancelDownloadMessageAsync(localChatMessageId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryCancelSendMessageAsync(localChatMessageId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    ValidateMessage(chatMessage: Windows.ApplicationModel.Chat.ChatMessage): Windows.ApplicationModel.Chat.ChatMessageValidationResult;
+    StoreChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Chat.ChatMessageStore, Windows.ApplicationModel.Chat.ChatMessageStoreChangedEventArgs> | null;
+  }
+  var IChatMessageStore2: abstract new (...args: any[]) => IChatMessageStore2;
+
+  interface IChatMessageStore3 extends Windows.ApplicationModel.Chat.IChatMessageStore {
+    DeleteMessageAsync(localMessageId: string): Windows.Foundation.IAsyncAction;
+    DownloadMessageAsync(localChatMessageId: string): Windows.Foundation.IAsyncAction;
+    GetMessageAsync(localChatMessageId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatMessage>;
+    GetMessageBySyncIdAsync(syncId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.ChatMessage>;
+    GetMessageReader(): Windows.ApplicationModel.Chat.ChatMessageReader;
+    GetMessageReader(recentTimeLimit: Windows.Foundation.TimeSpan): Windows.ApplicationModel.Chat.ChatMessageReader;
+    MarkMessageReadAsync(localChatMessageId: string): Windows.Foundation.IAsyncAction;
+    RetrySendMessageAsync(localChatMessageId: string): Windows.Foundation.IAsyncAction;
+    SendMessageAsync(chatMessage: Windows.ApplicationModel.Chat.ChatMessage): Windows.Foundation.IAsyncAction;
+    ValidateMessage(chatMessage: Windows.ApplicationModel.Chat.ChatMessage): Windows.ApplicationModel.Chat.ChatMessageValidationResult;
+  }
+  var IChatMessageStore3: abstract new (...args: any[]) => IChatMessageStore3;
+
+  interface IChatMessageStoreChangedEventArgs {
+    readonly Id: string;
+    readonly Kind: number;
+  }
+  var IChatMessageStoreChangedEventArgs: abstract new (...args: any[]) => IChatMessageStoreChangedEventArgs;
+
+  interface IChatMessageTransport {
+    RequestSetAsNotificationProviderAsync(): Windows.Foundation.IAsyncAction;
+    readonly IsActive: boolean;
+    readonly IsAppSetAsNotificationProvider: boolean;
+    readonly TransportFriendlyName: string;
+    readonly TransportId: string;
+  }
+  var IChatMessageTransport: abstract new (...args: any[]) => IChatMessageTransport;
+
+  interface IChatMessageTransport2 extends Windows.ApplicationModel.Chat.IChatMessageTransport {
+    RequestSetAsNotificationProviderAsync(): Windows.Foundation.IAsyncAction;
+    readonly Configuration: Windows.ApplicationModel.Chat.ChatMessageTransportConfiguration;
+    readonly TransportKind: number;
+  }
+  var IChatMessageTransport2: abstract new (...args: any[]) => IChatMessageTransport2;
+
+  interface IChatMessageTransportConfiguration {
+    readonly ExtendedProperties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly MaxAttachmentCount: number;
+    readonly MaxMessageSizeInKilobytes: number;
+    readonly MaxRecipientCount: number;
+    readonly SupportedVideoFormat: Windows.Media.MediaProperties.MediaEncodingProfile;
+  }
+  var IChatMessageTransportConfiguration: abstract new (...args: any[]) => IChatMessageTransportConfiguration;
+
+  interface IChatMessageValidationResult {
+    readonly MaxPartCount: number | null;
+    readonly PartCount: number | null;
+    readonly RemainingCharacterCountInPart: number | null;
+    readonly Status: number;
+  }
+  var IChatMessageValidationResult: abstract new (...args: any[]) => IChatMessageValidationResult;
+
+  interface IChatQueryOptions {
+    SearchString: string;
+  }
+  var IChatQueryOptions: abstract new (...args: any[]) => IChatQueryOptions;
+
+  interface IChatRecipientDeliveryInfo {
+    DeliveryTime: Windows.Foundation.DateTime | null;
+    readonly IsErrorPermanent: boolean;
+    ReadTime: Windows.Foundation.DateTime | null;
+    readonly Status: number;
+    TransportAddress: string;
+    readonly TransportErrorCode: number;
+    readonly TransportErrorCodeCategory: number;
+    readonly TransportInterpretedErrorCode: number;
+  }
+  var IChatRecipientDeliveryInfo: abstract new (...args: any[]) => IChatRecipientDeliveryInfo;
+
+  interface IChatSearchReader {
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.IChatItem> | Windows.ApplicationModel.Chat.IChatItem[]>;
+    ReadBatchAsync(count: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.IChatItem> | Windows.ApplicationModel.Chat.IChatItem[]>;
+  }
+  var IChatSearchReader: abstract new (...args: any[]) => IChatSearchReader;
+
+  interface IChatSyncConfiguration {
+    IsSyncEnabled: boolean;
+    RestoreHistorySpan: number;
+  }
+  var IChatSyncConfiguration: abstract new (...args: any[]) => IChatSyncConfiguration;
+
+  interface IChatSyncManager {
+    AssociateAccountAsync(webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncAction;
+    IsAccountAssociated(webAccount: Windows.Security.Credentials.WebAccount): boolean;
+    SetConfigurationAsync(configuration: Windows.ApplicationModel.Chat.ChatSyncConfiguration): Windows.Foundation.IAsyncAction;
+    StartSync(): void;
+    UnassociateAccountAsync(): Windows.Foundation.IAsyncAction;
+    readonly Configuration: Windows.ApplicationModel.Chat.ChatSyncConfiguration;
+  }
+  var IChatSyncManager: abstract new (...args: any[]) => IChatSyncManager;
+
+  interface IRcsEndUserMessage {
+    SendResponseAsync(action: Windows.ApplicationModel.Chat.RcsEndUserMessageAction): Windows.Foundation.IAsyncAction;
+    SendResponseWithPinAsync(action: Windows.ApplicationModel.Chat.RcsEndUserMessageAction, pin: string): Windows.Foundation.IAsyncAction;
+    readonly Actions: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.RcsEndUserMessageAction> | Windows.ApplicationModel.Chat.RcsEndUserMessageAction[];
+    readonly IsPinRequired: boolean;
+    readonly Text: string;
+    readonly Title: string;
+    readonly TransportId: string;
+  }
+  var IRcsEndUserMessage: abstract new (...args: any[]) => IRcsEndUserMessage;
+
+  interface IRcsEndUserMessageAction {
+    readonly Label: string;
+  }
+  var IRcsEndUserMessageAction: abstract new (...args: any[]) => IRcsEndUserMessageAction;
+
+  interface IRcsEndUserMessageAvailableEventArgs {
+    readonly IsMessageAvailable: boolean;
+    readonly Message: Windows.ApplicationModel.Chat.RcsEndUserMessage;
+  }
+  var IRcsEndUserMessageAvailableEventArgs: abstract new (...args: any[]) => IRcsEndUserMessageAvailableEventArgs;
+
+  interface IRcsEndUserMessageAvailableTriggerDetails {
+    readonly Text: string;
+    readonly Title: string;
+  }
+  var IRcsEndUserMessageAvailableTriggerDetails: abstract new (...args: any[]) => IRcsEndUserMessageAvailableTriggerDetails;
+
+  interface IRcsEndUserMessageManager {
+    MessageAvailableChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Chat.RcsEndUserMessageManager, Windows.ApplicationModel.Chat.RcsEndUserMessageAvailableEventArgs> | null;
+  }
+  var IRcsEndUserMessageManager: abstract new (...args: any[]) => IRcsEndUserMessageManager;
+
+  interface IRcsManagerStatics {
+    GetEndUserMessageManager(): Windows.ApplicationModel.Chat.RcsEndUserMessageManager;
+    GetTransportAsync(transportId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Chat.RcsTransport>;
+    GetTransportsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Chat.RcsTransport> | Windows.ApplicationModel.Chat.RcsTransport[]>;
+    LeaveConversationAsync(conversation: Windows.ApplicationModel.Chat.ChatConversation): Windows.Foundation.IAsyncAction;
+  }
+  var IRcsManagerStatics: abstract new (...args: any[]) => IRcsManagerStatics;
+
+  interface IRcsManagerStatics2 {
+    TransportListChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IRcsManagerStatics2: abstract new (...args: any[]) => IRcsManagerStatics2;
+
+  interface IRcsServiceKindSupportedChangedEventArgs {
+    readonly ServiceKind: number;
+  }
+  var IRcsServiceKindSupportedChangedEventArgs: abstract new (...args: any[]) => IRcsServiceKindSupportedChangedEventArgs;
+
+  interface IRcsTransport {
+    IsServiceKindSupported(serviceKind: number): boolean;
+    IsStoreAndForwardEnabled(serviceKind: number): boolean;
+    readonly Configuration: Windows.ApplicationModel.Chat.RcsTransportConfiguration;
+    readonly ExtendedProperties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly IsActive: boolean;
+    readonly TransportFriendlyName: string;
+    readonly TransportId: string;
+    ServiceKindSupportedChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Chat.RcsTransport, Windows.ApplicationModel.Chat.RcsServiceKindSupportedChangedEventArgs> | null;
+  }
+  var IRcsTransport: abstract new (...args: any[]) => IRcsTransport;
+
+  interface IRcsTransportConfiguration {
+    readonly MaxAttachmentCount: number;
+    readonly MaxFileSizeInKilobytes: number;
+    readonly MaxGroupMessageSizeInKilobytes: number;
+    readonly MaxMessageSizeInKilobytes: number;
+    readonly MaxRecipientCount: number;
+    readonly WarningFileSizeInKilobytes: number;
+  }
+  var IRcsTransportConfiguration: abstract new (...args: any[]) => IRcsTransportConfiguration;
+
+  interface IRemoteParticipantComposingChangedEventArgs {
+    readonly IsComposing: boolean;
+    readonly ParticipantAddress: string;
+    readonly TransportId: string;
+  }
+  var IRemoteParticipantComposingChangedEventArgs: abstract new (...args: any[]) => IRemoteParticipantComposingChangedEventArgs;
+
+}
+
+declare namespace Windows.ApplicationModel.CommunicationBlocking {
+  class CommunicationBlockingAccessManager {
+    static IsBlockedNumberAsync(number: string): Windows.Foundation.IAsyncOperation<boolean>;
+    static ShowBlockNumbersUI(phoneNumbers: Windows.Foundation.Collections.IIterable<string> | string[]): boolean;
+    static ShowBlockedCallsUI(): void;
+    static ShowBlockedMessagesUI(): void;
+    static ShowUnblockNumbersUI(phoneNumbers: Windows.Foundation.Collections.IIterable<string> | string[]): boolean;
+    static readonly IsBlockingActive: boolean;
+  }
+
+  class CommunicationBlockingAppManager {
+    static RequestSetAsActiveBlockingAppAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    static ShowCommunicationBlockingSettingsUI(): void;
+    static readonly IsCurrentAppActiveBlockingApp: boolean;
+  }
+
+  interface CommunicationBlockingContract {
+  }
+  var CommunicationBlockingContract: {
+    new(fields: {  }): CommunicationBlockingContract;
+  };
+
+  interface ICommunicationBlockingAccessManagerStatics {
+    IsBlockedNumberAsync(number: string): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowBlockNumbersUI(phoneNumbers: Windows.Foundation.Collections.IIterable<string> | string[]): boolean;
+    ShowBlockedCallsUI(): void;
+    ShowBlockedMessagesUI(): void;
+    ShowUnblockNumbersUI(phoneNumbers: Windows.Foundation.Collections.IIterable<string> | string[]): boolean;
+    readonly IsBlockingActive: boolean;
+  }
+  var ICommunicationBlockingAccessManagerStatics: abstract new (...args: any[]) => ICommunicationBlockingAccessManagerStatics;
+
+  interface ICommunicationBlockingAppManagerStatics {
+    ShowCommunicationBlockingSettingsUI(): void;
+    readonly IsCurrentAppActiveBlockingApp: boolean;
+  }
+  var ICommunicationBlockingAppManagerStatics: abstract new (...args: any[]) => ICommunicationBlockingAppManagerStatics;
+
+  interface ICommunicationBlockingAppManagerStatics2 extends Windows.ApplicationModel.CommunicationBlocking.ICommunicationBlockingAppManagerStatics {
+    RequestSetAsActiveBlockingAppAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowCommunicationBlockingSettingsUI(): void;
+  }
+  var ICommunicationBlockingAppManagerStatics2: abstract new (...args: any[]) => ICommunicationBlockingAppManagerStatics2;
+
+}
+
+declare namespace Windows.ApplicationModel.Contacts {
+  class AggregateContactManager implements Windows.ApplicationModel.Contacts.IAggregateContactManager, Windows.ApplicationModel.Contacts.IAggregateContactManager2 {
+    FindRawContactsAsync(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.Contact> | Windows.ApplicationModel.Contacts.Contact[]>;
+    SetRemoteIdentificationInformationAsync(contactListId: string, remoteSourceId: string, accountId: string): Windows.Foundation.IAsyncAction;
+    TryLinkContactsAsync(primaryContact: Windows.ApplicationModel.Contacts.Contact, secondaryContact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.Contact>;
+    TrySetPreferredSourceForPictureAsync(aggregateContact: Windows.ApplicationModel.Contacts.Contact, rawContact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncOperation<boolean>;
+    UnlinkRawContactAsync(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncAction;
+  }
+
+  class Contact implements Windows.ApplicationModel.Contacts.IContact, Windows.ApplicationModel.Contacts.IContact2, Windows.ApplicationModel.Contacts.IContact3, Windows.ApplicationModel.Contacts.IContactName {
+    constructor();
+    readonly Addresses: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.ContactAddress> | Windows.ApplicationModel.Contacts.ContactAddress[];
+    readonly AggregateId: string;
+    readonly ConnectedServiceAccounts: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.ContactConnectedServiceAccount> | Windows.ApplicationModel.Contacts.ContactConnectedServiceAccount[];
+    readonly ContactListId: string;
+    readonly DataSuppliers: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly DisplayName: string;
+    DisplayNameOverride: string;
+    DisplayPictureUserUpdateTime: Windows.Foundation.DateTime;
+    readonly Emails: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.ContactEmail> | Windows.ApplicationModel.Contacts.ContactEmail[];
+    readonly Fields: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.IContactField> | Windows.ApplicationModel.Contacts.IContactField[];
+    FirstName: string;
+    readonly FullName: string;
+    HonorificNamePrefix: string;
+    HonorificNameSuffix: string;
+    Id: string;
+    readonly ImportantDates: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.ContactDate> | Windows.ApplicationModel.Contacts.ContactDate[];
+    readonly IsAggregate: boolean;
+    readonly IsDisplayPictureManuallySet: boolean;
+    readonly IsMe: boolean;
+    readonly JobInfo: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.ContactJobInfo> | Windows.ApplicationModel.Contacts.ContactJobInfo[];
+    readonly LargeDisplayPicture: Windows.Storage.Streams.IRandomAccessStreamReference;
+    LastName: string;
+    MiddleName: string;
+    Name: string;
+    Nickname: string;
+    Notes: string;
+    readonly Phones: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.ContactPhone> | Windows.ApplicationModel.Contacts.ContactPhone[];
+    readonly ProviderProperties: Windows.Foundation.Collections.IPropertySet;
+    RemoteId: string;
+    RingToneToken: string;
+    readonly SignificantOthers: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.ContactSignificantOther> | Windows.ApplicationModel.Contacts.ContactSignificantOther[];
+    readonly SmallDisplayPicture: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly SortName: string;
+    SourceDisplayPicture: Windows.Storage.Streams.IRandomAccessStreamReference;
+    TextToneToken: string;
+    Thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly Websites: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.ContactWebsite> | Windows.ApplicationModel.Contacts.ContactWebsite[];
+    readonly YomiDisplayName: string;
+    YomiFamilyName: string;
+    YomiGivenName: string;
+  }
+
+  class ContactAddress implements Windows.ApplicationModel.Contacts.IContactAddress {
+    constructor();
+    Country: string;
+    Description: string;
+    Kind: number;
+    Locality: string;
+    PostalCode: string;
+    Region: string;
+    StreetAddress: string;
+  }
+
+  class ContactAnnotation implements Windows.ApplicationModel.Contacts.IContactAnnotation, Windows.ApplicationModel.Contacts.IContactAnnotation2 {
+    constructor();
+    readonly AnnotationListId: string;
+    ContactId: string;
+    ContactListId: string;
+    readonly Id: string;
+    readonly IsDisabled: boolean;
+    readonly ProviderProperties: Windows.Foundation.Collections.ValueSet;
+    RemoteId: string;
+    SupportedOperations: number;
+  }
+
+  class ContactAnnotationList implements Windows.ApplicationModel.Contacts.IContactAnnotationList {
+    DeleteAnnotationAsync(annotation: Windows.ApplicationModel.Contacts.ContactAnnotation): Windows.Foundation.IAsyncAction;
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    FindAnnotationsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactAnnotation> | Windows.ApplicationModel.Contacts.ContactAnnotation[]>;
+    FindAnnotationsByRemoteIdAsync(remoteId: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactAnnotation> | Windows.ApplicationModel.Contacts.ContactAnnotation[]>;
+    GetAnnotationAsync(annotationId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactAnnotation>;
+    TrySaveAnnotationAsync(annotation: Windows.ApplicationModel.Contacts.ContactAnnotation): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Id: string;
+    readonly ProviderPackageFamilyName: string;
+    readonly UserDataAccountId: string;
+  }
+
+  class ContactAnnotationStore implements Windows.ApplicationModel.Contacts.IContactAnnotationStore, Windows.ApplicationModel.Contacts.IContactAnnotationStore2 {
+    CreateAnnotationListAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactAnnotationList>;
+    CreateAnnotationListAsync(userDataAccountId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactAnnotationList>;
+    DisableAnnotationAsync(annotation: Windows.ApplicationModel.Contacts.ContactAnnotation): Windows.Foundation.IAsyncAction;
+    FindAnnotationListsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactAnnotationList> | Windows.ApplicationModel.Contacts.ContactAnnotationList[]>;
+    FindAnnotationsForContactAsync(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactAnnotation> | Windows.ApplicationModel.Contacts.ContactAnnotation[]>;
+    FindAnnotationsForContactListAsync(contactListId: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactAnnotation> | Windows.ApplicationModel.Contacts.ContactAnnotation[]>;
+    FindContactIdsByEmailAsync(emailAddress: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    FindContactIdsByPhoneNumberAsync(phoneNumber: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    GetAnnotationListAsync(annotationListId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactAnnotationList>;
+  }
+
+  class ContactBatch implements Windows.ApplicationModel.Contacts.IContactBatch {
+    readonly Contacts: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.Contact> | Windows.ApplicationModel.Contacts.Contact[];
+    readonly Status: number;
+  }
+
+  class ContactCardDelayedDataLoader implements Windows.ApplicationModel.Contacts.IContactCardDelayedDataLoader, Windows.Foundation.IClosable {
+    Close(): void;
+    SetData(contact: Windows.ApplicationModel.Contacts.Contact): void;
+  }
+
+  class ContactCardOptions implements Windows.ApplicationModel.Contacts.IContactCardOptions, Windows.ApplicationModel.Contacts.IContactCardOptions2 {
+    constructor();
+    HeaderKind: number;
+    InitialTabKind: number;
+    readonly ServerSearchContactListIds: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+
+  class ContactChange implements Windows.ApplicationModel.Contacts.IContactChange {
+    readonly ChangeType: number;
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+  }
+
+  class ContactChangeReader implements Windows.ApplicationModel.Contacts.IContactChangeReader {
+    AcceptChanges(): void;
+    AcceptChangesThrough(lastChangeToAccept: Windows.ApplicationModel.Contacts.ContactChange): void;
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactChange> | Windows.ApplicationModel.Contacts.ContactChange[]>;
+  }
+
+  class ContactChangeTracker implements Windows.ApplicationModel.Contacts.IContactChangeTracker, Windows.ApplicationModel.Contacts.IContactChangeTracker2 {
+    Enable(): void;
+    GetChangeReader(): Windows.ApplicationModel.Contacts.ContactChangeReader;
+    Reset(): void;
+    readonly IsTracking: boolean;
+  }
+
+  class ContactChangedDeferral implements Windows.ApplicationModel.Contacts.IContactChangedDeferral {
+    Complete(): void;
+  }
+
+  class ContactChangedEventArgs implements Windows.ApplicationModel.Contacts.IContactChangedEventArgs {
+    GetDeferral(): Windows.ApplicationModel.Contacts.ContactChangedDeferral;
+  }
+
+  class ContactConnectedServiceAccount implements Windows.ApplicationModel.Contacts.IContactConnectedServiceAccount {
+    constructor();
+    Id: string;
+    ServiceName: string;
+  }
+
+  class ContactDate implements Windows.ApplicationModel.Contacts.IContactDate {
+    constructor();
+    Day: number | null;
+    Description: string;
+    Kind: number;
+    Month: number | null;
+    Year: number | null;
+  }
+
+  class ContactEmail implements Windows.ApplicationModel.Contacts.IContactEmail {
+    constructor();
+    Address: string;
+    Description: string;
+    Kind: number;
+  }
+
+  class ContactField implements Windows.ApplicationModel.Contacts.IContactField {
+    constructor(value: string, type: number);
+    constructor(value: string, type: number, category: number);
+    constructor(name: string, value: string, type: number, category: number);
+    readonly Category: number;
+    readonly Name: string;
+    readonly Type: number;
+    readonly Value: string;
+  }
+
+  class ContactFieldFactory implements Windows.ApplicationModel.Contacts.IContactFieldFactory, Windows.ApplicationModel.Contacts.IContactInstantMessageFieldFactory, Windows.ApplicationModel.Contacts.IContactLocationFieldFactory {
+    constructor();
+    CreateField(value: string, type: number): Windows.ApplicationModel.Contacts.ContactField;
+    CreateField(value: string, type: number, category: number): Windows.ApplicationModel.Contacts.ContactField;
+    CreateField(name: string, value: string, type: number, category: number): Windows.ApplicationModel.Contacts.ContactField;
+    CreateInstantMessage(userName: string): Windows.ApplicationModel.Contacts.ContactInstantMessageField;
+    CreateInstantMessage(userName: string, category: number): Windows.ApplicationModel.Contacts.ContactInstantMessageField;
+    CreateInstantMessage(userName: string, category: number, service: string, displayText: string, verb: Windows.Foundation.Uri): Windows.ApplicationModel.Contacts.ContactInstantMessageField;
+    CreateLocation(unstructuredAddress: string): Windows.ApplicationModel.Contacts.ContactLocationField;
+    CreateLocation(unstructuredAddress: string, category: number): Windows.ApplicationModel.Contacts.ContactLocationField;
+    CreateLocation(unstructuredAddress: string, category: number, street: string, city: string, region: string, country: string, postalCode: string): Windows.ApplicationModel.Contacts.ContactLocationField;
+  }
+
+  class ContactGroup implements Windows.ApplicationModel.Contacts.IContactGroup {
+  }
+
+  class ContactInformation implements Windows.ApplicationModel.Contacts.IContactInformation {
+    GetThumbnailAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamWithContentType>;
+    QueryCustomFields(customName: string): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactField> | Windows.ApplicationModel.Contacts.ContactField[];
+    readonly CustomFields: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactField> | Windows.ApplicationModel.Contacts.ContactField[];
+    readonly Emails: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactField> | Windows.ApplicationModel.Contacts.ContactField[];
+    readonly InstantMessages: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactInstantMessageField> | Windows.ApplicationModel.Contacts.ContactInstantMessageField[];
+    readonly Locations: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactLocationField> | Windows.ApplicationModel.Contacts.ContactLocationField[];
+    readonly Name: string;
+    readonly PhoneNumbers: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactField> | Windows.ApplicationModel.Contacts.ContactField[];
+  }
+
+  class ContactInstantMessageField implements Windows.ApplicationModel.Contacts.IContactField, Windows.ApplicationModel.Contacts.IContactInstantMessageField {
+    constructor(userName: string);
+    constructor(userName: string, category: number);
+    constructor(userName: string, category: number, service: string, displayText: string, verb: Windows.Foundation.Uri);
+    readonly Category: number;
+    readonly DisplayText: string;
+    readonly LaunchUri: Windows.Foundation.Uri;
+    readonly Name: string;
+    readonly Service: string;
+    readonly Type: number;
+    readonly UserName: string;
+    readonly Value: string;
+  }
+
+  class ContactJobInfo implements Windows.ApplicationModel.Contacts.IContactJobInfo {
+    constructor();
+    CompanyAddress: string;
+    CompanyName: string;
+    CompanyYomiName: string;
+    Department: string;
+    Description: string;
+    Manager: string;
+    Office: string;
+    Title: string;
+  }
+
+  class ContactLaunchActionVerbs {
+    static readonly Call: string;
+    static readonly Map: string;
+    static readonly Message: string;
+    static readonly Post: string;
+    static readonly VideoCall: string;
+  }
+
+  class ContactList implements Windows.ApplicationModel.Contacts.IContactList, Windows.ApplicationModel.Contacts.IContactList2, Windows.ApplicationModel.Contacts.IContactList3 {
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    DeleteContactAsync(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncAction;
+    GetChangeTracker(identity: string): Windows.ApplicationModel.Contacts.ContactChangeTracker;
+    GetContactAsync(contactId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.Contact>;
+    GetContactFromRemoteIdAsync(remoteId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.Contact>;
+    GetContactReader(): Windows.ApplicationModel.Contacts.ContactReader;
+    GetContactReader(options: Windows.ApplicationModel.Contacts.ContactQueryOptions): Windows.ApplicationModel.Contacts.ContactReader;
+    GetMeContactAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.Contact>;
+    RegisterSyncManagerAsync(): Windows.Foundation.IAsyncAction;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    SaveContactAsync(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncAction;
+    readonly ChangeTracker: Windows.ApplicationModel.Contacts.ContactChangeTracker;
+    DisplayName: string;
+    readonly Id: string;
+    IsHidden: boolean;
+    readonly LimitedWriteOperations: Windows.ApplicationModel.Contacts.ContactListLimitedWriteOperations;
+    OtherAppReadAccess: number;
+    OtherAppWriteAccess: number;
+    readonly SourceDisplayName: string;
+    SupportsServerSearch: boolean;
+    readonly SyncConstraints: Windows.ApplicationModel.Contacts.ContactListSyncConstraints;
+    readonly SyncManager: Windows.ApplicationModel.Contacts.ContactListSyncManager;
+    readonly UserDataAccountId: string;
+    ContactChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.ContactList, Windows.ApplicationModel.Contacts.ContactChangedEventArgs> | null;
+  }
+
+  class ContactListLimitedWriteOperations implements Windows.ApplicationModel.Contacts.IContactListLimitedWriteOperations {
+    TryCreateOrUpdateContactAsync(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDeleteContactAsync(contactId: string): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+
+  class ContactListSyncConstraints implements Windows.ApplicationModel.Contacts.IContactListSyncConstraints {
+    CanSyncDescriptions: boolean;
+    MaxAnniversaryDates: number | null;
+    MaxAssistantPhoneNumbers: number | null;
+    MaxBirthdayDates: number | null;
+    MaxBusinessFaxPhoneNumbers: number | null;
+    MaxChildRelationships: number | null;
+    MaxCompanyPhoneNumbers: number | null;
+    MaxHomeAddresses: number | null;
+    MaxHomeFaxPhoneNumbers: number | null;
+    MaxHomePhoneNumbers: number | null;
+    MaxJobInfo: number | null;
+    MaxMobilePhoneNumbers: number | null;
+    MaxOtherAddresses: number | null;
+    MaxOtherDates: number | null;
+    MaxOtherEmailAddresses: number | null;
+    MaxOtherPhoneNumbers: number | null;
+    MaxOtherRelationships: number | null;
+    MaxPagerPhoneNumbers: number | null;
+    MaxParentRelationships: number | null;
+    MaxPartnerRelationships: number | null;
+    MaxPersonalEmailAddresses: number | null;
+    MaxRadioPhoneNumbers: number | null;
+    MaxSiblingRelationships: number | null;
+    MaxSpouseRelationships: number | null;
+    MaxWebsites: number | null;
+    MaxWorkAddresses: number | null;
+    MaxWorkEmailAddresses: number | null;
+    MaxWorkPhoneNumbers: number | null;
+  }
+
+  class ContactListSyncManager implements Windows.ApplicationModel.Contacts.IContactListSyncManager, Windows.ApplicationModel.Contacts.IContactListSyncManager2 {
+    SyncAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    LastAttemptedSyncTime: Windows.Foundation.DateTime;
+    LastSuccessfulSyncTime: Windows.Foundation.DateTime;
+    Status: number;
+    SyncStatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.ContactListSyncManager, Object> | null;
+  }
+
+  class ContactLocationField implements Windows.ApplicationModel.Contacts.IContactField, Windows.ApplicationModel.Contacts.IContactLocationField {
+    constructor(unstructuredAddress: string);
+    constructor(unstructuredAddress: string, category: number);
+    constructor(unstructuredAddress: string, category: number, street: string, city: string, region: string, country: string, postalCode: string);
+    readonly Category: number;
+    readonly City: string;
+    readonly Country: string;
+    readonly Name: string;
+    readonly PostalCode: string;
+    readonly Region: string;
+    readonly Street: string;
+    readonly Type: number;
+    readonly UnstructuredAddress: string;
+    readonly Value: string;
+  }
+
+  class ContactManager {
+    static ConvertContactToVCardAsync(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.RandomAccessStreamReference>;
+    static ConvertContactToVCardAsync(contact: Windows.ApplicationModel.Contacts.Contact, maxBytes: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.RandomAccessStreamReference>;
+    static ConvertVCardToContactAsync(vCard: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.Contact>;
+    static GetForUser(user: Windows.System.User): Windows.ApplicationModel.Contacts.ContactManagerForUser;
+    static IsShowContactCardSupported(): boolean;
+    static IsShowDelayLoadedContactCardSupported(): boolean;
+    static IsShowFullContactCardSupportedAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    static RequestAnnotationStoreAsync(accessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactAnnotationStore>;
+    static RequestStoreAsync(accessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactStore>;
+    static RequestStoreAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactStore>;
+    static ShowContactCard(contact: Windows.ApplicationModel.Contacts.Contact, selection: Windows.Foundation.Rect, preferredPlacement: number, contactCardOptions: Windows.ApplicationModel.Contacts.ContactCardOptions): void;
+    static ShowContactCard(contact: Windows.ApplicationModel.Contacts.Contact, selection: Windows.Foundation.Rect): void;
+    static ShowContactCard(contact: Windows.ApplicationModel.Contacts.Contact, selection: Windows.Foundation.Rect, preferredPlacement: number): void;
+    static ShowDelayLoadedContactCard(contact: Windows.ApplicationModel.Contacts.Contact, selection: Windows.Foundation.Rect, preferredPlacement: number, contactCardOptions: Windows.ApplicationModel.Contacts.ContactCardOptions): Windows.ApplicationModel.Contacts.ContactCardDelayedDataLoader;
+    static ShowDelayLoadedContactCard(contact: Windows.ApplicationModel.Contacts.Contact, selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.ApplicationModel.Contacts.ContactCardDelayedDataLoader;
+    static ShowFullContactCard(contact: Windows.ApplicationModel.Contacts.Contact, fullContactCardOptions: Windows.ApplicationModel.Contacts.FullContactCardOptions): void;
+    static IncludeMiddleNameInSystemDisplayAndSort: boolean;
+    static SystemDisplayNameOrder: number;
+    static SystemSortOrder: number;
+  }
+
+  class ContactManagerForUser implements Windows.ApplicationModel.Contacts.IContactManagerForUser, Windows.ApplicationModel.Contacts.IContactManagerForUser2 {
+    ConvertContactToVCardAsync(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.RandomAccessStreamReference>;
+    ConvertContactToVCardAsync(contact: Windows.ApplicationModel.Contacts.Contact, maxBytes: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.RandomAccessStreamReference>;
+    ConvertVCardToContactAsync(vCard: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.Contact>;
+    RequestAnnotationStoreAsync(accessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactAnnotationStore>;
+    RequestStoreAsync(accessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactStore>;
+    ShowFullContactCard(contact: Windows.ApplicationModel.Contacts.Contact, fullContactCardOptions: Windows.ApplicationModel.Contacts.FullContactCardOptions): void;
+    SystemDisplayNameOrder: number;
+    SystemSortOrder: number;
+    readonly User: Windows.System.User;
+  }
+
+  class ContactMatchReason implements Windows.ApplicationModel.Contacts.IContactMatchReason {
+    readonly Field: number;
+    readonly Segments: Windows.Foundation.Collections.IVectorView<Windows.Data.Text.TextSegment> | Windows.Data.Text.TextSegment[];
+    readonly Text: string;
+  }
+
+  class ContactPanel implements Windows.ApplicationModel.Contacts.IContactPanel {
+    ClosePanel(): void;
+    HeaderColor: Windows.UI.Color | null;
+    Closing: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.ContactPanel, Windows.ApplicationModel.Contacts.ContactPanelClosingEventArgs> | null;
+    LaunchFullAppRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.ContactPanel, Windows.ApplicationModel.Contacts.ContactPanelLaunchFullAppRequestedEventArgs> | null;
+  }
+
+  class ContactPanelClosingEventArgs implements Windows.ApplicationModel.Contacts.IContactPanelClosingEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+
+  class ContactPanelLaunchFullAppRequestedEventArgs implements Windows.ApplicationModel.Contacts.IContactPanelLaunchFullAppRequestedEventArgs {
+    Handled: boolean;
+  }
+
+  class ContactPhone implements Windows.ApplicationModel.Contacts.IContactPhone {
+    constructor();
+    Description: string;
+    Kind: number;
+    Number: string;
+  }
+
+  class ContactPicker implements Windows.ApplicationModel.Contacts.IContactPicker, Windows.ApplicationModel.Contacts.IContactPicker2, Windows.ApplicationModel.Contacts.IContactPicker3 {
+    constructor();
+    static CreateForUser(user: Windows.System.User): Windows.ApplicationModel.Contacts.ContactPicker;
+    static IsSupportedAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    PickContactAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.Contact>;
+    PickContactsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.Contact> | Windows.ApplicationModel.Contacts.Contact[]>;
+    PickMultipleContactsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactInformation> | Windows.ApplicationModel.Contacts.ContactInformation[]>;
+    PickSingleContactAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactInformation>;
+    CommitButtonText: string;
+    readonly DesiredFields: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly DesiredFieldsWithContactFieldType: Windows.Foundation.Collections.IVector<number> | number[];
+    SelectionMode: number;
+    readonly User: Windows.System.User;
+  }
+
+  class ContactQueryOptions implements Windows.ApplicationModel.Contacts.IContactQueryOptions {
+    constructor(text: string);
+    constructor(text: string, fields: number);
+    constructor();
+    readonly AnnotationListIds: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly ContactListIds: Windows.Foundation.Collections.IVector<string> | string[];
+    DesiredFields: number;
+    DesiredOperations: number;
+    IncludeContactsFromHiddenLists: boolean;
+    readonly TextSearch: Windows.ApplicationModel.Contacts.ContactQueryTextSearch;
+  }
+
+  class ContactQueryTextSearch implements Windows.ApplicationModel.Contacts.IContactQueryTextSearch {
+    Fields: number;
+    SearchScope: number;
+    Text: string;
+  }
+
+  class ContactReader implements Windows.ApplicationModel.Contacts.IContactReader {
+    GetMatchingPropertiesWithMatchReason(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactMatchReason> | Windows.ApplicationModel.Contacts.ContactMatchReason[];
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactBatch>;
+  }
+
+  class ContactSignificantOther implements Windows.ApplicationModel.Contacts.IContactSignificantOther, Windows.ApplicationModel.Contacts.IContactSignificantOther2 {
+    constructor();
+    Description: string;
+    Name: string;
+    Relationship: number;
+  }
+
+  class ContactStore implements Windows.ApplicationModel.Contacts.IContactStore, Windows.ApplicationModel.Contacts.IContactStore2, Windows.ApplicationModel.Contacts.IContactStore3 {
+    CreateContactListAsync(displayName: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactList>;
+    CreateContactListAsync(displayName: string, userDataAccountId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactList>;
+    FindContactListsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactList> | Windows.ApplicationModel.Contacts.ContactList[]>;
+    FindContactsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.Contact> | Windows.ApplicationModel.Contacts.Contact[]>;
+    FindContactsAsync(searchText: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.Contact> | Windows.ApplicationModel.Contacts.Contact[]>;
+    GetChangeTracker(identity: string): Windows.ApplicationModel.Contacts.ContactChangeTracker;
+    GetContactAsync(contactId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.Contact>;
+    GetContactListAsync(contactListId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactList>;
+    GetContactReader(): Windows.ApplicationModel.Contacts.ContactReader;
+    GetContactReader(options: Windows.ApplicationModel.Contacts.ContactQueryOptions): Windows.ApplicationModel.Contacts.ContactReader;
+    GetMeContactAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.Contact>;
+    readonly AggregateContactManager: Windows.ApplicationModel.Contacts.AggregateContactManager;
+    readonly ChangeTracker: Windows.ApplicationModel.Contacts.ContactChangeTracker;
+    ContactChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.ContactStore, Windows.ApplicationModel.Contacts.ContactChangedEventArgs> | null;
+  }
+
+  class ContactStoreNotificationTriggerDetails implements Windows.ApplicationModel.Contacts.IContactStoreNotificationTriggerDetails {
+  }
+
+  class ContactWebsite implements Windows.ApplicationModel.Contacts.IContactWebsite, Windows.ApplicationModel.Contacts.IContactWebsite2 {
+    constructor();
+    Description: string;
+    RawValue: string;
+    Uri: Windows.Foundation.Uri;
+  }
+
+  class FullContactCardOptions implements Windows.ApplicationModel.Contacts.IFullContactCardOptions {
+    constructor();
+    DesiredRemainingView: number;
+  }
+
+  class KnownContactField {
+    static ConvertNameToType(name: string): number;
+    static ConvertTypeToName(type: number): string;
+    static readonly Email: string;
+    static readonly InstantMessage: string;
+    static readonly Location: string;
+    static readonly PhoneNumber: string;
+  }
+
+  class PinnedContactIdsQueryResult implements Windows.ApplicationModel.Contacts.IPinnedContactIdsQueryResult {
+    readonly ContactIds: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+
+  class PinnedContactManager implements Windows.ApplicationModel.Contacts.IPinnedContactManager {
+    static GetDefault(): Windows.ApplicationModel.Contacts.PinnedContactManager;
+    static GetForUser(user: Windows.System.User): Windows.ApplicationModel.Contacts.PinnedContactManager;
+    GetPinnedContactIdsAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.PinnedContactIdsQueryResult>;
+    IsContactPinned(contact: Windows.ApplicationModel.Contacts.Contact, surface: number): boolean;
+    IsPinSurfaceSupported(surface: number): boolean;
+    static IsSupported(): boolean;
+    RequestPinContactAsync(contact: Windows.ApplicationModel.Contacts.Contact, surface: number): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestPinContactsAsync(contacts: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Contacts.Contact> | Windows.ApplicationModel.Contacts.Contact[], surface: number): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestUnpinContactAsync(contact: Windows.ApplicationModel.Contacts.Contact, surface: number): Windows.Foundation.IAsyncOperation<boolean>;
+    SignalContactActivity(contact: Windows.ApplicationModel.Contacts.Contact): void;
+    readonly User: Windows.System.User;
+  }
+
+  enum ContactAddressKind {
+    Home = 0,
+    Work = 1,
+    Other = 2,
+  }
+
+  enum ContactAnnotationOperations {
+    None = 0,
+    ContactProfile = 1,
+    Message = 2,
+    AudioCall = 4,
+    VideoCall = 8,
+    SocialFeeds = 16,
+    Share = 32,
+  }
+
+  enum ContactAnnotationStoreAccessType {
+    AppAnnotationsReadWrite = 0,
+    AllAnnotationsReadWrite = 1,
+  }
+
+  enum ContactBatchStatus {
+    Success = 0,
+    ServerSearchSyncManagerError = 1,
+    ServerSearchUnknownError = 2,
+  }
+
+  enum ContactCardHeaderKind {
+    Default = 0,
+    Basic = 1,
+    Enterprise = 2,
+  }
+
+  enum ContactCardTabKind {
+    Default = 0,
+    Email = 1,
+    Messaging = 2,
+    Phone = 3,
+    Video = 4,
+    OrganizationalHierarchy = 5,
+  }
+
+  enum ContactChangeType {
+    Created = 0,
+    Modified = 1,
+    Deleted = 2,
+    ChangeTrackingLost = 3,
+  }
+
+  enum ContactDateKind {
+    Birthday = 0,
+    Anniversary = 1,
+    Other = 2,
+  }
+
+  enum ContactEmailKind {
+    Personal = 0,
+    Work = 1,
+    Other = 2,
+  }
+
+  enum ContactFieldCategory {
+    None = 0,
+    Home = 1,
+    Work = 2,
+    Mobile = 3,
+    Other = 4,
+  }
+
+  enum ContactFieldType {
+    Email = 0,
+    PhoneNumber = 1,
+    Location = 2,
+    InstantMessage = 3,
+    Custom = 4,
+    ConnectedServiceAccount = 5,
+    ImportantDate = 6,
+    Address = 7,
+    SignificantOther = 8,
+    Notes = 9,
+    Website = 10,
+    JobInfo = 11,
+  }
+
+  enum ContactListOtherAppReadAccess {
+    SystemOnly = 0,
+    Limited = 1,
+    Full = 2,
+    None = 3,
+  }
+
+  enum ContactListOtherAppWriteAccess {
+    None = 0,
+    SystemOnly = 1,
+    Limited = 2,
+  }
+
+  enum ContactListSyncStatus {
+    Idle = 0,
+    Syncing = 1,
+    UpToDate = 2,
+    AuthenticationError = 3,
+    PolicyError = 4,
+    UnknownError = 5,
+    ManualAccountRemovalRequired = 6,
+  }
+
+  enum ContactMatchReasonKind {
+    Name = 0,
+    EmailAddress = 1,
+    PhoneNumber = 2,
+    JobInfo = 3,
+    YomiName = 4,
+    Other = 5,
+  }
+
+  enum ContactNameOrder {
+    FirstNameLastName = 0,
+    LastNameFirstName = 1,
+  }
+
+  enum ContactPhoneKind {
+    Home = 0,
+    Mobile = 1,
+    Work = 2,
+    Other = 3,
+    Pager = 4,
+    BusinessFax = 5,
+    HomeFax = 6,
+    Company = 7,
+    Assistant = 8,
+    Radio = 9,
+  }
+
+  enum ContactQueryDesiredFields {
+    None = 0,
+    PhoneNumber = 1,
+    EmailAddress = 2,
+    PostalAddress = 4,
+  }
+
+  enum ContactQuerySearchFields {
+    None = 0,
+    Name = 1,
+    Email = 2,
+    Phone = 4,
+    All = 4294967295,
+  }
+
+  enum ContactQuerySearchScope {
+    Local = 0,
+    Server = 1,
+  }
+
+  enum ContactRelationship {
+    Other = 0,
+    Spouse = 1,
+    Partner = 2,
+    Sibling = 3,
+    Parent = 4,
+    Child = 5,
+  }
+
+  enum ContactSelectionMode {
+    Contacts = 0,
+    Fields = 1,
+  }
+
+  enum ContactStoreAccessType {
+    AppContactsReadWrite = 0,
+    AllContactsReadOnly = 1,
+    AllContactsReadWrite = 2,
+  }
+
+  enum PinnedContactSurface {
+    StartMenu = 0,
+    Taskbar = 1,
+  }
+
+  interface IAggregateContactManager {
+    FindRawContactsAsync(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.Contact> | Windows.ApplicationModel.Contacts.Contact[]>;
+    TryLinkContactsAsync(primaryContact: Windows.ApplicationModel.Contacts.Contact, secondaryContact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.Contact>;
+    TrySetPreferredSourceForPictureAsync(aggregateContact: Windows.ApplicationModel.Contacts.Contact, rawContact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncOperation<boolean>;
+    UnlinkRawContactAsync(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncAction;
+  }
+  var IAggregateContactManager: abstract new (...args: any[]) => IAggregateContactManager;
+
+  interface IAggregateContactManager2 {
+    SetRemoteIdentificationInformationAsync(contactListId: string, remoteSourceId: string, accountId: string): Windows.Foundation.IAsyncAction;
+  }
+  var IAggregateContactManager2: abstract new (...args: any[]) => IAggregateContactManager2;
+
+  interface IContact {
+    readonly Fields: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.IContactField> | Windows.ApplicationModel.Contacts.IContactField[];
+    Name: string;
+    Thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+  }
+  var IContact: abstract new (...args: any[]) => IContact;
+
+  interface IContact2 extends Windows.ApplicationModel.Contacts.IContact {
+    readonly Addresses: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.ContactAddress> | Windows.ApplicationModel.Contacts.ContactAddress[];
+    readonly ConnectedServiceAccounts: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.ContactConnectedServiceAccount> | Windows.ApplicationModel.Contacts.ContactConnectedServiceAccount[];
+    readonly DataSuppliers: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Emails: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.ContactEmail> | Windows.ApplicationModel.Contacts.ContactEmail[];
+    Id: string;
+    readonly ImportantDates: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.ContactDate> | Windows.ApplicationModel.Contacts.ContactDate[];
+    readonly JobInfo: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.ContactJobInfo> | Windows.ApplicationModel.Contacts.ContactJobInfo[];
+    Notes: string;
+    readonly Phones: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.ContactPhone> | Windows.ApplicationModel.Contacts.ContactPhone[];
+    readonly ProviderProperties: Windows.Foundation.Collections.IPropertySet;
+    readonly SignificantOthers: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.ContactSignificantOther> | Windows.ApplicationModel.Contacts.ContactSignificantOther[];
+    readonly Websites: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.ContactWebsite> | Windows.ApplicationModel.Contacts.ContactWebsite[];
+  }
+  var IContact2: abstract new (...args: any[]) => IContact2;
+
+  interface IContact3 extends Windows.ApplicationModel.Contacts.IContact, Windows.ApplicationModel.Contacts.IContact2 {
+    readonly AggregateId: string;
+    readonly ContactListId: string;
+    DisplayNameOverride: string;
+    DisplayPictureUserUpdateTime: Windows.Foundation.DateTime;
+    readonly FullName: string;
+    readonly IsAggregate: boolean;
+    readonly IsDisplayPictureManuallySet: boolean;
+    readonly IsMe: boolean;
+    readonly LargeDisplayPicture: Windows.Storage.Streams.IRandomAccessStreamReference;
+    Nickname: string;
+    RemoteId: string;
+    RingToneToken: string;
+    readonly SmallDisplayPicture: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly SortName: string;
+    SourceDisplayPicture: Windows.Storage.Streams.IRandomAccessStreamReference;
+    TextToneToken: string;
+  }
+  var IContact3: abstract new (...args: any[]) => IContact3;
+
+  interface IContactAddress {
+    Country: string;
+    Description: string;
+    Kind: number;
+    Locality: string;
+    PostalCode: string;
+    Region: string;
+    StreetAddress: string;
+  }
+  var IContactAddress: abstract new (...args: any[]) => IContactAddress;
+
+  interface IContactAnnotation {
+    readonly AnnotationListId: string;
+    ContactId: string;
+    readonly Id: string;
+    readonly IsDisabled: boolean;
+    readonly ProviderProperties: Windows.Foundation.Collections.ValueSet;
+    RemoteId: string;
+    SupportedOperations: number;
+  }
+  var IContactAnnotation: abstract new (...args: any[]) => IContactAnnotation;
+
+  interface IContactAnnotation2 {
+    ContactListId: string;
+  }
+  var IContactAnnotation2: abstract new (...args: any[]) => IContactAnnotation2;
+
+  interface IContactAnnotationList {
+    DeleteAnnotationAsync(annotation: Windows.ApplicationModel.Contacts.ContactAnnotation): Windows.Foundation.IAsyncAction;
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    FindAnnotationsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactAnnotation> | Windows.ApplicationModel.Contacts.ContactAnnotation[]>;
+    FindAnnotationsByRemoteIdAsync(remoteId: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactAnnotation> | Windows.ApplicationModel.Contacts.ContactAnnotation[]>;
+    GetAnnotationAsync(annotationId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactAnnotation>;
+    TrySaveAnnotationAsync(annotation: Windows.ApplicationModel.Contacts.ContactAnnotation): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Id: string;
+    readonly ProviderPackageFamilyName: string;
+    readonly UserDataAccountId: string;
+  }
+  var IContactAnnotationList: abstract new (...args: any[]) => IContactAnnotationList;
+
+  interface IContactAnnotationStore {
+    CreateAnnotationListAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactAnnotationList>;
+    CreateAnnotationListAsync(userDataAccountId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactAnnotationList>;
+    DisableAnnotationAsync(annotation: Windows.ApplicationModel.Contacts.ContactAnnotation): Windows.Foundation.IAsyncAction;
+    FindAnnotationListsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactAnnotationList> | Windows.ApplicationModel.Contacts.ContactAnnotationList[]>;
+    FindAnnotationsForContactAsync(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactAnnotation> | Windows.ApplicationModel.Contacts.ContactAnnotation[]>;
+    FindContactIdsByEmailAsync(emailAddress: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    FindContactIdsByPhoneNumberAsync(phoneNumber: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    GetAnnotationListAsync(annotationListId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactAnnotationList>;
+  }
+  var IContactAnnotationStore: abstract new (...args: any[]) => IContactAnnotationStore;
+
+  interface IContactAnnotationStore2 {
+    FindAnnotationsForContactListAsync(contactListId: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactAnnotation> | Windows.ApplicationModel.Contacts.ContactAnnotation[]>;
+  }
+  var IContactAnnotationStore2: abstract new (...args: any[]) => IContactAnnotationStore2;
+
+  interface IContactBatch {
+    readonly Contacts: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.Contact> | Windows.ApplicationModel.Contacts.Contact[];
+    readonly Status: number;
+  }
+  var IContactBatch: abstract new (...args: any[]) => IContactBatch;
+
+  interface IContactCardDelayedDataLoader extends Windows.Foundation.IClosable {
+    Close(): void;
+    SetData(contact: Windows.ApplicationModel.Contacts.Contact): void;
+  }
+  var IContactCardDelayedDataLoader: abstract new (...args: any[]) => IContactCardDelayedDataLoader;
+
+  interface IContactCardOptions {
+    HeaderKind: number;
+    InitialTabKind: number;
+  }
+  var IContactCardOptions: abstract new (...args: any[]) => IContactCardOptions;
+
+  interface IContactCardOptions2 extends Windows.ApplicationModel.Contacts.IContactCardOptions {
+    readonly ServerSearchContactListIds: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var IContactCardOptions2: abstract new (...args: any[]) => IContactCardOptions2;
+
+  interface IContactChange {
+    readonly ChangeType: number;
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+  }
+  var IContactChange: abstract new (...args: any[]) => IContactChange;
+
+  interface IContactChangeReader {
+    AcceptChanges(): void;
+    AcceptChangesThrough(lastChangeToAccept: Windows.ApplicationModel.Contacts.ContactChange): void;
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactChange> | Windows.ApplicationModel.Contacts.ContactChange[]>;
+  }
+  var IContactChangeReader: abstract new (...args: any[]) => IContactChangeReader;
+
+  interface IContactChangeTracker {
+    Enable(): void;
+    GetChangeReader(): Windows.ApplicationModel.Contacts.ContactChangeReader;
+    Reset(): void;
+  }
+  var IContactChangeTracker: abstract new (...args: any[]) => IContactChangeTracker;
+
+  interface IContactChangeTracker2 {
+    readonly IsTracking: boolean;
+  }
+  var IContactChangeTracker2: abstract new (...args: any[]) => IContactChangeTracker2;
+
+  interface IContactChangedDeferral {
+    Complete(): void;
+  }
+  var IContactChangedDeferral: abstract new (...args: any[]) => IContactChangedDeferral;
+
+  interface IContactChangedEventArgs {
+    GetDeferral(): Windows.ApplicationModel.Contacts.ContactChangedDeferral;
+  }
+  var IContactChangedEventArgs: abstract new (...args: any[]) => IContactChangedEventArgs;
+
+  interface IContactConnectedServiceAccount {
+    Id: string;
+    ServiceName: string;
+  }
+  var IContactConnectedServiceAccount: abstract new (...args: any[]) => IContactConnectedServiceAccount;
+
+  interface IContactDate {
+    Day: number | null;
+    Description: string;
+    Kind: number;
+    Month: number | null;
+    Year: number | null;
+  }
+  var IContactDate: abstract new (...args: any[]) => IContactDate;
+
+  interface IContactEmail {
+    Address: string;
+    Description: string;
+    Kind: number;
+  }
+  var IContactEmail: abstract new (...args: any[]) => IContactEmail;
+
+  interface IContactField {
+    readonly Category: number;
+    readonly Name: string;
+    readonly Type: number;
+    readonly Value: string;
+  }
+  var IContactField: abstract new (...args: any[]) => IContactField;
+
+  interface IContactFieldFactory {
+    CreateField(value: string, type: number): Windows.ApplicationModel.Contacts.ContactField;
+    CreateField(value: string, type: number, category: number): Windows.ApplicationModel.Contacts.ContactField;
+    CreateField(name: string, value: string, type: number, category: number): Windows.ApplicationModel.Contacts.ContactField;
+  }
+  var IContactFieldFactory: abstract new (...args: any[]) => IContactFieldFactory;
+
+  interface IContactGroup {
+  }
+  var IContactGroup: abstract new (...args: any[]) => IContactGroup;
+
+  interface IContactInformation {
+    GetThumbnailAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamWithContentType>;
+    QueryCustomFields(customName: string): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactField> | Windows.ApplicationModel.Contacts.ContactField[];
+    readonly CustomFields: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactField> | Windows.ApplicationModel.Contacts.ContactField[];
+    readonly Emails: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactField> | Windows.ApplicationModel.Contacts.ContactField[];
+    readonly InstantMessages: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactInstantMessageField> | Windows.ApplicationModel.Contacts.ContactInstantMessageField[];
+    readonly Locations: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactLocationField> | Windows.ApplicationModel.Contacts.ContactLocationField[];
+    readonly Name: string;
+    readonly PhoneNumbers: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactField> | Windows.ApplicationModel.Contacts.ContactField[];
+  }
+  var IContactInformation: abstract new (...args: any[]) => IContactInformation;
+
+  interface IContactInstantMessageField extends Windows.ApplicationModel.Contacts.IContactField {
+    readonly DisplayText: string;
+    readonly LaunchUri: Windows.Foundation.Uri;
+    readonly Service: string;
+    readonly UserName: string;
+  }
+  var IContactInstantMessageField: abstract new (...args: any[]) => IContactInstantMessageField;
+
+  interface IContactInstantMessageFieldFactory {
+    CreateInstantMessage(userName: string): Windows.ApplicationModel.Contacts.ContactInstantMessageField;
+    CreateInstantMessage(userName: string, category: number): Windows.ApplicationModel.Contacts.ContactInstantMessageField;
+    CreateInstantMessage(userName: string, category: number, service: string, displayText: string, verb: Windows.Foundation.Uri): Windows.ApplicationModel.Contacts.ContactInstantMessageField;
+  }
+  var IContactInstantMessageFieldFactory: abstract new (...args: any[]) => IContactInstantMessageFieldFactory;
+
+  interface IContactJobInfo {
+    CompanyAddress: string;
+    CompanyName: string;
+    CompanyYomiName: string;
+    Department: string;
+    Description: string;
+    Manager: string;
+    Office: string;
+    Title: string;
+  }
+  var IContactJobInfo: abstract new (...args: any[]) => IContactJobInfo;
+
+  interface IContactLaunchActionVerbsStatics {
+    readonly Call: string;
+    readonly Map: string;
+    readonly Message: string;
+    readonly Post: string;
+    readonly VideoCall: string;
+  }
+  var IContactLaunchActionVerbsStatics: abstract new (...args: any[]) => IContactLaunchActionVerbsStatics;
+
+  interface IContactList {
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    DeleteContactAsync(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncAction;
+    GetContactAsync(contactId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.Contact>;
+    GetContactFromRemoteIdAsync(remoteId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.Contact>;
+    GetContactReader(): Windows.ApplicationModel.Contacts.ContactReader;
+    GetContactReader(options: Windows.ApplicationModel.Contacts.ContactQueryOptions): Windows.ApplicationModel.Contacts.ContactReader;
+    GetMeContactAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.Contact>;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    SaveContactAsync(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncAction;
+    readonly ChangeTracker: Windows.ApplicationModel.Contacts.ContactChangeTracker;
+    DisplayName: string;
+    readonly Id: string;
+    IsHidden: boolean;
+    OtherAppReadAccess: number;
+    OtherAppWriteAccess: number;
+    readonly SourceDisplayName: string;
+    readonly SupportsServerSearch: boolean;
+    readonly SyncManager: Windows.ApplicationModel.Contacts.ContactListSyncManager;
+    readonly UserDataAccountId: string;
+    ContactChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.ContactList, Windows.ApplicationModel.Contacts.ContactChangedEventArgs> | null;
+  }
+  var IContactList: abstract new (...args: any[]) => IContactList;
+
+  interface IContactList2 {
+    RegisterSyncManagerAsync(): Windows.Foundation.IAsyncAction;
+    SupportsServerSearch: Object;
+    readonly SyncConstraints: Windows.ApplicationModel.Contacts.ContactListSyncConstraints;
+  }
+  var IContactList2: abstract new (...args: any[]) => IContactList2;
+
+  interface IContactList3 {
+    GetChangeTracker(identity: string): Windows.ApplicationModel.Contacts.ContactChangeTracker;
+    readonly LimitedWriteOperations: Windows.ApplicationModel.Contacts.ContactListLimitedWriteOperations;
+  }
+  var IContactList3: abstract new (...args: any[]) => IContactList3;
+
+  interface IContactListLimitedWriteOperations {
+    TryCreateOrUpdateContactAsync(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDeleteContactAsync(contactId: string): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IContactListLimitedWriteOperations: abstract new (...args: any[]) => IContactListLimitedWriteOperations;
+
+  interface IContactListSyncConstraints {
+    CanSyncDescriptions: boolean;
+    MaxAnniversaryDates: number | null;
+    MaxAssistantPhoneNumbers: number | null;
+    MaxBirthdayDates: number | null;
+    MaxBusinessFaxPhoneNumbers: number | null;
+    MaxChildRelationships: number | null;
+    MaxCompanyPhoneNumbers: number | null;
+    MaxHomeAddresses: number | null;
+    MaxHomeFaxPhoneNumbers: number | null;
+    MaxHomePhoneNumbers: number | null;
+    MaxJobInfo: number | null;
+    MaxMobilePhoneNumbers: number | null;
+    MaxOtherAddresses: number | null;
+    MaxOtherDates: number | null;
+    MaxOtherEmailAddresses: number | null;
+    MaxOtherPhoneNumbers: number | null;
+    MaxOtherRelationships: number | null;
+    MaxPagerPhoneNumbers: number | null;
+    MaxParentRelationships: number | null;
+    MaxPartnerRelationships: number | null;
+    MaxPersonalEmailAddresses: number | null;
+    MaxRadioPhoneNumbers: number | null;
+    MaxSiblingRelationships: number | null;
+    MaxSpouseRelationships: number | null;
+    MaxWebsites: number | null;
+    MaxWorkAddresses: number | null;
+    MaxWorkEmailAddresses: number | null;
+    MaxWorkPhoneNumbers: number | null;
+  }
+  var IContactListSyncConstraints: abstract new (...args: any[]) => IContactListSyncConstraints;
+
+  interface IContactListSyncManager {
+    SyncAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly LastAttemptedSyncTime: Windows.Foundation.DateTime;
+    readonly LastSuccessfulSyncTime: Windows.Foundation.DateTime;
+    readonly Status: number;
+    SyncStatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.ContactListSyncManager, Object> | null;
+  }
+  var IContactListSyncManager: abstract new (...args: any[]) => IContactListSyncManager;
+
+  interface IContactListSyncManager2 {
+    LastAttemptedSyncTime: Object;
+    LastSuccessfulSyncTime: Object;
+    Status: Object;
+  }
+  var IContactListSyncManager2: abstract new (...args: any[]) => IContactListSyncManager2;
+
+  interface IContactLocationField extends Windows.ApplicationModel.Contacts.IContactField {
+    readonly City: string;
+    readonly Country: string;
+    readonly PostalCode: string;
+    readonly Region: string;
+    readonly Street: string;
+    readonly UnstructuredAddress: string;
+  }
+  var IContactLocationField: abstract new (...args: any[]) => IContactLocationField;
+
+  interface IContactLocationFieldFactory {
+    CreateLocation(unstructuredAddress: string): Windows.ApplicationModel.Contacts.ContactLocationField;
+    CreateLocation(unstructuredAddress: string, category: number): Windows.ApplicationModel.Contacts.ContactLocationField;
+    CreateLocation(unstructuredAddress: string, category: number, street: string, city: string, region: string, country: string, postalCode: string): Windows.ApplicationModel.Contacts.ContactLocationField;
+  }
+  var IContactLocationFieldFactory: abstract new (...args: any[]) => IContactLocationFieldFactory;
+
+  interface IContactManagerForUser {
+    ConvertContactToVCardAsync(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.RandomAccessStreamReference>;
+    ConvertContactToVCardAsync(contact: Windows.ApplicationModel.Contacts.Contact, maxBytes: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.RandomAccessStreamReference>;
+    ConvertVCardToContactAsync(vCard: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.Contact>;
+    RequestAnnotationStoreAsync(accessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactAnnotationStore>;
+    RequestStoreAsync(accessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactStore>;
+    SystemDisplayNameOrder: number;
+    SystemSortOrder: number;
+    readonly User: Windows.System.User;
+  }
+  var IContactManagerForUser: abstract new (...args: any[]) => IContactManagerForUser;
+
+  interface IContactManagerForUser2 {
+    ShowFullContactCard(contact: Windows.ApplicationModel.Contacts.Contact, fullContactCardOptions: Windows.ApplicationModel.Contacts.FullContactCardOptions): void;
+  }
+  var IContactManagerForUser2: abstract new (...args: any[]) => IContactManagerForUser2;
+
+  interface IContactManagerStatics {
+    ShowContactCard(contact: Windows.ApplicationModel.Contacts.Contact, selection: Windows.Foundation.Rect): void;
+    ShowContactCard(contact: Windows.ApplicationModel.Contacts.Contact, selection: Windows.Foundation.Rect, preferredPlacement: number): void;
+    ShowDelayLoadedContactCard(contact: Windows.ApplicationModel.Contacts.Contact, selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.ApplicationModel.Contacts.ContactCardDelayedDataLoader;
+  }
+  var IContactManagerStatics: abstract new (...args: any[]) => IContactManagerStatics;
+
+  interface IContactManagerStatics2 extends Windows.ApplicationModel.Contacts.IContactManagerStatics {
+    RequestStoreAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactStore>;
+    ShowContactCard(contact: Windows.ApplicationModel.Contacts.Contact, selection: Windows.Foundation.Rect): void;
+    ShowContactCard(contact: Windows.ApplicationModel.Contacts.Contact, selection: Windows.Foundation.Rect, preferredPlacement: number): void;
+    ShowDelayLoadedContactCard(contact: Windows.ApplicationModel.Contacts.Contact, selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.ApplicationModel.Contacts.ContactCardDelayedDataLoader;
+  }
+  var IContactManagerStatics2: abstract new (...args: any[]) => IContactManagerStatics2;
+
+  interface IContactManagerStatics3 extends Windows.ApplicationModel.Contacts.IContactManagerStatics, Windows.ApplicationModel.Contacts.IContactManagerStatics2 {
+    ConvertContactToVCardAsync(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.RandomAccessStreamReference>;
+    ConvertContactToVCardAsync(contact: Windows.ApplicationModel.Contacts.Contact, maxBytes: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.RandomAccessStreamReference>;
+    ConvertVCardToContactAsync(vCard: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.Contact>;
+    IsShowContactCardSupported(): boolean;
+    IsShowDelayLoadedContactCardSupported(): boolean;
+    RequestAnnotationStoreAsync(accessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactAnnotationStore>;
+    RequestStoreAsync(accessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactStore>;
+    RequestStoreAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactStore>;
+    ShowContactCard(contact: Windows.ApplicationModel.Contacts.Contact, selection: Windows.Foundation.Rect, preferredPlacement: number, contactCardOptions: Windows.ApplicationModel.Contacts.ContactCardOptions): void;
+    ShowContactCard(contact: Windows.ApplicationModel.Contacts.Contact, selection: Windows.Foundation.Rect): void;
+    ShowContactCard(contact: Windows.ApplicationModel.Contacts.Contact, selection: Windows.Foundation.Rect, preferredPlacement: number): void;
+    ShowDelayLoadedContactCard(contact: Windows.ApplicationModel.Contacts.Contact, selection: Windows.Foundation.Rect, preferredPlacement: number, contactCardOptions: Windows.ApplicationModel.Contacts.ContactCardOptions): Windows.ApplicationModel.Contacts.ContactCardDelayedDataLoader;
+    ShowDelayLoadedContactCard(contact: Windows.ApplicationModel.Contacts.Contact, selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.ApplicationModel.Contacts.ContactCardDelayedDataLoader;
+    ShowFullContactCard(contact: Windows.ApplicationModel.Contacts.Contact, fullContactCardOptions: Windows.ApplicationModel.Contacts.FullContactCardOptions): void;
+    SystemDisplayNameOrder: number;
+    SystemSortOrder: number;
+  }
+  var IContactManagerStatics3: abstract new (...args: any[]) => IContactManagerStatics3;
+
+  interface IContactManagerStatics4 {
+    GetForUser(user: Windows.System.User): Windows.ApplicationModel.Contacts.ContactManagerForUser;
+  }
+  var IContactManagerStatics4: abstract new (...args: any[]) => IContactManagerStatics4;
+
+  interface IContactManagerStatics5 {
+    IsShowFullContactCardSupportedAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    IncludeMiddleNameInSystemDisplayAndSort: boolean;
+  }
+  var IContactManagerStatics5: abstract new (...args: any[]) => IContactManagerStatics5;
+
+  interface IContactMatchReason {
+    readonly Field: number;
+    readonly Segments: Windows.Foundation.Collections.IVectorView<Windows.Data.Text.TextSegment> | Windows.Data.Text.TextSegment[];
+    readonly Text: string;
+  }
+  var IContactMatchReason: abstract new (...args: any[]) => IContactMatchReason;
+
+  interface IContactName {
+    readonly DisplayName: string;
+    FirstName: string;
+    HonorificNamePrefix: string;
+    HonorificNameSuffix: string;
+    LastName: string;
+    MiddleName: string;
+    readonly YomiDisplayName: string;
+    YomiFamilyName: string;
+    YomiGivenName: string;
+  }
+  var IContactName: abstract new (...args: any[]) => IContactName;
+
+  interface IContactPanel {
+    ClosePanel(): void;
+    HeaderColor: Windows.UI.Color | null;
+    Closing: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.ContactPanel, Windows.ApplicationModel.Contacts.ContactPanelClosingEventArgs> | null;
+    LaunchFullAppRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.ContactPanel, Windows.ApplicationModel.Contacts.ContactPanelLaunchFullAppRequestedEventArgs> | null;
+  }
+  var IContactPanel: abstract new (...args: any[]) => IContactPanel;
+
+  interface IContactPanelClosingEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+  var IContactPanelClosingEventArgs: abstract new (...args: any[]) => IContactPanelClosingEventArgs;
+
+  interface IContactPanelLaunchFullAppRequestedEventArgs {
+    Handled: boolean;
+  }
+  var IContactPanelLaunchFullAppRequestedEventArgs: abstract new (...args: any[]) => IContactPanelLaunchFullAppRequestedEventArgs;
+
+  interface IContactPhone {
+    Description: string;
+    Kind: number;
+    Number: string;
+  }
+  var IContactPhone: abstract new (...args: any[]) => IContactPhone;
+
+  interface IContactPicker {
+    PickMultipleContactsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactInformation> | Windows.ApplicationModel.Contacts.ContactInformation[]>;
+    PickSingleContactAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactInformation>;
+    CommitButtonText: string;
+    readonly DesiredFields: Windows.Foundation.Collections.IVector<string> | string[];
+    SelectionMode: number;
+  }
+  var IContactPicker: abstract new (...args: any[]) => IContactPicker;
+
+  interface IContactPicker2 {
+    PickContactAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.Contact>;
+    PickContactsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Contacts.Contact> | Windows.ApplicationModel.Contacts.Contact[]>;
+    readonly DesiredFieldsWithContactFieldType: Windows.Foundation.Collections.IVector<number> | number[];
+  }
+  var IContactPicker2: abstract new (...args: any[]) => IContactPicker2;
+
+  interface IContactPicker3 {
+    readonly User: Windows.System.User;
+  }
+  var IContactPicker3: abstract new (...args: any[]) => IContactPicker3;
+
+  interface IContactPickerStatics {
+    CreateForUser(user: Windows.System.User): Windows.ApplicationModel.Contacts.ContactPicker;
+    IsSupportedAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IContactPickerStatics: abstract new (...args: any[]) => IContactPickerStatics;
+
+  interface IContactQueryOptions {
+    readonly AnnotationListIds: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly ContactListIds: Windows.Foundation.Collections.IVector<string> | string[];
+    DesiredFields: number;
+    DesiredOperations: number;
+    IncludeContactsFromHiddenLists: boolean;
+    readonly TextSearch: Windows.ApplicationModel.Contacts.ContactQueryTextSearch;
+  }
+  var IContactQueryOptions: abstract new (...args: any[]) => IContactQueryOptions;
+
+  interface IContactQueryOptionsFactory {
+    CreateWithText(text: string): Windows.ApplicationModel.Contacts.ContactQueryOptions;
+    CreateWithTextAndFields(text: string, fields: number): Windows.ApplicationModel.Contacts.ContactQueryOptions;
+  }
+  var IContactQueryOptionsFactory: abstract new (...args: any[]) => IContactQueryOptionsFactory;
+
+  interface IContactQueryTextSearch {
+    Fields: number;
+    SearchScope: number;
+    Text: string;
+  }
+  var IContactQueryTextSearch: abstract new (...args: any[]) => IContactQueryTextSearch;
+
+  interface IContactReader {
+    GetMatchingPropertiesWithMatchReason(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactMatchReason> | Windows.ApplicationModel.Contacts.ContactMatchReason[];
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactBatch>;
+  }
+  var IContactReader: abstract new (...args: any[]) => IContactReader;
+
+  interface IContactSignificantOther {
+    Description: string;
+    Name: string;
+  }
+  var IContactSignificantOther: abstract new (...args: any[]) => IContactSignificantOther;
+
+  interface IContactSignificantOther2 extends Windows.ApplicationModel.Contacts.IContactSignificantOther {
+    Relationship: number;
+  }
+  var IContactSignificantOther2: abstract new (...args: any[]) => IContactSignificantOther2;
+
+  interface IContactStore {
+    FindContactsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.Contact> | Windows.ApplicationModel.Contacts.Contact[]>;
+    FindContactsAsync(searchText: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.Contact> | Windows.ApplicationModel.Contacts.Contact[]>;
+    GetContactAsync(contactId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.Contact>;
+  }
+  var IContactStore: abstract new (...args: any[]) => IContactStore;
+
+  interface IContactStore2 extends Windows.ApplicationModel.Contacts.IContactStore {
+    CreateContactListAsync(displayName: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactList>;
+    CreateContactListAsync(displayName: string, userDataAccountId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactList>;
+    FindContactListsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactList> | Windows.ApplicationModel.Contacts.ContactList[]>;
+    FindContactsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.Contact> | Windows.ApplicationModel.Contacts.Contact[]>;
+    FindContactsAsync(searchText: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.Contact> | Windows.ApplicationModel.Contacts.Contact[]>;
+    GetContactAsync(contactId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.Contact>;
+    GetContactListAsync(contactListId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.ContactList>;
+    GetContactReader(): Windows.ApplicationModel.Contacts.ContactReader;
+    GetContactReader(options: Windows.ApplicationModel.Contacts.ContactQueryOptions): Windows.ApplicationModel.Contacts.ContactReader;
+    GetMeContactAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.Contact>;
+    readonly AggregateContactManager: Windows.ApplicationModel.Contacts.AggregateContactManager;
+    readonly ChangeTracker: Windows.ApplicationModel.Contacts.ContactChangeTracker;
+    ContactChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.ContactStore, Windows.ApplicationModel.Contacts.ContactChangedEventArgs> | null;
+  }
+  var IContactStore2: abstract new (...args: any[]) => IContactStore2;
+
+  interface IContactStore3 {
+    GetChangeTracker(identity: string): Windows.ApplicationModel.Contacts.ContactChangeTracker;
+  }
+  var IContactStore3: abstract new (...args: any[]) => IContactStore3;
+
+  interface IContactStoreNotificationTriggerDetails {
+  }
+  var IContactStoreNotificationTriggerDetails: abstract new (...args: any[]) => IContactStoreNotificationTriggerDetails;
+
+  interface IContactWebsite {
+    Description: string;
+    Uri: Windows.Foundation.Uri;
+  }
+  var IContactWebsite: abstract new (...args: any[]) => IContactWebsite;
+
+  interface IContactWebsite2 extends Windows.ApplicationModel.Contacts.IContactWebsite {
+    RawValue: string;
+  }
+  var IContactWebsite2: abstract new (...args: any[]) => IContactWebsite2;
+
+  interface IFullContactCardOptions {
+    DesiredRemainingView: number;
+  }
+  var IFullContactCardOptions: abstract new (...args: any[]) => IFullContactCardOptions;
+
+  interface IKnownContactFieldStatics {
+    ConvertNameToType(name: string): number;
+    ConvertTypeToName(type: number): string;
+    readonly Email: string;
+    readonly InstantMessage: string;
+    readonly Location: string;
+    readonly PhoneNumber: string;
+  }
+  var IKnownContactFieldStatics: abstract new (...args: any[]) => IKnownContactFieldStatics;
+
+  interface IPinnedContactIdsQueryResult {
+    readonly ContactIds: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var IPinnedContactIdsQueryResult: abstract new (...args: any[]) => IPinnedContactIdsQueryResult;
+
+  interface IPinnedContactManager {
+    GetPinnedContactIdsAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Contacts.PinnedContactIdsQueryResult>;
+    IsContactPinned(contact: Windows.ApplicationModel.Contacts.Contact, surface: number): boolean;
+    IsPinSurfaceSupported(surface: number): boolean;
+    RequestPinContactAsync(contact: Windows.ApplicationModel.Contacts.Contact, surface: number): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestPinContactsAsync(contacts: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Contacts.Contact> | Windows.ApplicationModel.Contacts.Contact[], surface: number): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestUnpinContactAsync(contact: Windows.ApplicationModel.Contacts.Contact, surface: number): Windows.Foundation.IAsyncOperation<boolean>;
+    SignalContactActivity(contact: Windows.ApplicationModel.Contacts.Contact): void;
+    readonly User: Windows.System.User;
+  }
+  var IPinnedContactManager: abstract new (...args: any[]) => IPinnedContactManager;
+
+  interface IPinnedContactManagerStatics {
+    GetDefault(): Windows.ApplicationModel.Contacts.PinnedContactManager;
+    GetForUser(user: Windows.System.User): Windows.ApplicationModel.Contacts.PinnedContactManager;
+    IsSupported(): boolean;
+  }
+  var IPinnedContactManagerStatics: abstract new (...args: any[]) => IPinnedContactManagerStatics;
+
+}
+
+declare namespace Windows.ApplicationModel.Contacts.DataProvider {
+  class ContactDataProviderConnection implements Windows.ApplicationModel.Contacts.DataProvider.IContactDataProviderConnection, Windows.ApplicationModel.Contacts.DataProvider.IContactDataProviderConnection2 {
+    Start(): void;
+    ServerSearchReadBatchRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection, Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequestEventArgs> | null;
+    SyncRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection, Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequestEventArgs> | null;
+    CreateOrUpdateContactRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection, Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequestEventArgs> | null;
+    DeleteContactRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection, Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequestEventArgs> | null;
+  }
+
+  class ContactDataProviderTriggerDetails implements Windows.ApplicationModel.Contacts.DataProvider.IContactDataProviderTriggerDetails {
+    readonly Connection: Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection;
+  }
+
+  class ContactListCreateOrUpdateContactRequest implements Windows.ApplicationModel.Contacts.DataProvider.IContactListCreateOrUpdateContactRequest {
+    ReportCompletedAsync(createdOrUpdatedContact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+    readonly ContactListId: string;
+  }
+
+  class ContactListCreateOrUpdateContactRequestEventArgs implements Windows.ApplicationModel.Contacts.DataProvider.IContactListCreateOrUpdateContactRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequest;
+  }
+
+  class ContactListDeleteContactRequest implements Windows.ApplicationModel.Contacts.DataProvider.IContactListDeleteContactRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly ContactId: string;
+    readonly ContactListId: string;
+  }
+
+  class ContactListDeleteContactRequestEventArgs implements Windows.ApplicationModel.Contacts.DataProvider.IContactListDeleteContactRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequest;
+  }
+
+  class ContactListServerSearchReadBatchRequest implements Windows.ApplicationModel.Contacts.DataProvider.IContactListServerSearchReadBatchRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(batchStatus: number): Windows.Foundation.IAsyncAction;
+    SaveContactAsync(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncAction;
+    readonly ContactListId: string;
+    readonly Options: Windows.ApplicationModel.Contacts.ContactQueryOptions;
+    readonly SessionId: string;
+    readonly SuggestedBatchSize: number;
+  }
+
+  class ContactListServerSearchReadBatchRequestEventArgs implements Windows.ApplicationModel.Contacts.DataProvider.IContactListServerSearchReadBatchRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequest;
+  }
+
+  class ContactListSyncManagerSyncRequest implements Windows.ApplicationModel.Contacts.DataProvider.IContactListSyncManagerSyncRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly ContactListId: string;
+  }
+
+  class ContactListSyncManagerSyncRequestEventArgs implements Windows.ApplicationModel.Contacts.DataProvider.IContactListSyncManagerSyncRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequest;
+  }
+
+  interface IContactDataProviderConnection {
+    Start(): void;
+    ServerSearchReadBatchRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection, Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequestEventArgs> | null;
+    SyncRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection, Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequestEventArgs> | null;
+  }
+  var IContactDataProviderConnection: abstract new (...args: any[]) => IContactDataProviderConnection;
+
+  interface IContactDataProviderConnection2 {
+    CreateOrUpdateContactRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection, Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequestEventArgs> | null;
+    DeleteContactRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection, Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequestEventArgs> | null;
+  }
+  var IContactDataProviderConnection2: abstract new (...args: any[]) => IContactDataProviderConnection2;
+
+  interface IContactDataProviderTriggerDetails {
+    readonly Connection: Windows.ApplicationModel.Contacts.DataProvider.ContactDataProviderConnection;
+  }
+  var IContactDataProviderTriggerDetails: abstract new (...args: any[]) => IContactDataProviderTriggerDetails;
+
+  interface IContactListCreateOrUpdateContactRequest {
+    ReportCompletedAsync(createdOrUpdatedContact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+    readonly ContactListId: string;
+  }
+  var IContactListCreateOrUpdateContactRequest: abstract new (...args: any[]) => IContactListCreateOrUpdateContactRequest;
+
+  interface IContactListCreateOrUpdateContactRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Contacts.DataProvider.ContactListCreateOrUpdateContactRequest;
+  }
+  var IContactListCreateOrUpdateContactRequestEventArgs: abstract new (...args: any[]) => IContactListCreateOrUpdateContactRequestEventArgs;
+
+  interface IContactListDeleteContactRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly ContactId: string;
+    readonly ContactListId: string;
+  }
+  var IContactListDeleteContactRequest: abstract new (...args: any[]) => IContactListDeleteContactRequest;
+
+  interface IContactListDeleteContactRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Contacts.DataProvider.ContactListDeleteContactRequest;
+  }
+  var IContactListDeleteContactRequestEventArgs: abstract new (...args: any[]) => IContactListDeleteContactRequestEventArgs;
+
+  interface IContactListServerSearchReadBatchRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(batchStatus: number): Windows.Foundation.IAsyncAction;
+    SaveContactAsync(contact: Windows.ApplicationModel.Contacts.Contact): Windows.Foundation.IAsyncAction;
+    readonly ContactListId: string;
+    readonly Options: Windows.ApplicationModel.Contacts.ContactQueryOptions;
+    readonly SessionId: string;
+    readonly SuggestedBatchSize: number;
+  }
+  var IContactListServerSearchReadBatchRequest: abstract new (...args: any[]) => IContactListServerSearchReadBatchRequest;
+
+  interface IContactListServerSearchReadBatchRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Contacts.DataProvider.ContactListServerSearchReadBatchRequest;
+  }
+  var IContactListServerSearchReadBatchRequestEventArgs: abstract new (...args: any[]) => IContactListServerSearchReadBatchRequestEventArgs;
+
+  interface IContactListSyncManagerSyncRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly ContactListId: string;
+  }
+  var IContactListSyncManagerSyncRequest: abstract new (...args: any[]) => IContactListSyncManagerSyncRequest;
+
+  interface IContactListSyncManagerSyncRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Contacts.DataProvider.ContactListSyncManagerSyncRequest;
+  }
+  var IContactListSyncManagerSyncRequestEventArgs: abstract new (...args: any[]) => IContactListSyncManagerSyncRequestEventArgs;
+
+}
+
+declare namespace Windows.ApplicationModel.Contacts.Provider {
+  class ContactPickerUI implements Windows.ApplicationModel.Contacts.Provider.IContactPickerUI, Windows.ApplicationModel.Contacts.Provider.IContactPickerUI2 {
+    AddContact(id: string, contact: Windows.ApplicationModel.Contacts.Contact): number;
+    AddContact(contact: Windows.ApplicationModel.Contacts.Contact): number;
+    ContainsContact(id: string): boolean;
+    RemoveContact(id: string): void;
+    readonly DesiredFields: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly DesiredFieldsWithContactFieldType: Windows.Foundation.Collections.IVector<number> | number[];
+    readonly SelectionMode: number;
+    ContactRemoved: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.Provider.ContactPickerUI, Windows.ApplicationModel.Contacts.Provider.ContactRemovedEventArgs> | null;
+  }
+
+  class ContactRemovedEventArgs implements Windows.ApplicationModel.Contacts.Provider.IContactRemovedEventArgs {
+    readonly Id: string;
+  }
+
+  enum AddContactResult {
+    Added = 0,
+    AlreadyAdded = 1,
+    Unavailable = 2,
+  }
+
+  interface IContactPickerUI {
+    AddContact(id: string, contact: Windows.ApplicationModel.Contacts.Contact): number;
+    ContainsContact(id: string): boolean;
+    RemoveContact(id: string): void;
+    readonly DesiredFields: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly SelectionMode: number;
+    ContactRemoved: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Contacts.Provider.ContactPickerUI, Windows.ApplicationModel.Contacts.Provider.ContactRemovedEventArgs> | null;
+  }
+  var IContactPickerUI: abstract new (...args: any[]) => IContactPickerUI;
+
+  interface IContactPickerUI2 {
+    AddContact(contact: Windows.ApplicationModel.Contacts.Contact): number;
+    readonly DesiredFieldsWithContactFieldType: Windows.Foundation.Collections.IVector<number> | number[];
+  }
+  var IContactPickerUI2: abstract new (...args: any[]) => IContactPickerUI2;
+
+  interface IContactRemovedEventArgs {
+    readonly Id: string;
+  }
+  var IContactRemovedEventArgs: abstract new (...args: any[]) => IContactRemovedEventArgs;
+
+}
+
+declare namespace Windows.ApplicationModel.ConversationalAgent {
+  class ActivationSignalDetectionConfiguration implements Windows.ApplicationModel.ConversationalAgent.IActivationSignalDetectionConfiguration, Windows.ApplicationModel.ConversationalAgent.IActivationSignalDetectionConfiguration2, Windows.Foundation.IClosable {
+    ApplyTrainingData(trainingDataFormat: number, trainingData: Windows.Storage.Streams.IInputStream): number;
+    ApplyTrainingDataAsync(trainingDataFormat: number, trainingData: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncOperation<number>;
+    ClearModelData(): void;
+    ClearModelDataAsync(): Windows.Foundation.IAsyncAction;
+    ClearTrainingData(): void;
+    ClearTrainingDataAsync(): Windows.Foundation.IAsyncAction;
+    Close(): void;
+    GetModelData(): Windows.Storage.Streams.IInputStream;
+    GetModelDataAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IInputStream>;
+    GetModelDataType(): string;
+    GetModelDataTypeAsync(): Windows.Foundation.IAsyncOperation<string>;
+    SetEnabled(value: boolean): void;
+    SetEnabledAsync(value: boolean): Windows.Foundation.IAsyncAction;
+    SetEnabledWithResult(value: boolean): number;
+    SetEnabledWithResultAsync(value: boolean): Windows.Foundation.IAsyncOperation<number>;
+    SetModelData(dataType: string, data: Windows.Storage.Streams.IInputStream): void;
+    SetModelDataAsync(dataType: string, data: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncAction;
+    SetModelDataWithResult(dataType: string, data: Windows.Storage.Streams.IInputStream): number;
+    SetModelDataWithResultAsync(dataType: string, data: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncOperation<number>;
+    readonly AvailabilityInfo: Windows.ApplicationModel.ConversationalAgent.DetectionConfigurationAvailabilityInfo;
+    readonly DisplayName: string;
+    readonly IsActive: boolean;
+    readonly ModelId: string;
+    readonly SignalId: string;
+    readonly TrainingDataFormat: number;
+    readonly TrainingStepCompletionMaxAllowedTime: number;
+    readonly TrainingStepsCompleted: number;
+    readonly TrainingStepsRemaining: number;
+    AvailabilityChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration, Windows.ApplicationModel.ConversationalAgent.DetectionConfigurationAvailabilityChangedEventArgs> | null;
+  }
+
+  class ActivationSignalDetectionConfigurationCreationResult implements Windows.ApplicationModel.ConversationalAgent.IActivationSignalDetectionConfigurationCreationResult {
+    readonly Configuration: Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration;
+    readonly Status: number;
+  }
+
+  class ActivationSignalDetector implements Windows.ApplicationModel.ConversationalAgent.IActivationSignalDetector, Windows.ApplicationModel.ConversationalAgent.IActivationSignalDetector2 {
+    CreateConfiguration(signalId: string, modelId: string, displayName: string): void;
+    CreateConfigurationAsync(signalId: string, modelId: string, displayName: string): Windows.Foundation.IAsyncAction;
+    CreateConfigurationWithResult(signalId: string, modelId: string, displayName: string): Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfigurationCreationResult;
+    CreateConfigurationWithResultAsync(signalId: string, modelId: string, displayName: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfigurationCreationResult>;
+    GetAvailableModelIdsForSignalId(signalId: string): Windows.Foundation.Collections.IVector<string> | string[];
+    GetAvailableModelIdsForSignalIdAsync(signalId: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<string> | string[]>;
+    GetConfiguration(signalId: string, modelId: string): Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration;
+    GetConfigurationAsync(signalId: string, modelId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration>;
+    GetConfigurations(): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration> | Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration[];
+    GetConfigurationsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration> | Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration[]>;
+    GetSupportedModelIdsForSignalId(signalId: string): Windows.Foundation.Collections.IVectorView<string> | string[];
+    GetSupportedModelIdsForSignalIdAsync(signalId: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    RemoveConfiguration(signalId: string, modelId: string): void;
+    RemoveConfigurationAsync(signalId: string, modelId: string): Windows.Foundation.IAsyncAction;
+    RemoveConfigurationWithResult(signalId: string, modelId: string): number;
+    RemoveConfigurationWithResultAsync(signalId: string, modelId: string): Windows.Foundation.IAsyncOperation<number>;
+    readonly CanCreateConfigurations: boolean;
+    readonly DetectorId: string;
+    readonly Kind: number;
+    readonly ProviderId: string;
+    readonly SupportedModelDataTypes: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly SupportedPowerStates: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedTrainingDataFormats: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class ConversationalAgentDetectorManager implements Windows.ApplicationModel.ConversationalAgent.IConversationalAgentDetectorManager, Windows.ApplicationModel.ConversationalAgent.IConversationalAgentDetectorManager2 {
+    GetActivationSignalDetectorFromId(detectorId: string): Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector;
+    GetActivationSignalDetectorFromIdAsync(detectorId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector>;
+    GetActivationSignalDetectors(kind: number): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector> | Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector[];
+    GetActivationSignalDetectorsAsync(kind: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector> | Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector[]>;
+    GetAllActivationSignalDetectors(): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector> | Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector[];
+    GetAllActivationSignalDetectorsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector> | Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector[]>;
+    static readonly Default: Windows.ApplicationModel.ConversationalAgent.ConversationalAgentDetectorManager;
+  }
+
+  class ConversationalAgentSession implements Windows.ApplicationModel.ConversationalAgent.IConversationalAgentSession, Windows.ApplicationModel.ConversationalAgent.IConversationalAgentSession2, Windows.Foundation.IClosable {
+    Close(): void;
+    CreateAudioDeviceInputNode(graph: Windows.Media.Audio.AudioGraph): Windows.Media.Audio.AudioDeviceInputNode;
+    CreateAudioDeviceInputNodeAsync(graph: Windows.Media.Audio.AudioGraph): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.AudioDeviceInputNode>;
+    GetAudioCaptureDeviceId(): string;
+    GetAudioCaptureDeviceIdAsync(): Windows.Foundation.IAsyncOperation<string>;
+    GetAudioClient(): Object;
+    GetAudioClientAsync(): Windows.Foundation.IAsyncOperation<Object>;
+    GetAudioRenderDeviceId(): string;
+    GetAudioRenderDeviceIdAsync(): Windows.Foundation.IAsyncOperation<string>;
+    static GetCurrentSessionAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession>;
+    static GetCurrentSessionSync(): Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession;
+    GetMissingPrerequisites(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    GetMissingPrerequisitesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<number> | number[]>;
+    GetSignalModelId(): number;
+    GetSignalModelIdAsync(): Windows.Foundation.IAsyncOperation<number>;
+    GetSupportedSignalModelIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    GetSupportedSignalModelIdsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<number> | number[]>;
+    RequestActivation(activationKind: number): number;
+    RequestActivationAsync(activationKind: number): Windows.Foundation.IAsyncOperation<number>;
+    RequestAgentStateChange(state: number): number;
+    RequestAgentStateChangeAsync(state: number): Windows.Foundation.IAsyncOperation<number>;
+    RequestForegroundActivation(): number;
+    RequestForegroundActivationAsync(): Windows.Foundation.IAsyncOperation<number>;
+    RequestInterruptible(interruptible: boolean): number;
+    RequestInterruptibleAsync(interruptible: boolean): Windows.Foundation.IAsyncOperation<number>;
+    SetSignalModelId(signalModelId: number): boolean;
+    SetSignalModelIdAsync(signalModelId: number): Windows.Foundation.IAsyncOperation<boolean>;
+    SetSupportLockScreenActivation(lockScreenActivationSupported: boolean): void;
+    SetSupportLockScreenActivationAsync(lockScreenActivationSupported: boolean): Windows.Foundation.IAsyncAction;
+    readonly AgentState: number;
+    readonly IsIndicatorLightAvailable: boolean;
+    readonly IsInterrupted: boolean;
+    readonly IsInterruptible: boolean;
+    readonly IsScreenAvailable: boolean;
+    readonly IsUserAuthenticated: boolean;
+    readonly IsVoiceActivationAvailable: boolean;
+    readonly Signal: Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSignal;
+    SessionInterrupted: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession, Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSessionInterruptedEventArgs> | null;
+    SignalDetected: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession, Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSignalDetectedEventArgs> | null;
+    SystemStateChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession, Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSystemStateChangedEventArgs> | null;
+  }
+
+  class ConversationalAgentSessionInterruptedEventArgs implements Windows.ApplicationModel.ConversationalAgent.IConversationalAgentSessionInterruptedEventArgs {
+  }
+
+  class ConversationalAgentSignal implements Windows.ApplicationModel.ConversationalAgent.IConversationalAgentSignal, Windows.ApplicationModel.ConversationalAgent.IConversationalAgentSignal2 {
+    readonly DetectorId: string;
+    readonly DetectorKind: number;
+    IsSignalVerificationRequired: boolean;
+    SignalContext: Object;
+    SignalEnd: Windows.Foundation.TimeSpan;
+    SignalId: string;
+    SignalName: string;
+    SignalStart: Windows.Foundation.TimeSpan;
+  }
+
+  class ConversationalAgentSignalDetectedEventArgs implements Windows.ApplicationModel.ConversationalAgent.IConversationalAgentSignalDetectedEventArgs {
+  }
+
+  class ConversationalAgentSystemStateChangedEventArgs implements Windows.ApplicationModel.ConversationalAgent.IConversationalAgentSystemStateChangedEventArgs {
+    readonly SystemStateChangeType: number;
+  }
+
+  class DetectionConfigurationAvailabilityChangedEventArgs implements Windows.ApplicationModel.ConversationalAgent.IDetectionConfigurationAvailabilityChangedEventArgs {
+    readonly Kind: number;
+  }
+
+  class DetectionConfigurationAvailabilityInfo implements Windows.ApplicationModel.ConversationalAgent.IDetectionConfigurationAvailabilityInfo, Windows.ApplicationModel.ConversationalAgent.IDetectionConfigurationAvailabilityInfo2 {
+    readonly HasLockScreenPermission: boolean;
+    readonly HasPermission: boolean;
+    readonly HasSystemResourceAccess: boolean;
+    readonly IsEnabled: boolean;
+    readonly UnavailableSystemResources: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  enum ActivationSignalDetectionConfigurationCreationStatus {
+    Success = 0,
+    SignalIdNotAvailable = 1,
+    ModelIdNotSupported = 2,
+    InvalidSignalId = 3,
+    InvalidModelId = 4,
+    InvalidDisplayName = 5,
+    ConfigurationAlreadyExists = 6,
+    CreationNotSupported = 7,
+  }
+
+  enum ActivationSignalDetectionConfigurationRemovalResult {
+    Success = 0,
+    NotFound = 1,
+    CurrentlyEnabled = 2,
+    RemovalNotSupported = 3,
+  }
+
+  enum ActivationSignalDetectionConfigurationSetModelDataResult {
+    Success = 0,
+    EmptyModelData = 1,
+    UnsupportedFormat = 2,
+    ConfigurationCurrentlyEnabled = 3,
+    InvalidData = 4,
+    SetModelDataNotSupported = 5,
+    ConfigurationNotFound = 6,
+    UnknownError = 7,
+  }
+
+  enum ActivationSignalDetectionConfigurationStateChangeResult {
+    Success = 0,
+    NoModelData = 1,
+    ConfigurationNotFound = 2,
+  }
+
+  enum ActivationSignalDetectionTrainingDataFormat {
+    Voice8kHz8BitMono = 0,
+    Voice8kHz16BitMono = 1,
+    Voice16kHz8BitMono = 2,
+    Voice16kHz16BitMono = 3,
+    VoiceOEMDefined = 4,
+    Audio44kHz8BitMono = 5,
+    Audio44kHz16BitMono = 6,
+    Audio48kHz8BitMono = 7,
+    Audio48kHz16BitMono = 8,
+    AudioOEMDefined = 9,
+    OtherOEMDefined = 10,
+  }
+
+  enum ActivationSignalDetectorKind {
+    AudioPattern = 0,
+    AudioImpulse = 1,
+    HardwareEvent = 2,
+  }
+
+  enum ActivationSignalDetectorPowerState {
+    HighPower = 0,
+    ConnectedLowPower = 1,
+    DisconnectedLowPower = 2,
+  }
+
+  enum ConversationalAgentActivationKind {
+    VoiceActivationPreview = 0,
+    Foreground = 1,
+  }
+
+  enum ConversationalAgentActivationResult {
+    Success = 0,
+    AgentInactive = 1,
+    ScreenNotAvailable = 2,
+    AgentInterrupted = 3,
+  }
+
+  enum ConversationalAgentSessionUpdateResponse {
+    Success = 0,
+    Failed = 1,
+  }
+
+  enum ConversationalAgentState {
+    Inactive = 0,
+    Detecting = 1,
+    Listening = 2,
+    Working = 3,
+    Speaking = 4,
+    ListeningAndSpeaking = 5,
+  }
+
+  enum ConversationalAgentSystemStateChangeType {
+    UserAuthentication = 0,
+    ScreenAvailability = 1,
+    IndicatorLightAvailability = 2,
+    VoiceActivationAvailability = 3,
+  }
+
+  enum ConversationalAgentVoiceActivationPrerequisiteKind {
+    MicrophonePermission = 0,
+    KnownAgents = 1,
+    AgentAllowed = 2,
+    AppCapability = 3,
+    BackgroundTaskRegistration = 4,
+    PolicyPermission = 5,
+  }
+
+  enum DetectionConfigurationAvailabilityChangeKind {
+    SystemResourceAccess = 0,
+    Permission = 1,
+    LockScreenPermission = 2,
+  }
+
+  enum DetectionConfigurationTrainingStatus {
+    Success = 0,
+    FormatNotSupported = 1,
+    VoiceTooQuiet = 2,
+    VoiceTooLoud = 3,
+    VoiceTooFast = 4,
+    VoiceTooSlow = 5,
+    VoiceQualityProblem = 6,
+    TrainingSystemInternalError = 7,
+    TrainingTimedOut = 8,
+    ConfigurationNotFound = 9,
+  }
+
+  enum SignalDetectorResourceKind {
+    ParallelModelSupport = 0,
+    ParallelModelSupportForAgent = 1,
+    ParallelSignalSupport = 2,
+    ParallelSignalSupportForAgent = 3,
+    DisplayOffSupport = 4,
+    PluggedInPower = 5,
+    Detector = 6,
+    SupportedSleepState = 7,
+    SupportedBatterySaverState = 8,
+    ScreenAvailability = 9,
+    InputHardware = 10,
+    AcousticEchoCancellation = 11,
+    ModelIdSupport = 12,
+    DataChannel = 13,
+  }
+
+  interface IActivationSignalDetectionConfiguration {
+    ApplyTrainingData(trainingDataFormat: number, trainingData: Windows.Storage.Streams.IInputStream): number;
+    ApplyTrainingDataAsync(trainingDataFormat: number, trainingData: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncOperation<number>;
+    ClearModelData(): void;
+    ClearModelDataAsync(): Windows.Foundation.IAsyncAction;
+    ClearTrainingData(): void;
+    ClearTrainingDataAsync(): Windows.Foundation.IAsyncAction;
+    GetModelData(): Windows.Storage.Streams.IInputStream;
+    GetModelDataAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IInputStream>;
+    GetModelDataType(): string;
+    GetModelDataTypeAsync(): Windows.Foundation.IAsyncOperation<string>;
+    SetEnabled(value: boolean): void;
+    SetEnabledAsync(value: boolean): Windows.Foundation.IAsyncAction;
+    SetModelData(dataType: string, data: Windows.Storage.Streams.IInputStream): void;
+    SetModelDataAsync(dataType: string, data: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncAction;
+    readonly AvailabilityInfo: Windows.ApplicationModel.ConversationalAgent.DetectionConfigurationAvailabilityInfo;
+    readonly DisplayName: string;
+    readonly IsActive: boolean;
+    readonly ModelId: string;
+    readonly SignalId: string;
+    readonly TrainingDataFormat: number;
+    readonly TrainingStepsCompleted: number;
+    readonly TrainingStepsRemaining: number;
+    AvailabilityChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration, Windows.ApplicationModel.ConversationalAgent.DetectionConfigurationAvailabilityChangedEventArgs> | null;
+  }
+  var IActivationSignalDetectionConfiguration: abstract new (...args: any[]) => IActivationSignalDetectionConfiguration;
+
+  interface IActivationSignalDetectionConfiguration2 {
+    SetEnabledWithResult(value: boolean): number;
+    SetEnabledWithResultAsync(value: boolean): Windows.Foundation.IAsyncOperation<number>;
+    SetModelDataWithResult(dataType: string, data: Windows.Storage.Streams.IInputStream): number;
+    SetModelDataWithResultAsync(dataType: string, data: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncOperation<number>;
+    readonly TrainingStepCompletionMaxAllowedTime: number;
+  }
+  var IActivationSignalDetectionConfiguration2: abstract new (...args: any[]) => IActivationSignalDetectionConfiguration2;
+
+  interface IActivationSignalDetectionConfigurationCreationResult {
+    readonly Configuration: Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration;
+    readonly Status: number;
+  }
+  var IActivationSignalDetectionConfigurationCreationResult: abstract new (...args: any[]) => IActivationSignalDetectionConfigurationCreationResult;
+
+  interface IActivationSignalDetector {
+    CreateConfiguration(signalId: string, modelId: string, displayName: string): void;
+    CreateConfigurationAsync(signalId: string, modelId: string, displayName: string): Windows.Foundation.IAsyncAction;
+    GetConfiguration(signalId: string, modelId: string): Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration;
+    GetConfigurationAsync(signalId: string, modelId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration>;
+    GetConfigurations(): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration> | Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration[];
+    GetConfigurationsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration> | Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfiguration[]>;
+    GetSupportedModelIdsForSignalId(signalId: string): Windows.Foundation.Collections.IVectorView<string> | string[];
+    GetSupportedModelIdsForSignalIdAsync(signalId: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    RemoveConfiguration(signalId: string, modelId: string): void;
+    RemoveConfigurationAsync(signalId: string, modelId: string): Windows.Foundation.IAsyncAction;
+    readonly CanCreateConfigurations: boolean;
+    readonly Kind: number;
+    readonly ProviderId: string;
+    readonly SupportedModelDataTypes: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly SupportedPowerStates: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedTrainingDataFormats: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IActivationSignalDetector: abstract new (...args: any[]) => IActivationSignalDetector;
+
+  interface IActivationSignalDetector2 {
+    CreateConfigurationWithResult(signalId: string, modelId: string, displayName: string): Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfigurationCreationResult;
+    CreateConfigurationWithResultAsync(signalId: string, modelId: string, displayName: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetectionConfigurationCreationResult>;
+    GetAvailableModelIdsForSignalId(signalId: string): Windows.Foundation.Collections.IVector<string> | string[];
+    GetAvailableModelIdsForSignalIdAsync(signalId: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<string> | string[]>;
+    RemoveConfigurationWithResult(signalId: string, modelId: string): number;
+    RemoveConfigurationWithResultAsync(signalId: string, modelId: string): Windows.Foundation.IAsyncOperation<number>;
+    readonly DetectorId: string;
+  }
+  var IActivationSignalDetector2: abstract new (...args: any[]) => IActivationSignalDetector2;
+
+  interface IConversationalAgentDetectorManager {
+    GetActivationSignalDetectors(kind: number): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector> | Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector[];
+    GetActivationSignalDetectorsAsync(kind: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector> | Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector[]>;
+    GetAllActivationSignalDetectors(): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector> | Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector[];
+    GetAllActivationSignalDetectorsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector> | Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector[]>;
+  }
+  var IConversationalAgentDetectorManager: abstract new (...args: any[]) => IConversationalAgentDetectorManager;
+
+  interface IConversationalAgentDetectorManager2 {
+    GetActivationSignalDetectorFromId(detectorId: string): Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector;
+    GetActivationSignalDetectorFromIdAsync(detectorId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.ConversationalAgent.ActivationSignalDetector>;
+  }
+  var IConversationalAgentDetectorManager2: abstract new (...args: any[]) => IConversationalAgentDetectorManager2;
+
+  interface IConversationalAgentDetectorManagerStatics {
+    readonly Default: Windows.ApplicationModel.ConversationalAgent.ConversationalAgentDetectorManager;
+  }
+  var IConversationalAgentDetectorManagerStatics: abstract new (...args: any[]) => IConversationalAgentDetectorManagerStatics;
+
+  interface IConversationalAgentSession {
+    CreateAudioDeviceInputNode(graph: Windows.Media.Audio.AudioGraph): Windows.Media.Audio.AudioDeviceInputNode;
+    CreateAudioDeviceInputNodeAsync(graph: Windows.Media.Audio.AudioGraph): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.AudioDeviceInputNode>;
+    GetAudioCaptureDeviceId(): string;
+    GetAudioCaptureDeviceIdAsync(): Windows.Foundation.IAsyncOperation<string>;
+    GetAudioClient(): Object;
+    GetAudioClientAsync(): Windows.Foundation.IAsyncOperation<Object>;
+    GetAudioRenderDeviceId(): string;
+    GetAudioRenderDeviceIdAsync(): Windows.Foundation.IAsyncOperation<string>;
+    GetSignalModelId(): number;
+    GetSignalModelIdAsync(): Windows.Foundation.IAsyncOperation<number>;
+    GetSupportedSignalModelIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    GetSupportedSignalModelIdsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<number> | number[]>;
+    RequestAgentStateChange(state: number): number;
+    RequestAgentStateChangeAsync(state: number): Windows.Foundation.IAsyncOperation<number>;
+    RequestForegroundActivation(): number;
+    RequestForegroundActivationAsync(): Windows.Foundation.IAsyncOperation<number>;
+    RequestInterruptible(interruptible: boolean): number;
+    RequestInterruptibleAsync(interruptible: boolean): Windows.Foundation.IAsyncOperation<number>;
+    SetSignalModelId(signalModelId: number): boolean;
+    SetSignalModelIdAsync(signalModelId: number): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly AgentState: number;
+    readonly IsIndicatorLightAvailable: boolean;
+    readonly IsInterrupted: boolean;
+    readonly IsInterruptible: boolean;
+    readonly IsScreenAvailable: boolean;
+    readonly IsUserAuthenticated: boolean;
+    readonly IsVoiceActivationAvailable: boolean;
+    readonly Signal: Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSignal;
+    SessionInterrupted: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession, Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSessionInterruptedEventArgs> | null;
+    SignalDetected: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession, Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSignalDetectedEventArgs> | null;
+    SystemStateChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession, Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSystemStateChangedEventArgs> | null;
+  }
+  var IConversationalAgentSession: abstract new (...args: any[]) => IConversationalAgentSession;
+
+  interface IConversationalAgentSession2 {
+    GetMissingPrerequisites(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    GetMissingPrerequisitesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<number> | number[]>;
+    RequestActivation(activationKind: number): number;
+    RequestActivationAsync(activationKind: number): Windows.Foundation.IAsyncOperation<number>;
+    SetSupportLockScreenActivation(lockScreenActivationSupported: boolean): void;
+    SetSupportLockScreenActivationAsync(lockScreenActivationSupported: boolean): Windows.Foundation.IAsyncAction;
+  }
+  var IConversationalAgentSession2: abstract new (...args: any[]) => IConversationalAgentSession2;
+
+  interface IConversationalAgentSessionInterruptedEventArgs {
+  }
+  var IConversationalAgentSessionInterruptedEventArgs: abstract new (...args: any[]) => IConversationalAgentSessionInterruptedEventArgs;
+
+  interface IConversationalAgentSessionStatics {
+    GetCurrentSessionAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession>;
+    GetCurrentSessionSync(): Windows.ApplicationModel.ConversationalAgent.ConversationalAgentSession;
+  }
+  var IConversationalAgentSessionStatics: abstract new (...args: any[]) => IConversationalAgentSessionStatics;
+
+  interface IConversationalAgentSignal {
+    IsSignalVerificationRequired: boolean;
+    SignalContext: Object;
+    SignalEnd: Windows.Foundation.TimeSpan;
+    SignalId: string;
+    SignalName: string;
+    SignalStart: Windows.Foundation.TimeSpan;
+  }
+  var IConversationalAgentSignal: abstract new (...args: any[]) => IConversationalAgentSignal;
+
+  interface IConversationalAgentSignal2 {
+    readonly DetectorId: string;
+    readonly DetectorKind: number;
+  }
+  var IConversationalAgentSignal2: abstract new (...args: any[]) => IConversationalAgentSignal2;
+
+  interface IConversationalAgentSignalDetectedEventArgs {
+  }
+  var IConversationalAgentSignalDetectedEventArgs: abstract new (...args: any[]) => IConversationalAgentSignalDetectedEventArgs;
+
+  interface IConversationalAgentSystemStateChangedEventArgs {
+    readonly SystemStateChangeType: number;
+  }
+  var IConversationalAgentSystemStateChangedEventArgs: abstract new (...args: any[]) => IConversationalAgentSystemStateChangedEventArgs;
+
+  interface IDetectionConfigurationAvailabilityChangedEventArgs {
+    readonly Kind: number;
+  }
+  var IDetectionConfigurationAvailabilityChangedEventArgs: abstract new (...args: any[]) => IDetectionConfigurationAvailabilityChangedEventArgs;
+
+  interface IDetectionConfigurationAvailabilityInfo {
+    readonly HasLockScreenPermission: boolean;
+    readonly HasPermission: boolean;
+    readonly HasSystemResourceAccess: boolean;
+    readonly IsEnabled: boolean;
+  }
+  var IDetectionConfigurationAvailabilityInfo: abstract new (...args: any[]) => IDetectionConfigurationAvailabilityInfo;
+
+  interface IDetectionConfigurationAvailabilityInfo2 {
+    readonly UnavailableSystemResources: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IDetectionConfigurationAvailabilityInfo2: abstract new (...args: any[]) => IDetectionConfigurationAvailabilityInfo2;
+
+}
+
+declare namespace Windows.ApplicationModel.Core {
+  class AppListEntry implements Windows.ApplicationModel.Core.IAppListEntry, Windows.ApplicationModel.Core.IAppListEntry2, Windows.ApplicationModel.Core.IAppListEntry3, Windows.ApplicationModel.Core.IAppListEntry4 {
+    LaunchAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    LaunchForUserAsync(user: Windows.System.User): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly AppInfo: Windows.ApplicationModel.AppInfo;
+    readonly AppUserModelId: string;
+    readonly DisplayInfo: Windows.ApplicationModel.AppDisplayInfo;
+  }
+
+  class CoreApplication {
+    static CreateNewView(viewSource: Windows.ApplicationModel.Core.IFrameworkViewSource): Windows.ApplicationModel.Core.CoreApplicationView;
+    static CreateNewView(): Windows.ApplicationModel.Core.CoreApplicationView;
+    static CreateNewView(runtimeType: string, entryPoint: string): Windows.ApplicationModel.Core.CoreApplicationView;
+    static DecrementApplicationUseCount(): void;
+    static EnablePrelaunch(value: boolean): void;
+    static Exit(): void;
+    static GetCurrentView(): Windows.ApplicationModel.Core.CoreApplicationView;
+    static IncrementApplicationUseCount(): void;
+    static RequestRestartAsync(launchArguments: string): Windows.Foundation.IAsyncOperation<number>;
+    static RequestRestartForUserAsync(user: Windows.System.User, launchArguments: string): Windows.Foundation.IAsyncOperation<number>;
+    static Run(viewSource: Windows.ApplicationModel.Core.IFrameworkViewSource): void;
+    static RunWithActivationFactories(activationFactoryCallback: Windows.Foundation.IGetActivationFactory): void;
+    static readonly Id: string;
+    static readonly MainView: Windows.ApplicationModel.Core.CoreApplicationView;
+    static readonly Properties: Windows.Foundation.Collections.IPropertySet;
+    static readonly Views: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Core.CoreApplicationView> | Windows.ApplicationModel.Core.CoreApplicationView[];
+    static UnhandledErrorDetected: Windows.Foundation.EventHandler<Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs> | null;
+    static Exiting: Windows.Foundation.EventHandler<Object> | null;
+    static BackgroundActivated: Windows.Foundation.EventHandler<Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs> | null;
+    static EnteredBackground: Windows.Foundation.EventHandler<Windows.ApplicationModel.EnteredBackgroundEventArgs> | null;
+    static LeavingBackground: Windows.Foundation.EventHandler<Windows.ApplicationModel.LeavingBackgroundEventArgs> | null;
+    static Resuming: Windows.Foundation.EventHandler<Object> | null;
+    static Suspending: Windows.Foundation.EventHandler<Windows.ApplicationModel.SuspendingEventArgs> | null;
+  }
+
+  class CoreApplicationView implements Windows.ApplicationModel.Core.ICoreApplicationView, Windows.ApplicationModel.Core.ICoreApplicationView2, Windows.ApplicationModel.Core.ICoreApplicationView3, Windows.ApplicationModel.Core.ICoreApplicationView5, Windows.ApplicationModel.Core.ICoreApplicationView6 {
+    readonly CoreWindow: Windows.UI.Core.CoreWindow;
+    readonly Dispatcher: Windows.UI.Core.CoreDispatcher;
+    readonly DispatcherQueue: Windows.System.DispatcherQueue;
+    readonly IsComponent: boolean;
+    readonly IsHosted: boolean;
+    readonly IsMain: boolean;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+    readonly TitleBar: Windows.ApplicationModel.Core.CoreApplicationViewTitleBar;
+    Activated: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Core.CoreApplicationView, Windows.ApplicationModel.Activation.IActivatedEventArgs> | null;
+    HostedViewClosing: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Core.CoreApplicationView, Windows.ApplicationModel.Core.HostedViewClosingEventArgs> | null;
+  }
+
+  class CoreApplicationViewTitleBar implements Windows.ApplicationModel.Core.ICoreApplicationViewTitleBar {
+    ExtendViewIntoTitleBar: boolean;
+    readonly Height: number;
+    readonly IsVisible: boolean;
+    readonly SystemOverlayLeftInset: number;
+    readonly SystemOverlayRightInset: number;
+    IsVisibleChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Core.CoreApplicationViewTitleBar, Object> | null;
+    LayoutMetricsChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Core.CoreApplicationViewTitleBar, Object> | null;
+  }
+
+  class HostedViewClosingEventArgs implements Windows.ApplicationModel.Core.IHostedViewClosingEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+
+  class UnhandledError implements Windows.ApplicationModel.Core.IUnhandledError {
+    Propagate(): void;
+    readonly Handled: boolean;
+  }
+
+  class UnhandledErrorDetectedEventArgs implements Windows.ApplicationModel.Core.IUnhandledErrorDetectedEventArgs {
+    readonly UnhandledError: Windows.ApplicationModel.Core.UnhandledError;
+  }
+
+  enum AppRestartFailureReason {
+    RestartPending = 0,
+    NotInForeground = 1,
+    InvalidUser = 2,
+    Other = 3,
+  }
+
+  interface IAppListEntry {
+    LaunchAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly DisplayInfo: Windows.ApplicationModel.AppDisplayInfo;
+  }
+  var IAppListEntry: abstract new (...args: any[]) => IAppListEntry;
+
+  interface IAppListEntry2 {
+    readonly AppUserModelId: string;
+  }
+  var IAppListEntry2: abstract new (...args: any[]) => IAppListEntry2;
+
+  interface IAppListEntry3 {
+    LaunchForUserAsync(user: Windows.System.User): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IAppListEntry3: abstract new (...args: any[]) => IAppListEntry3;
+
+  interface IAppListEntry4 {
+    readonly AppInfo: Windows.ApplicationModel.AppInfo;
+  }
+  var IAppListEntry4: abstract new (...args: any[]) => IAppListEntry4;
+
+  interface ICoreApplication {
+    GetCurrentView(): Windows.ApplicationModel.Core.CoreApplicationView;
+    Run(viewSource: Windows.ApplicationModel.Core.IFrameworkViewSource): void;
+    RunWithActivationFactories(activationFactoryCallback: Windows.Foundation.IGetActivationFactory): void;
+    readonly Id: string;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+    Resuming: Windows.Foundation.EventHandler<Object> | null;
+    Suspending: Windows.Foundation.EventHandler<Windows.ApplicationModel.SuspendingEventArgs> | null;
+  }
+  var ICoreApplication: abstract new (...args: any[]) => ICoreApplication;
+
+  interface ICoreApplication2 {
+    EnablePrelaunch(value: boolean): void;
+    BackgroundActivated: Windows.Foundation.EventHandler<Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs> | null;
+    EnteredBackground: Windows.Foundation.EventHandler<Windows.ApplicationModel.EnteredBackgroundEventArgs> | null;
+    LeavingBackground: Windows.Foundation.EventHandler<Windows.ApplicationModel.LeavingBackgroundEventArgs> | null;
+  }
+  var ICoreApplication2: abstract new (...args: any[]) => ICoreApplication2;
+
+  interface ICoreApplication3 {
+    RequestRestartAsync(launchArguments: string): Windows.Foundation.IAsyncOperation<number>;
+    RequestRestartForUserAsync(user: Windows.System.User, launchArguments: string): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var ICoreApplication3: abstract new (...args: any[]) => ICoreApplication3;
+
+  interface ICoreApplicationExit {
+    Exit(): void;
+    Exiting: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var ICoreApplicationExit: abstract new (...args: any[]) => ICoreApplicationExit;
+
+  interface ICoreApplicationUnhandledError {
+    UnhandledErrorDetected: Windows.Foundation.EventHandler<Windows.ApplicationModel.Core.UnhandledErrorDetectedEventArgs> | null;
+  }
+  var ICoreApplicationUnhandledError: abstract new (...args: any[]) => ICoreApplicationUnhandledError;
+
+  interface ICoreApplicationUseCount {
+    DecrementApplicationUseCount(): void;
+    IncrementApplicationUseCount(): void;
+  }
+  var ICoreApplicationUseCount: abstract new (...args: any[]) => ICoreApplicationUseCount;
+
+  interface ICoreApplicationView {
+    readonly CoreWindow: Windows.UI.Core.CoreWindow;
+    readonly IsHosted: boolean;
+    readonly IsMain: boolean;
+    Activated: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Core.CoreApplicationView, Windows.ApplicationModel.Activation.IActivatedEventArgs> | null;
+  }
+  var ICoreApplicationView: abstract new (...args: any[]) => ICoreApplicationView;
+
+  interface ICoreApplicationView2 {
+    readonly Dispatcher: Windows.UI.Core.CoreDispatcher;
+  }
+  var ICoreApplicationView2: abstract new (...args: any[]) => ICoreApplicationView2;
+
+  interface ICoreApplicationView3 {
+    readonly IsComponent: boolean;
+    readonly TitleBar: Windows.ApplicationModel.Core.CoreApplicationViewTitleBar;
+    HostedViewClosing: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Core.CoreApplicationView, Windows.ApplicationModel.Core.HostedViewClosingEventArgs> | null;
+  }
+  var ICoreApplicationView3: abstract new (...args: any[]) => ICoreApplicationView3;
+
+  interface ICoreApplicationView5 {
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+  }
+  var ICoreApplicationView5: abstract new (...args: any[]) => ICoreApplicationView5;
+
+  interface ICoreApplicationView6 {
+    readonly DispatcherQueue: Windows.System.DispatcherQueue;
+  }
+  var ICoreApplicationView6: abstract new (...args: any[]) => ICoreApplicationView6;
+
+  interface ICoreApplicationViewTitleBar {
+    ExtendViewIntoTitleBar: boolean;
+    readonly Height: number;
+    readonly IsVisible: boolean;
+    readonly SystemOverlayLeftInset: number;
+    readonly SystemOverlayRightInset: number;
+    IsVisibleChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Core.CoreApplicationViewTitleBar, Object> | null;
+    LayoutMetricsChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Core.CoreApplicationViewTitleBar, Object> | null;
+  }
+  var ICoreApplicationViewTitleBar: abstract new (...args: any[]) => ICoreApplicationViewTitleBar;
+
+  interface ICoreImmersiveApplication {
+    CreateNewView(runtimeType: string, entryPoint: string): Windows.ApplicationModel.Core.CoreApplicationView;
+    readonly MainView: Windows.ApplicationModel.Core.CoreApplicationView;
+    readonly Views: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Core.CoreApplicationView> | Windows.ApplicationModel.Core.CoreApplicationView[];
+  }
+  var ICoreImmersiveApplication: abstract new (...args: any[]) => ICoreImmersiveApplication;
+
+  interface ICoreImmersiveApplication2 {
+    CreateNewView(): Windows.ApplicationModel.Core.CoreApplicationView;
+  }
+  var ICoreImmersiveApplication2: abstract new (...args: any[]) => ICoreImmersiveApplication2;
+
+  interface ICoreImmersiveApplication3 {
+    CreateNewView(viewSource: Windows.ApplicationModel.Core.IFrameworkViewSource): Windows.ApplicationModel.Core.CoreApplicationView;
+  }
+  var ICoreImmersiveApplication3: abstract new (...args: any[]) => ICoreImmersiveApplication3;
+
+  interface IFrameworkView {
+    Initialize(applicationView: Windows.ApplicationModel.Core.CoreApplicationView): void;
+    Load(entryPoint: string): void;
+    Run(): void;
+    SetWindow(window: Windows.UI.Core.CoreWindow): void;
+    Uninitialize(): void;
+  }
+  var IFrameworkView: abstract new (...args: any[]) => IFrameworkView;
+
+  interface IFrameworkViewSource {
+    CreateView(): Windows.ApplicationModel.Core.IFrameworkView;
+  }
+  var IFrameworkViewSource: abstract new (...args: any[]) => IFrameworkViewSource;
+
+  interface IHostedViewClosingEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+  var IHostedViewClosingEventArgs: abstract new (...args: any[]) => IHostedViewClosingEventArgs;
+
+  interface IUnhandledError {
+    Propagate(): void;
+    readonly Handled: boolean;
+  }
+  var IUnhandledError: abstract new (...args: any[]) => IUnhandledError;
+
+  interface IUnhandledErrorDetectedEventArgs {
+    readonly UnhandledError: Windows.ApplicationModel.Core.UnhandledError;
+  }
+  var IUnhandledErrorDetectedEventArgs: abstract new (...args: any[]) => IUnhandledErrorDetectedEventArgs;
+
+}
+
+declare namespace Windows.ApplicationModel.DataTransfer {
+  class Clipboard {
+    static Clear(): void;
+    static ClearHistory(): boolean;
+    static DeleteItemFromHistory(item: Windows.ApplicationModel.DataTransfer.ClipboardHistoryItem): boolean;
+    static Flush(): void;
+    static GetContent(): Windows.ApplicationModel.DataTransfer.DataPackageView;
+    static GetHistoryItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.DataTransfer.ClipboardHistoryItemsResult>;
+    static IsHistoryEnabled(): boolean;
+    static IsRoamingEnabled(): boolean;
+    static SetContent(content: Windows.ApplicationModel.DataTransfer.DataPackage): void;
+    static SetContentWithOptions(content: Windows.ApplicationModel.DataTransfer.DataPackage, options: Windows.ApplicationModel.DataTransfer.ClipboardContentOptions): boolean;
+    static SetHistoryItemAsContent(item: Windows.ApplicationModel.DataTransfer.ClipboardHistoryItem): number;
+    static HistoryChanged: Windows.Foundation.EventHandler<Windows.ApplicationModel.DataTransfer.ClipboardHistoryChangedEventArgs> | null;
+    static HistoryEnabledChanged: Windows.Foundation.EventHandler<Object> | null;
+    static RoamingEnabledChanged: Windows.Foundation.EventHandler<Object> | null;
+    static ContentChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class ClipboardContentOptions implements Windows.ApplicationModel.DataTransfer.IClipboardContentOptions {
+    constructor();
+    readonly HistoryFormats: Windows.Foundation.Collections.IVector<string> | string[];
+    IsAllowedInHistory: boolean;
+    IsRoamable: boolean;
+    readonly RoamingFormats: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+
+  class ClipboardHistoryChangedEventArgs implements Windows.ApplicationModel.DataTransfer.IClipboardHistoryChangedEventArgs {
+  }
+
+  class ClipboardHistoryItem implements Windows.ApplicationModel.DataTransfer.IClipboardHistoryItem {
+    readonly Content: Windows.ApplicationModel.DataTransfer.DataPackageView;
+    readonly Id: string;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class ClipboardHistoryItemsResult implements Windows.ApplicationModel.DataTransfer.IClipboardHistoryItemsResult {
+    readonly Items: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.DataTransfer.ClipboardHistoryItem> | Windows.ApplicationModel.DataTransfer.ClipboardHistoryItem[];
+    readonly Status: number;
+  }
+
+  class DataPackage implements Windows.ApplicationModel.DataTransfer.IDataPackage, Windows.ApplicationModel.DataTransfer.IDataPackage2, Windows.ApplicationModel.DataTransfer.IDataPackage3, Windows.ApplicationModel.DataTransfer.IDataPackage4 {
+    constructor();
+    GetView(): Windows.ApplicationModel.DataTransfer.DataPackageView;
+    SetApplicationLink(value: Windows.Foundation.Uri): void;
+    SetBitmap(value: Windows.Storage.Streams.RandomAccessStreamReference): void;
+    SetData(formatId: string, value: Object): void;
+    SetDataProvider(formatId: string, delayRenderer: Windows.ApplicationModel.DataTransfer.DataProviderHandler): void;
+    SetHtmlFormat(value: string): void;
+    SetRtf(value: string): void;
+    SetStorageItems(value: Windows.Foundation.Collections.IIterable<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[]): void;
+    SetStorageItems(value: Windows.Foundation.Collections.IIterable<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[], readOnly: boolean): void;
+    SetText(value: string): void;
+    SetUri(value: Windows.Foundation.Uri): void;
+    SetWebLink(value: Windows.Foundation.Uri): void;
+    readonly Properties: Windows.ApplicationModel.DataTransfer.DataPackagePropertySet;
+    RequestedOperation: number;
+    readonly ResourceMap: Windows.Foundation.Collections.IMap<string, Windows.Storage.Streams.RandomAccessStreamReference> | Record<string, Windows.Storage.Streams.RandomAccessStreamReference>;
+    Destroyed: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.DataTransfer.DataPackage, Object> | null;
+    OperationCompleted: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.DataTransfer.DataPackage, Windows.ApplicationModel.DataTransfer.OperationCompletedEventArgs> | null;
+    ShareCompleted: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.DataTransfer.DataPackage, Windows.ApplicationModel.DataTransfer.ShareCompletedEventArgs> | null;
+    ShareCanceled: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.DataTransfer.DataPackage, Object> | null;
+  }
+
+  class DataPackagePropertySet implements Windows.ApplicationModel.DataTransfer.IDataPackagePropertySet, Windows.ApplicationModel.DataTransfer.IDataPackagePropertySet2, Windows.ApplicationModel.DataTransfer.IDataPackagePropertySet3, Windows.ApplicationModel.DataTransfer.IDataPackagePropertySet4 {
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, Object>>;
+    GetView(): Windows.Foundation.Collections.IMapView<string, Object>;
+    HasKey(key: string): boolean;
+    Insert(key: string, value: Object): boolean;
+    Lookup(key: string): Object;
+    Remove(key: string): void;
+    ApplicationListingUri: Windows.Foundation.Uri;
+    ApplicationName: string;
+    ContentSourceApplicationLink: Windows.Foundation.Uri;
+    ContentSourceUserActivityJson: string;
+    ContentSourceWebLink: Windows.Foundation.Uri;
+    Description: string;
+    EnterpriseId: string;
+    readonly FileTypes: Windows.Foundation.Collections.IVector<string> | string[];
+    LogoBackgroundColor: Windows.UI.Color;
+    PackageFamilyName: string;
+    readonly Size: number;
+    Square30x30Logo: Windows.Storage.Streams.IRandomAccessStreamReference;
+    Thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+    Title: string;
+  }
+
+  class DataPackagePropertySetView implements Windows.ApplicationModel.DataTransfer.IDataPackagePropertySetView, Windows.ApplicationModel.DataTransfer.IDataPackagePropertySetView2, Windows.ApplicationModel.DataTransfer.IDataPackagePropertySetView3, Windows.ApplicationModel.DataTransfer.IDataPackagePropertySetView4, Windows.ApplicationModel.DataTransfer.IDataPackagePropertySetView5 {
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, Object>>;
+    HasKey(key: string): boolean;
+    Lookup(key: string): Object;
+    Split(first: Windows.Foundation.Collections.IMapView<string, Object>, second: Windows.Foundation.Collections.IMapView<string, Object>): void;
+    readonly ApplicationListingUri: Windows.Foundation.Uri;
+    readonly ApplicationName: string;
+    readonly ContentSourceApplicationLink: Windows.Foundation.Uri;
+    readonly ContentSourceUserActivityJson: string;
+    readonly ContentSourceWebLink: Windows.Foundation.Uri;
+    readonly Description: string;
+    readonly EnterpriseId: string;
+    readonly FileTypes: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly IsFromRoamingClipboard: boolean;
+    readonly LogoBackgroundColor: Windows.UI.Color;
+    readonly PackageFamilyName: string;
+    readonly Size: number;
+    readonly Square30x30Logo: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly Thumbnail: Windows.Storage.Streams.RandomAccessStreamReference;
+    readonly Title: string;
+  }
+
+  class DataPackageView implements Windows.ApplicationModel.DataTransfer.IDataPackageView, Windows.ApplicationModel.DataTransfer.IDataPackageView2, Windows.ApplicationModel.DataTransfer.IDataPackageView3, Windows.ApplicationModel.DataTransfer.IDataPackageView4 {
+    Contains(formatId: string): boolean;
+    GetApplicationLinkAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Uri>;
+    GetBitmapAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.RandomAccessStreamReference>;
+    GetDataAsync(formatId: string): Windows.Foundation.IAsyncOperation<Object>;
+    GetHtmlFormatAsync(): Windows.Foundation.IAsyncOperation<string>;
+    GetResourceMapAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<string, Windows.Storage.Streams.RandomAccessStreamReference>>;
+    GetRtfAsync(): Windows.Foundation.IAsyncOperation<string>;
+    GetStorageItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[]>;
+    GetTextAsync(): Windows.Foundation.IAsyncOperation<string>;
+    GetTextAsync(formatId: string): Windows.Foundation.IAsyncOperation<string>;
+    GetUriAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Uri>;
+    GetWebLinkAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Uri>;
+    ReportOperationCompleted(value: number): void;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    RequestAccessAsync(enterpriseId: string): Windows.Foundation.IAsyncOperation<number>;
+    SetAcceptedFormatId(formatId: string): void;
+    UnlockAndAssumeEnterpriseIdentity(): number;
+    readonly AvailableFormats: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Properties: Windows.ApplicationModel.DataTransfer.DataPackagePropertySetView;
+    readonly RequestedOperation: number;
+  }
+
+  class DataProviderDeferral implements Windows.ApplicationModel.DataTransfer.IDataProviderDeferral {
+    Complete(): void;
+  }
+
+  class DataProviderRequest implements Windows.ApplicationModel.DataTransfer.IDataProviderRequest {
+    GetDeferral(): Windows.ApplicationModel.DataTransfer.DataProviderDeferral;
+    SetData(value: Object): void;
+    readonly Deadline: Windows.Foundation.DateTime;
+    readonly FormatId: string;
+  }
+
+  class DataRequest implements Windows.ApplicationModel.DataTransfer.IDataRequest {
+    FailWithDisplayText(value: string): void;
+    GetDeferral(): Windows.ApplicationModel.DataTransfer.DataRequestDeferral;
+    Data: Windows.ApplicationModel.DataTransfer.DataPackage;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+
+  class DataRequestDeferral implements Windows.ApplicationModel.DataTransfer.IDataRequestDeferral {
+    Complete(): void;
+  }
+
+  class DataRequestedEventArgs implements Windows.ApplicationModel.DataTransfer.IDataRequestedEventArgs {
+    readonly Request: Windows.ApplicationModel.DataTransfer.DataRequest;
+  }
+
+  class DataTransferManager implements Windows.ApplicationModel.DataTransfer.IDataTransferManager, Windows.ApplicationModel.DataTransfer.IDataTransferManager2 {
+    static GetForCurrentView(): Windows.ApplicationModel.DataTransfer.DataTransferManager;
+    static IsSupported(): boolean;
+    static ShowShareUI(options: Windows.ApplicationModel.DataTransfer.ShareUIOptions): void;
+    static ShowShareUI(): void;
+    DataRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.DataTransfer.DataTransferManager, Windows.ApplicationModel.DataTransfer.DataRequestedEventArgs> | null;
+    TargetApplicationChosen: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.DataTransfer.DataTransferManager, Windows.ApplicationModel.DataTransfer.TargetApplicationChosenEventArgs> | null;
+    ShareProvidersRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.DataTransfer.DataTransferManager, Windows.ApplicationModel.DataTransfer.ShareProvidersRequestedEventArgs> | null;
+  }
+
+  class HtmlFormatHelper {
+    static CreateHtmlFormat(htmlFragment: string): string;
+    static GetStaticFragment(htmlFormat: string): string;
+  }
+
+  class OperationCompletedEventArgs implements Windows.ApplicationModel.DataTransfer.IOperationCompletedEventArgs, Windows.ApplicationModel.DataTransfer.IOperationCompletedEventArgs2 {
+    readonly AcceptedFormatId: string;
+    readonly Operation: number;
+  }
+
+  class ShareCompletedEventArgs implements Windows.ApplicationModel.DataTransfer.IShareCompletedEventArgs {
+    readonly ShareTarget: Windows.ApplicationModel.DataTransfer.ShareTargetInfo;
+  }
+
+  class ShareProvider implements Windows.ApplicationModel.DataTransfer.IShareProvider {
+    constructor(title: string, displayIcon: Windows.Storage.Streams.RandomAccessStreamReference, backgroundColor: Windows.UI.Color, handler: Windows.ApplicationModel.DataTransfer.ShareProviderHandler);
+    readonly BackgroundColor: Windows.UI.Color;
+    readonly DisplayIcon: Windows.Storage.Streams.RandomAccessStreamReference;
+    Tag: Object;
+    readonly Title: string;
+  }
+
+  class ShareProviderOperation implements Windows.ApplicationModel.DataTransfer.IShareProviderOperation {
+    ReportCompleted(): void;
+    readonly Data: Windows.ApplicationModel.DataTransfer.DataPackageView;
+    readonly Provider: Windows.ApplicationModel.DataTransfer.ShareProvider;
+  }
+
+  class ShareProvidersRequestedEventArgs implements Windows.ApplicationModel.DataTransfer.IShareProvidersRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Data: Windows.ApplicationModel.DataTransfer.DataPackageView;
+    readonly Providers: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.DataTransfer.ShareProvider> | Windows.ApplicationModel.DataTransfer.ShareProvider[];
+  }
+
+  class ShareTargetInfo implements Windows.ApplicationModel.DataTransfer.IShareTargetInfo {
+    readonly AppUserModelId: string;
+    readonly ShareProvider: Windows.ApplicationModel.DataTransfer.ShareProvider;
+  }
+
+  class ShareUIOptions implements Windows.ApplicationModel.DataTransfer.IShareUIOptions {
+    constructor();
+    SelectionRect: Windows.Foundation.Rect | null;
+    Theme: number;
+  }
+
+  class SharedStorageAccessManager {
+    static AddFile(file: Windows.Storage.IStorageFile): string;
+    static RedeemTokenForFileAsync(token: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    static RemoveFile(token: string): void;
+  }
+
+  class StandardDataFormats {
+    static readonly ApplicationLink: string;
+    static readonly Bitmap: string;
+    static readonly Html: string;
+    static readonly Rtf: string;
+    static readonly StorageItems: string;
+    static readonly Text: string;
+    static readonly Uri: string;
+    static readonly UserActivityJsonArray: string;
+    static readonly WebLink: string;
+  }
+
+  class TargetApplicationChosenEventArgs implements Windows.ApplicationModel.DataTransfer.ITargetApplicationChosenEventArgs {
+    readonly ApplicationName: string;
+  }
+
+  enum ClipboardHistoryItemsResultStatus {
+    Success = 0,
+    AccessDenied = 1,
+    ClipboardHistoryDisabled = 2,
+  }
+
+  enum DataPackageOperation {
+    None = 0,
+    Copy = 1,
+    Move = 2,
+    Link = 4,
+  }
+
+  enum SetHistoryItemAsContentStatus {
+    Success = 0,
+    AccessDenied = 1,
+    ItemDeleted = 2,
+  }
+
+  enum ShareUITheme {
+    Default = 0,
+    Light = 1,
+    Dark = 2,
+  }
+
+  interface DataProviderHandler {
+    (request: Windows.ApplicationModel.DataTransfer.DataProviderRequest): void;
+  }
+  var DataProviderHandler: {
+    new(callback: (request: Windows.ApplicationModel.DataTransfer.DataProviderRequest) => void): DataProviderHandler;
+  };
+
+  interface IClipboardContentOptions {
+    readonly HistoryFormats: Windows.Foundation.Collections.IVector<string> | string[];
+    IsAllowedInHistory: boolean;
+    IsRoamable: boolean;
+    readonly RoamingFormats: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var IClipboardContentOptions: abstract new (...args: any[]) => IClipboardContentOptions;
+
+  interface IClipboardHistoryChangedEventArgs {
+  }
+  var IClipboardHistoryChangedEventArgs: abstract new (...args: any[]) => IClipboardHistoryChangedEventArgs;
+
+  interface IClipboardHistoryItem {
+    readonly Content: Windows.ApplicationModel.DataTransfer.DataPackageView;
+    readonly Id: string;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IClipboardHistoryItem: abstract new (...args: any[]) => IClipboardHistoryItem;
+
+  interface IClipboardHistoryItemsResult {
+    readonly Items: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.DataTransfer.ClipboardHistoryItem> | Windows.ApplicationModel.DataTransfer.ClipboardHistoryItem[];
+    readonly Status: number;
+  }
+  var IClipboardHistoryItemsResult: abstract new (...args: any[]) => IClipboardHistoryItemsResult;
+
+  interface IClipboardStatics {
+    Clear(): void;
+    Flush(): void;
+    GetContent(): Windows.ApplicationModel.DataTransfer.DataPackageView;
+    SetContent(content: Windows.ApplicationModel.DataTransfer.DataPackage): void;
+    ContentChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IClipboardStatics: abstract new (...args: any[]) => IClipboardStatics;
+
+  interface IClipboardStatics2 {
+    ClearHistory(): boolean;
+    DeleteItemFromHistory(item: Windows.ApplicationModel.DataTransfer.ClipboardHistoryItem): boolean;
+    GetHistoryItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.DataTransfer.ClipboardHistoryItemsResult>;
+    IsHistoryEnabled(): boolean;
+    IsRoamingEnabled(): boolean;
+    SetContentWithOptions(content: Windows.ApplicationModel.DataTransfer.DataPackage, options: Windows.ApplicationModel.DataTransfer.ClipboardContentOptions): boolean;
+    SetHistoryItemAsContent(item: Windows.ApplicationModel.DataTransfer.ClipboardHistoryItem): number;
+    HistoryChanged: Windows.Foundation.EventHandler<Windows.ApplicationModel.DataTransfer.ClipboardHistoryChangedEventArgs> | null;
+    HistoryEnabledChanged: Windows.Foundation.EventHandler<Object> | null;
+    RoamingEnabledChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IClipboardStatics2: abstract new (...args: any[]) => IClipboardStatics2;
+
+  interface IDataPackage {
+    GetView(): Windows.ApplicationModel.DataTransfer.DataPackageView;
+    SetBitmap(value: Windows.Storage.Streams.RandomAccessStreamReference): void;
+    SetData(formatId: string, value: Object): void;
+    SetDataProvider(formatId: string, delayRenderer: Windows.ApplicationModel.DataTransfer.DataProviderHandler): void;
+    SetHtmlFormat(value: string): void;
+    SetRtf(value: string): void;
+    SetStorageItems(value: Windows.Foundation.Collections.IIterable<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[]): void;
+    SetStorageItems(value: Windows.Foundation.Collections.IIterable<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[], readOnly: boolean): void;
+    SetText(value: string): void;
+    SetUri(value: Windows.Foundation.Uri): void;
+    readonly Properties: Windows.ApplicationModel.DataTransfer.DataPackagePropertySet;
+    RequestedOperation: number;
+    readonly ResourceMap: Windows.Foundation.Collections.IMap<string, Windows.Storage.Streams.RandomAccessStreamReference> | Record<string, Windows.Storage.Streams.RandomAccessStreamReference>;
+    Destroyed: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.DataTransfer.DataPackage, Object> | null;
+    OperationCompleted: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.DataTransfer.DataPackage, Windows.ApplicationModel.DataTransfer.OperationCompletedEventArgs> | null;
+  }
+  var IDataPackage: abstract new (...args: any[]) => IDataPackage;
+
+  interface IDataPackage2 {
+    SetApplicationLink(value: Windows.Foundation.Uri): void;
+    SetWebLink(value: Windows.Foundation.Uri): void;
+  }
+  var IDataPackage2: abstract new (...args: any[]) => IDataPackage2;
+
+  interface IDataPackage3 {
+    ShareCompleted: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.DataTransfer.DataPackage, Windows.ApplicationModel.DataTransfer.ShareCompletedEventArgs> | null;
+  }
+  var IDataPackage3: abstract new (...args: any[]) => IDataPackage3;
+
+  interface IDataPackage4 {
+    ShareCanceled: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.DataTransfer.DataPackage, Object> | null;
+  }
+  var IDataPackage4: abstract new (...args: any[]) => IDataPackage4;
+
+  interface IDataPackagePropertySet {
+    ApplicationListingUri: Windows.Foundation.Uri;
+    ApplicationName: string;
+    Description: string;
+    readonly FileTypes: Windows.Foundation.Collections.IVector<string> | string[];
+    Thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+    Title: string;
+  }
+  var IDataPackagePropertySet: abstract new (...args: any[]) => IDataPackagePropertySet;
+
+  interface IDataPackagePropertySet2 {
+    ContentSourceApplicationLink: Windows.Foundation.Uri;
+    ContentSourceWebLink: Windows.Foundation.Uri;
+    LogoBackgroundColor: Windows.UI.Color;
+    PackageFamilyName: string;
+    Square30x30Logo: Windows.Storage.Streams.IRandomAccessStreamReference;
+  }
+  var IDataPackagePropertySet2: abstract new (...args: any[]) => IDataPackagePropertySet2;
+
+  interface IDataPackagePropertySet3 {
+    EnterpriseId: string;
+  }
+  var IDataPackagePropertySet3: abstract new (...args: any[]) => IDataPackagePropertySet3;
+
+  interface IDataPackagePropertySet4 {
+    ContentSourceUserActivityJson: string;
+  }
+  var IDataPackagePropertySet4: abstract new (...args: any[]) => IDataPackagePropertySet4;
+
+  interface IDataPackagePropertySetView {
+    readonly ApplicationListingUri: Windows.Foundation.Uri;
+    readonly ApplicationName: string;
+    readonly Description: string;
+    readonly FileTypes: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Thumbnail: Windows.Storage.Streams.RandomAccessStreamReference;
+    readonly Title: string;
+  }
+  var IDataPackagePropertySetView: abstract new (...args: any[]) => IDataPackagePropertySetView;
+
+  interface IDataPackagePropertySetView2 {
+    readonly ContentSourceApplicationLink: Windows.Foundation.Uri;
+    readonly ContentSourceWebLink: Windows.Foundation.Uri;
+    readonly LogoBackgroundColor: Windows.UI.Color;
+    readonly PackageFamilyName: string;
+    readonly Square30x30Logo: Windows.Storage.Streams.IRandomAccessStreamReference;
+  }
+  var IDataPackagePropertySetView2: abstract new (...args: any[]) => IDataPackagePropertySetView2;
+
+  interface IDataPackagePropertySetView3 {
+    readonly EnterpriseId: string;
+  }
+  var IDataPackagePropertySetView3: abstract new (...args: any[]) => IDataPackagePropertySetView3;
+
+  interface IDataPackagePropertySetView4 {
+    readonly ContentSourceUserActivityJson: string;
+  }
+  var IDataPackagePropertySetView4: abstract new (...args: any[]) => IDataPackagePropertySetView4;
+
+  interface IDataPackagePropertySetView5 {
+    readonly IsFromRoamingClipboard: boolean;
+  }
+  var IDataPackagePropertySetView5: abstract new (...args: any[]) => IDataPackagePropertySetView5;
+
+  interface IDataPackageView {
+    Contains(formatId: string): boolean;
+    GetBitmapAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.RandomAccessStreamReference>;
+    GetDataAsync(formatId: string): Windows.Foundation.IAsyncOperation<Object>;
+    GetHtmlFormatAsync(): Windows.Foundation.IAsyncOperation<string>;
+    GetResourceMapAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<string, Windows.Storage.Streams.RandomAccessStreamReference>>;
+    GetRtfAsync(): Windows.Foundation.IAsyncOperation<string>;
+    GetStorageItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[]>;
+    GetTextAsync(): Windows.Foundation.IAsyncOperation<string>;
+    GetTextAsync(formatId: string): Windows.Foundation.IAsyncOperation<string>;
+    GetUriAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Uri>;
+    ReportOperationCompleted(value: number): void;
+    readonly AvailableFormats: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Properties: Windows.ApplicationModel.DataTransfer.DataPackagePropertySetView;
+    readonly RequestedOperation: number;
+  }
+  var IDataPackageView: abstract new (...args: any[]) => IDataPackageView;
+
+  interface IDataPackageView2 {
+    GetApplicationLinkAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Uri>;
+    GetWebLinkAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Uri>;
+  }
+  var IDataPackageView2: abstract new (...args: any[]) => IDataPackageView2;
+
+  interface IDataPackageView3 {
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    RequestAccessAsync(enterpriseId: string): Windows.Foundation.IAsyncOperation<number>;
+    UnlockAndAssumeEnterpriseIdentity(): number;
+  }
+  var IDataPackageView3: abstract new (...args: any[]) => IDataPackageView3;
+
+  interface IDataPackageView4 {
+    SetAcceptedFormatId(formatId: string): void;
+  }
+  var IDataPackageView4: abstract new (...args: any[]) => IDataPackageView4;
+
+  interface IDataProviderDeferral {
+    Complete(): void;
+  }
+  var IDataProviderDeferral: abstract new (...args: any[]) => IDataProviderDeferral;
+
+  interface IDataProviderRequest {
+    GetDeferral(): Windows.ApplicationModel.DataTransfer.DataProviderDeferral;
+    SetData(value: Object): void;
+    readonly Deadline: Windows.Foundation.DateTime;
+    readonly FormatId: string;
+  }
+  var IDataProviderRequest: abstract new (...args: any[]) => IDataProviderRequest;
+
+  interface IDataRequest {
+    FailWithDisplayText(value: string): void;
+    GetDeferral(): Windows.ApplicationModel.DataTransfer.DataRequestDeferral;
+    Data: Windows.ApplicationModel.DataTransfer.DataPackage;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+  var IDataRequest: abstract new (...args: any[]) => IDataRequest;
+
+  interface IDataRequestDeferral {
+    Complete(): void;
+  }
+  var IDataRequestDeferral: abstract new (...args: any[]) => IDataRequestDeferral;
+
+  interface IDataRequestedEventArgs {
+    readonly Request: Windows.ApplicationModel.DataTransfer.DataRequest;
+  }
+  var IDataRequestedEventArgs: abstract new (...args: any[]) => IDataRequestedEventArgs;
+
+  interface IDataTransferManager {
+    DataRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.DataTransfer.DataTransferManager, Windows.ApplicationModel.DataTransfer.DataRequestedEventArgs> | null;
+    TargetApplicationChosen: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.DataTransfer.DataTransferManager, Windows.ApplicationModel.DataTransfer.TargetApplicationChosenEventArgs> | null;
+  }
+  var IDataTransferManager: abstract new (...args: any[]) => IDataTransferManager;
+
+  interface IDataTransferManager2 {
+    ShareProvidersRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.DataTransfer.DataTransferManager, Windows.ApplicationModel.DataTransfer.ShareProvidersRequestedEventArgs> | null;
+  }
+  var IDataTransferManager2: abstract new (...args: any[]) => IDataTransferManager2;
+
+  interface IDataTransferManagerStatics {
+    GetForCurrentView(): Windows.ApplicationModel.DataTransfer.DataTransferManager;
+    ShowShareUI(): void;
+  }
+  var IDataTransferManagerStatics: abstract new (...args: any[]) => IDataTransferManagerStatics;
+
+  interface IDataTransferManagerStatics2 {
+    IsSupported(): boolean;
+  }
+  var IDataTransferManagerStatics2: abstract new (...args: any[]) => IDataTransferManagerStatics2;
+
+  interface IDataTransferManagerStatics3 {
+    ShowShareUI(options: Windows.ApplicationModel.DataTransfer.ShareUIOptions): void;
+  }
+  var IDataTransferManagerStatics3: abstract new (...args: any[]) => IDataTransferManagerStatics3;
+
+  interface IHtmlFormatHelperStatics {
+    CreateHtmlFormat(htmlFragment: string): string;
+    GetStaticFragment(htmlFormat: string): string;
+  }
+  var IHtmlFormatHelperStatics: abstract new (...args: any[]) => IHtmlFormatHelperStatics;
+
+  interface IOperationCompletedEventArgs {
+    readonly Operation: number;
+  }
+  var IOperationCompletedEventArgs: abstract new (...args: any[]) => IOperationCompletedEventArgs;
+
+  interface IOperationCompletedEventArgs2 {
+    readonly AcceptedFormatId: string;
+  }
+  var IOperationCompletedEventArgs2: abstract new (...args: any[]) => IOperationCompletedEventArgs2;
+
+  interface IShareCompletedEventArgs {
+    readonly ShareTarget: Windows.ApplicationModel.DataTransfer.ShareTargetInfo;
+  }
+  var IShareCompletedEventArgs: abstract new (...args: any[]) => IShareCompletedEventArgs;
+
+  interface IShareProvider {
+    readonly BackgroundColor: Windows.UI.Color;
+    readonly DisplayIcon: Windows.Storage.Streams.RandomAccessStreamReference;
+    Tag: Object;
+    readonly Title: string;
+  }
+  var IShareProvider: abstract new (...args: any[]) => IShareProvider;
+
+  interface IShareProviderFactory {
+    Create(title: string, displayIcon: Windows.Storage.Streams.RandomAccessStreamReference, backgroundColor: Windows.UI.Color, handler: Windows.ApplicationModel.DataTransfer.ShareProviderHandler): Windows.ApplicationModel.DataTransfer.ShareProvider;
+  }
+  var IShareProviderFactory: abstract new (...args: any[]) => IShareProviderFactory;
+
+  interface IShareProviderOperation {
+    ReportCompleted(): void;
+    readonly Data: Windows.ApplicationModel.DataTransfer.DataPackageView;
+    readonly Provider: Windows.ApplicationModel.DataTransfer.ShareProvider;
+  }
+  var IShareProviderOperation: abstract new (...args: any[]) => IShareProviderOperation;
+
+  interface IShareProvidersRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Data: Windows.ApplicationModel.DataTransfer.DataPackageView;
+    readonly Providers: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.DataTransfer.ShareProvider> | Windows.ApplicationModel.DataTransfer.ShareProvider[];
+  }
+  var IShareProvidersRequestedEventArgs: abstract new (...args: any[]) => IShareProvidersRequestedEventArgs;
+
+  interface IShareTargetInfo {
+    readonly AppUserModelId: string;
+    readonly ShareProvider: Windows.ApplicationModel.DataTransfer.ShareProvider;
+  }
+  var IShareTargetInfo: abstract new (...args: any[]) => IShareTargetInfo;
+
+  interface IShareUIOptions {
+    SelectionRect: Windows.Foundation.Rect | null;
+    Theme: number;
+  }
+  var IShareUIOptions: abstract new (...args: any[]) => IShareUIOptions;
+
+  interface ISharedStorageAccessManagerStatics {
+    AddFile(file: Windows.Storage.IStorageFile): string;
+    RedeemTokenForFileAsync(token: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    RemoveFile(token: string): void;
+  }
+  var ISharedStorageAccessManagerStatics: abstract new (...args: any[]) => ISharedStorageAccessManagerStatics;
+
+  interface IStandardDataFormatsStatics {
+    readonly Bitmap: string;
+    readonly Html: string;
+    readonly Rtf: string;
+    readonly StorageItems: string;
+    readonly Text: string;
+    readonly Uri: string;
+  }
+  var IStandardDataFormatsStatics: abstract new (...args: any[]) => IStandardDataFormatsStatics;
+
+  interface IStandardDataFormatsStatics2 {
+    readonly ApplicationLink: string;
+    readonly WebLink: string;
+  }
+  var IStandardDataFormatsStatics2: abstract new (...args: any[]) => IStandardDataFormatsStatics2;
+
+  interface IStandardDataFormatsStatics3 {
+    readonly UserActivityJsonArray: string;
+  }
+  var IStandardDataFormatsStatics3: abstract new (...args: any[]) => IStandardDataFormatsStatics3;
+
+  interface ITargetApplicationChosenEventArgs {
+    readonly ApplicationName: string;
+  }
+  var ITargetApplicationChosenEventArgs: abstract new (...args: any[]) => ITargetApplicationChosenEventArgs;
+
+  interface ShareProviderHandler {
+    (operation: Windows.ApplicationModel.DataTransfer.ShareProviderOperation): void;
+  }
+  var ShareProviderHandler: {
+    new(callback: (operation: Windows.ApplicationModel.DataTransfer.ShareProviderOperation) => void): ShareProviderHandler;
+  };
+
+}
+
+declare namespace Windows.ApplicationModel.DataTransfer.DragDrop {
+  enum DragDropModifiers {
+    None = 0,
+    Shift = 1,
+    Control = 2,
+    Alt = 4,
+    LeftButton = 8,
+    MiddleButton = 16,
+    RightButton = 32,
+  }
+
+}
+
+declare namespace Windows.ApplicationModel.DataTransfer.DragDrop.Core {
+  class CoreDragDropManager implements Windows.ApplicationModel.DataTransfer.DragDrop.Core.ICoreDragDropManager {
+    static GetForCurrentView(): Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager;
+    AreConcurrentOperationsEnabled: boolean;
+    TargetRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager, Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDropOperationTargetRequestedEventArgs> | null;
+  }
+
+  class CoreDragInfo implements Windows.ApplicationModel.DataTransfer.DragDrop.Core.ICoreDragInfo, Windows.ApplicationModel.DataTransfer.DragDrop.Core.ICoreDragInfo2 {
+    readonly AllowedOperations: number;
+    readonly Data: Windows.ApplicationModel.DataTransfer.DataPackageView;
+    readonly Modifiers: number;
+    readonly Position: Windows.Foundation.Point;
+  }
+
+  class CoreDragOperation implements Windows.ApplicationModel.DataTransfer.DragDrop.Core.ICoreDragOperation, Windows.ApplicationModel.DataTransfer.DragDrop.Core.ICoreDragOperation2 {
+    constructor();
+    SetDragUIContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap): void;
+    SetDragUIContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap, anchorPoint: Windows.Foundation.Point): void;
+    SetPointerId(pointerId: number): void;
+    StartAsync(): Windows.Foundation.IAsyncOperation<number>;
+    AllowedOperations: number;
+    readonly Data: Windows.ApplicationModel.DataTransfer.DataPackage;
+    DragUIContentMode: number;
+  }
+
+  class CoreDragUIOverride implements Windows.ApplicationModel.DataTransfer.DragDrop.Core.ICoreDragUIOverride {
+    Clear(): void;
+    SetContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap): void;
+    SetContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap, anchorPoint: Windows.Foundation.Point): void;
+    Caption: string;
+    IsCaptionVisible: boolean;
+    IsContentVisible: boolean;
+    IsGlyphVisible: boolean;
+  }
+
+  class CoreDropOperationTargetRequestedEventArgs implements Windows.ApplicationModel.DataTransfer.DragDrop.Core.ICoreDropOperationTargetRequestedEventArgs {
+    SetTarget(target: Windows.ApplicationModel.DataTransfer.DragDrop.Core.ICoreDropOperationTarget): void;
+  }
+
+  enum CoreDragUIContentMode {
+    Auto = 0,
+    Deferred = 1,
+  }
+
+  interface ICoreDragDropManager {
+    AreConcurrentOperationsEnabled: boolean;
+    TargetRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager, Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDropOperationTargetRequestedEventArgs> | null;
+  }
+  var ICoreDragDropManager: abstract new (...args: any[]) => ICoreDragDropManager;
+
+  interface ICoreDragDropManagerStatics {
+    GetForCurrentView(): Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager;
+  }
+  var ICoreDragDropManagerStatics: abstract new (...args: any[]) => ICoreDragDropManagerStatics;
+
+  interface ICoreDragInfo {
+    readonly Data: Windows.ApplicationModel.DataTransfer.DataPackageView;
+    readonly Modifiers: number;
+    readonly Position: Windows.Foundation.Point;
+  }
+  var ICoreDragInfo: abstract new (...args: any[]) => ICoreDragInfo;
+
+  interface ICoreDragInfo2 extends Windows.ApplicationModel.DataTransfer.DragDrop.Core.ICoreDragInfo {
+    readonly AllowedOperations: number;
+  }
+  var ICoreDragInfo2: abstract new (...args: any[]) => ICoreDragInfo2;
+
+  interface ICoreDragOperation {
+    SetDragUIContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap): void;
+    SetDragUIContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap, anchorPoint: Windows.Foundation.Point): void;
+    SetPointerId(pointerId: number): void;
+    StartAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly Data: Windows.ApplicationModel.DataTransfer.DataPackage;
+    DragUIContentMode: number;
+  }
+  var ICoreDragOperation: abstract new (...args: any[]) => ICoreDragOperation;
+
+  interface ICoreDragOperation2 extends Windows.ApplicationModel.DataTransfer.DragDrop.Core.ICoreDragOperation {
+    SetDragUIContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap): void;
+    SetDragUIContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap, anchorPoint: Windows.Foundation.Point): void;
+    SetPointerId(pointerId: number): void;
+    StartAsync(): Windows.Foundation.IAsyncOperation<number>;
+    AllowedOperations: number;
+  }
+  var ICoreDragOperation2: abstract new (...args: any[]) => ICoreDragOperation2;
+
+  interface ICoreDragUIOverride {
+    Clear(): void;
+    SetContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap): void;
+    SetContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap, anchorPoint: Windows.Foundation.Point): void;
+    Caption: string;
+    IsCaptionVisible: boolean;
+    IsContentVisible: boolean;
+    IsGlyphVisible: boolean;
+  }
+  var ICoreDragUIOverride: abstract new (...args: any[]) => ICoreDragUIOverride;
+
+  interface ICoreDropOperationTarget {
+    DropAsync(dragInfo: Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragInfo): Windows.Foundation.IAsyncOperation<number>;
+    EnterAsync(dragInfo: Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragInfo, dragUIOverride: Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragUIOverride): Windows.Foundation.IAsyncOperation<number>;
+    LeaveAsync(dragInfo: Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragInfo): Windows.Foundation.IAsyncAction;
+    OverAsync(dragInfo: Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragInfo, dragUIOverride: Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragUIOverride): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var ICoreDropOperationTarget: abstract new (...args: any[]) => ICoreDropOperationTarget;
+
+  interface ICoreDropOperationTargetRequestedEventArgs {
+    SetTarget(target: Windows.ApplicationModel.DataTransfer.DragDrop.Core.ICoreDropOperationTarget): void;
+  }
+  var ICoreDropOperationTargetRequestedEventArgs: abstract new (...args: any[]) => ICoreDropOperationTargetRequestedEventArgs;
+
+}
+
+declare namespace Windows.ApplicationModel.DataTransfer.ShareTarget {
+  class QuickLink implements Windows.ApplicationModel.DataTransfer.ShareTarget.IQuickLink {
+    constructor();
+    Id: string;
+    readonly SupportedDataFormats: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly SupportedFileTypes: Windows.Foundation.Collections.IVector<string> | string[];
+    Thumbnail: Windows.Storage.Streams.RandomAccessStreamReference;
+    Title: string;
+  }
+
+  class ShareOperation implements Windows.ApplicationModel.DataTransfer.ShareTarget.IShareOperation, Windows.ApplicationModel.DataTransfer.ShareTarget.IShareOperation2, Windows.ApplicationModel.DataTransfer.ShareTarget.IShareOperation3 {
+    DismissUI(): void;
+    RemoveThisQuickLink(): void;
+    ReportCompleted(quicklink: Windows.ApplicationModel.DataTransfer.ShareTarget.QuickLink): void;
+    ReportCompleted(): void;
+    ReportDataRetrieved(): void;
+    ReportError(value: string): void;
+    ReportStarted(): void;
+    ReportSubmittedBackgroundTask(): void;
+    readonly Contacts: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.Contact> | Windows.ApplicationModel.Contacts.Contact[];
+    readonly Data: Windows.ApplicationModel.DataTransfer.DataPackageView;
+    readonly QuickLinkId: string;
+  }
+
+  interface IQuickLink {
+    Id: string;
+    readonly SupportedDataFormats: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly SupportedFileTypes: Windows.Foundation.Collections.IVector<string> | string[];
+    Thumbnail: Windows.Storage.Streams.RandomAccessStreamReference;
+    Title: string;
+  }
+  var IQuickLink: abstract new (...args: any[]) => IQuickLink;
+
+  interface IShareOperation {
+    RemoveThisQuickLink(): void;
+    ReportCompleted(quicklink: Windows.ApplicationModel.DataTransfer.ShareTarget.QuickLink): void;
+    ReportCompleted(): void;
+    ReportDataRetrieved(): void;
+    ReportError(value: string): void;
+    ReportStarted(): void;
+    ReportSubmittedBackgroundTask(): void;
+    readonly Data: Windows.ApplicationModel.DataTransfer.DataPackageView;
+    readonly QuickLinkId: string;
+  }
+  var IShareOperation: abstract new (...args: any[]) => IShareOperation;
+
+  interface IShareOperation2 {
+    DismissUI(): void;
+  }
+  var IShareOperation2: abstract new (...args: any[]) => IShareOperation2;
+
+  interface IShareOperation3 {
+    readonly Contacts: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.Contact> | Windows.ApplicationModel.Contacts.Contact[];
+  }
+  var IShareOperation3: abstract new (...args: any[]) => IShareOperation3;
+
+}
+
+declare namespace Windows.ApplicationModel.Email {
+  class EmailAttachment implements Windows.ApplicationModel.Email.IEmailAttachment, Windows.ApplicationModel.Email.IEmailAttachment2 {
+    constructor(fileName: string, data: Windows.Storage.Streams.IRandomAccessStreamReference, mimeType: string);
+    constructor(fileName: string, data: Windows.Storage.Streams.IRandomAccessStreamReference);
+    constructor();
+    ContentId: string;
+    ContentLocation: string;
+    Data: Windows.Storage.Streams.IRandomAccessStreamReference;
+    DownloadState: number;
+    EstimatedDownloadSizeInBytes: number | bigint;
+    FileName: string;
+    readonly Id: string;
+    readonly IsFromBaseMessage: boolean;
+    IsInline: boolean;
+    MimeType: string;
+  }
+
+  class EmailConversation implements Windows.ApplicationModel.Email.IEmailConversation {
+    FindMessagesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailMessage> | Windows.ApplicationModel.Email.EmailMessage[]>;
+    FindMessagesAsync(count: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailMessage> | Windows.ApplicationModel.Email.EmailMessage[]>;
+    readonly FlagState: number;
+    readonly HasAttachment: boolean;
+    readonly Id: string;
+    readonly Importance: number;
+    readonly LastEmailResponseKind: number;
+    readonly LatestSender: Windows.ApplicationModel.Email.EmailRecipient;
+    readonly MailboxId: string;
+    readonly MessageCount: number;
+    readonly MostRecentMessageId: string;
+    readonly MostRecentMessageTime: Windows.Foundation.DateTime;
+    readonly Preview: string;
+    readonly Subject: string;
+    readonly UnreadMessageCount: number;
+  }
+
+  class EmailConversationBatch implements Windows.ApplicationModel.Email.IEmailConversationBatch {
+    readonly Conversations: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailConversation> | Windows.ApplicationModel.Email.EmailConversation[];
+    readonly Status: number;
+  }
+
+  class EmailConversationReader implements Windows.ApplicationModel.Email.IEmailConversationReader {
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailConversationBatch>;
+  }
+
+  class EmailFolder implements Windows.ApplicationModel.Email.IEmailFolder {
+    CreateFolderAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailFolder>;
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    FindChildFoldersAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailFolder> | Windows.ApplicationModel.Email.EmailFolder[]>;
+    GetConversationReader(): Windows.ApplicationModel.Email.EmailConversationReader;
+    GetConversationReader(options: Windows.ApplicationModel.Email.EmailQueryOptions): Windows.ApplicationModel.Email.EmailConversationReader;
+    GetMessageAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMessage>;
+    GetMessageCountsAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailItemCounts>;
+    GetMessageReader(): Windows.ApplicationModel.Email.EmailMessageReader;
+    GetMessageReader(options: Windows.ApplicationModel.Email.EmailQueryOptions): Windows.ApplicationModel.Email.EmailMessageReader;
+    SaveMessageAsync(message: Windows.ApplicationModel.Email.EmailMessage): Windows.Foundation.IAsyncAction;
+    TryMoveAsync(newParentFolder: Windows.ApplicationModel.Email.EmailFolder): Windows.Foundation.IAsyncOperation<boolean>;
+    TryMoveAsync(newParentFolder: Windows.ApplicationModel.Email.EmailFolder, newFolderName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySaveAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    DisplayName: string;
+    readonly Id: string;
+    IsSyncEnabled: boolean;
+    readonly Kind: number;
+    LastSuccessfulSyncTime: Windows.Foundation.DateTime;
+    readonly MailboxId: string;
+    readonly ParentFolderId: string;
+    RemoteId: string;
+  }
+
+  class EmailIrmInfo implements Windows.ApplicationModel.Email.IEmailIrmInfo {
+    constructor(expiration: Windows.Foundation.DateTime, irmTemplate: Windows.ApplicationModel.Email.EmailIrmTemplate);
+    constructor();
+    CanEdit: boolean;
+    CanExtractData: boolean;
+    CanForward: boolean;
+    CanModifyRecipientsOnResponse: boolean;
+    CanPrintData: boolean;
+    CanRemoveIrmOnResponse: boolean;
+    CanReply: boolean;
+    CanReplyAll: boolean;
+    ExpirationDate: Windows.Foundation.DateTime;
+    IsIrmOriginator: boolean;
+    IsProgramaticAccessAllowed: boolean;
+    Template: Windows.ApplicationModel.Email.EmailIrmTemplate;
+  }
+
+  class EmailIrmTemplate implements Windows.ApplicationModel.Email.IEmailIrmTemplate {
+    constructor(id: string, name: string, description: string);
+    constructor();
+    Description: string;
+    Id: string;
+    Name: string;
+  }
+
+  class EmailItemCounts implements Windows.ApplicationModel.Email.IEmailItemCounts {
+    readonly Flagged: number;
+    readonly Important: number;
+    readonly Total: number;
+    readonly Unread: number;
+  }
+
+  class EmailMailbox implements Windows.ApplicationModel.Email.IEmailMailbox, Windows.ApplicationModel.Email.IEmailMailbox2, Windows.ApplicationModel.Email.IEmailMailbox3, Windows.ApplicationModel.Email.IEmailMailbox4, Windows.ApplicationModel.Email.IEmailMailbox5 {
+    ChangeMessageFlagStateAsync(messageId: string, flagState: number): Windows.Foundation.IAsyncAction;
+    CreateResponseMessageAsync(messageId: string, responseType: number, subject: string, responseHeaderType: number, responseHeader: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMessage>;
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    DeleteMessageAsync(messageId: string): Windows.Foundation.IAsyncAction;
+    DownloadAttachmentAsync(attachmentId: string): Windows.Foundation.IAsyncAction;
+    DownloadMessageAsync(messageId: string): Windows.Foundation.IAsyncAction;
+    GetChangeTracker(identity: string): Windows.ApplicationModel.Email.EmailMailboxChangeTracker;
+    GetConversationAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailConversation>;
+    GetConversationReader(): Windows.ApplicationModel.Email.EmailConversationReader;
+    GetConversationReader(options: Windows.ApplicationModel.Email.EmailQueryOptions): Windows.ApplicationModel.Email.EmailConversationReader;
+    GetFolderAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailFolder>;
+    GetMessageAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMessage>;
+    GetMessageReader(): Windows.ApplicationModel.Email.EmailMessageReader;
+    GetMessageReader(options: Windows.ApplicationModel.Email.EmailQueryOptions): Windows.ApplicationModel.Email.EmailMessageReader;
+    GetSpecialFolderAsync(folderType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailFolder>;
+    MarkFolderAsSeenAsync(folderId: string): Windows.Foundation.IAsyncAction;
+    MarkFolderSyncEnabledAsync(folderId: string, isSyncEnabled: boolean): Windows.Foundation.IAsyncAction;
+    MarkMessageAsSeenAsync(messageId: string): Windows.Foundation.IAsyncAction;
+    MarkMessageReadAsync(messageId: string, isRead: boolean): Windows.Foundation.IAsyncAction;
+    RegisterSyncManagerAsync(): Windows.Foundation.IAsyncAction;
+    ResolveRecipientsAsync(recipients: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailRecipientResolutionResult> | Windows.ApplicationModel.Email.EmailRecipientResolutionResult[]>;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    SaveDraftAsync(message: Windows.ApplicationModel.Email.EmailMessage): Windows.Foundation.IAsyncAction;
+    SendMessageAsync(message: Windows.ApplicationModel.Email.EmailMessage): Windows.Foundation.IAsyncAction;
+    SendMessageAsync(message: Windows.ApplicationModel.Email.EmailMessage, smartSend: boolean): Windows.Foundation.IAsyncAction;
+    TryCreateFolderAsync(parentFolderId: string, name: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMailboxCreateFolderResult>;
+    TryDeleteFolderAsync(folderId: string): Windows.Foundation.IAsyncOperation<number>;
+    TryEmptyFolderAsync(folderId: string): Windows.Foundation.IAsyncOperation<number>;
+    TryForwardMeetingAsync(meeting: Windows.ApplicationModel.Email.EmailMessage, recipients: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Email.EmailRecipient> | Windows.ApplicationModel.Email.EmailRecipient[], subject: string, forwardHeaderType: number, forwardHeader: string, comment: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryGetAutoReplySettingsAsync(requestedFormat: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMailboxAutoReplySettings>;
+    TryMoveFolderAsync(folderId: string, newParentFolderId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryMoveFolderAsync(folderId: string, newParentFolderId: string, newFolderName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryMoveMessageAsync(messageId: string, newParentFolderId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryProposeNewTimeForMeetingAsync(meeting: Windows.ApplicationModel.Email.EmailMessage, newStartTime: Windows.Foundation.DateTime, newDuration: Windows.Foundation.TimeSpan, subject: string, comment: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySetAutoReplySettingsAsync(autoReplySettings: Windows.ApplicationModel.Email.EmailMailboxAutoReplySettings): Windows.Foundation.IAsyncOperation<boolean>;
+    TryUpdateMeetingResponseAsync(meeting: Windows.ApplicationModel.Email.EmailMessage, response: number, subject: string, comment: string, sendUpdate: boolean): Windows.Foundation.IAsyncOperation<boolean>;
+    ValidateCertificatesAsync(certificates: Windows.Foundation.Collections.IIterable<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<number> | number[]>;
+    readonly Capabilities: Windows.ApplicationModel.Email.EmailMailboxCapabilities;
+    readonly ChangeTracker: Windows.ApplicationModel.Email.EmailMailboxChangeTracker;
+    DisplayName: string;
+    readonly Id: string;
+    readonly IsDataEncryptedUnderLock: boolean;
+    readonly IsOwnedByCurrentApp: boolean;
+    readonly LinkedMailboxId: string;
+    MailAddress: string;
+    readonly MailAddressAliases: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly NetworkAccountId: string;
+    readonly NetworkId: string;
+    OtherAppReadAccess: number;
+    OtherAppWriteAccess: number;
+    readonly Policies: Windows.ApplicationModel.Email.EmailMailboxPolicies;
+    readonly SourceDisplayName: string;
+    readonly SyncManager: Windows.ApplicationModel.Email.EmailMailboxSyncManager;
+    readonly UserDataAccountId: string;
+    MailboxChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.EmailMailbox, Windows.ApplicationModel.Email.EmailMailboxChangedEventArgs> | null;
+  }
+
+  class EmailMailboxAction implements Windows.ApplicationModel.Email.IEmailMailboxAction {
+    readonly ChangeNumber: number | bigint;
+    readonly Kind: number;
+  }
+
+  class EmailMailboxAutoReply implements Windows.ApplicationModel.Email.IEmailMailboxAutoReply {
+    IsEnabled: boolean;
+    Response: string;
+  }
+
+  class EmailMailboxAutoReplySettings implements Windows.ApplicationModel.Email.IEmailMailboxAutoReplySettings {
+    constructor();
+    EndTime: Windows.Foundation.DateTime | null;
+    readonly InternalReply: Windows.ApplicationModel.Email.EmailMailboxAutoReply;
+    IsEnabled: boolean;
+    readonly KnownExternalReply: Windows.ApplicationModel.Email.EmailMailboxAutoReply;
+    ResponseKind: number;
+    StartTime: Windows.Foundation.DateTime | null;
+    readonly UnknownExternalReply: Windows.ApplicationModel.Email.EmailMailboxAutoReply;
+  }
+
+  class EmailMailboxCapabilities implements Windows.ApplicationModel.Email.IEmailMailboxCapabilities, Windows.ApplicationModel.Email.IEmailMailboxCapabilities2, Windows.ApplicationModel.Email.IEmailMailboxCapabilities3 {
+    CanCreateFolder: boolean;
+    CanDeleteFolder: boolean;
+    CanEmptyFolder: boolean;
+    CanForwardMeetings: boolean;
+    CanGetAndSetExternalAutoReplies: boolean;
+    CanGetAndSetInternalAutoReplies: boolean;
+    CanMoveFolder: boolean;
+    CanProposeNewTimeForMeetings: boolean;
+    CanResolveRecipients: boolean;
+    CanServerSearchFolders: boolean;
+    CanServerSearchMailbox: boolean;
+    CanSmartSend: boolean;
+    CanUpdateMeetingResponses: boolean;
+    CanValidateCertificates: boolean;
+  }
+
+  class EmailMailboxChange implements Windows.ApplicationModel.Email.IEmailMailboxChange {
+    readonly ChangeType: number;
+    readonly Folder: Windows.ApplicationModel.Email.EmailFolder;
+    readonly MailboxActions: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Email.EmailMailboxAction> | Windows.ApplicationModel.Email.EmailMailboxAction[];
+    readonly Message: Windows.ApplicationModel.Email.EmailMessage;
+  }
+
+  class EmailMailboxChangeReader implements Windows.ApplicationModel.Email.IEmailMailboxChangeReader {
+    AcceptChanges(): void;
+    AcceptChangesThrough(lastChangeToAcknowledge: Windows.ApplicationModel.Email.EmailMailboxChange): void;
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailMailboxChange> | Windows.ApplicationModel.Email.EmailMailboxChange[]>;
+  }
+
+  class EmailMailboxChangeTracker implements Windows.ApplicationModel.Email.IEmailMailboxChangeTracker {
+    Enable(): void;
+    GetChangeReader(): Windows.ApplicationModel.Email.EmailMailboxChangeReader;
+    Reset(): void;
+    readonly IsTracking: boolean;
+  }
+
+  class EmailMailboxChangedDeferral implements Windows.ApplicationModel.Email.IEmailMailboxChangedDeferral {
+    Complete(): void;
+  }
+
+  class EmailMailboxChangedEventArgs implements Windows.ApplicationModel.Email.IEmailMailboxChangedEventArgs {
+    GetDeferral(): Windows.ApplicationModel.Email.EmailMailboxChangedDeferral;
+  }
+
+  class EmailMailboxCreateFolderResult implements Windows.ApplicationModel.Email.IEmailMailboxCreateFolderResult {
+    readonly Folder: Windows.ApplicationModel.Email.EmailFolder;
+    readonly Status: number;
+  }
+
+  class EmailMailboxPolicies implements Windows.ApplicationModel.Email.IEmailMailboxPolicies, Windows.ApplicationModel.Email.IEmailMailboxPolicies2, Windows.ApplicationModel.Email.IEmailMailboxPolicies3 {
+    AllowSmimeSoftCertificates: boolean;
+    AllowedSmimeEncryptionAlgorithmNegotiation: number;
+    MustEncryptSmimeMessages: boolean;
+    MustSignSmimeMessages: boolean;
+    RequiredSmimeEncryptionAlgorithm: number | null;
+    RequiredSmimeSigningAlgorithm: number | null;
+  }
+
+  class EmailMailboxSyncManager implements Windows.ApplicationModel.Email.IEmailMailboxSyncManager, Windows.ApplicationModel.Email.IEmailMailboxSyncManager2 {
+    SyncAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    LastAttemptedSyncTime: Windows.Foundation.DateTime;
+    LastSuccessfulSyncTime: Windows.Foundation.DateTime;
+    Status: number;
+    SyncStatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.EmailMailboxSyncManager, Object> | null;
+  }
+
+  class EmailManager {
+    static GetForUser(user: Windows.System.User): Windows.ApplicationModel.Email.EmailManagerForUser;
+    static RequestStoreAsync(accessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailStore>;
+    static ShowComposeNewEmailAsync(message: Windows.ApplicationModel.Email.EmailMessage): Windows.Foundation.IAsyncAction;
+  }
+
+  class EmailManagerForUser implements Windows.ApplicationModel.Email.IEmailManagerForUser {
+    RequestStoreAsync(accessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailStore>;
+    ShowComposeNewEmailAsync(message: Windows.ApplicationModel.Email.EmailMessage): Windows.Foundation.IAsyncAction;
+    readonly User: Windows.System.User;
+  }
+
+  class EmailMeetingInfo implements Windows.ApplicationModel.Email.IEmailMeetingInfo, Windows.ApplicationModel.Email.IEmailMeetingInfo2 {
+    constructor();
+    AllowNewTimeProposal: boolean;
+    AppointmentOriginalStartTime: Windows.Foundation.DateTime | null;
+    AppointmentRoamingId: string;
+    Duration: Windows.Foundation.TimeSpan;
+    IsAllDay: boolean;
+    readonly IsReportedOutOfDateByServer: boolean;
+    IsResponseRequested: boolean;
+    Location: string;
+    ProposedDuration: Windows.Foundation.TimeSpan | null;
+    ProposedStartTime: Windows.Foundation.DateTime | null;
+    Recurrence: Windows.ApplicationModel.Appointments.AppointmentRecurrence;
+    RecurrenceStartTime: Windows.Foundation.DateTime | null;
+    RemoteChangeNumber: number | bigint;
+    StartTime: Windows.Foundation.DateTime;
+  }
+
+  class EmailMessage implements Windows.ApplicationModel.Email.IEmailMessage, Windows.ApplicationModel.Email.IEmailMessage2, Windows.ApplicationModel.Email.IEmailMessage3, Windows.ApplicationModel.Email.IEmailMessage4 {
+    constructor();
+    GetBodyStream(type: number): Windows.Storage.Streams.IRandomAccessStreamReference;
+    SetBodyStream(type: number, stream: Windows.Storage.Streams.IRandomAccessStreamReference): void;
+    AllowInternetImages: boolean;
+    readonly Attachments: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Email.EmailAttachment> | Windows.ApplicationModel.Email.EmailAttachment[];
+    readonly Bcc: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Email.EmailRecipient> | Windows.ApplicationModel.Email.EmailRecipient[];
+    Body: string;
+    readonly CC: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Email.EmailRecipient> | Windows.ApplicationModel.Email.EmailRecipient[];
+    readonly ChangeNumber: number | bigint;
+    readonly ConversationId: string;
+    DownloadState: number;
+    EstimatedDownloadSizeInBytes: number;
+    FlagState: number;
+    readonly FolderId: string;
+    readonly HasPartialBodies: boolean;
+    readonly Id: string;
+    Importance: number;
+    readonly InResponseToMessageId: string;
+    IrmInfo: Windows.ApplicationModel.Email.EmailIrmInfo;
+    readonly IsDraftMessage: boolean;
+    IsRead: boolean;
+    IsSeen: boolean;
+    readonly IsServerSearchMessage: boolean;
+    readonly IsSmartSendable: boolean;
+    LastResponseKind: number;
+    readonly MailboxId: string;
+    MeetingInfo: Windows.ApplicationModel.Email.EmailMeetingInfo;
+    MessageClass: string;
+    readonly NormalizedSubject: string;
+    OriginalCodePage: number;
+    Preview: string;
+    RemoteId: string;
+    readonly ReplyTo: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Email.EmailRecipient> | Windows.ApplicationModel.Email.EmailRecipient[];
+    Sender: Windows.ApplicationModel.Email.EmailRecipient;
+    SentRepresenting: Windows.ApplicationModel.Email.EmailRecipient;
+    SentTime: Windows.Foundation.DateTime | null;
+    SmimeData: Windows.Storage.Streams.IRandomAccessStreamReference;
+    SmimeKind: number;
+    Subject: string;
+    readonly To: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Email.EmailRecipient> | Windows.ApplicationModel.Email.EmailRecipient[];
+  }
+
+  class EmailMessageBatch implements Windows.ApplicationModel.Email.IEmailMessageBatch {
+    readonly Messages: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailMessage> | Windows.ApplicationModel.Email.EmailMessage[];
+    readonly Status: number;
+  }
+
+  class EmailMessageReader implements Windows.ApplicationModel.Email.IEmailMessageReader {
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMessageBatch>;
+  }
+
+  class EmailQueryOptions implements Windows.ApplicationModel.Email.IEmailQueryOptions {
+    constructor(text: string);
+    constructor(text: string, fields: number);
+    constructor();
+    readonly FolderIds: Windows.Foundation.Collections.IVector<string> | string[];
+    Kind: number;
+    SortDirection: number;
+    SortProperty: number;
+    readonly TextSearch: Windows.ApplicationModel.Email.EmailQueryTextSearch;
+  }
+
+  class EmailQueryTextSearch implements Windows.ApplicationModel.Email.IEmailQueryTextSearch {
+    Fields: number;
+    SearchScope: number;
+    Text: string;
+  }
+
+  class EmailRecipient implements Windows.ApplicationModel.Email.IEmailRecipient {
+    constructor(address: string);
+    constructor(address: string, name: string);
+    constructor();
+    Address: string;
+    Name: string;
+  }
+
+  class EmailRecipientResolutionResult implements Windows.ApplicationModel.Email.IEmailRecipientResolutionResult, Windows.ApplicationModel.Email.IEmailRecipientResolutionResult2 {
+    constructor();
+    SetPublicKeys(value: Windows.Foundation.Collections.IIterable<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[]): void;
+    readonly PublicKeys: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+    Status: number;
+  }
+
+  class EmailStore implements Windows.ApplicationModel.Email.IEmailStore {
+    CreateMailboxAsync(accountName: string, accountAddress: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMailbox>;
+    CreateMailboxAsync(accountName: string, accountAddress: string, userDataAccountId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMailbox>;
+    FindMailboxesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailMailbox> | Windows.ApplicationModel.Email.EmailMailbox[]>;
+    GetConversationAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailConversation>;
+    GetConversationReader(): Windows.ApplicationModel.Email.EmailConversationReader;
+    GetConversationReader(options: Windows.ApplicationModel.Email.EmailQueryOptions): Windows.ApplicationModel.Email.EmailConversationReader;
+    GetFolderAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailFolder>;
+    GetMailboxAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMailbox>;
+    GetMessageAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMessage>;
+    GetMessageReader(): Windows.ApplicationModel.Email.EmailMessageReader;
+    GetMessageReader(options: Windows.ApplicationModel.Email.EmailQueryOptions): Windows.ApplicationModel.Email.EmailMessageReader;
+  }
+
+  class EmailStoreNotificationTriggerDetails implements Windows.ApplicationModel.Email.IEmailStoreNotificationTriggerDetails {
+  }
+
+  enum EmailAttachmentDownloadState {
+    NotDownloaded = 0,
+    Downloading = 1,
+    Downloaded = 2,
+    Failed = 3,
+  }
+
+  enum EmailBatchStatus {
+    Success = 0,
+    ServerSearchSyncManagerError = 1,
+    ServerSearchUnknownError = 2,
+  }
+
+  enum EmailCertificateValidationStatus {
+    Success = 0,
+    NoMatch = 1,
+    InvalidUsage = 2,
+    InvalidCertificate = 3,
+    Revoked = 4,
+    ChainRevoked = 5,
+    RevocationServerFailure = 6,
+    Expired = 7,
+    Untrusted = 8,
+    ServerError = 9,
+    UnknownFailure = 10,
+  }
+
+  enum EmailFlagState {
+    Unflagged = 0,
+    Flagged = 1,
+    Completed = 2,
+    Cleared = 3,
+  }
+
+  enum EmailImportance {
+    Normal = 0,
+    High = 1,
+    Low = 2,
+  }
+
+  enum EmailMailboxActionKind {
+    MarkMessageAsSeen = 0,
+    MarkMessageRead = 1,
+    ChangeMessageFlagState = 2,
+    MoveMessage = 3,
+    SaveDraft = 4,
+    SendMessage = 5,
+    CreateResponseReplyMessage = 6,
+    CreateResponseReplyAllMessage = 7,
+    CreateResponseForwardMessage = 8,
+    MoveFolder = 9,
+    MarkFolderForSyncEnabled = 10,
+  }
+
+  enum EmailMailboxAllowedSmimeEncryptionAlgorithmNegotiation {
+    None = 0,
+    StrongAlgorithm = 1,
+    AnyAlgorithm = 2,
+  }
+
+  enum EmailMailboxAutoReplyMessageResponseKind {
+    Html = 0,
+    PlainText = 1,
+  }
+
+  enum EmailMailboxChangeType {
+    MessageCreated = 0,
+    MessageModified = 1,
+    MessageDeleted = 2,
+    FolderCreated = 3,
+    FolderModified = 4,
+    FolderDeleted = 5,
+    ChangeTrackingLost = 6,
+  }
+
+  enum EmailMailboxCreateFolderStatus {
+    Success = 0,
+    NetworkError = 1,
+    PermissionsError = 2,
+    ServerError = 3,
+    UnknownFailure = 4,
+    NameCollision = 5,
+    ServerRejected = 6,
+  }
+
+  enum EmailMailboxDeleteFolderStatus {
+    Success = 0,
+    NetworkError = 1,
+    PermissionsError = 2,
+    ServerError = 3,
+    UnknownFailure = 4,
+    CouldNotDeleteEverything = 5,
+  }
+
+  enum EmailMailboxEmptyFolderStatus {
+    Success = 0,
+    NetworkError = 1,
+    PermissionsError = 2,
+    ServerError = 3,
+    UnknownFailure = 4,
+    CouldNotDeleteEverything = 5,
+  }
+
+  enum EmailMailboxOtherAppReadAccess {
+    SystemOnly = 0,
+    Full = 1,
+    None = 2,
+  }
+
+  enum EmailMailboxOtherAppWriteAccess {
+    None = 0,
+    Limited = 1,
+  }
+
+  enum EmailMailboxSmimeEncryptionAlgorithm {
+    Any = 0,
+    TripleDes = 1,
+    Des = 2,
+    RC2128Bit = 3,
+    RC264Bit = 4,
+    RC240Bit = 5,
+  }
+
+  enum EmailMailboxSmimeSigningAlgorithm {
+    Any = 0,
+    Sha1 = 1,
+    MD5 = 2,
+  }
+
+  enum EmailMailboxSyncStatus {
+    Idle = 0,
+    Syncing = 1,
+    UpToDate = 2,
+    AuthenticationError = 3,
+    PolicyError = 4,
+    UnknownError = 5,
+    ManualAccountRemovalRequired = 6,
+  }
+
+  enum EmailMeetingResponseType {
+    Accept = 0,
+    Decline = 1,
+    Tentative = 2,
+  }
+
+  enum EmailMessageBodyKind {
+    Html = 0,
+    PlainText = 1,
+  }
+
+  enum EmailMessageDownloadState {
+    PartiallyDownloaded = 0,
+    Downloading = 1,
+    Downloaded = 2,
+    Failed = 3,
+  }
+
+  enum EmailMessageResponseKind {
+    None = 0,
+    Reply = 1,
+    ReplyAll = 2,
+    Forward = 3,
+  }
+
+  enum EmailMessageSmimeKind {
+    None = 0,
+    ClearSigned = 1,
+    OpaqueSigned = 2,
+    Encrypted = 3,
+  }
+
+  enum EmailQueryKind {
+    All = 0,
+    Important = 1,
+    Flagged = 2,
+    Unread = 3,
+    Read = 4,
+    Unseen = 5,
+  }
+
+  enum EmailQuerySearchFields {
+    None = 0,
+    Subject = 1,
+    Sender = 2,
+    Preview = 4,
+    Recipients = 8,
+    All = 4294967295,
+  }
+
+  enum EmailQuerySearchScope {
+    Local = 0,
+    Server = 1,
+  }
+
+  enum EmailQuerySortDirection {
+    Descending = 0,
+    Ascending = 1,
+  }
+
+  enum EmailQuerySortProperty {
+    Date = 0,
+  }
+
+  enum EmailRecipientResolutionStatus {
+    Success = 0,
+    RecipientNotFound = 1,
+    AmbiguousRecipient = 2,
+    NoCertificate = 3,
+    CertificateRequestLimitReached = 4,
+    CannotResolveDistributionList = 5,
+    ServerError = 6,
+    UnknownFailure = 7,
+  }
+
+  enum EmailSpecialFolderKind {
+    None = 0,
+    Root = 1,
+    Inbox = 2,
+    Outbox = 3,
+    Drafts = 4,
+    DeletedItems = 5,
+    Sent = 6,
+  }
+
+  enum EmailStoreAccessType {
+    AppMailboxesReadWrite = 0,
+    AllMailboxesLimitedReadWrite = 1,
+  }
+
+  interface IEmailAttachment {
+    Data: Windows.Storage.Streams.IRandomAccessStreamReference;
+    FileName: string;
+  }
+  var IEmailAttachment: abstract new (...args: any[]) => IEmailAttachment;
+
+  interface IEmailAttachment2 {
+    ContentId: string;
+    ContentLocation: string;
+    DownloadState: number;
+    EstimatedDownloadSizeInBytes: number | bigint;
+    readonly Id: string;
+    readonly IsFromBaseMessage: boolean;
+    IsInline: boolean;
+    MimeType: string;
+  }
+  var IEmailAttachment2: abstract new (...args: any[]) => IEmailAttachment2;
+
+  interface IEmailAttachmentFactory {
+    Create(fileName: string, data: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.ApplicationModel.Email.EmailAttachment;
+  }
+  var IEmailAttachmentFactory: abstract new (...args: any[]) => IEmailAttachmentFactory;
+
+  interface IEmailAttachmentFactory2 {
+    Create(fileName: string, data: Windows.Storage.Streams.IRandomAccessStreamReference, mimeType: string): Windows.ApplicationModel.Email.EmailAttachment;
+  }
+  var IEmailAttachmentFactory2: abstract new (...args: any[]) => IEmailAttachmentFactory2;
+
+  interface IEmailConversation {
+    FindMessagesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailMessage> | Windows.ApplicationModel.Email.EmailMessage[]>;
+    FindMessagesAsync(count: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailMessage> | Windows.ApplicationModel.Email.EmailMessage[]>;
+    readonly FlagState: number;
+    readonly HasAttachment: boolean;
+    readonly Id: string;
+    readonly Importance: number;
+    readonly LastEmailResponseKind: number;
+    readonly LatestSender: Windows.ApplicationModel.Email.EmailRecipient;
+    readonly MailboxId: string;
+    readonly MessageCount: number;
+    readonly MostRecentMessageId: string;
+    readonly MostRecentMessageTime: Windows.Foundation.DateTime;
+    readonly Preview: string;
+    readonly Subject: string;
+    readonly UnreadMessageCount: number;
+  }
+  var IEmailConversation: abstract new (...args: any[]) => IEmailConversation;
+
+  interface IEmailConversationBatch {
+    readonly Conversations: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailConversation> | Windows.ApplicationModel.Email.EmailConversation[];
+    readonly Status: number;
+  }
+  var IEmailConversationBatch: abstract new (...args: any[]) => IEmailConversationBatch;
+
+  interface IEmailConversationReader {
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailConversationBatch>;
+  }
+  var IEmailConversationReader: abstract new (...args: any[]) => IEmailConversationReader;
+
+  interface IEmailFolder {
+    CreateFolderAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailFolder>;
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    FindChildFoldersAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailFolder> | Windows.ApplicationModel.Email.EmailFolder[]>;
+    GetConversationReader(): Windows.ApplicationModel.Email.EmailConversationReader;
+    GetConversationReader(options: Windows.ApplicationModel.Email.EmailQueryOptions): Windows.ApplicationModel.Email.EmailConversationReader;
+    GetMessageAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMessage>;
+    GetMessageCountsAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailItemCounts>;
+    GetMessageReader(): Windows.ApplicationModel.Email.EmailMessageReader;
+    GetMessageReader(options: Windows.ApplicationModel.Email.EmailQueryOptions): Windows.ApplicationModel.Email.EmailMessageReader;
+    SaveMessageAsync(message: Windows.ApplicationModel.Email.EmailMessage): Windows.Foundation.IAsyncAction;
+    TryMoveAsync(newParentFolder: Windows.ApplicationModel.Email.EmailFolder): Windows.Foundation.IAsyncOperation<boolean>;
+    TryMoveAsync(newParentFolder: Windows.ApplicationModel.Email.EmailFolder, newFolderName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySaveAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    DisplayName: string;
+    readonly Id: string;
+    IsSyncEnabled: boolean;
+    readonly Kind: number;
+    LastSuccessfulSyncTime: Windows.Foundation.DateTime;
+    readonly MailboxId: string;
+    readonly ParentFolderId: string;
+    RemoteId: string;
+  }
+  var IEmailFolder: abstract new (...args: any[]) => IEmailFolder;
+
+  interface IEmailIrmInfo {
+    CanEdit: boolean;
+    CanExtractData: boolean;
+    CanForward: boolean;
+    CanModifyRecipientsOnResponse: boolean;
+    CanPrintData: boolean;
+    CanRemoveIrmOnResponse: boolean;
+    CanReply: boolean;
+    CanReplyAll: boolean;
+    ExpirationDate: Windows.Foundation.DateTime;
+    IsIrmOriginator: boolean;
+    IsProgramaticAccessAllowed: boolean;
+    Template: Windows.ApplicationModel.Email.EmailIrmTemplate;
+  }
+  var IEmailIrmInfo: abstract new (...args: any[]) => IEmailIrmInfo;
+
+  interface IEmailIrmInfoFactory {
+    Create(expiration: Windows.Foundation.DateTime, irmTemplate: Windows.ApplicationModel.Email.EmailIrmTemplate): Windows.ApplicationModel.Email.EmailIrmInfo;
+  }
+  var IEmailIrmInfoFactory: abstract new (...args: any[]) => IEmailIrmInfoFactory;
+
+  interface IEmailIrmTemplate {
+    Description: string;
+    Id: string;
+    Name: string;
+  }
+  var IEmailIrmTemplate: abstract new (...args: any[]) => IEmailIrmTemplate;
+
+  interface IEmailIrmTemplateFactory {
+    Create(id: string, name: string, description: string): Windows.ApplicationModel.Email.EmailIrmTemplate;
+  }
+  var IEmailIrmTemplateFactory: abstract new (...args: any[]) => IEmailIrmTemplateFactory;
+
+  interface IEmailItemCounts {
+    readonly Flagged: number;
+    readonly Important: number;
+    readonly Total: number;
+    readonly Unread: number;
+  }
+  var IEmailItemCounts: abstract new (...args: any[]) => IEmailItemCounts;
+
+  interface IEmailMailbox {
+    ChangeMessageFlagStateAsync(messageId: string, flagState: number): Windows.Foundation.IAsyncAction;
+    CreateResponseMessageAsync(messageId: string, responseType: number, subject: string, responseHeaderType: number, responseHeader: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMessage>;
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    DeleteMessageAsync(messageId: string): Windows.Foundation.IAsyncAction;
+    DownloadAttachmentAsync(attachmentId: string): Windows.Foundation.IAsyncAction;
+    DownloadMessageAsync(messageId: string): Windows.Foundation.IAsyncAction;
+    GetConversationAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailConversation>;
+    GetConversationReader(): Windows.ApplicationModel.Email.EmailConversationReader;
+    GetConversationReader(options: Windows.ApplicationModel.Email.EmailQueryOptions): Windows.ApplicationModel.Email.EmailConversationReader;
+    GetFolderAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailFolder>;
+    GetMessageAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMessage>;
+    GetMessageReader(): Windows.ApplicationModel.Email.EmailMessageReader;
+    GetMessageReader(options: Windows.ApplicationModel.Email.EmailQueryOptions): Windows.ApplicationModel.Email.EmailMessageReader;
+    GetSpecialFolderAsync(folderType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailFolder>;
+    MarkFolderAsSeenAsync(folderId: string): Windows.Foundation.IAsyncAction;
+    MarkFolderSyncEnabledAsync(folderId: string, isSyncEnabled: boolean): Windows.Foundation.IAsyncAction;
+    MarkMessageAsSeenAsync(messageId: string): Windows.Foundation.IAsyncAction;
+    MarkMessageReadAsync(messageId: string, isRead: boolean): Windows.Foundation.IAsyncAction;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    SaveDraftAsync(message: Windows.ApplicationModel.Email.EmailMessage): Windows.Foundation.IAsyncAction;
+    SendMessageAsync(message: Windows.ApplicationModel.Email.EmailMessage): Windows.Foundation.IAsyncAction;
+    SendMessageAsync(message: Windows.ApplicationModel.Email.EmailMessage, smartSend: boolean): Windows.Foundation.IAsyncAction;
+    TryForwardMeetingAsync(meeting: Windows.ApplicationModel.Email.EmailMessage, recipients: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Email.EmailRecipient> | Windows.ApplicationModel.Email.EmailRecipient[], subject: string, forwardHeaderType: number, forwardHeader: string, comment: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryGetAutoReplySettingsAsync(requestedFormat: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMailboxAutoReplySettings>;
+    TryMoveFolderAsync(folderId: string, newParentFolderId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryMoveFolderAsync(folderId: string, newParentFolderId: string, newFolderName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryMoveMessageAsync(messageId: string, newParentFolderId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryProposeNewTimeForMeetingAsync(meeting: Windows.ApplicationModel.Email.EmailMessage, newStartTime: Windows.Foundation.DateTime, newDuration: Windows.Foundation.TimeSpan, subject: string, comment: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySetAutoReplySettingsAsync(autoReplySettings: Windows.ApplicationModel.Email.EmailMailboxAutoReplySettings): Windows.Foundation.IAsyncOperation<boolean>;
+    TryUpdateMeetingResponseAsync(meeting: Windows.ApplicationModel.Email.EmailMessage, response: number, subject: string, comment: string, sendUpdate: boolean): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Capabilities: Windows.ApplicationModel.Email.EmailMailboxCapabilities;
+    readonly ChangeTracker: Windows.ApplicationModel.Email.EmailMailboxChangeTracker;
+    DisplayName: string;
+    readonly Id: string;
+    readonly IsDataEncryptedUnderLock: boolean;
+    readonly IsOwnedByCurrentApp: boolean;
+    MailAddress: string;
+    readonly MailAddressAliases: Windows.Foundation.Collections.IVector<string> | string[];
+    OtherAppReadAccess: number;
+    OtherAppWriteAccess: number;
+    readonly Policies: Windows.ApplicationModel.Email.EmailMailboxPolicies;
+    readonly SourceDisplayName: string;
+    readonly SyncManager: Windows.ApplicationModel.Email.EmailMailboxSyncManager;
+    readonly UserDataAccountId: string;
+    MailboxChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.EmailMailbox, Windows.ApplicationModel.Email.EmailMailboxChangedEventArgs> | null;
+  }
+  var IEmailMailbox: abstract new (...args: any[]) => IEmailMailbox;
+
+  interface IEmailMailbox2 extends Windows.ApplicationModel.Email.IEmailMailbox {
+    ChangeMessageFlagStateAsync(messageId: string, flagState: number): Windows.Foundation.IAsyncAction;
+    CreateResponseMessageAsync(messageId: string, responseType: number, subject: string, responseHeaderType: number, responseHeader: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMessage>;
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    DeleteMessageAsync(messageId: string): Windows.Foundation.IAsyncAction;
+    DownloadAttachmentAsync(attachmentId: string): Windows.Foundation.IAsyncAction;
+    DownloadMessageAsync(messageId: string): Windows.Foundation.IAsyncAction;
+    GetConversationAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailConversation>;
+    GetConversationReader(): Windows.ApplicationModel.Email.EmailConversationReader;
+    GetConversationReader(options: Windows.ApplicationModel.Email.EmailQueryOptions): Windows.ApplicationModel.Email.EmailConversationReader;
+    GetFolderAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailFolder>;
+    GetMessageAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMessage>;
+    GetMessageReader(): Windows.ApplicationModel.Email.EmailMessageReader;
+    GetMessageReader(options: Windows.ApplicationModel.Email.EmailQueryOptions): Windows.ApplicationModel.Email.EmailMessageReader;
+    GetSpecialFolderAsync(folderType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailFolder>;
+    MarkFolderAsSeenAsync(folderId: string): Windows.Foundation.IAsyncAction;
+    MarkFolderSyncEnabledAsync(folderId: string, isSyncEnabled: boolean): Windows.Foundation.IAsyncAction;
+    MarkMessageAsSeenAsync(messageId: string): Windows.Foundation.IAsyncAction;
+    MarkMessageReadAsync(messageId: string, isRead: boolean): Windows.Foundation.IAsyncAction;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    SaveDraftAsync(message: Windows.ApplicationModel.Email.EmailMessage): Windows.Foundation.IAsyncAction;
+    SendMessageAsync(message: Windows.ApplicationModel.Email.EmailMessage): Windows.Foundation.IAsyncAction;
+    SendMessageAsync(message: Windows.ApplicationModel.Email.EmailMessage, smartSend: boolean): Windows.Foundation.IAsyncAction;
+    TryForwardMeetingAsync(meeting: Windows.ApplicationModel.Email.EmailMessage, recipients: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Email.EmailRecipient> | Windows.ApplicationModel.Email.EmailRecipient[], subject: string, forwardHeaderType: number, forwardHeader: string, comment: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryGetAutoReplySettingsAsync(requestedFormat: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMailboxAutoReplySettings>;
+    TryMoveFolderAsync(folderId: string, newParentFolderId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryMoveFolderAsync(folderId: string, newParentFolderId: string, newFolderName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryMoveMessageAsync(messageId: string, newParentFolderId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryProposeNewTimeForMeetingAsync(meeting: Windows.ApplicationModel.Email.EmailMessage, newStartTime: Windows.Foundation.DateTime, newDuration: Windows.Foundation.TimeSpan, subject: string, comment: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySetAutoReplySettingsAsync(autoReplySettings: Windows.ApplicationModel.Email.EmailMailboxAutoReplySettings): Windows.Foundation.IAsyncOperation<boolean>;
+    TryUpdateMeetingResponseAsync(meeting: Windows.ApplicationModel.Email.EmailMessage, response: number, subject: string, comment: string, sendUpdate: boolean): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly LinkedMailboxId: string;
+    readonly NetworkAccountId: string;
+    readonly NetworkId: string;
+  }
+  var IEmailMailbox2: abstract new (...args: any[]) => IEmailMailbox2;
+
+  interface IEmailMailbox3 extends Windows.ApplicationModel.Email.IEmailMailbox, Windows.ApplicationModel.Email.IEmailMailbox2 {
+    ChangeMessageFlagStateAsync(messageId: string, flagState: number): Windows.Foundation.IAsyncAction;
+    CreateResponseMessageAsync(messageId: string, responseType: number, subject: string, responseHeaderType: number, responseHeader: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMessage>;
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    DeleteMessageAsync(messageId: string): Windows.Foundation.IAsyncAction;
+    DownloadAttachmentAsync(attachmentId: string): Windows.Foundation.IAsyncAction;
+    DownloadMessageAsync(messageId: string): Windows.Foundation.IAsyncAction;
+    GetConversationAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailConversation>;
+    GetConversationReader(): Windows.ApplicationModel.Email.EmailConversationReader;
+    GetConversationReader(options: Windows.ApplicationModel.Email.EmailQueryOptions): Windows.ApplicationModel.Email.EmailConversationReader;
+    GetFolderAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailFolder>;
+    GetMessageAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMessage>;
+    GetMessageReader(): Windows.ApplicationModel.Email.EmailMessageReader;
+    GetMessageReader(options: Windows.ApplicationModel.Email.EmailQueryOptions): Windows.ApplicationModel.Email.EmailMessageReader;
+    GetSpecialFolderAsync(folderType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailFolder>;
+    MarkFolderAsSeenAsync(folderId: string): Windows.Foundation.IAsyncAction;
+    MarkFolderSyncEnabledAsync(folderId: string, isSyncEnabled: boolean): Windows.Foundation.IAsyncAction;
+    MarkMessageAsSeenAsync(messageId: string): Windows.Foundation.IAsyncAction;
+    MarkMessageReadAsync(messageId: string, isRead: boolean): Windows.Foundation.IAsyncAction;
+    ResolveRecipientsAsync(recipients: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailRecipientResolutionResult> | Windows.ApplicationModel.Email.EmailRecipientResolutionResult[]>;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    SaveDraftAsync(message: Windows.ApplicationModel.Email.EmailMessage): Windows.Foundation.IAsyncAction;
+    SendMessageAsync(message: Windows.ApplicationModel.Email.EmailMessage): Windows.Foundation.IAsyncAction;
+    SendMessageAsync(message: Windows.ApplicationModel.Email.EmailMessage, smartSend: boolean): Windows.Foundation.IAsyncAction;
+    TryCreateFolderAsync(parentFolderId: string, name: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMailboxCreateFolderResult>;
+    TryDeleteFolderAsync(folderId: string): Windows.Foundation.IAsyncOperation<number>;
+    TryEmptyFolderAsync(folderId: string): Windows.Foundation.IAsyncOperation<number>;
+    TryForwardMeetingAsync(meeting: Windows.ApplicationModel.Email.EmailMessage, recipients: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Email.EmailRecipient> | Windows.ApplicationModel.Email.EmailRecipient[], subject: string, forwardHeaderType: number, forwardHeader: string, comment: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryGetAutoReplySettingsAsync(requestedFormat: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMailboxAutoReplySettings>;
+    TryMoveFolderAsync(folderId: string, newParentFolderId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryMoveFolderAsync(folderId: string, newParentFolderId: string, newFolderName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryMoveMessageAsync(messageId: string, newParentFolderId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryProposeNewTimeForMeetingAsync(meeting: Windows.ApplicationModel.Email.EmailMessage, newStartTime: Windows.Foundation.DateTime, newDuration: Windows.Foundation.TimeSpan, subject: string, comment: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySetAutoReplySettingsAsync(autoReplySettings: Windows.ApplicationModel.Email.EmailMailboxAutoReplySettings): Windows.Foundation.IAsyncOperation<boolean>;
+    TryUpdateMeetingResponseAsync(meeting: Windows.ApplicationModel.Email.EmailMessage, response: number, subject: string, comment: string, sendUpdate: boolean): Windows.Foundation.IAsyncOperation<boolean>;
+    ValidateCertificatesAsync(certificates: Windows.Foundation.Collections.IIterable<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<number> | number[]>;
+  }
+  var IEmailMailbox3: abstract new (...args: any[]) => IEmailMailbox3;
+
+  interface IEmailMailbox4 {
+    RegisterSyncManagerAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var IEmailMailbox4: abstract new (...args: any[]) => IEmailMailbox4;
+
+  interface IEmailMailbox5 {
+    GetChangeTracker(identity: string): Windows.ApplicationModel.Email.EmailMailboxChangeTracker;
+  }
+  var IEmailMailbox5: abstract new (...args: any[]) => IEmailMailbox5;
+
+  interface IEmailMailboxAction {
+    readonly ChangeNumber: number | bigint;
+    readonly Kind: number;
+  }
+  var IEmailMailboxAction: abstract new (...args: any[]) => IEmailMailboxAction;
+
+  interface IEmailMailboxAutoReply {
+    IsEnabled: boolean;
+    Response: string;
+  }
+  var IEmailMailboxAutoReply: abstract new (...args: any[]) => IEmailMailboxAutoReply;
+
+  interface IEmailMailboxAutoReplySettings {
+    EndTime: Windows.Foundation.DateTime | null;
+    readonly InternalReply: Windows.ApplicationModel.Email.EmailMailboxAutoReply;
+    IsEnabled: boolean;
+    readonly KnownExternalReply: Windows.ApplicationModel.Email.EmailMailboxAutoReply;
+    ResponseKind: number;
+    StartTime: Windows.Foundation.DateTime | null;
+    readonly UnknownExternalReply: Windows.ApplicationModel.Email.EmailMailboxAutoReply;
+  }
+  var IEmailMailboxAutoReplySettings: abstract new (...args: any[]) => IEmailMailboxAutoReplySettings;
+
+  interface IEmailMailboxCapabilities {
+    readonly CanForwardMeetings: boolean;
+    readonly CanGetAndSetExternalAutoReplies: boolean;
+    readonly CanGetAndSetInternalAutoReplies: boolean;
+    readonly CanProposeNewTimeForMeetings: boolean;
+    readonly CanServerSearchFolders: boolean;
+    readonly CanServerSearchMailbox: boolean;
+    readonly CanSmartSend: boolean;
+    readonly CanUpdateMeetingResponses: boolean;
+  }
+  var IEmailMailboxCapabilities: abstract new (...args: any[]) => IEmailMailboxCapabilities;
+
+  interface IEmailMailboxCapabilities2 {
+    readonly CanCreateFolder: boolean;
+    readonly CanDeleteFolder: boolean;
+    readonly CanEmptyFolder: boolean;
+    readonly CanMoveFolder: boolean;
+    readonly CanResolveRecipients: boolean;
+    readonly CanValidateCertificates: boolean;
+  }
+  var IEmailMailboxCapabilities2: abstract new (...args: any[]) => IEmailMailboxCapabilities2;
+
+  interface IEmailMailboxCapabilities3 {
+    CanCreateFolder: Object;
+    CanDeleteFolder: Object;
+    CanEmptyFolder: Object;
+    CanForwardMeetings: Object;
+    CanGetAndSetExternalAutoReplies: Object;
+    CanGetAndSetInternalAutoReplies: Object;
+    CanMoveFolder: Object;
+    CanProposeNewTimeForMeetings: Object;
+    CanResolveRecipients: Object;
+    CanServerSearchFolders: Object;
+    CanServerSearchMailbox: Object;
+    CanSmartSend: Object;
+    CanUpdateMeetingResponses: Object;
+    CanValidateCertificates: Object;
+  }
+  var IEmailMailboxCapabilities3: abstract new (...args: any[]) => IEmailMailboxCapabilities3;
+
+  interface IEmailMailboxChange {
+    readonly ChangeType: number;
+    readonly Folder: Windows.ApplicationModel.Email.EmailFolder;
+    readonly MailboxActions: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Email.EmailMailboxAction> | Windows.ApplicationModel.Email.EmailMailboxAction[];
+    readonly Message: Windows.ApplicationModel.Email.EmailMessage;
+  }
+  var IEmailMailboxChange: abstract new (...args: any[]) => IEmailMailboxChange;
+
+  interface IEmailMailboxChangeReader {
+    AcceptChanges(): void;
+    AcceptChangesThrough(lastChangeToAcknowledge: Windows.ApplicationModel.Email.EmailMailboxChange): void;
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailMailboxChange> | Windows.ApplicationModel.Email.EmailMailboxChange[]>;
+  }
+  var IEmailMailboxChangeReader: abstract new (...args: any[]) => IEmailMailboxChangeReader;
+
+  interface IEmailMailboxChangeTracker {
+    Enable(): void;
+    GetChangeReader(): Windows.ApplicationModel.Email.EmailMailboxChangeReader;
+    Reset(): void;
+    readonly IsTracking: boolean;
+  }
+  var IEmailMailboxChangeTracker: abstract new (...args: any[]) => IEmailMailboxChangeTracker;
+
+  interface IEmailMailboxChangedDeferral {
+    Complete(): void;
+  }
+  var IEmailMailboxChangedDeferral: abstract new (...args: any[]) => IEmailMailboxChangedDeferral;
+
+  interface IEmailMailboxChangedEventArgs {
+    GetDeferral(): Windows.ApplicationModel.Email.EmailMailboxChangedDeferral;
+  }
+  var IEmailMailboxChangedEventArgs: abstract new (...args: any[]) => IEmailMailboxChangedEventArgs;
+
+  interface IEmailMailboxCreateFolderResult {
+    readonly Folder: Windows.ApplicationModel.Email.EmailFolder;
+    readonly Status: number;
+  }
+  var IEmailMailboxCreateFolderResult: abstract new (...args: any[]) => IEmailMailboxCreateFolderResult;
+
+  interface IEmailMailboxPolicies {
+    readonly AllowSmimeSoftCertificates: boolean;
+    readonly AllowedSmimeEncryptionAlgorithmNegotiation: number;
+    readonly RequiredSmimeEncryptionAlgorithm: number | null;
+    readonly RequiredSmimeSigningAlgorithm: number | null;
+  }
+  var IEmailMailboxPolicies: abstract new (...args: any[]) => IEmailMailboxPolicies;
+
+  interface IEmailMailboxPolicies2 {
+    readonly MustEncryptSmimeMessages: boolean;
+    readonly MustSignSmimeMessages: boolean;
+  }
+  var IEmailMailboxPolicies2: abstract new (...args: any[]) => IEmailMailboxPolicies2;
+
+  interface IEmailMailboxPolicies3 {
+    AllowSmimeSoftCertificates: Object;
+    AllowedSmimeEncryptionAlgorithmNegotiation: Object;
+    MustEncryptSmimeMessages: Object;
+    MustSignSmimeMessages: Object;
+    RequiredSmimeEncryptionAlgorithm: Object;
+    RequiredSmimeSigningAlgorithm: Object;
+  }
+  var IEmailMailboxPolicies3: abstract new (...args: any[]) => IEmailMailboxPolicies3;
+
+  interface IEmailMailboxSyncManager {
+    SyncAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly LastAttemptedSyncTime: Windows.Foundation.DateTime;
+    readonly LastSuccessfulSyncTime: Windows.Foundation.DateTime;
+    readonly Status: number;
+    SyncStatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.EmailMailboxSyncManager, Object> | null;
+  }
+  var IEmailMailboxSyncManager: abstract new (...args: any[]) => IEmailMailboxSyncManager;
+
+  interface IEmailMailboxSyncManager2 {
+    LastAttemptedSyncTime: Object;
+    LastSuccessfulSyncTime: Object;
+    Status: Object;
+  }
+  var IEmailMailboxSyncManager2: abstract new (...args: any[]) => IEmailMailboxSyncManager2;
+
+  interface IEmailManagerForUser {
+    RequestStoreAsync(accessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailStore>;
+    ShowComposeNewEmailAsync(message: Windows.ApplicationModel.Email.EmailMessage): Windows.Foundation.IAsyncAction;
+    readonly User: Windows.System.User;
+  }
+  var IEmailManagerForUser: abstract new (...args: any[]) => IEmailManagerForUser;
+
+  interface IEmailManagerStatics {
+    ShowComposeNewEmailAsync(message: Windows.ApplicationModel.Email.EmailMessage): Windows.Foundation.IAsyncAction;
+  }
+  var IEmailManagerStatics: abstract new (...args: any[]) => IEmailManagerStatics;
+
+  interface IEmailManagerStatics2 {
+    RequestStoreAsync(accessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailStore>;
+  }
+  var IEmailManagerStatics2: abstract new (...args: any[]) => IEmailManagerStatics2;
+
+  interface IEmailManagerStatics3 {
+    GetForUser(user: Windows.System.User): Windows.ApplicationModel.Email.EmailManagerForUser;
+  }
+  var IEmailManagerStatics3: abstract new (...args: any[]) => IEmailManagerStatics3;
+
+  interface IEmailMeetingInfo {
+    AllowNewTimeProposal: boolean;
+    AppointmentOriginalStartTime: Windows.Foundation.DateTime | null;
+    AppointmentRoamingId: string;
+    Duration: Windows.Foundation.TimeSpan;
+    IsAllDay: boolean;
+    IsResponseRequested: boolean;
+    Location: string;
+    ProposedDuration: Windows.Foundation.TimeSpan | null;
+    ProposedStartTime: Windows.Foundation.DateTime | null;
+    Recurrence: Windows.ApplicationModel.Appointments.AppointmentRecurrence;
+    RecurrenceStartTime: Windows.Foundation.DateTime | null;
+    RemoteChangeNumber: number | bigint;
+    StartTime: Windows.Foundation.DateTime;
+  }
+  var IEmailMeetingInfo: abstract new (...args: any[]) => IEmailMeetingInfo;
+
+  interface IEmailMeetingInfo2 {
+    readonly IsReportedOutOfDateByServer: boolean;
+  }
+  var IEmailMeetingInfo2: abstract new (...args: any[]) => IEmailMeetingInfo2;
+
+  interface IEmailMessage {
+    readonly Attachments: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Email.EmailAttachment> | Windows.ApplicationModel.Email.EmailAttachment[];
+    readonly Bcc: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Email.EmailRecipient> | Windows.ApplicationModel.Email.EmailRecipient[];
+    Body: string;
+    readonly CC: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Email.EmailRecipient> | Windows.ApplicationModel.Email.EmailRecipient[];
+    Subject: string;
+    readonly To: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Email.EmailRecipient> | Windows.ApplicationModel.Email.EmailRecipient[];
+  }
+  var IEmailMessage: abstract new (...args: any[]) => IEmailMessage;
+
+  interface IEmailMessage2 {
+    GetBodyStream(type: number): Windows.Storage.Streams.IRandomAccessStreamReference;
+    SetBodyStream(type: number, stream: Windows.Storage.Streams.IRandomAccessStreamReference): void;
+    AllowInternetImages: boolean;
+    readonly ChangeNumber: number | bigint;
+    readonly ConversationId: string;
+    DownloadState: number;
+    EstimatedDownloadSizeInBytes: number;
+    FlagState: number;
+    readonly FolderId: string;
+    readonly HasPartialBodies: boolean;
+    readonly Id: string;
+    Importance: number;
+    readonly InResponseToMessageId: string;
+    IrmInfo: Windows.ApplicationModel.Email.EmailIrmInfo;
+    readonly IsDraftMessage: boolean;
+    IsRead: boolean;
+    IsSeen: boolean;
+    readonly IsServerSearchMessage: boolean;
+    readonly IsSmartSendable: boolean;
+    LastResponseKind: number;
+    readonly MailboxId: string;
+    MeetingInfo: Windows.ApplicationModel.Email.EmailMeetingInfo;
+    MessageClass: string;
+    readonly NormalizedSubject: string;
+    OriginalCodePage: number;
+    Preview: string;
+    RemoteId: string;
+    Sender: Windows.ApplicationModel.Email.EmailRecipient;
+    SentTime: Windows.Foundation.DateTime | null;
+  }
+  var IEmailMessage2: abstract new (...args: any[]) => IEmailMessage2;
+
+  interface IEmailMessage3 {
+    SmimeData: Windows.Storage.Streams.IRandomAccessStreamReference;
+    SmimeKind: number;
+  }
+  var IEmailMessage3: abstract new (...args: any[]) => IEmailMessage3;
+
+  interface IEmailMessage4 {
+    readonly ReplyTo: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Email.EmailRecipient> | Windows.ApplicationModel.Email.EmailRecipient[];
+    SentRepresenting: Windows.ApplicationModel.Email.EmailRecipient;
+  }
+  var IEmailMessage4: abstract new (...args: any[]) => IEmailMessage4;
+
+  interface IEmailMessageBatch {
+    readonly Messages: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailMessage> | Windows.ApplicationModel.Email.EmailMessage[];
+    readonly Status: number;
+  }
+  var IEmailMessageBatch: abstract new (...args: any[]) => IEmailMessageBatch;
+
+  interface IEmailMessageReader {
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMessageBatch>;
+  }
+  var IEmailMessageReader: abstract new (...args: any[]) => IEmailMessageReader;
+
+  interface IEmailQueryOptions {
+    readonly FolderIds: Windows.Foundation.Collections.IVector<string> | string[];
+    Kind: number;
+    SortDirection: number;
+    SortProperty: number;
+    readonly TextSearch: Windows.ApplicationModel.Email.EmailQueryTextSearch;
+  }
+  var IEmailQueryOptions: abstract new (...args: any[]) => IEmailQueryOptions;
+
+  interface IEmailQueryOptionsFactory {
+    CreateWithText(text: string): Windows.ApplicationModel.Email.EmailQueryOptions;
+    CreateWithTextAndFields(text: string, fields: number): Windows.ApplicationModel.Email.EmailQueryOptions;
+  }
+  var IEmailQueryOptionsFactory: abstract new (...args: any[]) => IEmailQueryOptionsFactory;
+
+  interface IEmailQueryTextSearch {
+    Fields: number;
+    SearchScope: number;
+    Text: string;
+  }
+  var IEmailQueryTextSearch: abstract new (...args: any[]) => IEmailQueryTextSearch;
+
+  interface IEmailRecipient {
+    Address: string;
+    Name: string;
+  }
+  var IEmailRecipient: abstract new (...args: any[]) => IEmailRecipient;
+
+  interface IEmailRecipientFactory {
+    Create(address: string): Windows.ApplicationModel.Email.EmailRecipient;
+    CreateWithName(address: string, name: string): Windows.ApplicationModel.Email.EmailRecipient;
+  }
+  var IEmailRecipientFactory: abstract new (...args: any[]) => IEmailRecipientFactory;
+
+  interface IEmailRecipientResolutionResult {
+    readonly PublicKeys: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+    readonly Status: number;
+  }
+  var IEmailRecipientResolutionResult: abstract new (...args: any[]) => IEmailRecipientResolutionResult;
+
+  interface IEmailRecipientResolutionResult2 {
+    SetPublicKeys(value: Windows.Foundation.Collections.IIterable<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[]): void;
+    Status: Object;
+  }
+  var IEmailRecipientResolutionResult2: abstract new (...args: any[]) => IEmailRecipientResolutionResult2;
+
+  interface IEmailStore {
+    CreateMailboxAsync(accountName: string, accountAddress: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMailbox>;
+    CreateMailboxAsync(accountName: string, accountAddress: string, userDataAccountId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMailbox>;
+    FindMailboxesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailMailbox> | Windows.ApplicationModel.Email.EmailMailbox[]>;
+    GetConversationAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailConversation>;
+    GetConversationReader(): Windows.ApplicationModel.Email.EmailConversationReader;
+    GetConversationReader(options: Windows.ApplicationModel.Email.EmailQueryOptions): Windows.ApplicationModel.Email.EmailConversationReader;
+    GetFolderAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailFolder>;
+    GetMailboxAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMailbox>;
+    GetMessageAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Email.EmailMessage>;
+    GetMessageReader(): Windows.ApplicationModel.Email.EmailMessageReader;
+    GetMessageReader(options: Windows.ApplicationModel.Email.EmailQueryOptions): Windows.ApplicationModel.Email.EmailMessageReader;
+  }
+  var IEmailStore: abstract new (...args: any[]) => IEmailStore;
+
+  interface IEmailStoreNotificationTriggerDetails {
+  }
+  var IEmailStoreNotificationTriggerDetails: abstract new (...args: any[]) => IEmailStoreNotificationTriggerDetails;
+
+}
+
+declare namespace Windows.ApplicationModel.Email.DataProvider {
+  class EmailDataProviderConnection implements Windows.ApplicationModel.Email.DataProvider.IEmailDataProviderConnection {
+    Start(): void;
+    CreateFolderRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequestEventArgs> | null;
+    DeleteFolderRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequestEventArgs> | null;
+    DownloadAttachmentRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequestEventArgs> | null;
+    DownloadMessageRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequestEventArgs> | null;
+    EmptyFolderRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequestEventArgs> | null;
+    ForwardMeetingRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequestEventArgs> | null;
+    GetAutoReplySettingsRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequestEventArgs> | null;
+    MailboxSyncRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequestEventArgs> | null;
+    MoveFolderRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequestEventArgs> | null;
+    ProposeNewTimeForMeetingRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequestEventArgs> | null;
+    ResolveRecipientsRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequestEventArgs> | null;
+    ServerSearchReadBatchRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequestEventArgs> | null;
+    SetAutoReplySettingsRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequestEventArgs> | null;
+    UpdateMeetingResponseRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequestEventArgs> | null;
+    ValidateCertificatesRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequestEventArgs> | null;
+  }
+
+  class EmailDataProviderTriggerDetails implements Windows.ApplicationModel.Email.DataProvider.IEmailDataProviderTriggerDetails {
+    readonly Connection: Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection;
+  }
+
+  class EmailMailboxCreateFolderRequest implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxCreateFolderRequest {
+    ReportCompletedAsync(folder: Windows.ApplicationModel.Email.EmailFolder): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(status: number): Windows.Foundation.IAsyncAction;
+    readonly EmailMailboxId: string;
+    readonly Name: string;
+    readonly ParentFolderId: string;
+  }
+
+  class EmailMailboxCreateFolderRequestEventArgs implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxCreateFolderRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequest;
+  }
+
+  class EmailMailboxDeleteFolderRequest implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxDeleteFolderRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(status: number): Windows.Foundation.IAsyncAction;
+    readonly EmailFolderId: string;
+    readonly EmailMailboxId: string;
+  }
+
+  class EmailMailboxDeleteFolderRequestEventArgs implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxDeleteFolderRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequest;
+  }
+
+  class EmailMailboxDownloadAttachmentRequest implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxDownloadAttachmentRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly EmailAttachmentId: string;
+    readonly EmailMailboxId: string;
+    readonly EmailMessageId: string;
+  }
+
+  class EmailMailboxDownloadAttachmentRequestEventArgs implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxDownloadAttachmentRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequest;
+  }
+
+  class EmailMailboxDownloadMessageRequest implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxDownloadMessageRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly EmailMailboxId: string;
+    readonly EmailMessageId: string;
+  }
+
+  class EmailMailboxDownloadMessageRequestEventArgs implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxDownloadMessageRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequest;
+  }
+
+  class EmailMailboxEmptyFolderRequest implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxEmptyFolderRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(status: number): Windows.Foundation.IAsyncAction;
+    readonly EmailFolderId: string;
+    readonly EmailMailboxId: string;
+  }
+
+  class EmailMailboxEmptyFolderRequestEventArgs implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxEmptyFolderRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequest;
+  }
+
+  class EmailMailboxForwardMeetingRequest implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxForwardMeetingRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly Comment: string;
+    readonly EmailMailboxId: string;
+    readonly EmailMessageId: string;
+    readonly ForwardHeader: string;
+    readonly ForwardHeaderType: number;
+    readonly Recipients: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailRecipient> | Windows.ApplicationModel.Email.EmailRecipient[];
+    readonly Subject: string;
+  }
+
+  class EmailMailboxForwardMeetingRequestEventArgs implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxForwardMeetingRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequest;
+  }
+
+  class EmailMailboxGetAutoReplySettingsRequest implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxGetAutoReplySettingsRequest {
+    ReportCompletedAsync(autoReplySettings: Windows.ApplicationModel.Email.EmailMailboxAutoReplySettings): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly EmailMailboxId: string;
+    readonly RequestedFormat: number;
+  }
+
+  class EmailMailboxGetAutoReplySettingsRequestEventArgs implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxGetAutoReplySettingsRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequest;
+  }
+
+  class EmailMailboxMoveFolderRequest implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxMoveFolderRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly EmailFolderId: string;
+    readonly EmailMailboxId: string;
+    readonly NewFolderName: string;
+    readonly NewParentFolderId: string;
+  }
+
+  class EmailMailboxMoveFolderRequestEventArgs implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxMoveFolderRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequest;
+  }
+
+  class EmailMailboxProposeNewTimeForMeetingRequest implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxProposeNewTimeForMeetingRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly Comment: string;
+    readonly EmailMailboxId: string;
+    readonly EmailMessageId: string;
+    readonly NewDuration: Windows.Foundation.TimeSpan;
+    readonly NewStartTime: Windows.Foundation.DateTime;
+    readonly Subject: string;
+  }
+
+  class EmailMailboxProposeNewTimeForMeetingRequestEventArgs implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxProposeNewTimeForMeetingRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequest;
+  }
+
+  class EmailMailboxResolveRecipientsRequest implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxResolveRecipientsRequest {
+    ReportCompletedAsync(resolutionResults: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Email.EmailRecipientResolutionResult> | Windows.ApplicationModel.Email.EmailRecipientResolutionResult[]): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly EmailMailboxId: string;
+    readonly Recipients: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+
+  class EmailMailboxResolveRecipientsRequestEventArgs implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxResolveRecipientsRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequest;
+  }
+
+  class EmailMailboxServerSearchReadBatchRequest implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxServerSearchReadBatchRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(batchStatus: number): Windows.Foundation.IAsyncAction;
+    SaveMessageAsync(message: Windows.ApplicationModel.Email.EmailMessage): Windows.Foundation.IAsyncAction;
+    readonly EmailFolderId: string;
+    readonly EmailMailboxId: string;
+    readonly Options: Windows.ApplicationModel.Email.EmailQueryOptions;
+    readonly SessionId: string;
+    readonly SuggestedBatchSize: number;
+  }
+
+  class EmailMailboxServerSearchReadBatchRequestEventArgs implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxServerSearchReadBatchRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequest;
+  }
+
+  class EmailMailboxSetAutoReplySettingsRequest implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxSetAutoReplySettingsRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly AutoReplySettings: Windows.ApplicationModel.Email.EmailMailboxAutoReplySettings;
+    readonly EmailMailboxId: string;
+  }
+
+  class EmailMailboxSetAutoReplySettingsRequestEventArgs implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxSetAutoReplySettingsRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequest;
+  }
+
+  class EmailMailboxSyncManagerSyncRequest implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxSyncManagerSyncRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly EmailMailboxId: string;
+  }
+
+  class EmailMailboxSyncManagerSyncRequestEventArgs implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxSyncManagerSyncRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequest;
+  }
+
+  class EmailMailboxUpdateMeetingResponseRequest implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxUpdateMeetingResponseRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly Comment: string;
+    readonly EmailMailboxId: string;
+    readonly EmailMessageId: string;
+    readonly Response: number;
+    readonly SendUpdate: boolean;
+    readonly Subject: string;
+  }
+
+  class EmailMailboxUpdateMeetingResponseRequestEventArgs implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxUpdateMeetingResponseRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequest;
+  }
+
+  class EmailMailboxValidateCertificatesRequest implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxValidateCertificatesRequest {
+    ReportCompletedAsync(validationStatuses: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly Certificates: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+    readonly EmailMailboxId: string;
+  }
+
+  class EmailMailboxValidateCertificatesRequestEventArgs implements Windows.ApplicationModel.Email.DataProvider.IEmailMailboxValidateCertificatesRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequest;
+  }
+
+  interface IEmailDataProviderConnection {
+    Start(): void;
+    CreateFolderRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequestEventArgs> | null;
+    DeleteFolderRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequestEventArgs> | null;
+    DownloadAttachmentRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequestEventArgs> | null;
+    DownloadMessageRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequestEventArgs> | null;
+    EmptyFolderRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequestEventArgs> | null;
+    ForwardMeetingRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequestEventArgs> | null;
+    GetAutoReplySettingsRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequestEventArgs> | null;
+    MailboxSyncRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequestEventArgs> | null;
+    MoveFolderRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequestEventArgs> | null;
+    ProposeNewTimeForMeetingRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequestEventArgs> | null;
+    ResolveRecipientsRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequestEventArgs> | null;
+    ServerSearchReadBatchRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequestEventArgs> | null;
+    SetAutoReplySettingsRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequestEventArgs> | null;
+    UpdateMeetingResponseRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequestEventArgs> | null;
+    ValidateCertificatesRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection, Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequestEventArgs> | null;
+  }
+  var IEmailDataProviderConnection: abstract new (...args: any[]) => IEmailDataProviderConnection;
+
+  interface IEmailDataProviderTriggerDetails {
+    readonly Connection: Windows.ApplicationModel.Email.DataProvider.EmailDataProviderConnection;
+  }
+  var IEmailDataProviderTriggerDetails: abstract new (...args: any[]) => IEmailDataProviderTriggerDetails;
+
+  interface IEmailMailboxCreateFolderRequest {
+    ReportCompletedAsync(folder: Windows.ApplicationModel.Email.EmailFolder): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(status: number): Windows.Foundation.IAsyncAction;
+    readonly EmailMailboxId: string;
+    readonly Name: string;
+    readonly ParentFolderId: string;
+  }
+  var IEmailMailboxCreateFolderRequest: abstract new (...args: any[]) => IEmailMailboxCreateFolderRequest;
+
+  interface IEmailMailboxCreateFolderRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxCreateFolderRequest;
+  }
+  var IEmailMailboxCreateFolderRequestEventArgs: abstract new (...args: any[]) => IEmailMailboxCreateFolderRequestEventArgs;
+
+  interface IEmailMailboxDeleteFolderRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(status: number): Windows.Foundation.IAsyncAction;
+    readonly EmailFolderId: string;
+    readonly EmailMailboxId: string;
+  }
+  var IEmailMailboxDeleteFolderRequest: abstract new (...args: any[]) => IEmailMailboxDeleteFolderRequest;
+
+  interface IEmailMailboxDeleteFolderRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxDeleteFolderRequest;
+  }
+  var IEmailMailboxDeleteFolderRequestEventArgs: abstract new (...args: any[]) => IEmailMailboxDeleteFolderRequestEventArgs;
+
+  interface IEmailMailboxDownloadAttachmentRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly EmailAttachmentId: string;
+    readonly EmailMailboxId: string;
+    readonly EmailMessageId: string;
+  }
+  var IEmailMailboxDownloadAttachmentRequest: abstract new (...args: any[]) => IEmailMailboxDownloadAttachmentRequest;
+
+  interface IEmailMailboxDownloadAttachmentRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadAttachmentRequest;
+  }
+  var IEmailMailboxDownloadAttachmentRequestEventArgs: abstract new (...args: any[]) => IEmailMailboxDownloadAttachmentRequestEventArgs;
+
+  interface IEmailMailboxDownloadMessageRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly EmailMailboxId: string;
+    readonly EmailMessageId: string;
+  }
+  var IEmailMailboxDownloadMessageRequest: abstract new (...args: any[]) => IEmailMailboxDownloadMessageRequest;
+
+  interface IEmailMailboxDownloadMessageRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxDownloadMessageRequest;
+  }
+  var IEmailMailboxDownloadMessageRequestEventArgs: abstract new (...args: any[]) => IEmailMailboxDownloadMessageRequestEventArgs;
+
+  interface IEmailMailboxEmptyFolderRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(status: number): Windows.Foundation.IAsyncAction;
+    readonly EmailFolderId: string;
+    readonly EmailMailboxId: string;
+  }
+  var IEmailMailboxEmptyFolderRequest: abstract new (...args: any[]) => IEmailMailboxEmptyFolderRequest;
+
+  interface IEmailMailboxEmptyFolderRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxEmptyFolderRequest;
+  }
+  var IEmailMailboxEmptyFolderRequestEventArgs: abstract new (...args: any[]) => IEmailMailboxEmptyFolderRequestEventArgs;
+
+  interface IEmailMailboxForwardMeetingRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly Comment: string;
+    readonly EmailMailboxId: string;
+    readonly EmailMessageId: string;
+    readonly ForwardHeader: string;
+    readonly ForwardHeaderType: number;
+    readonly Recipients: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailRecipient> | Windows.ApplicationModel.Email.EmailRecipient[];
+    readonly Subject: string;
+  }
+  var IEmailMailboxForwardMeetingRequest: abstract new (...args: any[]) => IEmailMailboxForwardMeetingRequest;
+
+  interface IEmailMailboxForwardMeetingRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxForwardMeetingRequest;
+  }
+  var IEmailMailboxForwardMeetingRequestEventArgs: abstract new (...args: any[]) => IEmailMailboxForwardMeetingRequestEventArgs;
+
+  interface IEmailMailboxGetAutoReplySettingsRequest {
+    ReportCompletedAsync(autoReplySettings: Windows.ApplicationModel.Email.EmailMailboxAutoReplySettings): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly EmailMailboxId: string;
+    readonly RequestedFormat: number;
+  }
+  var IEmailMailboxGetAutoReplySettingsRequest: abstract new (...args: any[]) => IEmailMailboxGetAutoReplySettingsRequest;
+
+  interface IEmailMailboxGetAutoReplySettingsRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxGetAutoReplySettingsRequest;
+  }
+  var IEmailMailboxGetAutoReplySettingsRequestEventArgs: abstract new (...args: any[]) => IEmailMailboxGetAutoReplySettingsRequestEventArgs;
+
+  interface IEmailMailboxMoveFolderRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly EmailFolderId: string;
+    readonly EmailMailboxId: string;
+    readonly NewFolderName: string;
+    readonly NewParentFolderId: string;
+  }
+  var IEmailMailboxMoveFolderRequest: abstract new (...args: any[]) => IEmailMailboxMoveFolderRequest;
+
+  interface IEmailMailboxMoveFolderRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxMoveFolderRequest;
+  }
+  var IEmailMailboxMoveFolderRequestEventArgs: abstract new (...args: any[]) => IEmailMailboxMoveFolderRequestEventArgs;
+
+  interface IEmailMailboxProposeNewTimeForMeetingRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly Comment: string;
+    readonly EmailMailboxId: string;
+    readonly EmailMessageId: string;
+    readonly NewDuration: Windows.Foundation.TimeSpan;
+    readonly NewStartTime: Windows.Foundation.DateTime;
+    readonly Subject: string;
+  }
+  var IEmailMailboxProposeNewTimeForMeetingRequest: abstract new (...args: any[]) => IEmailMailboxProposeNewTimeForMeetingRequest;
+
+  interface IEmailMailboxProposeNewTimeForMeetingRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxProposeNewTimeForMeetingRequest;
+  }
+  var IEmailMailboxProposeNewTimeForMeetingRequestEventArgs: abstract new (...args: any[]) => IEmailMailboxProposeNewTimeForMeetingRequestEventArgs;
+
+  interface IEmailMailboxResolveRecipientsRequest {
+    ReportCompletedAsync(resolutionResults: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Email.EmailRecipientResolutionResult> | Windows.ApplicationModel.Email.EmailRecipientResolutionResult[]): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly EmailMailboxId: string;
+    readonly Recipients: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var IEmailMailboxResolveRecipientsRequest: abstract new (...args: any[]) => IEmailMailboxResolveRecipientsRequest;
+
+  interface IEmailMailboxResolveRecipientsRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxResolveRecipientsRequest;
+  }
+  var IEmailMailboxResolveRecipientsRequestEventArgs: abstract new (...args: any[]) => IEmailMailboxResolveRecipientsRequestEventArgs;
+
+  interface IEmailMailboxServerSearchReadBatchRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(batchStatus: number): Windows.Foundation.IAsyncAction;
+    SaveMessageAsync(message: Windows.ApplicationModel.Email.EmailMessage): Windows.Foundation.IAsyncAction;
+    readonly EmailFolderId: string;
+    readonly EmailMailboxId: string;
+    readonly Options: Windows.ApplicationModel.Email.EmailQueryOptions;
+    readonly SessionId: string;
+    readonly SuggestedBatchSize: number;
+  }
+  var IEmailMailboxServerSearchReadBatchRequest: abstract new (...args: any[]) => IEmailMailboxServerSearchReadBatchRequest;
+
+  interface IEmailMailboxServerSearchReadBatchRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxServerSearchReadBatchRequest;
+  }
+  var IEmailMailboxServerSearchReadBatchRequestEventArgs: abstract new (...args: any[]) => IEmailMailboxServerSearchReadBatchRequestEventArgs;
+
+  interface IEmailMailboxSetAutoReplySettingsRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly AutoReplySettings: Windows.ApplicationModel.Email.EmailMailboxAutoReplySettings;
+    readonly EmailMailboxId: string;
+  }
+  var IEmailMailboxSetAutoReplySettingsRequest: abstract new (...args: any[]) => IEmailMailboxSetAutoReplySettingsRequest;
+
+  interface IEmailMailboxSetAutoReplySettingsRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxSetAutoReplySettingsRequest;
+  }
+  var IEmailMailboxSetAutoReplySettingsRequestEventArgs: abstract new (...args: any[]) => IEmailMailboxSetAutoReplySettingsRequestEventArgs;
+
+  interface IEmailMailboxSyncManagerSyncRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly EmailMailboxId: string;
+  }
+  var IEmailMailboxSyncManagerSyncRequest: abstract new (...args: any[]) => IEmailMailboxSyncManagerSyncRequest;
+
+  interface IEmailMailboxSyncManagerSyncRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxSyncManagerSyncRequest;
+  }
+  var IEmailMailboxSyncManagerSyncRequestEventArgs: abstract new (...args: any[]) => IEmailMailboxSyncManagerSyncRequestEventArgs;
+
+  interface IEmailMailboxUpdateMeetingResponseRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly Comment: string;
+    readonly EmailMailboxId: string;
+    readonly EmailMessageId: string;
+    readonly Response: number;
+    readonly SendUpdate: boolean;
+    readonly Subject: string;
+  }
+  var IEmailMailboxUpdateMeetingResponseRequest: abstract new (...args: any[]) => IEmailMailboxUpdateMeetingResponseRequest;
+
+  interface IEmailMailboxUpdateMeetingResponseRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxUpdateMeetingResponseRequest;
+  }
+  var IEmailMailboxUpdateMeetingResponseRequestEventArgs: abstract new (...args: any[]) => IEmailMailboxUpdateMeetingResponseRequestEventArgs;
+
+  interface IEmailMailboxValidateCertificatesRequest {
+    ReportCompletedAsync(validationStatuses: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly Certificates: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+    readonly EmailMailboxId: string;
+  }
+  var IEmailMailboxValidateCertificatesRequest: abstract new (...args: any[]) => IEmailMailboxValidateCertificatesRequest;
+
+  interface IEmailMailboxValidateCertificatesRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.Email.DataProvider.EmailMailboxValidateCertificatesRequest;
+  }
+  var IEmailMailboxValidateCertificatesRequestEventArgs: abstract new (...args: any[]) => IEmailMailboxValidateCertificatesRequestEventArgs;
+
+}
+
+declare namespace Windows.ApplicationModel.ExtendedExecution {
+  class ExtendedExecutionRevokedEventArgs implements Windows.ApplicationModel.ExtendedExecution.IExtendedExecutionRevokedEventArgs {
+    readonly Reason: number;
+  }
+
+  class ExtendedExecutionSession implements Windows.ApplicationModel.ExtendedExecution.IExtendedExecutionSession, Windows.Foundation.IClosable {
+    constructor();
+    Close(): void;
+    RequestExtensionAsync(): Windows.Foundation.IAsyncOperation<number>;
+    Description: string;
+    PercentProgress: number;
+    Reason: number;
+    Revoked: Windows.Foundation.TypedEventHandler<Object, Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionRevokedEventArgs> | null;
+  }
+
+  enum ExtendedExecutionReason {
+    Unspecified = 0,
+    LocationTracking = 1,
+    SavingData = 2,
+  }
+
+  enum ExtendedExecutionResult {
+    Allowed = 0,
+    Denied = 1,
+  }
+
+  enum ExtendedExecutionRevokedReason {
+    Resumed = 0,
+    SystemPolicy = 1,
+  }
+
+  interface IExtendedExecutionRevokedEventArgs {
+    readonly Reason: number;
+  }
+  var IExtendedExecutionRevokedEventArgs: abstract new (...args: any[]) => IExtendedExecutionRevokedEventArgs;
+
+  interface IExtendedExecutionSession extends Windows.Foundation.IClosable {
+    Close(): void;
+    RequestExtensionAsync(): Windows.Foundation.IAsyncOperation<number>;
+    Description: string;
+    PercentProgress: number;
+    Reason: number;
+    Revoked: Windows.Foundation.TypedEventHandler<Object, Windows.ApplicationModel.ExtendedExecution.ExtendedExecutionRevokedEventArgs> | null;
+  }
+  var IExtendedExecutionSession: abstract new (...args: any[]) => IExtendedExecutionSession;
+
+}
+
+declare namespace Windows.ApplicationModel.ExtendedExecution.Foreground {
+  class ExtendedExecutionForegroundRevokedEventArgs implements Windows.ApplicationModel.ExtendedExecution.Foreground.IExtendedExecutionForegroundRevokedEventArgs {
+    readonly Reason: number;
+  }
+
+  class ExtendedExecutionForegroundSession implements Windows.ApplicationModel.ExtendedExecution.Foreground.IExtendedExecutionForegroundSession, Windows.Foundation.IClosable {
+    constructor();
+    Close(): void;
+    RequestExtensionAsync(): Windows.Foundation.IAsyncOperation<number>;
+    Description: string;
+    Reason: number;
+    Revoked: Windows.Foundation.TypedEventHandler<Object, Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundRevokedEventArgs> | null;
+  }
+
+  enum ExtendedExecutionForegroundReason {
+    Unspecified = 0,
+    SavingData = 1,
+    BackgroundAudio = 2,
+    Unconstrained = 3,
+  }
+
+  enum ExtendedExecutionForegroundResult {
+    Allowed = 0,
+    Denied = 1,
+  }
+
+  enum ExtendedExecutionForegroundRevokedReason {
+    Resumed = 0,
+    SystemPolicy = 1,
+  }
+
+  interface IExtendedExecutionForegroundRevokedEventArgs {
+    readonly Reason: number;
+  }
+  var IExtendedExecutionForegroundRevokedEventArgs: abstract new (...args: any[]) => IExtendedExecutionForegroundRevokedEventArgs;
+
+  interface IExtendedExecutionForegroundSession extends Windows.Foundation.IClosable {
+    Close(): void;
+    RequestExtensionAsync(): Windows.Foundation.IAsyncOperation<number>;
+    Description: string;
+    Reason: number;
+    Revoked: Windows.Foundation.TypedEventHandler<Object, Windows.ApplicationModel.ExtendedExecution.Foreground.ExtendedExecutionForegroundRevokedEventArgs> | null;
+  }
+  var IExtendedExecutionForegroundSession: abstract new (...args: any[]) => IExtendedExecutionForegroundSession;
+
+}
+
+declare namespace Windows.ApplicationModel.Holographic {
+  class HolographicKeyboard implements Windows.ApplicationModel.Holographic.IHolographicKeyboard {
+    static GetDefault(): Windows.ApplicationModel.Holographic.HolographicKeyboard;
+    ResetPlacementOverride(): void;
+    SetPlacementOverride(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, topCenterPosition: Windows.Foundation.Numerics.Vector3, orientation: Windows.Foundation.Numerics.Quaternion): void;
+    SetPlacementOverride(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, topCenterPosition: Windows.Foundation.Numerics.Vector3, orientation: Windows.Foundation.Numerics.Quaternion, maxSize: Windows.Foundation.Numerics.Vector2): void;
+  }
+
+  interface IHolographicKeyboard {
+    ResetPlacementOverride(): void;
+    SetPlacementOverride(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, topCenterPosition: Windows.Foundation.Numerics.Vector3, orientation: Windows.Foundation.Numerics.Quaternion): void;
+    SetPlacementOverride(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, topCenterPosition: Windows.Foundation.Numerics.Vector3, orientation: Windows.Foundation.Numerics.Quaternion, maxSize: Windows.Foundation.Numerics.Vector2): void;
+  }
+  var IHolographicKeyboard: abstract new (...args: any[]) => IHolographicKeyboard;
+
+  interface IHolographicKeyboardStatics {
+    GetDefault(): Windows.ApplicationModel.Holographic.HolographicKeyboard;
+  }
+  var IHolographicKeyboardStatics: abstract new (...args: any[]) => IHolographicKeyboardStatics;
+
+}
+
+declare namespace Windows.ApplicationModel.LockScreen {
+  class LockApplicationHost implements Windows.ApplicationModel.LockScreen.ILockApplicationHost {
+    static GetForCurrentView(): Windows.ApplicationModel.LockScreen.LockApplicationHost;
+    RequestUnlock(): void;
+    Unlocking: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.LockScreen.LockApplicationHost, Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs> | null;
+  }
+
+  class LockScreenBadge implements Windows.ApplicationModel.LockScreen.ILockScreenBadge {
+    LaunchApp(): void;
+    readonly AutomationName: string;
+    readonly Glyph: Windows.Storage.Streams.IRandomAccessStream;
+    readonly Logo: Windows.Storage.Streams.IRandomAccessStream;
+    readonly Number: number | null;
+  }
+
+  class LockScreenInfo implements Windows.ApplicationModel.LockScreen.ILockScreenInfo {
+    readonly AlarmIcon: Windows.Storage.Streams.IRandomAccessStream;
+    readonly Badges: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.LockScreen.LockScreenBadge> | Windows.ApplicationModel.LockScreen.LockScreenBadge[];
+    readonly DetailText: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly LockScreenImage: Windows.Storage.Streams.IRandomAccessStream;
+    AlarmIconChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.LockScreen.LockScreenInfo, Object> | null;
+    BadgesChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.LockScreen.LockScreenInfo, Object> | null;
+    DetailTextChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.LockScreen.LockScreenInfo, Object> | null;
+    LockScreenImageChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.LockScreen.LockScreenInfo, Object> | null;
+  }
+
+  class LockScreenUnlockingDeferral implements Windows.ApplicationModel.LockScreen.ILockScreenUnlockingDeferral {
+    Complete(): void;
+  }
+
+  class LockScreenUnlockingEventArgs implements Windows.ApplicationModel.LockScreen.ILockScreenUnlockingEventArgs {
+    GetDeferral(): Windows.ApplicationModel.LockScreen.LockScreenUnlockingDeferral;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+
+  interface ILockApplicationHost {
+    RequestUnlock(): void;
+    Unlocking: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.LockScreen.LockApplicationHost, Windows.ApplicationModel.LockScreen.LockScreenUnlockingEventArgs> | null;
+  }
+  var ILockApplicationHost: abstract new (...args: any[]) => ILockApplicationHost;
+
+  interface ILockApplicationHostStatics {
+    GetForCurrentView(): Windows.ApplicationModel.LockScreen.LockApplicationHost;
+  }
+  var ILockApplicationHostStatics: abstract new (...args: any[]) => ILockApplicationHostStatics;
+
+  interface ILockScreenBadge {
+    LaunchApp(): void;
+    readonly AutomationName: string;
+    readonly Glyph: Windows.Storage.Streams.IRandomAccessStream;
+    readonly Logo: Windows.Storage.Streams.IRandomAccessStream;
+    readonly Number: number | null;
+  }
+  var ILockScreenBadge: abstract new (...args: any[]) => ILockScreenBadge;
+
+  interface ILockScreenInfo {
+    readonly AlarmIcon: Windows.Storage.Streams.IRandomAccessStream;
+    readonly Badges: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.LockScreen.LockScreenBadge> | Windows.ApplicationModel.LockScreen.LockScreenBadge[];
+    readonly DetailText: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly LockScreenImage: Windows.Storage.Streams.IRandomAccessStream;
+    AlarmIconChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.LockScreen.LockScreenInfo, Object> | null;
+    BadgesChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.LockScreen.LockScreenInfo, Object> | null;
+    DetailTextChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.LockScreen.LockScreenInfo, Object> | null;
+    LockScreenImageChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.LockScreen.LockScreenInfo, Object> | null;
+  }
+  var ILockScreenInfo: abstract new (...args: any[]) => ILockScreenInfo;
+
+  interface ILockScreenUnlockingDeferral {
+    Complete(): void;
+  }
+  var ILockScreenUnlockingDeferral: abstract new (...args: any[]) => ILockScreenUnlockingDeferral;
+
+  interface ILockScreenUnlockingEventArgs {
+    GetDeferral(): Windows.ApplicationModel.LockScreen.LockScreenUnlockingDeferral;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+  var ILockScreenUnlockingEventArgs: abstract new (...args: any[]) => ILockScreenUnlockingEventArgs;
+
+}
+
+declare namespace Windows.ApplicationModel.PackageExtensions {
+  class PackageExtension implements Windows.ApplicationModel.PackageExtensions.IPackageExtension {
+    GetExtensionProperties(): Windows.Foundation.Collections.IPropertySet;
+    GetExtensionPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IPropertySet>;
+    GetPublicFolder(): Windows.Storage.StorageFolder;
+    GetPublicFolderAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetPublicPath(): string;
+    readonly Description: string;
+    readonly DisplayName: string;
+    readonly Id: string;
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+
+  class PackageExtensionCatalog implements Windows.ApplicationModel.PackageExtensions.IPackageExtensionCatalog {
+    FindAll(): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.PackageExtensions.PackageExtension> | Windows.ApplicationModel.PackageExtensions.PackageExtension[];
+    FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.PackageExtensions.PackageExtension> | Windows.ApplicationModel.PackageExtensions.PackageExtension[]>;
+    static Open(packageExtensionName: string): Windows.ApplicationModel.PackageExtensions.PackageExtensionCatalog;
+    RequestRemovePackageAsync(packageFullName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    PackageInstalled: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageExtensions.PackageExtensionCatalog, Windows.ApplicationModel.PackageExtensions.PackageExtensionPackageInstalledEventArgs> | null;
+    PackageStatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageExtensions.PackageExtensionCatalog, Windows.ApplicationModel.PackageExtensions.PackageExtensionPackageStatusChangedEventArgs> | null;
+    PackageUninstalling: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageExtensions.PackageExtensionCatalog, Windows.ApplicationModel.PackageExtensions.PackageExtensionPackageUninstallingEventArgs> | null;
+    PackageUpdated: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageExtensions.PackageExtensionCatalog, Windows.ApplicationModel.PackageExtensions.PackageExtensionPackageUpdatedEventArgs> | null;
+    PackageUpdating: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageExtensions.PackageExtensionCatalog, Windows.ApplicationModel.PackageExtensions.PackageExtensionPackageUpdatingEventArgs> | null;
+  }
+
+  class PackageExtensionPackageInstalledEventArgs implements Windows.ApplicationModel.PackageExtensions.IPackageExtensionPackageInstalledEventArgs {
+    readonly Extensions: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.PackageExtensions.PackageExtension> | Windows.ApplicationModel.PackageExtensions.PackageExtension[];
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly PackageExtensionName: string;
+  }
+
+  class PackageExtensionPackageStatusChangedEventArgs implements Windows.ApplicationModel.PackageExtensions.IPackageExtensionPackageStatusChangedEventArgs {
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly PackageExtensionName: string;
+  }
+
+  class PackageExtensionPackageUninstallingEventArgs implements Windows.ApplicationModel.PackageExtensions.IPackageExtensionPackageUninstallingEventArgs {
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly PackageExtensionName: string;
+  }
+
+  class PackageExtensionPackageUpdatedEventArgs implements Windows.ApplicationModel.PackageExtensions.IPackageExtensionPackageUpdatedEventArgs {
+    readonly Extensions: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.PackageExtensions.PackageExtension> | Windows.ApplicationModel.PackageExtensions.PackageExtension[];
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly PackageExtensionName: string;
+  }
+
+  class PackageExtensionPackageUpdatingEventArgs implements Windows.ApplicationModel.PackageExtensions.IPackageExtensionPackageUpdatingEventArgs {
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly PackageExtensionName: string;
+  }
+
+  interface IPackageExtension {
+    GetExtensionProperties(): Windows.Foundation.Collections.IPropertySet;
+    GetExtensionPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IPropertySet>;
+    GetPublicFolder(): Windows.Storage.StorageFolder;
+    GetPublicFolderAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetPublicPath(): string;
+    readonly Description: string;
+    readonly DisplayName: string;
+    readonly Id: string;
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+  var IPackageExtension: abstract new (...args: any[]) => IPackageExtension;
+
+  interface IPackageExtensionCatalog {
+    FindAll(): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.PackageExtensions.PackageExtension> | Windows.ApplicationModel.PackageExtensions.PackageExtension[];
+    FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.PackageExtensions.PackageExtension> | Windows.ApplicationModel.PackageExtensions.PackageExtension[]>;
+    RequestRemovePackageAsync(packageFullName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    PackageInstalled: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageExtensions.PackageExtensionCatalog, Windows.ApplicationModel.PackageExtensions.PackageExtensionPackageInstalledEventArgs> | null;
+    PackageStatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageExtensions.PackageExtensionCatalog, Windows.ApplicationModel.PackageExtensions.PackageExtensionPackageStatusChangedEventArgs> | null;
+    PackageUninstalling: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageExtensions.PackageExtensionCatalog, Windows.ApplicationModel.PackageExtensions.PackageExtensionPackageUninstallingEventArgs> | null;
+    PackageUpdated: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageExtensions.PackageExtensionCatalog, Windows.ApplicationModel.PackageExtensions.PackageExtensionPackageUpdatedEventArgs> | null;
+    PackageUpdating: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.PackageExtensions.PackageExtensionCatalog, Windows.ApplicationModel.PackageExtensions.PackageExtensionPackageUpdatingEventArgs> | null;
+  }
+  var IPackageExtensionCatalog: abstract new (...args: any[]) => IPackageExtensionCatalog;
+
+  interface IPackageExtensionCatalogStatics {
+    Open(packageExtensionName: string): Windows.ApplicationModel.PackageExtensions.PackageExtensionCatalog;
+  }
+  var IPackageExtensionCatalogStatics: abstract new (...args: any[]) => IPackageExtensionCatalogStatics;
+
+  interface IPackageExtensionPackageInstalledEventArgs {
+    readonly Extensions: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.PackageExtensions.PackageExtension> | Windows.ApplicationModel.PackageExtensions.PackageExtension[];
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly PackageExtensionName: string;
+  }
+  var IPackageExtensionPackageInstalledEventArgs: abstract new (...args: any[]) => IPackageExtensionPackageInstalledEventArgs;
+
+  interface IPackageExtensionPackageStatusChangedEventArgs {
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly PackageExtensionName: string;
+  }
+  var IPackageExtensionPackageStatusChangedEventArgs: abstract new (...args: any[]) => IPackageExtensionPackageStatusChangedEventArgs;
+
+  interface IPackageExtensionPackageUninstallingEventArgs {
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly PackageExtensionName: string;
+  }
+  var IPackageExtensionPackageUninstallingEventArgs: abstract new (...args: any[]) => IPackageExtensionPackageUninstallingEventArgs;
+
+  interface IPackageExtensionPackageUpdatedEventArgs {
+    readonly Extensions: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.PackageExtensions.PackageExtension> | Windows.ApplicationModel.PackageExtensions.PackageExtension[];
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly PackageExtensionName: string;
+  }
+  var IPackageExtensionPackageUpdatedEventArgs: abstract new (...args: any[]) => IPackageExtensionPackageUpdatedEventArgs;
+
+  interface IPackageExtensionPackageUpdatingEventArgs {
+    readonly Package: Windows.ApplicationModel.Package;
+    readonly PackageExtensionName: string;
+  }
+  var IPackageExtensionPackageUpdatingEventArgs: abstract new (...args: any[]) => IPackageExtensionPackageUpdatingEventArgs;
+
+}
+
+declare namespace Windows.ApplicationModel.Payments {
+  class PaymentAddress implements Windows.ApplicationModel.Payments.IPaymentAddress {
+    constructor();
+    AddressLines: Windows.Foundation.Collections.IVectorView<string> | string[];
+    City: string;
+    Country: string;
+    DependentLocality: string;
+    LanguageCode: string;
+    Organization: string;
+    PhoneNumber: string;
+    PostalCode: string;
+    readonly Properties: Windows.Foundation.Collections.ValueSet;
+    Recipient: string;
+    Region: string;
+    SortingCode: string;
+  }
+
+  class PaymentCanMakePaymentResult implements Windows.ApplicationModel.Payments.IPaymentCanMakePaymentResult {
+    constructor(value: number);
+    readonly Status: number;
+  }
+
+  class PaymentCurrencyAmount implements Windows.ApplicationModel.Payments.IPaymentCurrencyAmount {
+    constructor(value: string, currency: string);
+    constructor(value: string, currency: string, currencySystem: string);
+    Currency: string;
+    CurrencySystem: string;
+    Value: string;
+  }
+
+  class PaymentDetails implements Windows.ApplicationModel.Payments.IPaymentDetails {
+    constructor(total: Windows.ApplicationModel.Payments.PaymentItem);
+    constructor(total: Windows.ApplicationModel.Payments.PaymentItem, displayItems: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Payments.PaymentItem> | Windows.ApplicationModel.Payments.PaymentItem[]);
+    constructor();
+    DisplayItems: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Payments.PaymentItem> | Windows.ApplicationModel.Payments.PaymentItem[];
+    Modifiers: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Payments.PaymentDetailsModifier> | Windows.ApplicationModel.Payments.PaymentDetailsModifier[];
+    ShippingOptions: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Payments.PaymentShippingOption> | Windows.ApplicationModel.Payments.PaymentShippingOption[];
+    Total: Windows.ApplicationModel.Payments.PaymentItem;
+  }
+
+  class PaymentDetailsModifier implements Windows.ApplicationModel.Payments.IPaymentDetailsModifier {
+    constructor(supportedMethodIds: Windows.Foundation.Collections.IIterable<string> | string[], total: Windows.ApplicationModel.Payments.PaymentItem);
+    constructor(supportedMethodIds: Windows.Foundation.Collections.IIterable<string> | string[], total: Windows.ApplicationModel.Payments.PaymentItem, additionalDisplayItems: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Payments.PaymentItem> | Windows.ApplicationModel.Payments.PaymentItem[]);
+    constructor(supportedMethodIds: Windows.Foundation.Collections.IIterable<string> | string[], total: Windows.ApplicationModel.Payments.PaymentItem, additionalDisplayItems: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Payments.PaymentItem> | Windows.ApplicationModel.Payments.PaymentItem[], jsonData: string);
+    readonly AdditionalDisplayItems: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Payments.PaymentItem> | Windows.ApplicationModel.Payments.PaymentItem[];
+    readonly JsonData: string;
+    readonly SupportedMethodIds: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Total: Windows.ApplicationModel.Payments.PaymentItem;
+  }
+
+  class PaymentItem implements Windows.ApplicationModel.Payments.IPaymentItem {
+    constructor(label: string, amount: Windows.ApplicationModel.Payments.PaymentCurrencyAmount);
+    Amount: Windows.ApplicationModel.Payments.PaymentCurrencyAmount;
+    Label: string;
+    Pending: boolean;
+  }
+
+  class PaymentMediator implements Windows.ApplicationModel.Payments.IPaymentMediator, Windows.ApplicationModel.Payments.IPaymentMediator2 {
+    constructor();
+    CanMakePaymentAsync(paymentRequest: Windows.ApplicationModel.Payments.PaymentRequest): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Payments.PaymentCanMakePaymentResult>;
+    GetSupportedMethodIdsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    SubmitPaymentRequestAsync(paymentRequest: Windows.ApplicationModel.Payments.PaymentRequest): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Payments.PaymentRequestSubmitResult>;
+    SubmitPaymentRequestAsync(paymentRequest: Windows.ApplicationModel.Payments.PaymentRequest, changeHandler: Windows.ApplicationModel.Payments.PaymentRequestChangedHandler): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Payments.PaymentRequestSubmitResult>;
+  }
+
+  class PaymentMerchantInfo implements Windows.ApplicationModel.Payments.IPaymentMerchantInfo {
+    constructor(uri: Windows.Foundation.Uri);
+    constructor();
+    readonly PackageFullName: string;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class PaymentMethodData implements Windows.ApplicationModel.Payments.IPaymentMethodData {
+    constructor(supportedMethodIds: Windows.Foundation.Collections.IIterable<string> | string[]);
+    constructor(supportedMethodIds: Windows.Foundation.Collections.IIterable<string> | string[], jsonData: string);
+    readonly JsonData: string;
+    readonly SupportedMethodIds: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+
+  class PaymentOptions implements Windows.ApplicationModel.Payments.IPaymentOptions {
+    constructor();
+    RequestPayerEmail: number;
+    RequestPayerName: number;
+    RequestPayerPhoneNumber: number;
+    RequestShipping: boolean;
+    ShippingType: number;
+  }
+
+  class PaymentRequest implements Windows.ApplicationModel.Payments.IPaymentRequest, Windows.ApplicationModel.Payments.IPaymentRequest2 {
+    constructor(details: Windows.ApplicationModel.Payments.PaymentDetails, methodData: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Payments.PaymentMethodData> | Windows.ApplicationModel.Payments.PaymentMethodData[], merchantInfo: Windows.ApplicationModel.Payments.PaymentMerchantInfo, options: Windows.ApplicationModel.Payments.PaymentOptions, id: string);
+    constructor(details: Windows.ApplicationModel.Payments.PaymentDetails, methodData: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Payments.PaymentMethodData> | Windows.ApplicationModel.Payments.PaymentMethodData[]);
+    constructor(details: Windows.ApplicationModel.Payments.PaymentDetails, methodData: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Payments.PaymentMethodData> | Windows.ApplicationModel.Payments.PaymentMethodData[], merchantInfo: Windows.ApplicationModel.Payments.PaymentMerchantInfo);
+    constructor(details: Windows.ApplicationModel.Payments.PaymentDetails, methodData: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Payments.PaymentMethodData> | Windows.ApplicationModel.Payments.PaymentMethodData[], merchantInfo: Windows.ApplicationModel.Payments.PaymentMerchantInfo, options: Windows.ApplicationModel.Payments.PaymentOptions);
+    readonly Details: Windows.ApplicationModel.Payments.PaymentDetails;
+    readonly Id: string;
+    readonly MerchantInfo: Windows.ApplicationModel.Payments.PaymentMerchantInfo;
+    readonly MethodData: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Payments.PaymentMethodData> | Windows.ApplicationModel.Payments.PaymentMethodData[];
+    readonly Options: Windows.ApplicationModel.Payments.PaymentOptions;
+  }
+
+  class PaymentRequestChangedArgs implements Windows.ApplicationModel.Payments.IPaymentRequestChangedArgs {
+    Acknowledge(changeResult: Windows.ApplicationModel.Payments.PaymentRequestChangedResult): void;
+    readonly ChangeKind: number;
+    readonly SelectedShippingOption: Windows.ApplicationModel.Payments.PaymentShippingOption;
+    readonly ShippingAddress: Windows.ApplicationModel.Payments.PaymentAddress;
+  }
+
+  class PaymentRequestChangedResult implements Windows.ApplicationModel.Payments.IPaymentRequestChangedResult {
+    constructor(changeAcceptedByMerchant: boolean);
+    constructor(changeAcceptedByMerchant: boolean, updatedPaymentDetails: Windows.ApplicationModel.Payments.PaymentDetails);
+    ChangeAcceptedByMerchant: boolean;
+    Message: string;
+    UpdatedPaymentDetails: Windows.ApplicationModel.Payments.PaymentDetails;
+  }
+
+  class PaymentRequestSubmitResult implements Windows.ApplicationModel.Payments.IPaymentRequestSubmitResult {
+    readonly Response: Windows.ApplicationModel.Payments.PaymentResponse;
+    readonly Status: number;
+  }
+
+  class PaymentResponse implements Windows.ApplicationModel.Payments.IPaymentResponse {
+    CompleteAsync(status: number): Windows.Foundation.IAsyncAction;
+    readonly PayerEmail: string;
+    readonly PayerName: string;
+    readonly PayerPhoneNumber: string;
+    readonly PaymentToken: Windows.ApplicationModel.Payments.PaymentToken;
+    readonly ShippingAddress: Windows.ApplicationModel.Payments.PaymentAddress;
+    readonly ShippingOption: Windows.ApplicationModel.Payments.PaymentShippingOption;
+  }
+
+  class PaymentShippingOption implements Windows.ApplicationModel.Payments.IPaymentShippingOption {
+    constructor(label: string, amount: Windows.ApplicationModel.Payments.PaymentCurrencyAmount);
+    constructor(label: string, amount: Windows.ApplicationModel.Payments.PaymentCurrencyAmount, selected: boolean);
+    constructor(label: string, amount: Windows.ApplicationModel.Payments.PaymentCurrencyAmount, selected: boolean, tag: string);
+    Amount: Windows.ApplicationModel.Payments.PaymentCurrencyAmount;
+    IsSelected: boolean;
+    Label: string;
+    Tag: string;
+  }
+
+  class PaymentToken implements Windows.ApplicationModel.Payments.IPaymentToken {
+    constructor(paymentMethodId: string);
+    constructor(paymentMethodId: string, jsonDetails: string);
+    readonly JsonDetails: string;
+    readonly PaymentMethodId: string;
+  }
+
+  enum PaymentCanMakePaymentResultStatus {
+    Unknown = 0,
+    Yes = 1,
+    No = 2,
+    NotAllowed = 3,
+    UserNotSignedIn = 4,
+    SpecifiedPaymentMethodIdsNotSupported = 5,
+    NoQualifyingCardOnFile = 6,
+  }
+
+  enum PaymentOptionPresence {
+    None = 0,
+    Optional = 1,
+    Required = 2,
+  }
+
+  enum PaymentRequestChangeKind {
+    ShippingOption = 0,
+    ShippingAddress = 1,
+  }
+
+  enum PaymentRequestCompletionStatus {
+    Succeeded = 0,
+    Failed = 1,
+    Unknown = 2,
+  }
+
+  enum PaymentRequestStatus {
+    Succeeded = 0,
+    Failed = 1,
+    Canceled = 2,
+  }
+
+  enum PaymentShippingType {
+    Shipping = 0,
+    Delivery = 1,
+    Pickup = 2,
+  }
+
+  interface IPaymentAddress {
+    AddressLines: Windows.Foundation.Collections.IVectorView<string> | string[];
+    City: string;
+    Country: string;
+    DependentLocality: string;
+    LanguageCode: string;
+    Organization: string;
+    PhoneNumber: string;
+    PostalCode: string;
+    readonly Properties: Windows.Foundation.Collections.ValueSet;
+    Recipient: string;
+    Region: string;
+    SortingCode: string;
+  }
+  var IPaymentAddress: abstract new (...args: any[]) => IPaymentAddress;
+
+  interface IPaymentCanMakePaymentResult {
+    readonly Status: number;
+  }
+  var IPaymentCanMakePaymentResult: abstract new (...args: any[]) => IPaymentCanMakePaymentResult;
+
+  interface IPaymentCanMakePaymentResultFactory {
+    Create(value: number): Windows.ApplicationModel.Payments.PaymentCanMakePaymentResult;
+  }
+  var IPaymentCanMakePaymentResultFactory: abstract new (...args: any[]) => IPaymentCanMakePaymentResultFactory;
+
+  interface IPaymentCurrencyAmount {
+    Currency: string;
+    CurrencySystem: string;
+    Value: string;
+  }
+  var IPaymentCurrencyAmount: abstract new (...args: any[]) => IPaymentCurrencyAmount;
+
+  interface IPaymentCurrencyAmountFactory {
+    Create(value: string, currency: string): Windows.ApplicationModel.Payments.PaymentCurrencyAmount;
+    CreateWithCurrencySystem(value: string, currency: string, currencySystem: string): Windows.ApplicationModel.Payments.PaymentCurrencyAmount;
+  }
+  var IPaymentCurrencyAmountFactory: abstract new (...args: any[]) => IPaymentCurrencyAmountFactory;
+
+  interface IPaymentDetails {
+    DisplayItems: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Payments.PaymentItem> | Windows.ApplicationModel.Payments.PaymentItem[];
+    Modifiers: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Payments.PaymentDetailsModifier> | Windows.ApplicationModel.Payments.PaymentDetailsModifier[];
+    ShippingOptions: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Payments.PaymentShippingOption> | Windows.ApplicationModel.Payments.PaymentShippingOption[];
+    Total: Windows.ApplicationModel.Payments.PaymentItem;
+  }
+  var IPaymentDetails: abstract new (...args: any[]) => IPaymentDetails;
+
+  interface IPaymentDetailsFactory {
+    Create(total: Windows.ApplicationModel.Payments.PaymentItem): Windows.ApplicationModel.Payments.PaymentDetails;
+    CreateWithDisplayItems(total: Windows.ApplicationModel.Payments.PaymentItem, displayItems: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Payments.PaymentItem> | Windows.ApplicationModel.Payments.PaymentItem[]): Windows.ApplicationModel.Payments.PaymentDetails;
+  }
+  var IPaymentDetailsFactory: abstract new (...args: any[]) => IPaymentDetailsFactory;
+
+  interface IPaymentDetailsModifier {
+    readonly AdditionalDisplayItems: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Payments.PaymentItem> | Windows.ApplicationModel.Payments.PaymentItem[];
+    readonly JsonData: string;
+    readonly SupportedMethodIds: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Total: Windows.ApplicationModel.Payments.PaymentItem;
+  }
+  var IPaymentDetailsModifier: abstract new (...args: any[]) => IPaymentDetailsModifier;
+
+  interface IPaymentDetailsModifierFactory {
+    Create(supportedMethodIds: Windows.Foundation.Collections.IIterable<string> | string[], total: Windows.ApplicationModel.Payments.PaymentItem): Windows.ApplicationModel.Payments.PaymentDetailsModifier;
+    CreateWithAdditionalDisplayItems(supportedMethodIds: Windows.Foundation.Collections.IIterable<string> | string[], total: Windows.ApplicationModel.Payments.PaymentItem, additionalDisplayItems: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Payments.PaymentItem> | Windows.ApplicationModel.Payments.PaymentItem[]): Windows.ApplicationModel.Payments.PaymentDetailsModifier;
+    CreateWithAdditionalDisplayItemsAndJsonData(supportedMethodIds: Windows.Foundation.Collections.IIterable<string> | string[], total: Windows.ApplicationModel.Payments.PaymentItem, additionalDisplayItems: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Payments.PaymentItem> | Windows.ApplicationModel.Payments.PaymentItem[], jsonData: string): Windows.ApplicationModel.Payments.PaymentDetailsModifier;
+  }
+  var IPaymentDetailsModifierFactory: abstract new (...args: any[]) => IPaymentDetailsModifierFactory;
+
+  interface IPaymentItem {
+    Amount: Windows.ApplicationModel.Payments.PaymentCurrencyAmount;
+    Label: string;
+    Pending: boolean;
+  }
+  var IPaymentItem: abstract new (...args: any[]) => IPaymentItem;
+
+  interface IPaymentItemFactory {
+    Create(label: string, amount: Windows.ApplicationModel.Payments.PaymentCurrencyAmount): Windows.ApplicationModel.Payments.PaymentItem;
+  }
+  var IPaymentItemFactory: abstract new (...args: any[]) => IPaymentItemFactory;
+
+  interface IPaymentMediator {
+    GetSupportedMethodIdsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    SubmitPaymentRequestAsync(paymentRequest: Windows.ApplicationModel.Payments.PaymentRequest): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Payments.PaymentRequestSubmitResult>;
+    SubmitPaymentRequestAsync(paymentRequest: Windows.ApplicationModel.Payments.PaymentRequest, changeHandler: Windows.ApplicationModel.Payments.PaymentRequestChangedHandler): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Payments.PaymentRequestSubmitResult>;
+  }
+  var IPaymentMediator: abstract new (...args: any[]) => IPaymentMediator;
+
+  interface IPaymentMediator2 {
+    CanMakePaymentAsync(paymentRequest: Windows.ApplicationModel.Payments.PaymentRequest): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Payments.PaymentCanMakePaymentResult>;
+  }
+  var IPaymentMediator2: abstract new (...args: any[]) => IPaymentMediator2;
+
+  interface IPaymentMerchantInfo {
+    readonly PackageFullName: string;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IPaymentMerchantInfo: abstract new (...args: any[]) => IPaymentMerchantInfo;
+
+  interface IPaymentMerchantInfoFactory {
+    Create(uri: Windows.Foundation.Uri): Windows.ApplicationModel.Payments.PaymentMerchantInfo;
+  }
+  var IPaymentMerchantInfoFactory: abstract new (...args: any[]) => IPaymentMerchantInfoFactory;
+
+  interface IPaymentMethodData {
+    readonly JsonData: string;
+    readonly SupportedMethodIds: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var IPaymentMethodData: abstract new (...args: any[]) => IPaymentMethodData;
+
+  interface IPaymentMethodDataFactory {
+    Create(supportedMethodIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.ApplicationModel.Payments.PaymentMethodData;
+    CreateWithJsonData(supportedMethodIds: Windows.Foundation.Collections.IIterable<string> | string[], jsonData: string): Windows.ApplicationModel.Payments.PaymentMethodData;
+  }
+  var IPaymentMethodDataFactory: abstract new (...args: any[]) => IPaymentMethodDataFactory;
+
+  interface IPaymentOptions {
+    RequestPayerEmail: number;
+    RequestPayerName: number;
+    RequestPayerPhoneNumber: number;
+    RequestShipping: boolean;
+    ShippingType: number;
+  }
+  var IPaymentOptions: abstract new (...args: any[]) => IPaymentOptions;
+
+  interface IPaymentRequest {
+    readonly Details: Windows.ApplicationModel.Payments.PaymentDetails;
+    readonly MerchantInfo: Windows.ApplicationModel.Payments.PaymentMerchantInfo;
+    readonly MethodData: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Payments.PaymentMethodData> | Windows.ApplicationModel.Payments.PaymentMethodData[];
+    readonly Options: Windows.ApplicationModel.Payments.PaymentOptions;
+  }
+  var IPaymentRequest: abstract new (...args: any[]) => IPaymentRequest;
+
+  interface IPaymentRequest2 {
+    readonly Id: string;
+  }
+  var IPaymentRequest2: abstract new (...args: any[]) => IPaymentRequest2;
+
+  interface IPaymentRequestChangedArgs {
+    Acknowledge(changeResult: Windows.ApplicationModel.Payments.PaymentRequestChangedResult): void;
+    readonly ChangeKind: number;
+    readonly SelectedShippingOption: Windows.ApplicationModel.Payments.PaymentShippingOption;
+    readonly ShippingAddress: Windows.ApplicationModel.Payments.PaymentAddress;
+  }
+  var IPaymentRequestChangedArgs: abstract new (...args: any[]) => IPaymentRequestChangedArgs;
+
+  interface IPaymentRequestChangedResult {
+    ChangeAcceptedByMerchant: boolean;
+    Message: string;
+    UpdatedPaymentDetails: Windows.ApplicationModel.Payments.PaymentDetails;
+  }
+  var IPaymentRequestChangedResult: abstract new (...args: any[]) => IPaymentRequestChangedResult;
+
+  interface IPaymentRequestChangedResultFactory {
+    Create(changeAcceptedByMerchant: boolean): Windows.ApplicationModel.Payments.PaymentRequestChangedResult;
+    CreateWithPaymentDetails(changeAcceptedByMerchant: boolean, updatedPaymentDetails: Windows.ApplicationModel.Payments.PaymentDetails): Windows.ApplicationModel.Payments.PaymentRequestChangedResult;
+  }
+  var IPaymentRequestChangedResultFactory: abstract new (...args: any[]) => IPaymentRequestChangedResultFactory;
+
+  interface IPaymentRequestFactory {
+    Create(details: Windows.ApplicationModel.Payments.PaymentDetails, methodData: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Payments.PaymentMethodData> | Windows.ApplicationModel.Payments.PaymentMethodData[]): Windows.ApplicationModel.Payments.PaymentRequest;
+    CreateWithMerchantInfo(details: Windows.ApplicationModel.Payments.PaymentDetails, methodData: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Payments.PaymentMethodData> | Windows.ApplicationModel.Payments.PaymentMethodData[], merchantInfo: Windows.ApplicationModel.Payments.PaymentMerchantInfo): Windows.ApplicationModel.Payments.PaymentRequest;
+    CreateWithMerchantInfoAndOptions(details: Windows.ApplicationModel.Payments.PaymentDetails, methodData: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Payments.PaymentMethodData> | Windows.ApplicationModel.Payments.PaymentMethodData[], merchantInfo: Windows.ApplicationModel.Payments.PaymentMerchantInfo, options: Windows.ApplicationModel.Payments.PaymentOptions): Windows.ApplicationModel.Payments.PaymentRequest;
+  }
+  var IPaymentRequestFactory: abstract new (...args: any[]) => IPaymentRequestFactory;
+
+  interface IPaymentRequestFactory2 {
+    CreateWithMerchantInfoOptionsAndId(details: Windows.ApplicationModel.Payments.PaymentDetails, methodData: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Payments.PaymentMethodData> | Windows.ApplicationModel.Payments.PaymentMethodData[], merchantInfo: Windows.ApplicationModel.Payments.PaymentMerchantInfo, options: Windows.ApplicationModel.Payments.PaymentOptions, id: string): Windows.ApplicationModel.Payments.PaymentRequest;
+  }
+  var IPaymentRequestFactory2: abstract new (...args: any[]) => IPaymentRequestFactory2;
+
+  interface IPaymentRequestSubmitResult {
+    readonly Response: Windows.ApplicationModel.Payments.PaymentResponse;
+    readonly Status: number;
+  }
+  var IPaymentRequestSubmitResult: abstract new (...args: any[]) => IPaymentRequestSubmitResult;
+
+  interface IPaymentResponse {
+    CompleteAsync(status: number): Windows.Foundation.IAsyncAction;
+    readonly PayerEmail: string;
+    readonly PayerName: string;
+    readonly PayerPhoneNumber: string;
+    readonly PaymentToken: Windows.ApplicationModel.Payments.PaymentToken;
+    readonly ShippingAddress: Windows.ApplicationModel.Payments.PaymentAddress;
+    readonly ShippingOption: Windows.ApplicationModel.Payments.PaymentShippingOption;
+  }
+  var IPaymentResponse: abstract new (...args: any[]) => IPaymentResponse;
+
+  interface IPaymentShippingOption {
+    Amount: Windows.ApplicationModel.Payments.PaymentCurrencyAmount;
+    IsSelected: boolean;
+    Label: string;
+    Tag: string;
+  }
+  var IPaymentShippingOption: abstract new (...args: any[]) => IPaymentShippingOption;
+
+  interface IPaymentShippingOptionFactory {
+    Create(label: string, amount: Windows.ApplicationModel.Payments.PaymentCurrencyAmount): Windows.ApplicationModel.Payments.PaymentShippingOption;
+    CreateWithSelected(label: string, amount: Windows.ApplicationModel.Payments.PaymentCurrencyAmount, selected: boolean): Windows.ApplicationModel.Payments.PaymentShippingOption;
+    CreateWithSelectedAndTag(label: string, amount: Windows.ApplicationModel.Payments.PaymentCurrencyAmount, selected: boolean, tag: string): Windows.ApplicationModel.Payments.PaymentShippingOption;
+  }
+  var IPaymentShippingOptionFactory: abstract new (...args: any[]) => IPaymentShippingOptionFactory;
+
+  interface IPaymentToken {
+    readonly JsonDetails: string;
+    readonly PaymentMethodId: string;
+  }
+  var IPaymentToken: abstract new (...args: any[]) => IPaymentToken;
+
+  interface IPaymentTokenFactory {
+    Create(paymentMethodId: string): Windows.ApplicationModel.Payments.PaymentToken;
+    CreateWithJsonDetails(paymentMethodId: string, jsonDetails: string): Windows.ApplicationModel.Payments.PaymentToken;
+  }
+  var IPaymentTokenFactory: abstract new (...args: any[]) => IPaymentTokenFactory;
+
+  interface PaymentRequestChangedHandler {
+    (paymentRequest: Windows.ApplicationModel.Payments.PaymentRequest, args: Windows.ApplicationModel.Payments.PaymentRequestChangedArgs): void;
+  }
+  var PaymentRequestChangedHandler: {
+    new(callback: (paymentRequest: Windows.ApplicationModel.Payments.PaymentRequest, args: Windows.ApplicationModel.Payments.PaymentRequestChangedArgs) => void): PaymentRequestChangedHandler;
+  };
+
+}
+
+declare namespace Windows.ApplicationModel.Payments.Provider {
+  class PaymentAppCanMakePaymentTriggerDetails implements Windows.ApplicationModel.Payments.Provider.IPaymentAppCanMakePaymentTriggerDetails {
+    ReportCanMakePaymentResult(value: Windows.ApplicationModel.Payments.PaymentCanMakePaymentResult): void;
+    readonly Request: Windows.ApplicationModel.Payments.PaymentRequest;
+  }
+
+  class PaymentAppManager implements Windows.ApplicationModel.Payments.Provider.IPaymentAppManager {
+    RegisterAsync(supportedPaymentMethodIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    UnregisterAsync(): Windows.Foundation.IAsyncAction;
+    static readonly Current: Windows.ApplicationModel.Payments.Provider.PaymentAppManager;
+  }
+
+  class PaymentTransaction implements Windows.ApplicationModel.Payments.Provider.IPaymentTransaction {
+    AcceptAsync(paymentToken: Windows.ApplicationModel.Payments.PaymentToken): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Payments.Provider.PaymentTransactionAcceptResult>;
+    static FromIdAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Payments.Provider.PaymentTransaction>;
+    Reject(): void;
+    UpdateSelectedShippingOptionAsync(selectedShippingOption: Windows.ApplicationModel.Payments.PaymentShippingOption): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Payments.PaymentRequestChangedResult>;
+    UpdateShippingAddressAsync(shippingAddress: Windows.ApplicationModel.Payments.PaymentAddress): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Payments.PaymentRequestChangedResult>;
+    PayerEmail: string;
+    PayerName: string;
+    PayerPhoneNumber: string;
+    readonly PaymentRequest: Windows.ApplicationModel.Payments.PaymentRequest;
+  }
+
+  class PaymentTransactionAcceptResult implements Windows.ApplicationModel.Payments.Provider.IPaymentTransactionAcceptResult {
+    readonly Status: number;
+  }
+
+  interface IPaymentAppCanMakePaymentTriggerDetails {
+    ReportCanMakePaymentResult(value: Windows.ApplicationModel.Payments.PaymentCanMakePaymentResult): void;
+    readonly Request: Windows.ApplicationModel.Payments.PaymentRequest;
+  }
+  var IPaymentAppCanMakePaymentTriggerDetails: abstract new (...args: any[]) => IPaymentAppCanMakePaymentTriggerDetails;
+
+  interface IPaymentAppManager {
+    RegisterAsync(supportedPaymentMethodIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    UnregisterAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var IPaymentAppManager: abstract new (...args: any[]) => IPaymentAppManager;
+
+  interface IPaymentAppManagerStatics {
+    readonly Current: Windows.ApplicationModel.Payments.Provider.PaymentAppManager;
+  }
+  var IPaymentAppManagerStatics: abstract new (...args: any[]) => IPaymentAppManagerStatics;
+
+  interface IPaymentTransaction {
+    AcceptAsync(paymentToken: Windows.ApplicationModel.Payments.PaymentToken): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Payments.Provider.PaymentTransactionAcceptResult>;
+    Reject(): void;
+    UpdateSelectedShippingOptionAsync(selectedShippingOption: Windows.ApplicationModel.Payments.PaymentShippingOption): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Payments.PaymentRequestChangedResult>;
+    UpdateShippingAddressAsync(shippingAddress: Windows.ApplicationModel.Payments.PaymentAddress): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Payments.PaymentRequestChangedResult>;
+    PayerEmail: string;
+    PayerName: string;
+    PayerPhoneNumber: string;
+    readonly PaymentRequest: Windows.ApplicationModel.Payments.PaymentRequest;
+  }
+  var IPaymentTransaction: abstract new (...args: any[]) => IPaymentTransaction;
+
+  interface IPaymentTransactionAcceptResult {
+    readonly Status: number;
+  }
+  var IPaymentTransactionAcceptResult: abstract new (...args: any[]) => IPaymentTransactionAcceptResult;
+
+  interface IPaymentTransactionStatics {
+    FromIdAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Payments.Provider.PaymentTransaction>;
+  }
+  var IPaymentTransactionStatics: abstract new (...args: any[]) => IPaymentTransactionStatics;
+
+}
+
+declare namespace Windows.ApplicationModel.Preview.Holographic {
+  class HolographicApplicationPreview {
+    static IsCurrentViewPresentedOnHolographicDisplay(): boolean;
+    static IsHolographicActivation(activatedEventArgs: Windows.ApplicationModel.Activation.IActivatedEventArgs): boolean;
+  }
+
+  class HolographicKeyboardPlacementOverridePreview implements Windows.ApplicationModel.Preview.Holographic.IHolographicKeyboardPlacementOverridePreview {
+    static GetForCurrentView(): Windows.ApplicationModel.Preview.Holographic.HolographicKeyboardPlacementOverridePreview;
+    ResetPlacementOverride(): void;
+    SetPlacementOverride(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, topCenterPosition: Windows.Foundation.Numerics.Vector3, normal: Windows.Foundation.Numerics.Vector3): void;
+    SetPlacementOverride(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, topCenterPosition: Windows.Foundation.Numerics.Vector3, normal: Windows.Foundation.Numerics.Vector3, maxSize: Windows.Foundation.Numerics.Vector2): void;
+  }
+
+  interface IHolographicApplicationPreviewStatics {
+    IsCurrentViewPresentedOnHolographicDisplay(): boolean;
+    IsHolographicActivation(activatedEventArgs: Windows.ApplicationModel.Activation.IActivatedEventArgs): boolean;
+  }
+  var IHolographicApplicationPreviewStatics: abstract new (...args: any[]) => IHolographicApplicationPreviewStatics;
+
+  interface IHolographicKeyboardPlacementOverridePreview {
+    ResetPlacementOverride(): void;
+    SetPlacementOverride(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, topCenterPosition: Windows.Foundation.Numerics.Vector3, normal: Windows.Foundation.Numerics.Vector3): void;
+    SetPlacementOverride(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, topCenterPosition: Windows.Foundation.Numerics.Vector3, normal: Windows.Foundation.Numerics.Vector3, maxSize: Windows.Foundation.Numerics.Vector2): void;
+  }
+  var IHolographicKeyboardPlacementOverridePreview: abstract new (...args: any[]) => IHolographicKeyboardPlacementOverridePreview;
+
+  interface IHolographicKeyboardPlacementOverridePreviewStatics {
+    GetForCurrentView(): Windows.ApplicationModel.Preview.Holographic.HolographicKeyboardPlacementOverridePreview;
+  }
+  var IHolographicKeyboardPlacementOverridePreviewStatics: abstract new (...args: any[]) => IHolographicKeyboardPlacementOverridePreviewStatics;
+
+}
+
+declare namespace Windows.ApplicationModel.Preview.InkWorkspace {
+  class InkWorkspaceHostedAppManager implements Windows.ApplicationModel.Preview.InkWorkspace.IInkWorkspaceHostedAppManager {
+    static GetForCurrentApp(): Windows.ApplicationModel.Preview.InkWorkspace.InkWorkspaceHostedAppManager;
+    SetThumbnailAsync(bitmap: Windows.Graphics.Imaging.SoftwareBitmap): Windows.Foundation.IAsyncAction;
+  }
+
+  interface IInkWorkspaceHostedAppManager {
+    SetThumbnailAsync(bitmap: Windows.Graphics.Imaging.SoftwareBitmap): Windows.Foundation.IAsyncAction;
+  }
+  var IInkWorkspaceHostedAppManager: abstract new (...args: any[]) => IInkWorkspaceHostedAppManager;
+
+  interface IInkWorkspaceHostedAppManagerStatics {
+    GetForCurrentApp(): Windows.ApplicationModel.Preview.InkWorkspace.InkWorkspaceHostedAppManager;
+  }
+  var IInkWorkspaceHostedAppManagerStatics: abstract new (...args: any[]) => IInkWorkspaceHostedAppManagerStatics;
+
+  interface PreviewInkWorkspaceContract {
+  }
+  var PreviewInkWorkspaceContract: {
+    new(fields: {  }): PreviewInkWorkspaceContract;
+  };
+
+}
+
+declare namespace Windows.ApplicationModel.Preview.Notes {
+  class NotePlacementChangedPreviewEventArgs implements Windows.ApplicationModel.Preview.Notes.INotePlacementChangedPreviewEventArgs {
+    readonly ViewId: number;
+  }
+
+  class NoteVisibilityChangedPreviewEventArgs implements Windows.ApplicationModel.Preview.Notes.INoteVisibilityChangedPreviewEventArgs {
+    readonly IsVisible: boolean;
+    readonly ViewId: number;
+  }
+
+  class NotesWindowManagerPreview implements Windows.ApplicationModel.Preview.Notes.INotesWindowManagerPreview, Windows.ApplicationModel.Preview.Notes.INotesWindowManagerPreview2 {
+    static GetForCurrentApp(): Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview;
+    GetNotePlacement(noteViewId: number): Windows.Storage.Streams.IBuffer;
+    HideNote(noteViewId: number): void;
+    SetFocusToNextView(): void;
+    SetFocusToPreviousView(): void;
+    SetNotesThumbnailAsync(thumbnail: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncAction;
+    SetThumbnailImageForTaskSwitcherAsync(bitmap: Windows.Graphics.Imaging.SoftwareBitmap): Windows.Foundation.IAsyncAction;
+    ShowNote(noteViewId: number): void;
+    ShowNoteRelativeTo(noteViewId: number, anchorNoteViewId: number): void;
+    ShowNoteRelativeTo(noteViewId: number, anchorNoteViewId: number, options: Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreviewShowNoteOptions): void;
+    ShowNoteWithPlacement(noteViewId: number, data: Windows.Storage.Streams.IBuffer): void;
+    ShowNoteWithPlacement(noteViewId: number, data: Windows.Storage.Streams.IBuffer, options: Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreviewShowNoteOptions): void;
+    TrySetNoteSize(noteViewId: number, size: Windows.Foundation.Size): boolean;
+    readonly IsScreenLocked: boolean;
+    NotePlacementChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview, Windows.ApplicationModel.Preview.Notes.NotePlacementChangedPreviewEventArgs> | null;
+    NoteVisibilityChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview, Windows.ApplicationModel.Preview.Notes.NoteVisibilityChangedPreviewEventArgs> | null;
+    SystemLockStateChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview, Object> | null;
+  }
+
+  class NotesWindowManagerPreviewShowNoteOptions implements Windows.ApplicationModel.Preview.Notes.INotesWindowManagerPreviewShowNoteOptions {
+    constructor();
+    ShowWithFocus: boolean;
+  }
+
+  interface INotePlacementChangedPreviewEventArgs {
+    readonly ViewId: number;
+  }
+  var INotePlacementChangedPreviewEventArgs: abstract new (...args: any[]) => INotePlacementChangedPreviewEventArgs;
+
+  interface INoteVisibilityChangedPreviewEventArgs {
+    readonly IsVisible: boolean;
+    readonly ViewId: number;
+  }
+  var INoteVisibilityChangedPreviewEventArgs: abstract new (...args: any[]) => INoteVisibilityChangedPreviewEventArgs;
+
+  interface INotesWindowManagerPreview {
+    GetNotePlacement(noteViewId: number): Windows.Storage.Streams.IBuffer;
+    HideNote(noteViewId: number): void;
+    SetFocusToNextView(): void;
+    SetNotesThumbnailAsync(thumbnail: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncAction;
+    ShowNote(noteViewId: number): void;
+    ShowNoteRelativeTo(noteViewId: number, anchorNoteViewId: number): void;
+    ShowNoteWithPlacement(noteViewId: number, data: Windows.Storage.Streams.IBuffer): void;
+    TrySetNoteSize(noteViewId: number, size: Windows.Foundation.Size): boolean;
+    readonly IsScreenLocked: boolean;
+    NotePlacementChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview, Windows.ApplicationModel.Preview.Notes.NotePlacementChangedPreviewEventArgs> | null;
+    NoteVisibilityChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview, Windows.ApplicationModel.Preview.Notes.NoteVisibilityChangedPreviewEventArgs> | null;
+    SystemLockStateChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview, Object> | null;
+  }
+  var INotesWindowManagerPreview: abstract new (...args: any[]) => INotesWindowManagerPreview;
+
+  interface INotesWindowManagerPreview2 {
+    SetFocusToPreviousView(): void;
+    SetThumbnailImageForTaskSwitcherAsync(bitmap: Windows.Graphics.Imaging.SoftwareBitmap): Windows.Foundation.IAsyncAction;
+    ShowNoteRelativeTo(noteViewId: number, anchorNoteViewId: number, options: Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreviewShowNoteOptions): void;
+    ShowNoteWithPlacement(noteViewId: number, data: Windows.Storage.Streams.IBuffer, options: Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreviewShowNoteOptions): void;
+  }
+  var INotesWindowManagerPreview2: abstract new (...args: any[]) => INotesWindowManagerPreview2;
+
+  interface INotesWindowManagerPreviewShowNoteOptions {
+    ShowWithFocus: boolean;
+  }
+  var INotesWindowManagerPreviewShowNoteOptions: abstract new (...args: any[]) => INotesWindowManagerPreviewShowNoteOptions;
+
+  interface INotesWindowManagerPreviewStatics {
+    GetForCurrentApp(): Windows.ApplicationModel.Preview.Notes.NotesWindowManagerPreview;
+  }
+  var INotesWindowManagerPreviewStatics: abstract new (...args: any[]) => INotesWindowManagerPreviewStatics;
+
+  interface PreviewNotesContract {
+  }
+  var PreviewNotesContract: {
+    new(fields: {  }): PreviewNotesContract;
+  };
+
+}
+
+declare namespace Windows.ApplicationModel.Resources {
+  class ResourceLoader implements Windows.ApplicationModel.Resources.IResourceLoader, Windows.ApplicationModel.Resources.IResourceLoader2 {
+    constructor(name: string);
+    constructor();
+    static GetDefaultPriPath(packageFullName: string): string;
+    static GetForCurrentView(): Windows.ApplicationModel.Resources.ResourceLoader;
+    static GetForCurrentView(name: string): Windows.ApplicationModel.Resources.ResourceLoader;
+    static GetForUIContext(context: Windows.UI.UIContext): Windows.ApplicationModel.Resources.ResourceLoader;
+    static GetForViewIndependentUse(): Windows.ApplicationModel.Resources.ResourceLoader;
+    static GetForViewIndependentUse(name: string): Windows.ApplicationModel.Resources.ResourceLoader;
+    GetString(resource: string): string;
+    static GetStringForReference(uri: Windows.Foundation.Uri): string;
+    GetStringForUri(uri: Windows.Foundation.Uri): string;
+  }
+
+  interface IResourceLoader {
+    GetString(resource: string): string;
+  }
+  var IResourceLoader: abstract new (...args: any[]) => IResourceLoader;
+
+  interface IResourceLoader2 {
+    GetStringForUri(uri: Windows.Foundation.Uri): string;
+  }
+  var IResourceLoader2: abstract new (...args: any[]) => IResourceLoader2;
+
+  interface IResourceLoaderFactory {
+    CreateResourceLoaderByName(name: string): Windows.ApplicationModel.Resources.ResourceLoader;
+  }
+  var IResourceLoaderFactory: abstract new (...args: any[]) => IResourceLoaderFactory;
+
+  interface IResourceLoaderStatics {
+    GetStringForReference(uri: Windows.Foundation.Uri): string;
+  }
+  var IResourceLoaderStatics: abstract new (...args: any[]) => IResourceLoaderStatics;
+
+  interface IResourceLoaderStatics2 {
+    GetForCurrentView(): Windows.ApplicationModel.Resources.ResourceLoader;
+    GetForCurrentView(name: string): Windows.ApplicationModel.Resources.ResourceLoader;
+    GetForViewIndependentUse(): Windows.ApplicationModel.Resources.ResourceLoader;
+    GetForViewIndependentUse(name: string): Windows.ApplicationModel.Resources.ResourceLoader;
+  }
+  var IResourceLoaderStatics2: abstract new (...args: any[]) => IResourceLoaderStatics2;
+
+  interface IResourceLoaderStatics3 {
+    GetForUIContext(context: Windows.UI.UIContext): Windows.ApplicationModel.Resources.ResourceLoader;
+  }
+  var IResourceLoaderStatics3: abstract new (...args: any[]) => IResourceLoaderStatics3;
+
+  interface IResourceLoaderStatics4 {
+    GetDefaultPriPath(packageFullName: string): string;
+  }
+  var IResourceLoaderStatics4: abstract new (...args: any[]) => IResourceLoaderStatics4;
+
+}
+
+declare namespace Windows.ApplicationModel.Resources.Core {
+  class NamedResource implements Windows.ApplicationModel.Resources.Core.INamedResource {
+    Resolve(): Windows.ApplicationModel.Resources.Core.ResourceCandidate;
+    Resolve(resourceContext: Windows.ApplicationModel.Resources.Core.ResourceContext): Windows.ApplicationModel.Resources.Core.ResourceCandidate;
+    ResolveAll(): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Resources.Core.ResourceCandidate> | Windows.ApplicationModel.Resources.Core.ResourceCandidate[];
+    ResolveAll(resourceContext: Windows.ApplicationModel.Resources.Core.ResourceContext): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Resources.Core.ResourceCandidate> | Windows.ApplicationModel.Resources.Core.ResourceCandidate[];
+    readonly Candidates: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Resources.Core.ResourceCandidate> | Windows.ApplicationModel.Resources.Core.ResourceCandidate[];
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class ResourceCandidate implements Windows.ApplicationModel.Resources.Core.IResourceCandidate, Windows.ApplicationModel.Resources.Core.IResourceCandidate2, Windows.ApplicationModel.Resources.Core.IResourceCandidate3 {
+    GetQualifierValue(qualifierName: string): string;
+    GetValueAsFileAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    GetValueAsStreamAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    readonly IsDefault: boolean;
+    readonly IsMatch: boolean;
+    readonly IsMatchAsDefault: boolean;
+    readonly Kind: number;
+    readonly Qualifiers: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Resources.Core.ResourceQualifier> | Windows.ApplicationModel.Resources.Core.ResourceQualifier[];
+    readonly ValueAsString: string;
+  }
+
+  class ResourceCandidateVectorView {
+    First(): Windows.Foundation.Collections.IIterator<Windows.ApplicationModel.Resources.Core.ResourceCandidate>;
+    GetAt(index: number): Windows.ApplicationModel.Resources.Core.ResourceCandidate;
+    GetMany(startIndex: number, items: Windows.ApplicationModel.Resources.Core.ResourceCandidate[]): number;
+    IndexOf(value: Windows.ApplicationModel.Resources.Core.ResourceCandidate, index: number): boolean;
+    readonly Size: number;
+  }
+
+  class ResourceContext implements Windows.ApplicationModel.Resources.Core.IResourceContext {
+    constructor();
+    Clone(): Windows.ApplicationModel.Resources.Core.ResourceContext;
+    static CreateMatchingContext(result: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Resources.Core.ResourceQualifier> | Windows.ApplicationModel.Resources.Core.ResourceQualifier[]): Windows.ApplicationModel.Resources.Core.ResourceContext;
+    static GetForCurrentView(): Windows.ApplicationModel.Resources.Core.ResourceContext;
+    static GetForUIContext(context: Windows.UI.UIContext): Windows.ApplicationModel.Resources.Core.ResourceContext;
+    static GetForViewIndependentUse(): Windows.ApplicationModel.Resources.Core.ResourceContext;
+    OverrideToMatch(result: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Resources.Core.ResourceQualifier> | Windows.ApplicationModel.Resources.Core.ResourceQualifier[]): void;
+    Reset(): void;
+    Reset(qualifierNames: Windows.Foundation.Collections.IIterable<string> | string[]): void;
+    static ResetGlobalQualifierValues(): void;
+    static ResetGlobalQualifierValues(qualifierNames: Windows.Foundation.Collections.IIterable<string> | string[]): void;
+    static SetGlobalQualifierValue(key: string, value: string, persistence: number): void;
+    static SetGlobalQualifierValue(key: string, value: string): void;
+    Languages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly QualifierValues: Windows.Foundation.Collections.IObservableMap<string, string>;
+  }
+
+  class ResourceContextLanguagesVectorView {
+    First(): Windows.Foundation.Collections.IIterator<string>;
+    GetAt(index: number): string;
+    GetMany(startIndex: number, items: string[]): number;
+    IndexOf(value: string, index: number): boolean;
+    readonly Size: number;
+  }
+
+  class ResourceManager implements Windows.ApplicationModel.Resources.Core.IResourceManager, Windows.ApplicationModel.Resources.Core.IResourceManager2 {
+    GetAllNamedResourcesForPackage(packageName: string, resourceLayoutInfo: Windows.ApplicationModel.Resources.Core.ResourceLayoutInfo): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Resources.Core.NamedResource> | Windows.ApplicationModel.Resources.Core.NamedResource[];
+    GetAllSubtreesForPackage(packageName: string, resourceLayoutInfo: Windows.ApplicationModel.Resources.Core.ResourceLayoutInfo): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Resources.Core.ResourceMap> | Windows.ApplicationModel.Resources.Core.ResourceMap[];
+    static IsResourceReference(resourceReference: string): boolean;
+    LoadPriFiles(files: Windows.Foundation.Collections.IIterable<Windows.Storage.IStorageFile> | Windows.Storage.IStorageFile[]): void;
+    UnloadPriFiles(files: Windows.Foundation.Collections.IIterable<Windows.Storage.IStorageFile> | Windows.Storage.IStorageFile[]): void;
+    readonly AllResourceMaps: Windows.Foundation.Collections.IMapView<string, Windows.ApplicationModel.Resources.Core.ResourceMap>;
+    static readonly Current: Windows.ApplicationModel.Resources.Core.ResourceManager;
+    readonly DefaultContext: Windows.ApplicationModel.Resources.Core.ResourceContext;
+    readonly MainResourceMap: Windows.ApplicationModel.Resources.Core.ResourceMap;
+  }
+
+  class ResourceMap implements Windows.ApplicationModel.Resources.Core.IResourceMap {
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, Windows.ApplicationModel.Resources.Core.NamedResource>>;
+    GetSubtree(reference: string): Windows.ApplicationModel.Resources.Core.ResourceMap;
+    GetValue(resource: string): Windows.ApplicationModel.Resources.Core.ResourceCandidate;
+    GetValue(resource: string, context: Windows.ApplicationModel.Resources.Core.ResourceContext): Windows.ApplicationModel.Resources.Core.ResourceCandidate;
+    HasKey(key: string): boolean;
+    Lookup(key: string): Windows.ApplicationModel.Resources.Core.NamedResource;
+    Split(first: Windows.Foundation.Collections.IMapView<string, Windows.ApplicationModel.Resources.Core.NamedResource>, second: Windows.Foundation.Collections.IMapView<string, Windows.ApplicationModel.Resources.Core.NamedResource>): void;
+    readonly Size: number;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class ResourceMapIterator {
+    GetMany(items: Windows.Foundation.Collections.IKeyValuePair<string, Windows.ApplicationModel.Resources.Core.NamedResource>[]): number;
+    MoveNext(): boolean;
+    readonly Current: Windows.Foundation.Collections.IKeyValuePair<string, Windows.ApplicationModel.Resources.Core.NamedResource>;
+    readonly HasCurrent: boolean;
+  }
+
+  class ResourceMapMapView {
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, Windows.ApplicationModel.Resources.Core.ResourceMap>>;
+    HasKey(key: string): boolean;
+    Lookup(key: string): Windows.ApplicationModel.Resources.Core.ResourceMap;
+    Split(first: Windows.Foundation.Collections.IMapView<string, Windows.ApplicationModel.Resources.Core.ResourceMap>, second: Windows.Foundation.Collections.IMapView<string, Windows.ApplicationModel.Resources.Core.ResourceMap>): void;
+    readonly Size: number;
+  }
+
+  class ResourceMapMapViewIterator {
+    GetMany(items: Windows.Foundation.Collections.IKeyValuePair<string, Windows.ApplicationModel.Resources.Core.ResourceMap>[]): number;
+    MoveNext(): boolean;
+    readonly Current: Windows.Foundation.Collections.IKeyValuePair<string, Windows.ApplicationModel.Resources.Core.ResourceMap>;
+    readonly HasCurrent: boolean;
+  }
+
+  class ResourceQualifier implements Windows.ApplicationModel.Resources.Core.IResourceQualifier {
+    readonly IsDefault: boolean;
+    readonly IsMatch: boolean;
+    readonly QualifierName: string;
+    readonly QualifierValue: string;
+    readonly Score: number;
+  }
+
+  class ResourceQualifierMapView {
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, string>>;
+    HasKey(key: string): boolean;
+    Lookup(key: string): string;
+    Split(first: Windows.Foundation.Collections.IMapView<string, string>, second: Windows.Foundation.Collections.IMapView<string, string>): void;
+    readonly Size: number;
+  }
+
+  class ResourceQualifierObservableMap {
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, string>>;
+    GetView(): Windows.Foundation.Collections.IMapView<string, string>;
+    HasKey(key: string): boolean;
+    Insert(key: string, value: string): boolean;
+    Lookup(key: string): string;
+    Remove(key: string): void;
+    readonly Size: number;
+    MapChanged: Windows.Foundation.Collections.MapChangedEventHandler<string, string> | null;
+  }
+
+  class ResourceQualifierVectorView {
+    First(): Windows.Foundation.Collections.IIterator<Windows.ApplicationModel.Resources.Core.ResourceQualifier>;
+    GetAt(index: number): Windows.ApplicationModel.Resources.Core.ResourceQualifier;
+    GetMany(startIndex: number, items: Windows.ApplicationModel.Resources.Core.ResourceQualifier[]): number;
+    IndexOf(value: Windows.ApplicationModel.Resources.Core.ResourceQualifier, index: number): boolean;
+    readonly Size: number;
+  }
+
+  enum ResourceCandidateKind {
+    String = 0,
+    File = 1,
+    EmbeddedData = 2,
+  }
+
+  enum ResourceQualifierPersistence {
+    None = 0,
+    LocalMachine = 1,
+  }
+
+  interface INamedResource {
+    Resolve(): Windows.ApplicationModel.Resources.Core.ResourceCandidate;
+    Resolve(resourceContext: Windows.ApplicationModel.Resources.Core.ResourceContext): Windows.ApplicationModel.Resources.Core.ResourceCandidate;
+    ResolveAll(): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Resources.Core.ResourceCandidate> | Windows.ApplicationModel.Resources.Core.ResourceCandidate[];
+    ResolveAll(resourceContext: Windows.ApplicationModel.Resources.Core.ResourceContext): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Resources.Core.ResourceCandidate> | Windows.ApplicationModel.Resources.Core.ResourceCandidate[];
+    readonly Candidates: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Resources.Core.ResourceCandidate> | Windows.ApplicationModel.Resources.Core.ResourceCandidate[];
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var INamedResource: abstract new (...args: any[]) => INamedResource;
+
+  interface IResourceCandidate {
+    GetQualifierValue(qualifierName: string): string;
+    GetValueAsFileAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    readonly IsDefault: boolean;
+    readonly IsMatch: boolean;
+    readonly IsMatchAsDefault: boolean;
+    readonly Qualifiers: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Resources.Core.ResourceQualifier> | Windows.ApplicationModel.Resources.Core.ResourceQualifier[];
+    readonly ValueAsString: string;
+  }
+  var IResourceCandidate: abstract new (...args: any[]) => IResourceCandidate;
+
+  interface IResourceCandidate2 {
+    GetValueAsStreamAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+  }
+  var IResourceCandidate2: abstract new (...args: any[]) => IResourceCandidate2;
+
+  interface IResourceCandidate3 {
+    readonly Kind: number;
+  }
+  var IResourceCandidate3: abstract new (...args: any[]) => IResourceCandidate3;
+
+  interface IResourceContext {
+    Clone(): Windows.ApplicationModel.Resources.Core.ResourceContext;
+    OverrideToMatch(result: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Resources.Core.ResourceQualifier> | Windows.ApplicationModel.Resources.Core.ResourceQualifier[]): void;
+    Reset(): void;
+    Reset(qualifierNames: Windows.Foundation.Collections.IIterable<string> | string[]): void;
+    Languages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly QualifierValues: Windows.Foundation.Collections.IObservableMap<string, string>;
+  }
+  var IResourceContext: abstract new (...args: any[]) => IResourceContext;
+
+  interface IResourceContextStatics {
+    CreateMatchingContext(result: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Resources.Core.ResourceQualifier> | Windows.ApplicationModel.Resources.Core.ResourceQualifier[]): Windows.ApplicationModel.Resources.Core.ResourceContext;
+  }
+  var IResourceContextStatics: abstract new (...args: any[]) => IResourceContextStatics;
+
+  interface IResourceContextStatics2 {
+    GetForCurrentView(): Windows.ApplicationModel.Resources.Core.ResourceContext;
+    GetForViewIndependentUse(): Windows.ApplicationModel.Resources.Core.ResourceContext;
+    ResetGlobalQualifierValues(): void;
+    ResetGlobalQualifierValues(qualifierNames: Windows.Foundation.Collections.IIterable<string> | string[]): void;
+    SetGlobalQualifierValue(key: string, value: string): void;
+  }
+  var IResourceContextStatics2: abstract new (...args: any[]) => IResourceContextStatics2;
+
+  interface IResourceContextStatics3 {
+    SetGlobalQualifierValue(key: string, value: string, persistence: number): void;
+  }
+  var IResourceContextStatics3: abstract new (...args: any[]) => IResourceContextStatics3;
+
+  interface IResourceContextStatics4 {
+    GetForUIContext(context: Windows.UI.UIContext): Windows.ApplicationModel.Resources.Core.ResourceContext;
+  }
+  var IResourceContextStatics4: abstract new (...args: any[]) => IResourceContextStatics4;
+
+  interface IResourceManager {
+    LoadPriFiles(files: Windows.Foundation.Collections.IIterable<Windows.Storage.IStorageFile> | Windows.Storage.IStorageFile[]): void;
+    UnloadPriFiles(files: Windows.Foundation.Collections.IIterable<Windows.Storage.IStorageFile> | Windows.Storage.IStorageFile[]): void;
+    readonly AllResourceMaps: Windows.Foundation.Collections.IMapView<string, Windows.ApplicationModel.Resources.Core.ResourceMap>;
+    readonly DefaultContext: Windows.ApplicationModel.Resources.Core.ResourceContext;
+    readonly MainResourceMap: Windows.ApplicationModel.Resources.Core.ResourceMap;
+  }
+  var IResourceManager: abstract new (...args: any[]) => IResourceManager;
+
+  interface IResourceManager2 {
+    GetAllNamedResourcesForPackage(packageName: string, resourceLayoutInfo: Windows.ApplicationModel.Resources.Core.ResourceLayoutInfo): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Resources.Core.NamedResource> | Windows.ApplicationModel.Resources.Core.NamedResource[];
+    GetAllSubtreesForPackage(packageName: string, resourceLayoutInfo: Windows.ApplicationModel.Resources.Core.ResourceLayoutInfo): Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Resources.Core.ResourceMap> | Windows.ApplicationModel.Resources.Core.ResourceMap[];
+  }
+  var IResourceManager2: abstract new (...args: any[]) => IResourceManager2;
+
+  interface IResourceManagerStatics {
+    IsResourceReference(resourceReference: string): boolean;
+    readonly Current: Windows.ApplicationModel.Resources.Core.ResourceManager;
+  }
+  var IResourceManagerStatics: abstract new (...args: any[]) => IResourceManagerStatics;
+
+  interface IResourceMap {
+    GetSubtree(reference: string): Windows.ApplicationModel.Resources.Core.ResourceMap;
+    GetValue(resource: string): Windows.ApplicationModel.Resources.Core.ResourceCandidate;
+    GetValue(resource: string, context: Windows.ApplicationModel.Resources.Core.ResourceContext): Windows.ApplicationModel.Resources.Core.ResourceCandidate;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IResourceMap: abstract new (...args: any[]) => IResourceMap;
+
+  interface IResourceQualifier {
+    readonly IsDefault: boolean;
+    readonly IsMatch: boolean;
+    readonly QualifierName: string;
+    readonly QualifierValue: string;
+    readonly Score: number;
+  }
+  var IResourceQualifier: abstract new (...args: any[]) => IResourceQualifier;
+
+  interface ResourceLayoutInfo {
+    MajorVersion: number;
+    MinorVersion: number;
+    ResourceSubtreeCount: number;
+    NamedResourceCount: number;
+    Checksum: number;
+  }
+  var ResourceLayoutInfo: {
+    new(majorVersion: number, minorVersion: number, resourceSubtreeCount: number, namedResourceCount: number, checksum: number): ResourceLayoutInfo;
+    new(fields: { MajorVersion?: number; MinorVersion?: number; ResourceSubtreeCount?: number; NamedResourceCount?: number; Checksum?: number }): ResourceLayoutInfo;
+  };
+
+}
+
+declare namespace Windows.ApplicationModel.Resources.Management {
+  class IndexedResourceCandidate implements Windows.ApplicationModel.Resources.Management.IIndexedResourceCandidate {
+    GetQualifierValue(qualifierName: string): string;
+    readonly Metadata: Windows.Foundation.Collections.IMapView<string, string>;
+    readonly Qualifiers: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Resources.Management.IndexedResourceQualifier> | Windows.ApplicationModel.Resources.Management.IndexedResourceQualifier[];
+    readonly Type: number;
+    readonly Uri: Windows.Foundation.Uri;
+    readonly ValueAsString: string;
+  }
+
+  class IndexedResourceQualifier implements Windows.ApplicationModel.Resources.Management.IIndexedResourceQualifier {
+    readonly QualifierName: string;
+    readonly QualifierValue: string;
+  }
+
+  class ResourceIndexer implements Windows.ApplicationModel.Resources.Management.IResourceIndexer {
+    constructor(projectRoot: Windows.Foundation.Uri, extensionDllPath: Windows.Foundation.Uri);
+    constructor(projectRoot: Windows.Foundation.Uri);
+    IndexFileContentsAsync(file: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Resources.Management.IndexedResourceCandidate> | Windows.ApplicationModel.Resources.Management.IndexedResourceCandidate[]>;
+    IndexFilePath(filePath: Windows.Foundation.Uri): Windows.ApplicationModel.Resources.Management.IndexedResourceCandidate;
+  }
+
+  enum IndexedResourceType {
+    String = 0,
+    Path = 1,
+    EmbeddedData = 2,
+  }
+
+  interface IIndexedResourceCandidate {
+    GetQualifierValue(qualifierName: string): string;
+    readonly Metadata: Windows.Foundation.Collections.IMapView<string, string>;
+    readonly Qualifiers: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Resources.Management.IndexedResourceQualifier> | Windows.ApplicationModel.Resources.Management.IndexedResourceQualifier[];
+    readonly Type: number;
+    readonly Uri: Windows.Foundation.Uri;
+    readonly ValueAsString: string;
+  }
+  var IIndexedResourceCandidate: abstract new (...args: any[]) => IIndexedResourceCandidate;
+
+  interface IIndexedResourceQualifier {
+    readonly QualifierName: string;
+    readonly QualifierValue: string;
+  }
+  var IIndexedResourceQualifier: abstract new (...args: any[]) => IIndexedResourceQualifier;
+
+  interface IResourceIndexer {
+    IndexFileContentsAsync(file: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Resources.Management.IndexedResourceCandidate> | Windows.ApplicationModel.Resources.Management.IndexedResourceCandidate[]>;
+    IndexFilePath(filePath: Windows.Foundation.Uri): Windows.ApplicationModel.Resources.Management.IndexedResourceCandidate;
+  }
+  var IResourceIndexer: abstract new (...args: any[]) => IResourceIndexer;
+
+  interface IResourceIndexerFactory {
+    CreateResourceIndexer(projectRoot: Windows.Foundation.Uri): Windows.ApplicationModel.Resources.Management.ResourceIndexer;
+  }
+  var IResourceIndexerFactory: abstract new (...args: any[]) => IResourceIndexerFactory;
+
+  interface IResourceIndexerFactory2 {
+    CreateResourceIndexerWithExtension(projectRoot: Windows.Foundation.Uri, extensionDllPath: Windows.Foundation.Uri): Windows.ApplicationModel.Resources.Management.ResourceIndexer;
+  }
+  var IResourceIndexerFactory2: abstract new (...args: any[]) => IResourceIndexerFactory2;
+
+  interface ResourceIndexerContract {
+  }
+  var ResourceIndexerContract: {
+    new(fields: {  }): ResourceIndexerContract;
+  };
+
+}
+
+declare namespace Windows.ApplicationModel.Search {
+  class LocalContentSuggestionSettings implements Windows.ApplicationModel.Search.ILocalContentSuggestionSettings {
+    constructor();
+    AqsFilter: string;
+    Enabled: boolean;
+    readonly Locations: Windows.Foundation.Collections.IVector<Windows.Storage.StorageFolder> | Windows.Storage.StorageFolder[];
+    readonly PropertiesToMatch: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+
+  class SearchPane implements Windows.ApplicationModel.Search.ISearchPane {
+    static GetForCurrentView(): Windows.ApplicationModel.Search.SearchPane;
+    static HideThisApplication(): void;
+    SetLocalContentSuggestionSettings(settings: Windows.ApplicationModel.Search.LocalContentSuggestionSettings): void;
+    Show(): void;
+    Show(query: string): void;
+    TrySetQueryText(query: string): boolean;
+    readonly Language: string;
+    PlaceholderText: string;
+    readonly QueryText: string;
+    SearchHistoryContext: string;
+    SearchHistoryEnabled: boolean;
+    ShowOnKeyboardInput: boolean;
+    readonly Visible: boolean;
+    QueryChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Search.SearchPane, Windows.ApplicationModel.Search.SearchPaneQueryChangedEventArgs> | null;
+    QuerySubmitted: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Search.SearchPane, Windows.ApplicationModel.Search.SearchPaneQuerySubmittedEventArgs> | null;
+    ResultSuggestionChosen: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Search.SearchPane, Windows.ApplicationModel.Search.SearchPaneResultSuggestionChosenEventArgs> | null;
+    SuggestionsRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Search.SearchPane, Windows.ApplicationModel.Search.SearchPaneSuggestionsRequestedEventArgs> | null;
+    VisibilityChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Search.SearchPane, Windows.ApplicationModel.Search.SearchPaneVisibilityChangedEventArgs> | null;
+  }
+
+  class SearchPaneQueryChangedEventArgs implements Windows.ApplicationModel.Search.ISearchPaneQueryChangedEventArgs {
+    readonly Language: string;
+    readonly LinguisticDetails: Windows.ApplicationModel.Search.SearchPaneQueryLinguisticDetails;
+    readonly QueryText: string;
+  }
+
+  class SearchPaneQueryLinguisticDetails implements Windows.ApplicationModel.Search.ISearchPaneQueryLinguisticDetails {
+    readonly QueryTextAlternatives: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly QueryTextCompositionLength: number;
+    readonly QueryTextCompositionStart: number;
+  }
+
+  class SearchPaneQuerySubmittedEventArgs implements Windows.ApplicationModel.Search.ISearchPaneQuerySubmittedEventArgs, Windows.ApplicationModel.Search.ISearchPaneQuerySubmittedEventArgsWithLinguisticDetails {
+    readonly Language: string;
+    readonly LinguisticDetails: Windows.ApplicationModel.Search.SearchPaneQueryLinguisticDetails;
+    readonly QueryText: string;
+  }
+
+  class SearchPaneResultSuggestionChosenEventArgs implements Windows.ApplicationModel.Search.ISearchPaneResultSuggestionChosenEventArgs {
+    readonly Tag: string;
+  }
+
+  class SearchPaneSuggestionsRequest implements Windows.ApplicationModel.Search.ISearchPaneSuggestionsRequest {
+    GetDeferral(): Windows.ApplicationModel.Search.SearchPaneSuggestionsRequestDeferral;
+    readonly IsCanceled: boolean;
+    readonly SearchSuggestionCollection: Windows.ApplicationModel.Search.SearchSuggestionCollection;
+  }
+
+  class SearchPaneSuggestionsRequestDeferral implements Windows.ApplicationModel.Search.ISearchPaneSuggestionsRequestDeferral {
+    Complete(): void;
+  }
+
+  class SearchPaneSuggestionsRequestedEventArgs implements Windows.ApplicationModel.Search.ISearchPaneQueryChangedEventArgs, Windows.ApplicationModel.Search.ISearchPaneSuggestionsRequestedEventArgs {
+    readonly Language: string;
+    readonly LinguisticDetails: Windows.ApplicationModel.Search.SearchPaneQueryLinguisticDetails;
+    readonly QueryText: string;
+    readonly Request: Windows.ApplicationModel.Search.SearchPaneSuggestionsRequest;
+  }
+
+  class SearchPaneVisibilityChangedEventArgs implements Windows.ApplicationModel.Search.ISearchPaneVisibilityChangedEventArgs {
+    readonly Visible: boolean;
+  }
+
+  class SearchQueryLinguisticDetails implements Windows.ApplicationModel.Search.ISearchQueryLinguisticDetails {
+    constructor(queryTextAlternatives: Windows.Foundation.Collections.IIterable<string> | string[], queryTextCompositionStart: number, queryTextCompositionLength: number);
+    readonly QueryTextAlternatives: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly QueryTextCompositionLength: number;
+    readonly QueryTextCompositionStart: number;
+  }
+
+  class SearchSuggestionCollection implements Windows.ApplicationModel.Search.ISearchSuggestionCollection {
+    AppendQuerySuggestion(text: string): void;
+    AppendQuerySuggestions(suggestions: Windows.Foundation.Collections.IIterable<string> | string[]): void;
+    AppendResultSuggestion(text: string, detailText: string, tag: string, image: Windows.Storage.Streams.IRandomAccessStreamReference, imageAlternateText: string): void;
+    AppendSearchSeparator(label: string): void;
+    readonly Size: number;
+  }
+
+  class SearchSuggestionsRequest implements Windows.ApplicationModel.Search.ISearchSuggestionsRequest {
+    GetDeferral(): Windows.ApplicationModel.Search.SearchSuggestionsRequestDeferral;
+    readonly IsCanceled: boolean;
+    readonly SearchSuggestionCollection: Windows.ApplicationModel.Search.SearchSuggestionCollection;
+  }
+
+  class SearchSuggestionsRequestDeferral implements Windows.ApplicationModel.Search.ISearchSuggestionsRequestDeferral {
+    Complete(): void;
+  }
+
+  interface ILocalContentSuggestionSettings {
+    AqsFilter: string;
+    Enabled: boolean;
+    readonly Locations: Windows.Foundation.Collections.IVector<Windows.Storage.StorageFolder> | Windows.Storage.StorageFolder[];
+    readonly PropertiesToMatch: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var ILocalContentSuggestionSettings: abstract new (...args: any[]) => ILocalContentSuggestionSettings;
+
+  interface ISearchPane {
+    SetLocalContentSuggestionSettings(settings: Windows.ApplicationModel.Search.LocalContentSuggestionSettings): void;
+    Show(): void;
+    Show(query: string): void;
+    TrySetQueryText(query: string): boolean;
+    readonly Language: string;
+    PlaceholderText: string;
+    readonly QueryText: string;
+    SearchHistoryContext: string;
+    SearchHistoryEnabled: boolean;
+    ShowOnKeyboardInput: boolean;
+    readonly Visible: boolean;
+    QueryChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Search.SearchPane, Windows.ApplicationModel.Search.SearchPaneQueryChangedEventArgs> | null;
+    QuerySubmitted: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Search.SearchPane, Windows.ApplicationModel.Search.SearchPaneQuerySubmittedEventArgs> | null;
+    ResultSuggestionChosen: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Search.SearchPane, Windows.ApplicationModel.Search.SearchPaneResultSuggestionChosenEventArgs> | null;
+    SuggestionsRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Search.SearchPane, Windows.ApplicationModel.Search.SearchPaneSuggestionsRequestedEventArgs> | null;
+    VisibilityChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Search.SearchPane, Windows.ApplicationModel.Search.SearchPaneVisibilityChangedEventArgs> | null;
+  }
+  var ISearchPane: abstract new (...args: any[]) => ISearchPane;
+
+  interface ISearchPaneQueryChangedEventArgs {
+    readonly Language: string;
+    readonly LinguisticDetails: Windows.ApplicationModel.Search.SearchPaneQueryLinguisticDetails;
+    readonly QueryText: string;
+  }
+  var ISearchPaneQueryChangedEventArgs: abstract new (...args: any[]) => ISearchPaneQueryChangedEventArgs;
+
+  interface ISearchPaneQueryLinguisticDetails {
+    readonly QueryTextAlternatives: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly QueryTextCompositionLength: number;
+    readonly QueryTextCompositionStart: number;
+  }
+  var ISearchPaneQueryLinguisticDetails: abstract new (...args: any[]) => ISearchPaneQueryLinguisticDetails;
+
+  interface ISearchPaneQuerySubmittedEventArgs {
+    readonly Language: string;
+    readonly QueryText: string;
+  }
+  var ISearchPaneQuerySubmittedEventArgs: abstract new (...args: any[]) => ISearchPaneQuerySubmittedEventArgs;
+
+  interface ISearchPaneQuerySubmittedEventArgsWithLinguisticDetails {
+    readonly LinguisticDetails: Windows.ApplicationModel.Search.SearchPaneQueryLinguisticDetails;
+  }
+  var ISearchPaneQuerySubmittedEventArgsWithLinguisticDetails: abstract new (...args: any[]) => ISearchPaneQuerySubmittedEventArgsWithLinguisticDetails;
+
+  interface ISearchPaneResultSuggestionChosenEventArgs {
+    readonly Tag: string;
+  }
+  var ISearchPaneResultSuggestionChosenEventArgs: abstract new (...args: any[]) => ISearchPaneResultSuggestionChosenEventArgs;
+
+  interface ISearchPaneStatics {
+    GetForCurrentView(): Windows.ApplicationModel.Search.SearchPane;
+  }
+  var ISearchPaneStatics: abstract new (...args: any[]) => ISearchPaneStatics;
+
+  interface ISearchPaneStaticsWithHideThisApplication {
+    HideThisApplication(): void;
+  }
+  var ISearchPaneStaticsWithHideThisApplication: abstract new (...args: any[]) => ISearchPaneStaticsWithHideThisApplication;
+
+  interface ISearchPaneSuggestionsRequest {
+    GetDeferral(): Windows.ApplicationModel.Search.SearchPaneSuggestionsRequestDeferral;
+    readonly IsCanceled: boolean;
+    readonly SearchSuggestionCollection: Windows.ApplicationModel.Search.SearchSuggestionCollection;
+  }
+  var ISearchPaneSuggestionsRequest: abstract new (...args: any[]) => ISearchPaneSuggestionsRequest;
+
+  interface ISearchPaneSuggestionsRequestDeferral {
+    Complete(): void;
+  }
+  var ISearchPaneSuggestionsRequestDeferral: abstract new (...args: any[]) => ISearchPaneSuggestionsRequestDeferral;
+
+  interface ISearchPaneSuggestionsRequestedEventArgs extends Windows.ApplicationModel.Search.ISearchPaneQueryChangedEventArgs {
+    readonly Request: Windows.ApplicationModel.Search.SearchPaneSuggestionsRequest;
+  }
+  var ISearchPaneSuggestionsRequestedEventArgs: abstract new (...args: any[]) => ISearchPaneSuggestionsRequestedEventArgs;
+
+  interface ISearchPaneVisibilityChangedEventArgs {
+    readonly Visible: boolean;
+  }
+  var ISearchPaneVisibilityChangedEventArgs: abstract new (...args: any[]) => ISearchPaneVisibilityChangedEventArgs;
+
+  interface ISearchQueryLinguisticDetails {
+    readonly QueryTextAlternatives: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly QueryTextCompositionLength: number;
+    readonly QueryTextCompositionStart: number;
+  }
+  var ISearchQueryLinguisticDetails: abstract new (...args: any[]) => ISearchQueryLinguisticDetails;
+
+  interface ISearchQueryLinguisticDetailsFactory {
+    CreateInstance(queryTextAlternatives: Windows.Foundation.Collections.IIterable<string> | string[], queryTextCompositionStart: number, queryTextCompositionLength: number): Windows.ApplicationModel.Search.SearchQueryLinguisticDetails;
+  }
+  var ISearchQueryLinguisticDetailsFactory: abstract new (...args: any[]) => ISearchQueryLinguisticDetailsFactory;
+
+  interface ISearchSuggestionCollection {
+    AppendQuerySuggestion(text: string): void;
+    AppendQuerySuggestions(suggestions: Windows.Foundation.Collections.IIterable<string> | string[]): void;
+    AppendResultSuggestion(text: string, detailText: string, tag: string, image: Windows.Storage.Streams.IRandomAccessStreamReference, imageAlternateText: string): void;
+    AppendSearchSeparator(label: string): void;
+    readonly Size: number;
+  }
+  var ISearchSuggestionCollection: abstract new (...args: any[]) => ISearchSuggestionCollection;
+
+  interface ISearchSuggestionsRequest {
+    GetDeferral(): Windows.ApplicationModel.Search.SearchSuggestionsRequestDeferral;
+    readonly IsCanceled: boolean;
+    readonly SearchSuggestionCollection: Windows.ApplicationModel.Search.SearchSuggestionCollection;
+  }
+  var ISearchSuggestionsRequest: abstract new (...args: any[]) => ISearchSuggestionsRequest;
+
+  interface ISearchSuggestionsRequestDeferral {
+    Complete(): void;
+  }
+  var ISearchSuggestionsRequestDeferral: abstract new (...args: any[]) => ISearchSuggestionsRequestDeferral;
+
+  interface SearchContract {
+  }
+  var SearchContract: {
+    new(fields: {  }): SearchContract;
+  };
+
+}
+
+declare namespace Windows.ApplicationModel.Search.Core {
+  class RequestingFocusOnKeyboardInputEventArgs implements Windows.ApplicationModel.Search.Core.IRequestingFocusOnKeyboardInputEventArgs {
+  }
+
+  class SearchSuggestion implements Windows.ApplicationModel.Search.Core.ISearchSuggestion {
+    readonly DetailText: string;
+    readonly Image: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly ImageAlternateText: string;
+    readonly Kind: number;
+    readonly Tag: string;
+    readonly Text: string;
+  }
+
+  class SearchSuggestionManager implements Windows.ApplicationModel.Search.Core.ISearchSuggestionManager {
+    constructor();
+    AddToHistory(queryText: string): void;
+    AddToHistory(queryText: string, language: string): void;
+    ClearHistory(): void;
+    SetLocalContentSuggestionSettings(settings: Windows.ApplicationModel.Search.LocalContentSuggestionSettings): void;
+    SetQuery(queryText: string): void;
+    SetQuery(queryText: string, language: string): void;
+    SetQuery(queryText: string, language: string, linguisticDetails: Windows.ApplicationModel.Search.SearchQueryLinguisticDetails): void;
+    SearchHistoryContext: string;
+    SearchHistoryEnabled: boolean;
+    readonly Suggestions: Windows.Foundation.Collections.IObservableVector<Windows.ApplicationModel.Search.Core.SearchSuggestion>;
+    RequestingFocusOnKeyboardInput: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Search.Core.SearchSuggestionManager, Windows.ApplicationModel.Search.Core.RequestingFocusOnKeyboardInputEventArgs> | null;
+    SuggestionsRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Search.Core.SearchSuggestionManager, Windows.ApplicationModel.Search.Core.SearchSuggestionsRequestedEventArgs> | null;
+  }
+
+  class SearchSuggestionsRequestedEventArgs implements Windows.ApplicationModel.Search.Core.ISearchSuggestionsRequestedEventArgs {
+    readonly Language: string;
+    readonly LinguisticDetails: Windows.ApplicationModel.Search.SearchQueryLinguisticDetails;
+    readonly QueryText: string;
+    readonly Request: Windows.ApplicationModel.Search.SearchSuggestionsRequest;
+  }
+
+  enum SearchSuggestionKind {
+    Query = 0,
+    Result = 1,
+    Separator = 2,
+  }
+
+  interface IRequestingFocusOnKeyboardInputEventArgs {
+  }
+  var IRequestingFocusOnKeyboardInputEventArgs: abstract new (...args: any[]) => IRequestingFocusOnKeyboardInputEventArgs;
+
+  interface ISearchSuggestion {
+    readonly DetailText: string;
+    readonly Image: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly ImageAlternateText: string;
+    readonly Kind: number;
+    readonly Tag: string;
+    readonly Text: string;
+  }
+  var ISearchSuggestion: abstract new (...args: any[]) => ISearchSuggestion;
+
+  interface ISearchSuggestionManager {
+    AddToHistory(queryText: string): void;
+    AddToHistory(queryText: string, language: string): void;
+    ClearHistory(): void;
+    SetLocalContentSuggestionSettings(settings: Windows.ApplicationModel.Search.LocalContentSuggestionSettings): void;
+    SetQuery(queryText: string): void;
+    SetQuery(queryText: string, language: string): void;
+    SetQuery(queryText: string, language: string, linguisticDetails: Windows.ApplicationModel.Search.SearchQueryLinguisticDetails): void;
+    SearchHistoryContext: string;
+    SearchHistoryEnabled: boolean;
+    readonly Suggestions: Windows.Foundation.Collections.IObservableVector<Windows.ApplicationModel.Search.Core.SearchSuggestion>;
+    RequestingFocusOnKeyboardInput: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Search.Core.SearchSuggestionManager, Windows.ApplicationModel.Search.Core.RequestingFocusOnKeyboardInputEventArgs> | null;
+    SuggestionsRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Search.Core.SearchSuggestionManager, Windows.ApplicationModel.Search.Core.SearchSuggestionsRequestedEventArgs> | null;
+  }
+  var ISearchSuggestionManager: abstract new (...args: any[]) => ISearchSuggestionManager;
+
+  interface ISearchSuggestionsRequestedEventArgs {
+    readonly Language: string;
+    readonly LinguisticDetails: Windows.ApplicationModel.Search.SearchQueryLinguisticDetails;
+    readonly QueryText: string;
+    readonly Request: Windows.ApplicationModel.Search.SearchSuggestionsRequest;
+  }
+  var ISearchSuggestionsRequestedEventArgs: abstract new (...args: any[]) => ISearchSuggestionsRequestedEventArgs;
+
+  interface SearchCoreContract {
+  }
+  var SearchCoreContract: {
+    new(fields: {  }): SearchCoreContract;
+  };
+
+}
+
+declare namespace Windows.ApplicationModel.SocialInfo {
+  class SocialFeedChildItem implements Windows.ApplicationModel.SocialInfo.ISocialFeedChildItem {
+    constructor();
+    readonly Author: Windows.ApplicationModel.SocialInfo.SocialUserInfo;
+    readonly PrimaryContent: Windows.ApplicationModel.SocialInfo.SocialFeedContent;
+    readonly SecondaryContent: Windows.ApplicationModel.SocialInfo.SocialFeedContent;
+    SharedItem: Windows.ApplicationModel.SocialInfo.SocialFeedSharedItem;
+    TargetUri: Windows.Foundation.Uri;
+    readonly Thumbnails: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.SocialInfo.SocialItemThumbnail> | Windows.ApplicationModel.SocialInfo.SocialItemThumbnail[];
+    Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class SocialFeedContent implements Windows.ApplicationModel.SocialInfo.ISocialFeedContent {
+    Message: string;
+    TargetUri: Windows.Foundation.Uri;
+    Title: string;
+  }
+
+  class SocialFeedItem implements Windows.ApplicationModel.SocialInfo.ISocialFeedItem {
+    constructor();
+    readonly Author: Windows.ApplicationModel.SocialInfo.SocialUserInfo;
+    BadgeCountValue: number;
+    BadgeStyle: number;
+    ChildItem: Windows.ApplicationModel.SocialInfo.SocialFeedChildItem;
+    readonly PrimaryContent: Windows.ApplicationModel.SocialInfo.SocialFeedContent;
+    RemoteId: string;
+    readonly SecondaryContent: Windows.ApplicationModel.SocialInfo.SocialFeedContent;
+    SharedItem: Windows.ApplicationModel.SocialInfo.SocialFeedSharedItem;
+    Style: number;
+    TargetUri: Windows.Foundation.Uri;
+    readonly Thumbnails: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.SocialInfo.SocialItemThumbnail> | Windows.ApplicationModel.SocialInfo.SocialItemThumbnail[];
+    Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class SocialFeedSharedItem implements Windows.ApplicationModel.SocialInfo.ISocialFeedSharedItem {
+    constructor();
+    readonly Content: Windows.ApplicationModel.SocialInfo.SocialFeedContent;
+    OriginalSource: Windows.Foundation.Uri;
+    TargetUri: Windows.Foundation.Uri;
+    Thumbnail: Windows.ApplicationModel.SocialInfo.SocialItemThumbnail;
+    Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class SocialItemThumbnail implements Windows.ApplicationModel.SocialInfo.ISocialItemThumbnail {
+    constructor();
+    SetImageAsync(image: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncAction;
+    BitmapSize: Windows.Graphics.Imaging.BitmapSize;
+    ImageUri: Windows.Foundation.Uri;
+    TargetUri: Windows.Foundation.Uri;
+  }
+
+  class SocialUserInfo implements Windows.ApplicationModel.SocialInfo.ISocialUserInfo {
+    DisplayName: string;
+    RemoteId: string;
+    TargetUri: Windows.Foundation.Uri;
+    UserName: string;
+  }
+
+  enum SocialFeedItemStyle {
+    Default = 0,
+    Photo = 1,
+  }
+
+  enum SocialFeedKind {
+    HomeFeed = 0,
+    ContactFeed = 1,
+    Dashboard = 2,
+  }
+
+  enum SocialFeedUpdateMode {
+    Append = 0,
+    Replace = 1,
+  }
+
+  enum SocialItemBadgeStyle {
+    Hidden = 0,
+    Visible = 1,
+    VisibleWithCount = 2,
+  }
+
+  interface ISocialFeedChildItem {
+    readonly Author: Windows.ApplicationModel.SocialInfo.SocialUserInfo;
+    readonly PrimaryContent: Windows.ApplicationModel.SocialInfo.SocialFeedContent;
+    readonly SecondaryContent: Windows.ApplicationModel.SocialInfo.SocialFeedContent;
+    SharedItem: Windows.ApplicationModel.SocialInfo.SocialFeedSharedItem;
+    TargetUri: Windows.Foundation.Uri;
+    readonly Thumbnails: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.SocialInfo.SocialItemThumbnail> | Windows.ApplicationModel.SocialInfo.SocialItemThumbnail[];
+    Timestamp: Windows.Foundation.DateTime;
+  }
+  var ISocialFeedChildItem: abstract new (...args: any[]) => ISocialFeedChildItem;
+
+  interface ISocialFeedContent {
+    Message: string;
+    TargetUri: Windows.Foundation.Uri;
+    Title: string;
+  }
+  var ISocialFeedContent: abstract new (...args: any[]) => ISocialFeedContent;
+
+  interface ISocialFeedItem {
+    readonly Author: Windows.ApplicationModel.SocialInfo.SocialUserInfo;
+    BadgeCountValue: number;
+    BadgeStyle: number;
+    ChildItem: Windows.ApplicationModel.SocialInfo.SocialFeedChildItem;
+    readonly PrimaryContent: Windows.ApplicationModel.SocialInfo.SocialFeedContent;
+    RemoteId: string;
+    readonly SecondaryContent: Windows.ApplicationModel.SocialInfo.SocialFeedContent;
+    SharedItem: Windows.ApplicationModel.SocialInfo.SocialFeedSharedItem;
+    Style: number;
+    TargetUri: Windows.Foundation.Uri;
+    readonly Thumbnails: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.SocialInfo.SocialItemThumbnail> | Windows.ApplicationModel.SocialInfo.SocialItemThumbnail[];
+    Timestamp: Windows.Foundation.DateTime;
+  }
+  var ISocialFeedItem: abstract new (...args: any[]) => ISocialFeedItem;
+
+  interface ISocialFeedSharedItem {
+    readonly Content: Windows.ApplicationModel.SocialInfo.SocialFeedContent;
+    OriginalSource: Windows.Foundation.Uri;
+    TargetUri: Windows.Foundation.Uri;
+    Thumbnail: Windows.ApplicationModel.SocialInfo.SocialItemThumbnail;
+    Timestamp: Windows.Foundation.DateTime;
+  }
+  var ISocialFeedSharedItem: abstract new (...args: any[]) => ISocialFeedSharedItem;
+
+  interface ISocialItemThumbnail {
+    SetImageAsync(image: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncAction;
+    BitmapSize: Windows.Graphics.Imaging.BitmapSize;
+    ImageUri: Windows.Foundation.Uri;
+    TargetUri: Windows.Foundation.Uri;
+  }
+  var ISocialItemThumbnail: abstract new (...args: any[]) => ISocialItemThumbnail;
+
+  interface ISocialUserInfo {
+    DisplayName: string;
+    RemoteId: string;
+    TargetUri: Windows.Foundation.Uri;
+    UserName: string;
+  }
+  var ISocialUserInfo: abstract new (...args: any[]) => ISocialUserInfo;
+
+  interface SocialInfoContract {
+  }
+  var SocialInfoContract: {
+    new(fields: {  }): SocialInfoContract;
+  };
+
+}
+
+declare namespace Windows.ApplicationModel.SocialInfo.Provider {
+  class SocialDashboardItemUpdater implements Windows.ApplicationModel.SocialInfo.Provider.ISocialDashboardItemUpdater {
+    CommitAsync(): Windows.Foundation.IAsyncAction;
+    readonly Content: Windows.ApplicationModel.SocialInfo.SocialFeedContent;
+    readonly OwnerRemoteId: string;
+    TargetUri: Windows.Foundation.Uri;
+    Thumbnail: Windows.ApplicationModel.SocialInfo.SocialItemThumbnail;
+    Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class SocialFeedUpdater implements Windows.ApplicationModel.SocialInfo.Provider.ISocialFeedUpdater {
+    CommitAsync(): Windows.Foundation.IAsyncAction;
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.SocialInfo.SocialFeedItem> | Windows.ApplicationModel.SocialInfo.SocialFeedItem[];
+    readonly Kind: number;
+    readonly OwnerRemoteId: string;
+  }
+
+  class SocialInfoProviderManager {
+    static CreateDashboardItemUpdaterAsync(ownerRemoteId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.SocialInfo.Provider.SocialDashboardItemUpdater>;
+    static CreateSocialFeedUpdaterAsync(kind: number, mode: number, ownerRemoteId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.SocialInfo.Provider.SocialFeedUpdater>;
+    static DeprovisionAsync(): Windows.Foundation.IAsyncAction;
+    static ProvisionAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    static ReportNewContentAvailable(contactRemoteId: string, kind: number): void;
+    static UpdateBadgeCountValue(itemRemoteId: string, newCount: number): void;
+  }
+
+  interface ISocialDashboardItemUpdater {
+    CommitAsync(): Windows.Foundation.IAsyncAction;
+    readonly Content: Windows.ApplicationModel.SocialInfo.SocialFeedContent;
+    readonly OwnerRemoteId: string;
+    TargetUri: Windows.Foundation.Uri;
+    Thumbnail: Windows.ApplicationModel.SocialInfo.SocialItemThumbnail;
+    Timestamp: Windows.Foundation.DateTime;
+  }
+  var ISocialDashboardItemUpdater: abstract new (...args: any[]) => ISocialDashboardItemUpdater;
+
+  interface ISocialFeedUpdater {
+    CommitAsync(): Windows.Foundation.IAsyncAction;
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.SocialInfo.SocialFeedItem> | Windows.ApplicationModel.SocialInfo.SocialFeedItem[];
+    readonly Kind: number;
+    readonly OwnerRemoteId: string;
+  }
+  var ISocialFeedUpdater: abstract new (...args: any[]) => ISocialFeedUpdater;
+
+  interface ISocialInfoProviderManagerStatics {
+    CreateDashboardItemUpdaterAsync(ownerRemoteId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.SocialInfo.Provider.SocialDashboardItemUpdater>;
+    CreateSocialFeedUpdaterAsync(kind: number, mode: number, ownerRemoteId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.SocialInfo.Provider.SocialFeedUpdater>;
+    DeprovisionAsync(): Windows.Foundation.IAsyncAction;
+    ProvisionAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    ReportNewContentAvailable(contactRemoteId: string, kind: number): void;
+    UpdateBadgeCountValue(itemRemoteId: string, newCount: number): void;
+  }
+  var ISocialInfoProviderManagerStatics: abstract new (...args: any[]) => ISocialInfoProviderManagerStatics;
+
+}
+
+declare namespace Windows.ApplicationModel.Store {
+  class CurrentApp {
+    static GetAppPurchaseCampaignIdAsync(): Windows.Foundation.IAsyncOperation<string>;
+    static GetAppReceiptAsync(): Windows.Foundation.IAsyncOperation<string>;
+    static GetCustomerCollectionsIdAsync(serviceTicket: string, publisherUserId: string): Windows.Foundation.IAsyncOperation<string>;
+    static GetCustomerPurchaseIdAsync(serviceTicket: string, publisherUserId: string): Windows.Foundation.IAsyncOperation<string>;
+    static GetProductReceiptAsync(productId: string): Windows.Foundation.IAsyncOperation<string>;
+    static GetUnfulfilledConsumablesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.UnfulfilledConsumable> | Windows.ApplicationModel.Store.UnfulfilledConsumable[]>;
+    static LoadListingInformationAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.ListingInformation>;
+    static LoadListingInformationByKeywordsAsync(keywords: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.ListingInformation>;
+    static LoadListingInformationByProductIdsAsync(productIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.ListingInformation>;
+    static ReportConsumableFulfillmentAsync(productId: string, transactionId: Guid): Windows.Foundation.IAsyncOperation<number>;
+    static ReportProductFulfillment(productId: string): void;
+    static RequestAppPurchaseAsync(includeReceipt: boolean): Windows.Foundation.IAsyncOperation<string>;
+    static RequestProductPurchaseAsync(productId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.PurchaseResults>;
+    static RequestProductPurchaseAsync(productId: string, offerId: string, displayProperties: Windows.ApplicationModel.Store.ProductPurchaseDisplayProperties): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.PurchaseResults>;
+    static RequestProductPurchaseAsync(productId: string, includeReceipt: boolean): Windows.Foundation.IAsyncOperation<string>;
+    static readonly AppId: Guid;
+    static readonly LicenseInformation: Windows.ApplicationModel.Store.LicenseInformation;
+    static readonly LinkUri: Windows.Foundation.Uri;
+  }
+
+  class CurrentAppSimulator {
+    static GetAppPurchaseCampaignIdAsync(): Windows.Foundation.IAsyncOperation<string>;
+    static GetAppReceiptAsync(): Windows.Foundation.IAsyncOperation<string>;
+    static GetProductReceiptAsync(productId: string): Windows.Foundation.IAsyncOperation<string>;
+    static GetUnfulfilledConsumablesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.UnfulfilledConsumable> | Windows.ApplicationModel.Store.UnfulfilledConsumable[]>;
+    static LoadListingInformationAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.ListingInformation>;
+    static LoadListingInformationByKeywordsAsync(keywords: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.ListingInformation>;
+    static LoadListingInformationByProductIdsAsync(productIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.ListingInformation>;
+    static ReloadSimulatorAsync(simulatorSettingsFile: Windows.Storage.StorageFile): Windows.Foundation.IAsyncAction;
+    static ReportConsumableFulfillmentAsync(productId: string, transactionId: Guid): Windows.Foundation.IAsyncOperation<number>;
+    static RequestAppPurchaseAsync(includeReceipt: boolean): Windows.Foundation.IAsyncOperation<string>;
+    static RequestProductPurchaseAsync(productId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.PurchaseResults>;
+    static RequestProductPurchaseAsync(productId: string, offerId: string, displayProperties: Windows.ApplicationModel.Store.ProductPurchaseDisplayProperties): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.PurchaseResults>;
+    static RequestProductPurchaseAsync(productId: string, includeReceipt: boolean): Windows.Foundation.IAsyncOperation<string>;
+    static readonly AppId: Guid;
+    static readonly LicenseInformation: Windows.ApplicationModel.Store.LicenseInformation;
+    static readonly LinkUri: Windows.Foundation.Uri;
+  }
+
+  class LicenseInformation implements Windows.ApplicationModel.Store.ILicenseInformation {
+    readonly ExpirationDate: Windows.Foundation.DateTime;
+    readonly IsActive: boolean;
+    readonly IsTrial: boolean;
+    readonly ProductLicenses: Windows.Foundation.Collections.IMapView<string, Windows.ApplicationModel.Store.ProductLicense>;
+    LicenseChanged: Windows.ApplicationModel.Store.LicenseChangedEventHandler | null;
+  }
+
+  class ListingInformation implements Windows.ApplicationModel.Store.IListingInformation, Windows.ApplicationModel.Store.IListingInformation2 {
+    readonly AgeRating: number;
+    readonly CurrencyCode: string;
+    readonly CurrentMarket: string;
+    readonly Description: string;
+    readonly FormattedBasePrice: string;
+    readonly FormattedPrice: string;
+    readonly IsOnSale: boolean;
+    readonly Name: string;
+    readonly ProductListings: Windows.Foundation.Collections.IMapView<string, Windows.ApplicationModel.Store.ProductListing>;
+    readonly SaleEndDate: Windows.Foundation.DateTime;
+  }
+
+  class ProductLicense implements Windows.ApplicationModel.Store.IProductLicense, Windows.ApplicationModel.Store.IProductLicenseWithFulfillment {
+    readonly ExpirationDate: Windows.Foundation.DateTime;
+    readonly IsActive: boolean;
+    readonly IsConsumable: boolean;
+    readonly ProductId: string;
+  }
+
+  class ProductListing implements Windows.ApplicationModel.Store.IProductListing, Windows.ApplicationModel.Store.IProductListing2, Windows.ApplicationModel.Store.IProductListingWithMetadata {
+    readonly CurrencyCode: string;
+    readonly Description: string;
+    readonly FormattedBasePrice: string;
+    readonly FormattedPrice: string;
+    readonly ImageUri: Windows.Foundation.Uri;
+    readonly IsOnSale: boolean;
+    readonly Keywords: Windows.Foundation.Collections.IIterable<string> | string[];
+    readonly Name: string;
+    readonly ProductId: string;
+    readonly ProductType: number;
+    readonly SaleEndDate: Windows.Foundation.DateTime;
+    readonly Tag: string;
+  }
+
+  class ProductPurchaseDisplayProperties implements Windows.ApplicationModel.Store.IProductPurchaseDisplayProperties {
+    constructor(name: string);
+    constructor();
+    Description: string;
+    Image: Windows.Foundation.Uri;
+    Name: string;
+  }
+
+  class PurchaseResults implements Windows.ApplicationModel.Store.IPurchaseResults {
+    readonly OfferId: string;
+    readonly ReceiptXml: string;
+    readonly Status: number;
+    readonly TransactionId: Guid;
+  }
+
+  class UnfulfilledConsumable implements Windows.ApplicationModel.Store.IUnfulfilledConsumable {
+    readonly OfferId: string;
+    readonly ProductId: string;
+    readonly TransactionId: Guid;
+  }
+
+  enum FulfillmentResult {
+    Succeeded = 0,
+    NothingToFulfill = 1,
+    PurchasePending = 2,
+    PurchaseReverted = 3,
+    ServerError = 4,
+  }
+
+  enum ProductPurchaseStatus {
+    Succeeded = 0,
+    AlreadyPurchased = 1,
+    NotFulfilled = 2,
+    NotPurchased = 3,
+  }
+
+  enum ProductType {
+    Unknown = 0,
+    Durable = 1,
+    Consumable = 2,
+  }
+
+  interface ICurrentApp {
+    GetAppReceiptAsync(): Windows.Foundation.IAsyncOperation<string>;
+    GetProductReceiptAsync(productId: string): Windows.Foundation.IAsyncOperation<string>;
+    LoadListingInformationAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.ListingInformation>;
+    RequestAppPurchaseAsync(includeReceipt: boolean): Windows.Foundation.IAsyncOperation<string>;
+    RequestProductPurchaseAsync(productId: string, includeReceipt: boolean): Windows.Foundation.IAsyncOperation<string>;
+    readonly AppId: Guid;
+    readonly LicenseInformation: Windows.ApplicationModel.Store.LicenseInformation;
+    readonly LinkUri: Windows.Foundation.Uri;
+  }
+  var ICurrentApp: abstract new (...args: any[]) => ICurrentApp;
+
+  interface ICurrentApp2Statics {
+    GetCustomerCollectionsIdAsync(serviceTicket: string, publisherUserId: string): Windows.Foundation.IAsyncOperation<string>;
+    GetCustomerPurchaseIdAsync(serviceTicket: string, publisherUserId: string): Windows.Foundation.IAsyncOperation<string>;
+  }
+  var ICurrentApp2Statics: abstract new (...args: any[]) => ICurrentApp2Statics;
+
+  interface ICurrentAppSimulator {
+    GetAppReceiptAsync(): Windows.Foundation.IAsyncOperation<string>;
+    GetProductReceiptAsync(productId: string): Windows.Foundation.IAsyncOperation<string>;
+    LoadListingInformationAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.ListingInformation>;
+    ReloadSimulatorAsync(simulatorSettingsFile: Windows.Storage.StorageFile): Windows.Foundation.IAsyncAction;
+    RequestAppPurchaseAsync(includeReceipt: boolean): Windows.Foundation.IAsyncOperation<string>;
+    RequestProductPurchaseAsync(productId: string, includeReceipt: boolean): Windows.Foundation.IAsyncOperation<string>;
+    readonly AppId: Guid;
+    readonly LicenseInformation: Windows.ApplicationModel.Store.LicenseInformation;
+    readonly LinkUri: Windows.Foundation.Uri;
+  }
+  var ICurrentAppSimulator: abstract new (...args: any[]) => ICurrentAppSimulator;
+
+  interface ICurrentAppSimulatorStaticsWithFiltering {
+    LoadListingInformationByKeywordsAsync(keywords: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.ListingInformation>;
+    LoadListingInformationByProductIdsAsync(productIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.ListingInformation>;
+  }
+  var ICurrentAppSimulatorStaticsWithFiltering: abstract new (...args: any[]) => ICurrentAppSimulatorStaticsWithFiltering;
+
+  interface ICurrentAppSimulatorWithCampaignId {
+    GetAppPurchaseCampaignIdAsync(): Windows.Foundation.IAsyncOperation<string>;
+  }
+  var ICurrentAppSimulatorWithCampaignId: abstract new (...args: any[]) => ICurrentAppSimulatorWithCampaignId;
+
+  interface ICurrentAppSimulatorWithConsumables {
+    GetUnfulfilledConsumablesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.UnfulfilledConsumable> | Windows.ApplicationModel.Store.UnfulfilledConsumable[]>;
+    ReportConsumableFulfillmentAsync(productId: string, transactionId: Guid): Windows.Foundation.IAsyncOperation<number>;
+    RequestProductPurchaseAsync(productId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.PurchaseResults>;
+    RequestProductPurchaseAsync(productId: string, offerId: string, displayProperties: Windows.ApplicationModel.Store.ProductPurchaseDisplayProperties): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.PurchaseResults>;
+  }
+  var ICurrentAppSimulatorWithConsumables: abstract new (...args: any[]) => ICurrentAppSimulatorWithConsumables;
+
+  interface ICurrentAppStaticsWithFiltering {
+    LoadListingInformationByKeywordsAsync(keywords: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.ListingInformation>;
+    LoadListingInformationByProductIdsAsync(productIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.ListingInformation>;
+    ReportProductFulfillment(productId: string): void;
+  }
+  var ICurrentAppStaticsWithFiltering: abstract new (...args: any[]) => ICurrentAppStaticsWithFiltering;
+
+  interface ICurrentAppWithCampaignId {
+    GetAppPurchaseCampaignIdAsync(): Windows.Foundation.IAsyncOperation<string>;
+  }
+  var ICurrentAppWithCampaignId: abstract new (...args: any[]) => ICurrentAppWithCampaignId;
+
+  interface ICurrentAppWithConsumables {
+    GetUnfulfilledConsumablesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.UnfulfilledConsumable> | Windows.ApplicationModel.Store.UnfulfilledConsumable[]>;
+    ReportConsumableFulfillmentAsync(productId: string, transactionId: Guid): Windows.Foundation.IAsyncOperation<number>;
+    RequestProductPurchaseAsync(productId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.PurchaseResults>;
+    RequestProductPurchaseAsync(productId: string, offerId: string, displayProperties: Windows.ApplicationModel.Store.ProductPurchaseDisplayProperties): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.PurchaseResults>;
+  }
+  var ICurrentAppWithConsumables: abstract new (...args: any[]) => ICurrentAppWithConsumables;
+
+  interface ILicenseInformation {
+    readonly ExpirationDate: Windows.Foundation.DateTime;
+    readonly IsActive: boolean;
+    readonly IsTrial: boolean;
+    readonly ProductLicenses: Windows.Foundation.Collections.IMapView<string, Windows.ApplicationModel.Store.ProductLicense>;
+    LicenseChanged: Windows.ApplicationModel.Store.LicenseChangedEventHandler | null;
+  }
+  var ILicenseInformation: abstract new (...args: any[]) => ILicenseInformation;
+
+  interface IListingInformation {
+    readonly AgeRating: number;
+    readonly CurrentMarket: string;
+    readonly Description: string;
+    readonly FormattedPrice: string;
+    readonly Name: string;
+    readonly ProductListings: Windows.Foundation.Collections.IMapView<string, Windows.ApplicationModel.Store.ProductListing>;
+  }
+  var IListingInformation: abstract new (...args: any[]) => IListingInformation;
+
+  interface IListingInformation2 {
+    readonly CurrencyCode: string;
+    readonly FormattedBasePrice: string;
+    readonly IsOnSale: boolean;
+    readonly SaleEndDate: Windows.Foundation.DateTime;
+  }
+  var IListingInformation2: abstract new (...args: any[]) => IListingInformation2;
+
+  interface IProductLicense {
+    readonly ExpirationDate: Windows.Foundation.DateTime;
+    readonly IsActive: boolean;
+    readonly ProductId: string;
+  }
+  var IProductLicense: abstract new (...args: any[]) => IProductLicense;
+
+  interface IProductLicenseWithFulfillment extends Windows.ApplicationModel.Store.IProductLicense {
+    readonly IsConsumable: boolean;
+  }
+  var IProductLicenseWithFulfillment: abstract new (...args: any[]) => IProductLicenseWithFulfillment;
+
+  interface IProductListing {
+    readonly FormattedPrice: string;
+    readonly Name: string;
+    readonly ProductId: string;
+  }
+  var IProductListing: abstract new (...args: any[]) => IProductListing;
+
+  interface IProductListing2 {
+    readonly CurrencyCode: string;
+    readonly FormattedBasePrice: string;
+    readonly IsOnSale: boolean;
+    readonly SaleEndDate: Windows.Foundation.DateTime;
+  }
+  var IProductListing2: abstract new (...args: any[]) => IProductListing2;
+
+  interface IProductListingWithConsumables {
+    readonly ProductType: number;
+  }
+  var IProductListingWithConsumables: abstract new (...args: any[]) => IProductListingWithConsumables;
+
+  interface IProductListingWithMetadata extends Windows.ApplicationModel.Store.IProductListing {
+    readonly Description: string;
+    readonly ImageUri: Windows.Foundation.Uri;
+    readonly Keywords: Windows.Foundation.Collections.IIterable<string> | string[];
+    readonly ProductType: number;
+    readonly Tag: string;
+  }
+  var IProductListingWithMetadata: abstract new (...args: any[]) => IProductListingWithMetadata;
+
+  interface IProductPurchaseDisplayProperties {
+    Description: string;
+    Image: Windows.Foundation.Uri;
+    Name: string;
+  }
+  var IProductPurchaseDisplayProperties: abstract new (...args: any[]) => IProductPurchaseDisplayProperties;
+
+  interface IProductPurchaseDisplayPropertiesFactory {
+    CreateProductPurchaseDisplayProperties(name: string): Windows.ApplicationModel.Store.ProductPurchaseDisplayProperties;
+  }
+  var IProductPurchaseDisplayPropertiesFactory: abstract new (...args: any[]) => IProductPurchaseDisplayPropertiesFactory;
+
+  interface IPurchaseResults {
+    readonly OfferId: string;
+    readonly ReceiptXml: string;
+    readonly Status: number;
+    readonly TransactionId: Guid;
+  }
+  var IPurchaseResults: abstract new (...args: any[]) => IPurchaseResults;
+
+  interface IUnfulfilledConsumable {
+    readonly OfferId: string;
+    readonly ProductId: string;
+    readonly TransactionId: Guid;
+  }
+  var IUnfulfilledConsumable: abstract new (...args: any[]) => IUnfulfilledConsumable;
+
+  interface LicenseChangedEventHandler {
+    (): void;
+  }
+  var LicenseChangedEventHandler: {
+    new(callback: () => void): LicenseChangedEventHandler;
+  };
+
+}
+
+declare namespace Windows.ApplicationModel.Store.LicenseManagement {
+  class LicenseManager {
+    static AddLicenseAsync(license: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncAction;
+    static GetSatisfactionInfosAsync(contentIds: Windows.Foundation.Collections.IIterable<string> | string[], keyIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.LicenseManagement.LicenseSatisfactionResult>;
+    static RefreshLicensesAsync(refreshOption: number): Windows.Foundation.IAsyncAction;
+  }
+
+  class LicenseSatisfactionInfo implements Windows.ApplicationModel.Store.LicenseManagement.ILicenseSatisfactionInfo {
+    readonly IsSatisfied: boolean;
+    readonly SatisfiedByDevice: boolean;
+    readonly SatisfiedByInstallMedia: boolean;
+    readonly SatisfiedByOpenLicense: boolean;
+    readonly SatisfiedByPass: boolean;
+    readonly SatisfiedBySignedInUser: boolean;
+    readonly SatisfiedByTrial: boolean;
+  }
+
+  class LicenseSatisfactionResult implements Windows.ApplicationModel.Store.LicenseManagement.ILicenseSatisfactionResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly LicenseSatisfactionInfos: Windows.Foundation.Collections.IMapView<string, Windows.ApplicationModel.Store.LicenseManagement.LicenseSatisfactionInfo>;
+  }
+
+  enum LicenseRefreshOption {
+    RunningLicenses = 0,
+    AllLicenses = 1,
+  }
+
+  interface ILicenseManagerStatics {
+    AddLicenseAsync(license: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncAction;
+    GetSatisfactionInfosAsync(contentIds: Windows.Foundation.Collections.IIterable<string> | string[], keyIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.LicenseManagement.LicenseSatisfactionResult>;
+  }
+  var ILicenseManagerStatics: abstract new (...args: any[]) => ILicenseManagerStatics;
+
+  interface ILicenseManagerStatics2 {
+    RefreshLicensesAsync(refreshOption: number): Windows.Foundation.IAsyncAction;
+  }
+  var ILicenseManagerStatics2: abstract new (...args: any[]) => ILicenseManagerStatics2;
+
+  interface ILicenseSatisfactionInfo {
+    readonly IsSatisfied: boolean;
+    readonly SatisfiedByDevice: boolean;
+    readonly SatisfiedByInstallMedia: boolean;
+    readonly SatisfiedByOpenLicense: boolean;
+    readonly SatisfiedByPass: boolean;
+    readonly SatisfiedBySignedInUser: boolean;
+    readonly SatisfiedByTrial: boolean;
+  }
+  var ILicenseSatisfactionInfo: abstract new (...args: any[]) => ILicenseSatisfactionInfo;
+
+  interface ILicenseSatisfactionResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly LicenseSatisfactionInfos: Windows.Foundation.Collections.IMapView<string, Windows.ApplicationModel.Store.LicenseManagement.LicenseSatisfactionInfo>;
+  }
+  var ILicenseSatisfactionResult: abstract new (...args: any[]) => ILicenseSatisfactionResult;
+
+}
+
+declare namespace Windows.ApplicationModel.Store.Preview {
+  class DeliveryOptimizationSettings implements Windows.ApplicationModel.Store.Preview.IDeliveryOptimizationSettings {
+    static GetCurrentSettings(): Windows.ApplicationModel.Store.Preview.DeliveryOptimizationSettings;
+    readonly DownloadMode: number;
+    readonly DownloadModeSource: number;
+  }
+
+  class StoreConfiguration {
+    static FilterUnsupportedSystemFeaturesAsync(systemFeatures: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<number> | number[]>;
+    static GetEnterpriseStoreWebAccountId(): string;
+    static GetEnterpriseStoreWebAccountIdForUser(user: Windows.System.User): string;
+    static GetPurchasePromptingPolicyForUser(user: Windows.System.User): number | null;
+    static GetStoreLogDataAsync(options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamReference>;
+    static GetStoreWebAccountId(): string;
+    static GetStoreWebAccountIdForUser(user: Windows.System.User): string;
+    static HasStoreWebAccount(): boolean;
+    static HasStoreWebAccountForUser(user: Windows.System.User): boolean;
+    static IsPinToDesktopSupported(): boolean;
+    static IsPinToStartSupported(): boolean;
+    static IsPinToTaskbarSupported(): boolean;
+    static IsStoreWebAccountId(webAccountId: string): boolean;
+    static IsStoreWebAccountIdForUser(user: Windows.System.User, webAccountId: string): boolean;
+    static PinToDesktop(appPackageFamilyName: string): void;
+    static PinToDesktopForUser(user: Windows.System.User, appPackageFamilyName: string): void;
+    static SetEnterpriseStoreWebAccountId(webAccountId: string): void;
+    static SetEnterpriseStoreWebAccountIdForUser(user: Windows.System.User, webAccountId: string): void;
+    static SetMobileOperatorConfiguration(mobileOperatorId: string, appDownloadLimitInMegabytes: number, updateDownloadLimitInMegabytes: number): void;
+    static SetPurchasePromptingPolicyForUser(user: Windows.System.User, value: number | null): void;
+    static SetStoreWebAccountId(webAccountId: string): void;
+    static SetStoreWebAccountIdForUser(user: Windows.System.User, webAccountId: string): void;
+    static SetSystemConfiguration(catalogHardwareManufacturerId: string, catalogStoreContentModifierId: string, systemConfigurationExpiration: Windows.Foundation.DateTime, catalogHardwareDescriptor: string): void;
+    static ShouldRestrictToEnterpriseStoreOnly(): boolean;
+    static ShouldRestrictToEnterpriseStoreOnlyForUser(user: Windows.System.User): boolean;
+    static readonly HardwareManufacturerInfo: Windows.ApplicationModel.Store.Preview.StoreHardwareManufacturerInfo;
+    static PurchasePromptingPolicy: number | null;
+  }
+
+  class StoreHardwareManufacturerInfo implements Windows.ApplicationModel.Store.Preview.IStoreHardwareManufacturerInfo {
+    readonly HardwareManufacturerId: string;
+    readonly ManufacturerName: string;
+    readonly ModelName: string;
+    readonly StoreContentModifierId: string;
+  }
+
+  class StorePreview {
+    static LoadAddOnProductInfosAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.StorePreviewProductInfo> | Windows.ApplicationModel.Store.Preview.StorePreviewProductInfo[]>;
+    static RequestProductPurchaseByProductIdAndSkuIdAsync(productId: string, skuId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.StorePreviewPurchaseResults>;
+  }
+
+  class StorePreviewProductInfo implements Windows.ApplicationModel.Store.Preview.IStorePreviewProductInfo {
+    readonly Description: string;
+    readonly ProductId: string;
+    readonly ProductType: string;
+    readonly SkuInfoList: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.StorePreviewSkuInfo> | Windows.ApplicationModel.Store.Preview.StorePreviewSkuInfo[];
+    readonly Title: string;
+  }
+
+  class StorePreviewPurchaseResults implements Windows.ApplicationModel.Store.Preview.IStorePreviewPurchaseResults {
+    readonly ProductPurchaseStatus: number;
+  }
+
+  class StorePreviewSkuInfo implements Windows.ApplicationModel.Store.Preview.IStorePreviewSkuInfo {
+    readonly CurrencyCode: string;
+    readonly CustomDeveloperData: string;
+    readonly Description: string;
+    readonly ExtendedData: string;
+    readonly FormattedListPrice: string;
+    readonly ProductId: string;
+    readonly SkuId: string;
+    readonly SkuType: string;
+    readonly Title: string;
+  }
+
+  class WebAuthenticationCoreManagerHelper {
+    static RequestTokenWithUIElementHostingAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest, uiElement: Windows.UI.Xaml.UIElement): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+    static RequestTokenWithUIElementHostingAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest, webAccount: Windows.Security.Credentials.WebAccount, uiElement: Windows.UI.Xaml.UIElement): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+  }
+
+  enum DeliveryOptimizationDownloadMode {
+    Simple = 0,
+    HttpOnly = 1,
+    Lan = 2,
+    Group = 3,
+    Internet = 4,
+    Bypass = 5,
+  }
+
+  enum DeliveryOptimizationDownloadModeSource {
+    Default = 0,
+    Policy = 1,
+  }
+
+  enum StoreLogOptions {
+    None = 0,
+    TryElevate = 1,
+  }
+
+  enum StorePreviewProductPurchaseStatus {
+    Succeeded = 0,
+    AlreadyPurchased = 1,
+    NotFulfilled = 2,
+    NotPurchased = 3,
+  }
+
+  enum StoreSystemFeature {
+    ArchitectureX86 = 0,
+    ArchitectureX64 = 1,
+    ArchitectureArm = 2,
+    DirectX9 = 3,
+    DirectX10 = 4,
+    DirectX11 = 5,
+    D3D12HardwareFL11 = 6,
+    D3D12HardwareFL12 = 7,
+    Memory300MB = 8,
+    Memory750MB = 9,
+    Memory1GB = 10,
+    Memory2GB = 11,
+    CameraFront = 12,
+    CameraRear = 13,
+    Gyroscope = 14,
+    Hover = 15,
+    Magnetometer = 16,
+    Nfc = 17,
+    Resolution720P = 18,
+    ResolutionWvga = 19,
+    ResolutionWvgaOr720P = 20,
+    ResolutionWxga = 21,
+    ResolutionWvgaOrWxga = 22,
+    ResolutionWxgaOr720P = 23,
+    Memory4GB = 24,
+    Memory6GB = 25,
+    Memory8GB = 26,
+    Memory12GB = 27,
+    Memory16GB = 28,
+    Memory20GB = 29,
+    VideoMemory2GB = 30,
+    VideoMemory4GB = 31,
+    VideoMemory6GB = 32,
+    VideoMemory1GB = 33,
+    ArchitectureArm64 = 34,
+  }
+
+  interface IDeliveryOptimizationSettings {
+    readonly DownloadMode: number;
+    readonly DownloadModeSource: number;
+  }
+  var IDeliveryOptimizationSettings: abstract new (...args: any[]) => IDeliveryOptimizationSettings;
+
+  interface IDeliveryOptimizationSettingsStatics {
+    GetCurrentSettings(): Windows.ApplicationModel.Store.Preview.DeliveryOptimizationSettings;
+  }
+  var IDeliveryOptimizationSettingsStatics: abstract new (...args: any[]) => IDeliveryOptimizationSettingsStatics;
+
+  interface IStoreConfigurationStatics {
+    FilterUnsupportedSystemFeaturesAsync(systemFeatures: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<number> | number[]>;
+    IsStoreWebAccountId(webAccountId: string): boolean;
+    SetMobileOperatorConfiguration(mobileOperatorId: string, appDownloadLimitInMegabytes: number, updateDownloadLimitInMegabytes: number): void;
+    SetStoreWebAccountId(webAccountId: string): void;
+    SetSystemConfiguration(catalogHardwareManufacturerId: string, catalogStoreContentModifierId: string, systemConfigurationExpiration: Windows.Foundation.DateTime, catalogHardwareDescriptor: string): void;
+    readonly HardwareManufacturerInfo: Windows.ApplicationModel.Store.Preview.StoreHardwareManufacturerInfo;
+  }
+  var IStoreConfigurationStatics: abstract new (...args: any[]) => IStoreConfigurationStatics;
+
+  interface IStoreConfigurationStatics2 {
+    PurchasePromptingPolicy: number | null;
+  }
+  var IStoreConfigurationStatics2: abstract new (...args: any[]) => IStoreConfigurationStatics2;
+
+  interface IStoreConfigurationStatics3 {
+    GetPurchasePromptingPolicyForUser(user: Windows.System.User): number | null;
+    GetStoreLogDataAsync(options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamReference>;
+    HasStoreWebAccount(): boolean;
+    HasStoreWebAccountForUser(user: Windows.System.User): boolean;
+    IsStoreWebAccountIdForUser(user: Windows.System.User, webAccountId: string): boolean;
+    SetPurchasePromptingPolicyForUser(user: Windows.System.User, value: number | null): void;
+    SetStoreWebAccountIdForUser(user: Windows.System.User, webAccountId: string): void;
+  }
+  var IStoreConfigurationStatics3: abstract new (...args: any[]) => IStoreConfigurationStatics3;
+
+  interface IStoreConfigurationStatics4 {
+    GetEnterpriseStoreWebAccountId(): string;
+    GetEnterpriseStoreWebAccountIdForUser(user: Windows.System.User): string;
+    GetStoreWebAccountId(): string;
+    GetStoreWebAccountIdForUser(user: Windows.System.User): string;
+    SetEnterpriseStoreWebAccountId(webAccountId: string): void;
+    SetEnterpriseStoreWebAccountIdForUser(user: Windows.System.User, webAccountId: string): void;
+    ShouldRestrictToEnterpriseStoreOnly(): boolean;
+    ShouldRestrictToEnterpriseStoreOnlyForUser(user: Windows.System.User): boolean;
+  }
+  var IStoreConfigurationStatics4: abstract new (...args: any[]) => IStoreConfigurationStatics4;
+
+  interface IStoreConfigurationStatics5 {
+    IsPinToDesktopSupported(): boolean;
+    IsPinToStartSupported(): boolean;
+    IsPinToTaskbarSupported(): boolean;
+    PinToDesktop(appPackageFamilyName: string): void;
+    PinToDesktopForUser(user: Windows.System.User, appPackageFamilyName: string): void;
+  }
+  var IStoreConfigurationStatics5: abstract new (...args: any[]) => IStoreConfigurationStatics5;
+
+  interface IStoreHardwareManufacturerInfo {
+    readonly HardwareManufacturerId: string;
+    readonly ManufacturerName: string;
+    readonly ModelName: string;
+    readonly StoreContentModifierId: string;
+  }
+  var IStoreHardwareManufacturerInfo: abstract new (...args: any[]) => IStoreHardwareManufacturerInfo;
+
+  interface IStorePreview {
+    LoadAddOnProductInfosAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.StorePreviewProductInfo> | Windows.ApplicationModel.Store.Preview.StorePreviewProductInfo[]>;
+    RequestProductPurchaseByProductIdAndSkuIdAsync(productId: string, skuId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.StorePreviewPurchaseResults>;
+  }
+  var IStorePreview: abstract new (...args: any[]) => IStorePreview;
+
+  interface IStorePreviewProductInfo {
+    readonly Description: string;
+    readonly ProductId: string;
+    readonly ProductType: string;
+    readonly SkuInfoList: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.StorePreviewSkuInfo> | Windows.ApplicationModel.Store.Preview.StorePreviewSkuInfo[];
+    readonly Title: string;
+  }
+  var IStorePreviewProductInfo: abstract new (...args: any[]) => IStorePreviewProductInfo;
+
+  interface IStorePreviewPurchaseResults {
+    readonly ProductPurchaseStatus: number;
+  }
+  var IStorePreviewPurchaseResults: abstract new (...args: any[]) => IStorePreviewPurchaseResults;
+
+  interface IStorePreviewSkuInfo {
+    readonly CurrencyCode: string;
+    readonly CustomDeveloperData: string;
+    readonly Description: string;
+    readonly ExtendedData: string;
+    readonly FormattedListPrice: string;
+    readonly ProductId: string;
+    readonly SkuId: string;
+    readonly SkuType: string;
+    readonly Title: string;
+  }
+  var IStorePreviewSkuInfo: abstract new (...args: any[]) => IStorePreviewSkuInfo;
+
+  interface IWebAuthenticationCoreManagerHelper {
+    RequestTokenWithUIElementHostingAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest, uiElement: Windows.UI.Xaml.UIElement): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+    RequestTokenWithUIElementHostingAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest, webAccount: Windows.Security.Credentials.WebAccount, uiElement: Windows.UI.Xaml.UIElement): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+  }
+  var IWebAuthenticationCoreManagerHelper: abstract new (...args: any[]) => IWebAuthenticationCoreManagerHelper;
+
+}
+
+declare namespace Windows.ApplicationModel.Store.Preview.InstallControl {
+  class AppInstallItem implements Windows.ApplicationModel.Store.Preview.InstallControl.IAppInstallItem, Windows.ApplicationModel.Store.Preview.InstallControl.IAppInstallItem2, Windows.ApplicationModel.Store.Preview.InstallControl.IAppInstallItem3, Windows.ApplicationModel.Store.Preview.InstallControl.IAppInstallItem4, Windows.ApplicationModel.Store.Preview.InstallControl.IAppInstallItem5 {
+    Cancel(): void;
+    Cancel(correlationVector: string): void;
+    GetCurrentStatus(): Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallStatus;
+    Pause(): void;
+    Pause(correlationVector: string): void;
+    Restart(): void;
+    Restart(correlationVector: string): void;
+    readonly Children: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[];
+    CompletedInstallToastNotificationMode: number;
+    InstallInProgressToastNotificationMode: number;
+    readonly InstallType: number;
+    readonly IsUserInitiated: boolean;
+    readonly ItemOperationsMightAffectOtherItems: boolean;
+    LaunchAfterInstall: boolean;
+    readonly PackageFamilyName: string;
+    PinToDesktopAfterInstall: boolean;
+    PinToStartAfterInstall: boolean;
+    PinToTaskbarAfterInstall: boolean;
+    readonly ProductId: string;
+    Completed: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem, Object> | null;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem, Object> | null;
+  }
+
+  class AppInstallManager implements Windows.ApplicationModel.Store.Preview.InstallControl.IAppInstallManager, Windows.ApplicationModel.Store.Preview.InstallControl.IAppInstallManager2, Windows.ApplicationModel.Store.Preview.InstallControl.IAppInstallManager3, Windows.ApplicationModel.Store.Preview.InstallControl.IAppInstallManager4, Windows.ApplicationModel.Store.Preview.InstallControl.IAppInstallManager5, Windows.ApplicationModel.Store.Preview.InstallControl.IAppInstallManager6, Windows.ApplicationModel.Store.Preview.InstallControl.IAppInstallManager7 {
+    constructor();
+    Cancel(productId: string): void;
+    Cancel(productId: string, correlationVector: string): void;
+    GetFreeDeviceEntitlementAsync(storeId: string, campaignId: string, correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.GetEntitlementResult>;
+    GetFreeUserEntitlementAsync(storeId: string, campaignId: string, correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.GetEntitlementResult>;
+    GetFreeUserEntitlementForUserAsync(user: Windows.System.User, storeId: string, campaignId: string, correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.GetEntitlementResult>;
+    GetIsAppAllowedToInstallAsync(productId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    GetIsAppAllowedToInstallAsync(productId: string, skuId: string, catalogId: string, correlationVector: string): Windows.Foundation.IAsyncOperation<boolean>;
+    GetIsAppAllowedToInstallForUserAsync(user: Windows.System.User, productId: string, skuId: string, catalogId: string, correlationVector: string): Windows.Foundation.IAsyncOperation<boolean>;
+    GetIsApplicableAsync(productId: string, skuId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    GetIsApplicableForUserAsync(user: Windows.System.User, productId: string, skuId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    GetIsPackageIdentityAllowedToInstallAsync(correlationVector: string, packageIdentityName: string, publisherCertificateName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    GetIsPackageIdentityAllowedToInstallForUserAsync(user: Windows.System.User, correlationVector: string, packageIdentityName: string, publisherCertificateName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    IsStoreBlockedByPolicyAsync(storeClientName: string, storeClientPublisher: string): Windows.Foundation.IAsyncOperation<boolean>;
+    MoveToFrontOfDownloadQueue(productId: string, correlationVector: string): void;
+    Pause(productId: string): void;
+    Pause(productId: string, correlationVector: string): void;
+    Restart(productId: string): void;
+    Restart(productId: string, correlationVector: string): void;
+    SearchForAllUpdatesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[]>;
+    SearchForAllUpdatesAsync(correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[]>;
+    SearchForAllUpdatesAsync(correlationVector: string, clientId: string, updateOptions: Windows.ApplicationModel.Store.Preview.InstallControl.AppUpdateOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[]>;
+    SearchForAllUpdatesForUserAsync(user: Windows.System.User, correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[]>;
+    SearchForAllUpdatesForUserAsync(user: Windows.System.User, correlationVector: string, clientId: string, updateOptions: Windows.ApplicationModel.Store.Preview.InstallControl.AppUpdateOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[]>;
+    SearchForUpdatesAsync(productId: string, skuId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+    SearchForUpdatesAsync(productId: string, skuId: string, catalogId: string, correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+    SearchForUpdatesAsync(productId: string, skuId: string, correlationVector: string, clientId: string, updateOptions: Windows.ApplicationModel.Store.Preview.InstallControl.AppUpdateOptions): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+    SearchForUpdatesForUserAsync(user: Windows.System.User, productId: string, skuId: string, catalogId: string, correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+    SearchForUpdatesForUserAsync(user: Windows.System.User, productId: string, skuId: string, correlationVector: string, clientId: string, updateOptions: Windows.ApplicationModel.Store.Preview.InstallControl.AppUpdateOptions): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+    StartAppInstallAsync(productId: string, skuId: string, repair: boolean, forceUseOfNonRemovableStorage: boolean): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+    StartAppInstallAsync(productId: string, skuId: string, repair: boolean, forceUseOfNonRemovableStorage: boolean, catalogId: string, bundleId: string, correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+    StartProductInstallAsync(productId: string, catalogId: string, flightId: string, clientId: string, repair: boolean, forceUseOfNonRemovableStorage: boolean, correlationVector: string, targetVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[]>;
+    StartProductInstallAsync(productId: string, flightId: string, clientId: string, correlationVector: string, installOptions: Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[]>;
+    StartProductInstallForUserAsync(user: Windows.System.User, productId: string, catalogId: string, flightId: string, clientId: string, repair: boolean, forceUseOfNonRemovableStorage: boolean, correlationVector: string, targetVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[]>;
+    StartProductInstallForUserAsync(user: Windows.System.User, productId: string, flightId: string, clientId: string, correlationVector: string, installOptions: Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[]>;
+    UpdateAppByPackageFamilyNameAsync(packageFamilyName: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+    UpdateAppByPackageFamilyNameAsync(packageFamilyName: string, correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+    UpdateAppByPackageFamilyNameForUserAsync(user: Windows.System.User, packageFamilyName: string, correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+    AcquisitionIdentity: string;
+    readonly AppInstallItems: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[];
+    readonly AppInstallItemsWithGroupSupport: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[];
+    AutoUpdateSetting: number;
+    readonly CanInstallForAllUsers: boolean;
+    ItemCompleted: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager, Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs> | null;
+    ItemStatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager, Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs> | null;
+  }
+
+  class AppInstallManagerItemEventArgs implements Windows.ApplicationModel.Store.Preview.InstallControl.IAppInstallManagerItemEventArgs {
+    readonly Item: Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem;
+  }
+
+  class AppInstallOptions implements Windows.ApplicationModel.Store.Preview.InstallControl.IAppInstallOptions, Windows.ApplicationModel.Store.Preview.InstallControl.IAppInstallOptions2 {
+    constructor();
+    AllowForcedAppRestart: boolean;
+    CampaignId: string;
+    CatalogId: string;
+    CompletedInstallToastNotificationMode: number;
+    ExtendedCampaignId: string;
+    ForceUseOfNonRemovableStorage: boolean;
+    InstallForAllUsers: boolean;
+    InstallInProgressToastNotificationMode: number;
+    LaunchAfterInstall: boolean;
+    PinToDesktopAfterInstall: boolean;
+    PinToStartAfterInstall: boolean;
+    PinToTaskbarAfterInstall: boolean;
+    Repair: boolean;
+    StageButDoNotInstall: boolean;
+    TargetVolume: Windows.Management.Deployment.PackageVolume;
+  }
+
+  class AppInstallStatus implements Windows.ApplicationModel.Store.Preview.InstallControl.IAppInstallStatus, Windows.ApplicationModel.Store.Preview.InstallControl.IAppInstallStatus2, Windows.ApplicationModel.Store.Preview.InstallControl.IAppInstallStatus3 {
+    readonly BytesDownloaded: number | bigint;
+    readonly DownloadSizeInBytes: number | bigint;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly InstallState: number;
+    readonly IsStaged: boolean;
+    readonly PercentComplete: number;
+    readonly ReadyForLaunch: boolean;
+    readonly User: Windows.System.User;
+  }
+
+  class AppUpdateOptions implements Windows.ApplicationModel.Store.Preview.InstallControl.IAppUpdateOptions, Windows.ApplicationModel.Store.Preview.InstallControl.IAppUpdateOptions2 {
+    constructor();
+    AllowForcedAppRestart: boolean;
+    AutomaticallyDownloadAndInstallUpdateIfFound: boolean;
+    CatalogId: string;
+  }
+
+  class GetEntitlementResult implements Windows.ApplicationModel.Store.Preview.InstallControl.IGetEntitlementResult, Windows.ApplicationModel.Store.Preview.InstallControl.IGetEntitlementResult2 {
+    readonly AvailabilityId: string;
+    readonly IsAlreadyOwned: boolean;
+    readonly OrderId: string;
+    readonly SkuId: string;
+    readonly Status: number;
+  }
+
+  enum AppInstallState {
+    Pending = 0,
+    Starting = 1,
+    AcquiringLicense = 2,
+    Downloading = 3,
+    RestoringData = 4,
+    Installing = 5,
+    Completed = 6,
+    Canceled = 7,
+    Paused = 8,
+    Error = 9,
+    PausedLowBattery = 10,
+    PausedWiFiRecommended = 11,
+    PausedWiFiRequired = 12,
+    ReadyToDownload = 13,
+  }
+
+  enum AppInstallType {
+    Install = 0,
+    Update = 1,
+    Repair = 2,
+  }
+
+  enum AppInstallationToastNotificationMode {
+    Default = 0,
+    Toast = 1,
+    ToastWithoutPopup = 2,
+    NoToast = 3,
+  }
+
+  enum AutoUpdateSetting {
+    Disabled = 0,
+    Enabled = 1,
+    DisabledByPolicy = 2,
+    EnabledByPolicy = 3,
+  }
+
+  enum GetEntitlementStatus {
+    Succeeded = 0,
+    NoStoreAccount = 1,
+    NetworkError = 2,
+    ServerError = 3,
+  }
+
+  interface IAppInstallItem {
+    Cancel(): void;
+    GetCurrentStatus(): Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallStatus;
+    Pause(): void;
+    Restart(): void;
+    readonly InstallType: number;
+    readonly IsUserInitiated: boolean;
+    readonly PackageFamilyName: string;
+    readonly ProductId: string;
+    Completed: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem, Object> | null;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem, Object> | null;
+  }
+  var IAppInstallItem: abstract new (...args: any[]) => IAppInstallItem;
+
+  interface IAppInstallItem2 {
+    Cancel(correlationVector: string): void;
+    Pause(correlationVector: string): void;
+    Restart(correlationVector: string): void;
+  }
+  var IAppInstallItem2: abstract new (...args: any[]) => IAppInstallItem2;
+
+  interface IAppInstallItem3 {
+    readonly Children: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[];
+    readonly ItemOperationsMightAffectOtherItems: boolean;
+  }
+  var IAppInstallItem3: abstract new (...args: any[]) => IAppInstallItem3;
+
+  interface IAppInstallItem4 {
+    LaunchAfterInstall: boolean;
+  }
+  var IAppInstallItem4: abstract new (...args: any[]) => IAppInstallItem4;
+
+  interface IAppInstallItem5 {
+    CompletedInstallToastNotificationMode: number;
+    InstallInProgressToastNotificationMode: number;
+    PinToDesktopAfterInstall: boolean;
+    PinToStartAfterInstall: boolean;
+    PinToTaskbarAfterInstall: boolean;
+  }
+  var IAppInstallItem5: abstract new (...args: any[]) => IAppInstallItem5;
+
+  interface IAppInstallManager {
+    Cancel(productId: string): void;
+    GetIsAppAllowedToInstallAsync(productId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    GetIsApplicableAsync(productId: string, skuId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    IsStoreBlockedByPolicyAsync(storeClientName: string, storeClientPublisher: string): Windows.Foundation.IAsyncOperation<boolean>;
+    Pause(productId: string): void;
+    Restart(productId: string): void;
+    SearchForAllUpdatesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[]>;
+    SearchForUpdatesAsync(productId: string, skuId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+    StartAppInstallAsync(productId: string, skuId: string, repair: boolean, forceUseOfNonRemovableStorage: boolean): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+    UpdateAppByPackageFamilyNameAsync(packageFamilyName: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+    AcquisitionIdentity: string;
+    readonly AppInstallItems: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[];
+    AutoUpdateSetting: number;
+    ItemCompleted: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager, Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs> | null;
+    ItemStatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManager, Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallManagerItemEventArgs> | null;
+  }
+  var IAppInstallManager: abstract new (...args: any[]) => IAppInstallManager;
+
+  interface IAppInstallManager2 {
+    Cancel(productId: string, correlationVector: string): void;
+    GetIsAppAllowedToInstallAsync(productId: string, skuId: string, catalogId: string, correlationVector: string): Windows.Foundation.IAsyncOperation<boolean>;
+    Pause(productId: string, correlationVector: string): void;
+    Restart(productId: string, correlationVector: string): void;
+    SearchForAllUpdatesAsync(correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[]>;
+    SearchForUpdatesAsync(productId: string, skuId: string, catalogId: string, correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+    StartAppInstallAsync(productId: string, skuId: string, repair: boolean, forceUseOfNonRemovableStorage: boolean, catalogId: string, bundleId: string, correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+    UpdateAppByPackageFamilyNameAsync(packageFamilyName: string, correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+  }
+  var IAppInstallManager2: abstract new (...args: any[]) => IAppInstallManager2;
+
+  interface IAppInstallManager3 {
+    GetIsAppAllowedToInstallForUserAsync(user: Windows.System.User, productId: string, skuId: string, catalogId: string, correlationVector: string): Windows.Foundation.IAsyncOperation<boolean>;
+    GetIsApplicableForUserAsync(user: Windows.System.User, productId: string, skuId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    MoveToFrontOfDownloadQueue(productId: string, correlationVector: string): void;
+    SearchForAllUpdatesForUserAsync(user: Windows.System.User, correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[]>;
+    SearchForUpdatesForUserAsync(user: Windows.System.User, productId: string, skuId: string, catalogId: string, correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+    StartProductInstallAsync(productId: string, catalogId: string, flightId: string, clientId: string, repair: boolean, forceUseOfNonRemovableStorage: boolean, correlationVector: string, targetVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[]>;
+    StartProductInstallForUserAsync(user: Windows.System.User, productId: string, catalogId: string, flightId: string, clientId: string, repair: boolean, forceUseOfNonRemovableStorage: boolean, correlationVector: string, targetVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[]>;
+    UpdateAppByPackageFamilyNameForUserAsync(user: Windows.System.User, packageFamilyName: string, correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+  }
+  var IAppInstallManager3: abstract new (...args: any[]) => IAppInstallManager3;
+
+  interface IAppInstallManager4 {
+    GetFreeDeviceEntitlementAsync(storeId: string, campaignId: string, correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.GetEntitlementResult>;
+    GetFreeUserEntitlementAsync(storeId: string, campaignId: string, correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.GetEntitlementResult>;
+    GetFreeUserEntitlementForUserAsync(user: Windows.System.User, storeId: string, campaignId: string, correlationVector: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.GetEntitlementResult>;
+  }
+  var IAppInstallManager4: abstract new (...args: any[]) => IAppInstallManager4;
+
+  interface IAppInstallManager5 {
+    readonly AppInstallItemsWithGroupSupport: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[];
+  }
+  var IAppInstallManager5: abstract new (...args: any[]) => IAppInstallManager5;
+
+  interface IAppInstallManager6 {
+    GetIsPackageIdentityAllowedToInstallAsync(correlationVector: string, packageIdentityName: string, publisherCertificateName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    GetIsPackageIdentityAllowedToInstallForUserAsync(user: Windows.System.User, correlationVector: string, packageIdentityName: string, publisherCertificateName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    SearchForAllUpdatesAsync(correlationVector: string, clientId: string, updateOptions: Windows.ApplicationModel.Store.Preview.InstallControl.AppUpdateOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[]>;
+    SearchForAllUpdatesForUserAsync(user: Windows.System.User, correlationVector: string, clientId: string, updateOptions: Windows.ApplicationModel.Store.Preview.InstallControl.AppUpdateOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[]>;
+    SearchForUpdatesAsync(productId: string, skuId: string, correlationVector: string, clientId: string, updateOptions: Windows.ApplicationModel.Store.Preview.InstallControl.AppUpdateOptions): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+    SearchForUpdatesForUserAsync(user: Windows.System.User, productId: string, skuId: string, correlationVector: string, clientId: string, updateOptions: Windows.ApplicationModel.Store.Preview.InstallControl.AppUpdateOptions): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem>;
+    StartProductInstallAsync(productId: string, flightId: string, clientId: string, correlationVector: string, installOptions: Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[]>;
+    StartProductInstallForUserAsync(user: Windows.System.User, productId: string, flightId: string, clientId: string, correlationVector: string, installOptions: Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallOptions): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem> | Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem[]>;
+  }
+  var IAppInstallManager6: abstract new (...args: any[]) => IAppInstallManager6;
+
+  interface IAppInstallManager7 {
+    readonly CanInstallForAllUsers: boolean;
+  }
+  var IAppInstallManager7: abstract new (...args: any[]) => IAppInstallManager7;
+
+  interface IAppInstallManagerItemEventArgs {
+    readonly Item: Windows.ApplicationModel.Store.Preview.InstallControl.AppInstallItem;
+  }
+  var IAppInstallManagerItemEventArgs: abstract new (...args: any[]) => IAppInstallManagerItemEventArgs;
+
+  interface IAppInstallOptions {
+    AllowForcedAppRestart: boolean;
+    CatalogId: string;
+    ForceUseOfNonRemovableStorage: boolean;
+    LaunchAfterInstall: boolean;
+    Repair: boolean;
+    TargetVolume: Windows.Management.Deployment.PackageVolume;
+  }
+  var IAppInstallOptions: abstract new (...args: any[]) => IAppInstallOptions;
+
+  interface IAppInstallOptions2 {
+    CampaignId: string;
+    CompletedInstallToastNotificationMode: number;
+    ExtendedCampaignId: string;
+    InstallForAllUsers: boolean;
+    InstallInProgressToastNotificationMode: number;
+    PinToDesktopAfterInstall: boolean;
+    PinToStartAfterInstall: boolean;
+    PinToTaskbarAfterInstall: boolean;
+    StageButDoNotInstall: boolean;
+  }
+  var IAppInstallOptions2: abstract new (...args: any[]) => IAppInstallOptions2;
+
+  interface IAppInstallStatus {
+    readonly BytesDownloaded: number | bigint;
+    readonly DownloadSizeInBytes: number | bigint;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly InstallState: number;
+    readonly PercentComplete: number;
+  }
+  var IAppInstallStatus: abstract new (...args: any[]) => IAppInstallStatus;
+
+  interface IAppInstallStatus2 {
+    readonly ReadyForLaunch: boolean;
+    readonly User: Windows.System.User;
+  }
+  var IAppInstallStatus2: abstract new (...args: any[]) => IAppInstallStatus2;
+
+  interface IAppInstallStatus3 {
+    readonly IsStaged: boolean;
+  }
+  var IAppInstallStatus3: abstract new (...args: any[]) => IAppInstallStatus3;
+
+  interface IAppUpdateOptions {
+    AllowForcedAppRestart: boolean;
+    CatalogId: string;
+  }
+  var IAppUpdateOptions: abstract new (...args: any[]) => IAppUpdateOptions;
+
+  interface IAppUpdateOptions2 {
+    AutomaticallyDownloadAndInstallUpdateIfFound: boolean;
+  }
+  var IAppUpdateOptions2: abstract new (...args: any[]) => IAppUpdateOptions2;
+
+  interface IGetEntitlementResult {
+    readonly Status: number;
+  }
+  var IGetEntitlementResult: abstract new (...args: any[]) => IGetEntitlementResult;
+
+  interface IGetEntitlementResult2 {
+    readonly AvailabilityId: string;
+    readonly IsAlreadyOwned: boolean;
+    readonly OrderId: string;
+    readonly SkuId: string;
+  }
+  var IGetEntitlementResult2: abstract new (...args: any[]) => IGetEntitlementResult2;
+
+}
+
+declare namespace Windows.ApplicationModel.UserActivities {
+  class UserActivity implements Windows.ApplicationModel.UserActivities.IUserActivity, Windows.ApplicationModel.UserActivities.IUserActivity2, Windows.ApplicationModel.UserActivities.IUserActivity3 {
+    constructor(activityId: string);
+    CreateSession(): Windows.ApplicationModel.UserActivities.UserActivitySession;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    ToJson(): string;
+    static ToJsonArray(activities: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.UserActivities.UserActivity> | Windows.ApplicationModel.UserActivities.UserActivity[]): string;
+    static TryParseFromJson(json: string): Windows.ApplicationModel.UserActivities.UserActivity;
+    static TryParseFromJsonArray(json: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.UserActivities.UserActivity> | Windows.ApplicationModel.UserActivities.UserActivity[];
+    ActivationUri: Windows.Foundation.Uri;
+    readonly ActivityId: string;
+    ContentInfo: Windows.ApplicationModel.UserActivities.IUserActivityContentInfo;
+    ContentType: string;
+    ContentUri: Windows.Foundation.Uri;
+    FallbackUri: Windows.Foundation.Uri;
+    IsRoamable: boolean;
+    readonly State: number;
+    readonly VisualElements: Windows.ApplicationModel.UserActivities.UserActivityVisualElements;
+  }
+
+  class UserActivityAttribution implements Windows.ApplicationModel.UserActivities.IUserActivityAttribution {
+    constructor(iconUri: Windows.Foundation.Uri);
+    constructor();
+    AddImageQuery: boolean;
+    AlternateText: string;
+    IconUri: Windows.Foundation.Uri;
+  }
+
+  class UserActivityChannel implements Windows.ApplicationModel.UserActivities.IUserActivityChannel, Windows.ApplicationModel.UserActivities.IUserActivityChannel2 {
+    DeleteActivityAsync(activityId: string): Windows.Foundation.IAsyncAction;
+    DeleteAllActivitiesAsync(): Windows.Foundation.IAsyncAction;
+    static DisableAutoSessionCreation(): void;
+    static GetDefault(): Windows.ApplicationModel.UserActivities.UserActivityChannel;
+    static GetForUser(user: Windows.System.User): Windows.ApplicationModel.UserActivities.UserActivityChannel;
+    GetOrCreateUserActivityAsync(activityId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserActivities.UserActivity>;
+    GetRecentUserActivitiesAsync(maxUniqueActivities: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.ApplicationModel.UserActivities.UserActivitySessionHistoryItem> | Windows.ApplicationModel.UserActivities.UserActivitySessionHistoryItem[]>;
+    GetSessionHistoryItemsForUserActivityAsync(activityId: string, startTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.ApplicationModel.UserActivities.UserActivitySessionHistoryItem> | Windows.ApplicationModel.UserActivities.UserActivitySessionHistoryItem[]>;
+    static TryGetForWebAccount(account: Windows.Security.Credentials.WebAccount): Windows.ApplicationModel.UserActivities.UserActivityChannel;
+  }
+
+  class UserActivityContentInfo implements Windows.ApplicationModel.UserActivities.IUserActivityContentInfo {
+    static FromJson(value: string): Windows.ApplicationModel.UserActivities.UserActivityContentInfo;
+    ToJson(): string;
+  }
+
+  class UserActivityRequest implements Windows.ApplicationModel.UserActivities.IUserActivityRequest {
+    SetUserActivity(activity: Windows.ApplicationModel.UserActivities.UserActivity): void;
+  }
+
+  class UserActivityRequestManager implements Windows.ApplicationModel.UserActivities.IUserActivityRequestManager {
+    static GetForCurrentView(): Windows.ApplicationModel.UserActivities.UserActivityRequestManager;
+    UserActivityRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.UserActivities.UserActivityRequestManager, Windows.ApplicationModel.UserActivities.UserActivityRequestedEventArgs> | null;
+  }
+
+  class UserActivityRequestedEventArgs implements Windows.ApplicationModel.UserActivities.IUserActivityRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.UserActivities.UserActivityRequest;
+  }
+
+  class UserActivitySession implements Windows.ApplicationModel.UserActivities.IUserActivitySession, Windows.Foundation.IClosable {
+    Close(): void;
+    readonly ActivityId: string;
+  }
+
+  class UserActivitySessionHistoryItem implements Windows.ApplicationModel.UserActivities.IUserActivitySessionHistoryItem {
+    readonly EndTime: Windows.Foundation.DateTime | null;
+    readonly StartTime: Windows.Foundation.DateTime;
+    readonly UserActivity: Windows.ApplicationModel.UserActivities.UserActivity;
+  }
+
+  class UserActivityVisualElements implements Windows.ApplicationModel.UserActivities.IUserActivityVisualElements, Windows.ApplicationModel.UserActivities.IUserActivityVisualElements2 {
+    Attribution: Windows.ApplicationModel.UserActivities.UserActivityAttribution;
+    AttributionDisplayText: string;
+    BackgroundColor: Windows.UI.Color;
+    Content: Windows.UI.Shell.IAdaptiveCard;
+    Description: string;
+    DisplayText: string;
+  }
+
+  enum UserActivityState {
+    New = 0,
+    Published = 1,
+  }
+
+  interface IUserActivity {
+    CreateSession(): Windows.ApplicationModel.UserActivities.UserActivitySession;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    ActivationUri: Windows.Foundation.Uri;
+    readonly ActivityId: string;
+    ContentInfo: Windows.ApplicationModel.UserActivities.IUserActivityContentInfo;
+    ContentType: string;
+    ContentUri: Windows.Foundation.Uri;
+    FallbackUri: Windows.Foundation.Uri;
+    readonly State: number;
+    readonly VisualElements: Windows.ApplicationModel.UserActivities.UserActivityVisualElements;
+  }
+  var IUserActivity: abstract new (...args: any[]) => IUserActivity;
+
+  interface IUserActivity2 {
+    ToJson(): string;
+  }
+  var IUserActivity2: abstract new (...args: any[]) => IUserActivity2;
+
+  interface IUserActivity3 {
+    IsRoamable: boolean;
+  }
+  var IUserActivity3: abstract new (...args: any[]) => IUserActivity3;
+
+  interface IUserActivityAttribution {
+    AddImageQuery: boolean;
+    AlternateText: string;
+    IconUri: Windows.Foundation.Uri;
+  }
+  var IUserActivityAttribution: abstract new (...args: any[]) => IUserActivityAttribution;
+
+  interface IUserActivityAttributionFactory {
+    CreateWithUri(iconUri: Windows.Foundation.Uri): Windows.ApplicationModel.UserActivities.UserActivityAttribution;
+  }
+  var IUserActivityAttributionFactory: abstract new (...args: any[]) => IUserActivityAttributionFactory;
+
+  interface IUserActivityChannel {
+    DeleteActivityAsync(activityId: string): Windows.Foundation.IAsyncAction;
+    DeleteAllActivitiesAsync(): Windows.Foundation.IAsyncAction;
+    GetOrCreateUserActivityAsync(activityId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserActivities.UserActivity>;
+  }
+  var IUserActivityChannel: abstract new (...args: any[]) => IUserActivityChannel;
+
+  interface IUserActivityChannel2 {
+    GetRecentUserActivitiesAsync(maxUniqueActivities: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.ApplicationModel.UserActivities.UserActivitySessionHistoryItem> | Windows.ApplicationModel.UserActivities.UserActivitySessionHistoryItem[]>;
+    GetSessionHistoryItemsForUserActivityAsync(activityId: string, startTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.ApplicationModel.UserActivities.UserActivitySessionHistoryItem> | Windows.ApplicationModel.UserActivities.UserActivitySessionHistoryItem[]>;
+  }
+  var IUserActivityChannel2: abstract new (...args: any[]) => IUserActivityChannel2;
+
+  interface IUserActivityChannelStatics {
+    GetDefault(): Windows.ApplicationModel.UserActivities.UserActivityChannel;
+  }
+  var IUserActivityChannelStatics: abstract new (...args: any[]) => IUserActivityChannelStatics;
+
+  interface IUserActivityChannelStatics2 {
+    DisableAutoSessionCreation(): void;
+    TryGetForWebAccount(account: Windows.Security.Credentials.WebAccount): Windows.ApplicationModel.UserActivities.UserActivityChannel;
+  }
+  var IUserActivityChannelStatics2: abstract new (...args: any[]) => IUserActivityChannelStatics2;
+
+  interface IUserActivityChannelStatics3 {
+    GetForUser(user: Windows.System.User): Windows.ApplicationModel.UserActivities.UserActivityChannel;
+  }
+  var IUserActivityChannelStatics3: abstract new (...args: any[]) => IUserActivityChannelStatics3;
+
+  interface IUserActivityContentInfo {
+    ToJson(): string;
+  }
+  var IUserActivityContentInfo: abstract new (...args: any[]) => IUserActivityContentInfo;
+
+  interface IUserActivityContentInfoStatics {
+    FromJson(value: string): Windows.ApplicationModel.UserActivities.UserActivityContentInfo;
+  }
+  var IUserActivityContentInfoStatics: abstract new (...args: any[]) => IUserActivityContentInfoStatics;
+
+  interface IUserActivityFactory {
+    CreateWithActivityId(activityId: string): Windows.ApplicationModel.UserActivities.UserActivity;
+  }
+  var IUserActivityFactory: abstract new (...args: any[]) => IUserActivityFactory;
+
+  interface IUserActivityRequest {
+    SetUserActivity(activity: Windows.ApplicationModel.UserActivities.UserActivity): void;
+  }
+  var IUserActivityRequest: abstract new (...args: any[]) => IUserActivityRequest;
+
+  interface IUserActivityRequestManager {
+    UserActivityRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.UserActivities.UserActivityRequestManager, Windows.ApplicationModel.UserActivities.UserActivityRequestedEventArgs> | null;
+  }
+  var IUserActivityRequestManager: abstract new (...args: any[]) => IUserActivityRequestManager;
+
+  interface IUserActivityRequestManagerStatics {
+    GetForCurrentView(): Windows.ApplicationModel.UserActivities.UserActivityRequestManager;
+  }
+  var IUserActivityRequestManagerStatics: abstract new (...args: any[]) => IUserActivityRequestManagerStatics;
+
+  interface IUserActivityRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.UserActivities.UserActivityRequest;
+  }
+  var IUserActivityRequestedEventArgs: abstract new (...args: any[]) => IUserActivityRequestedEventArgs;
+
+  interface IUserActivitySession {
+    readonly ActivityId: string;
+  }
+  var IUserActivitySession: abstract new (...args: any[]) => IUserActivitySession;
+
+  interface IUserActivitySessionHistoryItem {
+    readonly EndTime: Windows.Foundation.DateTime | null;
+    readonly StartTime: Windows.Foundation.DateTime;
+    readonly UserActivity: Windows.ApplicationModel.UserActivities.UserActivity;
+  }
+  var IUserActivitySessionHistoryItem: abstract new (...args: any[]) => IUserActivitySessionHistoryItem;
+
+  interface IUserActivityStatics {
+    ToJsonArray(activities: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.UserActivities.UserActivity> | Windows.ApplicationModel.UserActivities.UserActivity[]): string;
+    TryParseFromJson(json: string): Windows.ApplicationModel.UserActivities.UserActivity;
+    TryParseFromJsonArray(json: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.UserActivities.UserActivity> | Windows.ApplicationModel.UserActivities.UserActivity[];
+  }
+  var IUserActivityStatics: abstract new (...args: any[]) => IUserActivityStatics;
+
+  interface IUserActivityVisualElements {
+    Attribution: Windows.ApplicationModel.UserActivities.UserActivityAttribution;
+    BackgroundColor: Windows.UI.Color;
+    Content: Windows.UI.Shell.IAdaptiveCard;
+    Description: string;
+    DisplayText: string;
+  }
+  var IUserActivityVisualElements: abstract new (...args: any[]) => IUserActivityVisualElements;
+
+  interface IUserActivityVisualElements2 {
+    AttributionDisplayText: string;
+  }
+  var IUserActivityVisualElements2: abstract new (...args: any[]) => IUserActivityVisualElements2;
+
+}
+
+declare namespace Windows.ApplicationModel.UserActivities.Core {
+  class CoreUserActivityManager {
+    static CreateUserActivitySessionInBackground(activity: Windows.ApplicationModel.UserActivities.UserActivity): Windows.ApplicationModel.UserActivities.UserActivitySession;
+    static DeleteUserActivitySessionsInTimeRangeAsync(channel: Windows.ApplicationModel.UserActivities.UserActivityChannel, startTime: Windows.Foundation.DateTime, endTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncAction;
+  }
+
+  interface ICoreUserActivityManagerStatics {
+    CreateUserActivitySessionInBackground(activity: Windows.ApplicationModel.UserActivities.UserActivity): Windows.ApplicationModel.UserActivities.UserActivitySession;
+    DeleteUserActivitySessionsInTimeRangeAsync(channel: Windows.ApplicationModel.UserActivities.UserActivityChannel, startTime: Windows.Foundation.DateTime, endTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncAction;
+  }
+  var ICoreUserActivityManagerStatics: abstract new (...args: any[]) => ICoreUserActivityManagerStatics;
+
+}
+
+declare namespace Windows.ApplicationModel.UserDataAccounts {
+  class UserDataAccount implements Windows.ApplicationModel.UserDataAccounts.IUserDataAccount, Windows.ApplicationModel.UserDataAccounts.IUserDataAccount2, Windows.ApplicationModel.UserDataAccounts.IUserDataAccount3, Windows.ApplicationModel.UserDataAccounts.IUserDataAccount4 {
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    FindAppointmentCalendarsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.AppointmentCalendar> | Windows.ApplicationModel.Appointments.AppointmentCalendar[]>;
+    FindContactAnnotationListsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactAnnotationList> | Windows.ApplicationModel.Contacts.ContactAnnotationList[]>;
+    FindContactGroupsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactGroup> | Windows.ApplicationModel.Contacts.ContactGroup[]>;
+    FindContactListsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactList> | Windows.ApplicationModel.Contacts.ContactList[]>;
+    FindEmailMailboxesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailMailbox> | Windows.ApplicationModel.Email.EmailMailbox[]>;
+    FindUserDataTaskListsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.UserDataTasks.UserDataTaskList> | Windows.ApplicationModel.UserDataTasks.UserDataTaskList[]>;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    TryShowCreateContactGroupAsync(): Windows.Foundation.IAsyncOperation<string>;
+    CanShowCreateContactGroup: boolean;
+    readonly DeviceAccountTypeId: string;
+    DisplayName: string;
+    readonly EnterpriseId: string;
+    readonly ExplictReadAccessPackageFamilyNames: Windows.Foundation.Collections.IVector<string> | string[];
+    Icon: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly Id: string;
+    IsProtectedUnderLock: boolean;
+    OtherAppReadAccess: number;
+    readonly PackageFamilyName: string;
+    readonly ProviderProperties: Windows.Foundation.Collections.IPropertySet;
+    UserDisplayName: string;
+  }
+
+  class UserDataAccountManager {
+    static GetForUser(user: Windows.System.User): Windows.ApplicationModel.UserDataAccounts.UserDataAccountManagerForUser;
+    static RequestStoreAsync(storeAccessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore>;
+    static ShowAccountErrorResolverAsync(id: string): Windows.Foundation.IAsyncAction;
+    static ShowAccountSettingsAsync(id: string): Windows.Foundation.IAsyncAction;
+    static ShowAddAccountAsync(contentKinds: number): Windows.Foundation.IAsyncOperation<string>;
+  }
+
+  class UserDataAccountManagerForUser implements Windows.ApplicationModel.UserDataAccounts.IUserDataAccountManagerForUser {
+    RequestStoreAsync(storeAccessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore>;
+    readonly User: Windows.System.User;
+  }
+
+  class UserDataAccountStore implements Windows.ApplicationModel.UserDataAccounts.IUserDataAccountStore, Windows.ApplicationModel.UserDataAccounts.IUserDataAccountStore2, Windows.ApplicationModel.UserDataAccounts.IUserDataAccountStore3 {
+    CreateAccountAsync(userDisplayName: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataAccounts.UserDataAccount>;
+    CreateAccountAsync(userDisplayName: string, packageRelativeAppId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataAccounts.UserDataAccount>;
+    CreateAccountAsync(userDisplayName: string, packageRelativeAppId: string, enterpriseId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataAccounts.UserDataAccount>;
+    FindAccountsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.UserDataAccounts.UserDataAccount> | Windows.ApplicationModel.UserDataAccounts.UserDataAccount[]>;
+    GetAccountAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataAccounts.UserDataAccount>;
+    StoreChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore, Windows.ApplicationModel.UserDataAccounts.UserDataAccountStoreChangedEventArgs> | null;
+  }
+
+  class UserDataAccountStoreChangedEventArgs implements Windows.ApplicationModel.UserDataAccounts.IUserDataAccountStoreChangedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+
+  enum UserDataAccountContentKinds {
+    Email = 1,
+    Contact = 2,
+    Appointment = 4,
+  }
+
+  enum UserDataAccountOtherAppReadAccess {
+    SystemOnly = 0,
+    Full = 1,
+    None = 2,
+  }
+
+  enum UserDataAccountStoreAccessType {
+    AllAccountsReadOnly = 0,
+    AppAccountsReadWrite = 1,
+  }
+
+  interface IUserDataAccount {
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    FindAppointmentCalendarsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.AppointmentCalendar> | Windows.ApplicationModel.Appointments.AppointmentCalendar[]>;
+    FindContactAnnotationListsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactAnnotationList> | Windows.ApplicationModel.Contacts.ContactAnnotationList[]>;
+    FindContactListsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactList> | Windows.ApplicationModel.Contacts.ContactList[]>;
+    FindEmailMailboxesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailMailbox> | Windows.ApplicationModel.Email.EmailMailbox[]>;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    readonly DeviceAccountTypeId: string;
+    readonly Icon: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly Id: string;
+    OtherAppReadAccess: number;
+    readonly PackageFamilyName: string;
+    UserDisplayName: string;
+  }
+  var IUserDataAccount: abstract new (...args: any[]) => IUserDataAccount;
+
+  interface IUserDataAccount2 extends Windows.ApplicationModel.UserDataAccounts.IUserDataAccount {
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    FindAppointmentCalendarsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Appointments.AppointmentCalendar> | Windows.ApplicationModel.Appointments.AppointmentCalendar[]>;
+    FindContactAnnotationListsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactAnnotationList> | Windows.ApplicationModel.Contacts.ContactAnnotationList[]>;
+    FindContactListsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactList> | Windows.ApplicationModel.Contacts.ContactList[]>;
+    FindEmailMailboxesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Email.EmailMailbox> | Windows.ApplicationModel.Email.EmailMailbox[]>;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    readonly EnterpriseId: string;
+    readonly IsProtectedUnderLock: boolean;
+  }
+  var IUserDataAccount2: abstract new (...args: any[]) => IUserDataAccount2;
+
+  interface IUserDataAccount3 {
+    DisplayName: string;
+    readonly ExplictReadAccessPackageFamilyNames: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var IUserDataAccount3: abstract new (...args: any[]) => IUserDataAccount3;
+
+  interface IUserDataAccount4 {
+    FindContactGroupsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Contacts.ContactGroup> | Windows.ApplicationModel.Contacts.ContactGroup[]>;
+    FindUserDataTaskListsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.UserDataTasks.UserDataTaskList> | Windows.ApplicationModel.UserDataTasks.UserDataTaskList[]>;
+    TryShowCreateContactGroupAsync(): Windows.Foundation.IAsyncOperation<string>;
+    CanShowCreateContactGroup: boolean;
+    Icon: Object;
+    IsProtectedUnderLock: Object;
+    readonly ProviderProperties: Windows.Foundation.Collections.IPropertySet;
+  }
+  var IUserDataAccount4: abstract new (...args: any[]) => IUserDataAccount4;
+
+  interface IUserDataAccountManagerForUser {
+    RequestStoreAsync(storeAccessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore>;
+    readonly User: Windows.System.User;
+  }
+  var IUserDataAccountManagerForUser: abstract new (...args: any[]) => IUserDataAccountManagerForUser;
+
+  interface IUserDataAccountManagerStatics {
+    RequestStoreAsync(storeAccessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore>;
+    ShowAccountErrorResolverAsync(id: string): Windows.Foundation.IAsyncAction;
+    ShowAccountSettingsAsync(id: string): Windows.Foundation.IAsyncAction;
+    ShowAddAccountAsync(contentKinds: number): Windows.Foundation.IAsyncOperation<string>;
+  }
+  var IUserDataAccountManagerStatics: abstract new (...args: any[]) => IUserDataAccountManagerStatics;
+
+  interface IUserDataAccountManagerStatics2 {
+    GetForUser(user: Windows.System.User): Windows.ApplicationModel.UserDataAccounts.UserDataAccountManagerForUser;
+  }
+  var IUserDataAccountManagerStatics2: abstract new (...args: any[]) => IUserDataAccountManagerStatics2;
+
+  interface IUserDataAccountStore {
+    CreateAccountAsync(userDisplayName: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataAccounts.UserDataAccount>;
+    FindAccountsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.UserDataAccounts.UserDataAccount> | Windows.ApplicationModel.UserDataAccounts.UserDataAccount[]>;
+    GetAccountAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataAccounts.UserDataAccount>;
+  }
+  var IUserDataAccountStore: abstract new (...args: any[]) => IUserDataAccountStore;
+
+  interface IUserDataAccountStore2 extends Windows.ApplicationModel.UserDataAccounts.IUserDataAccountStore {
+    CreateAccountAsync(userDisplayName: string, packageRelativeAppId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataAccounts.UserDataAccount>;
+    CreateAccountAsync(userDisplayName: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataAccounts.UserDataAccount>;
+    FindAccountsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.UserDataAccounts.UserDataAccount> | Windows.ApplicationModel.UserDataAccounts.UserDataAccount[]>;
+    GetAccountAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataAccounts.UserDataAccount>;
+    StoreChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.UserDataAccounts.UserDataAccountStore, Windows.ApplicationModel.UserDataAccounts.UserDataAccountStoreChangedEventArgs> | null;
+  }
+  var IUserDataAccountStore2: abstract new (...args: any[]) => IUserDataAccountStore2;
+
+  interface IUserDataAccountStore3 extends Windows.ApplicationModel.UserDataAccounts.IUserDataAccountStore {
+    CreateAccountAsync(userDisplayName: string, packageRelativeAppId: string, enterpriseId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataAccounts.UserDataAccount>;
+    CreateAccountAsync(userDisplayName: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataAccounts.UserDataAccount>;
+    FindAccountsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.UserDataAccounts.UserDataAccount> | Windows.ApplicationModel.UserDataAccounts.UserDataAccount[]>;
+    GetAccountAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataAccounts.UserDataAccount>;
+  }
+  var IUserDataAccountStore3: abstract new (...args: any[]) => IUserDataAccountStore3;
+
+  interface IUserDataAccountStoreChangedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+  var IUserDataAccountStoreChangedEventArgs: abstract new (...args: any[]) => IUserDataAccountStoreChangedEventArgs;
+
+}
+
+declare namespace Windows.ApplicationModel.UserDataAccounts.Provider {
+  class UserDataAccountPartnerAccountInfo implements Windows.ApplicationModel.UserDataAccounts.Provider.IUserDataAccountPartnerAccountInfo {
+    readonly AccountKind: number;
+    readonly DisplayName: string;
+    readonly Priority: number;
+  }
+
+  class UserDataAccountProviderAddAccountOperation implements Windows.ApplicationModel.UserDataAccounts.Provider.IUserDataAccountProviderAddAccountOperation, Windows.ApplicationModel.UserDataAccounts.Provider.IUserDataAccountProviderOperation {
+    ReportCompleted(userDataAccountId: string): void;
+    readonly ContentKinds: number;
+    readonly Kind: number;
+    readonly PartnerAccountInfos: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.UserDataAccounts.Provider.UserDataAccountPartnerAccountInfo> | Windows.ApplicationModel.UserDataAccounts.Provider.UserDataAccountPartnerAccountInfo[];
+  }
+
+  class UserDataAccountProviderResolveErrorsOperation implements Windows.ApplicationModel.UserDataAccounts.Provider.IUserDataAccountProviderOperation, Windows.ApplicationModel.UserDataAccounts.Provider.IUserDataAccountProviderResolveErrorsOperation {
+    ReportCompleted(): void;
+    readonly Kind: number;
+    readonly UserDataAccountId: string;
+  }
+
+  class UserDataAccountProviderSettingsOperation implements Windows.ApplicationModel.UserDataAccounts.Provider.IUserDataAccountProviderOperation, Windows.ApplicationModel.UserDataAccounts.Provider.IUserDataAccountProviderSettingsOperation {
+    ReportCompleted(): void;
+    readonly Kind: number;
+    readonly UserDataAccountId: string;
+  }
+
+  enum UserDataAccountProviderOperationKind {
+    AddAccount = 0,
+    Settings = 1,
+    ResolveErrors = 2,
+  }
+
+  enum UserDataAccountProviderPartnerAccountKind {
+    Exchange = 0,
+    PopOrImap = 1,
+  }
+
+  interface IUserDataAccountPartnerAccountInfo {
+    readonly AccountKind: number;
+    readonly DisplayName: string;
+    readonly Priority: number;
+  }
+  var IUserDataAccountPartnerAccountInfo: abstract new (...args: any[]) => IUserDataAccountPartnerAccountInfo;
+
+  interface IUserDataAccountProviderAddAccountOperation extends Windows.ApplicationModel.UserDataAccounts.Provider.IUserDataAccountProviderOperation {
+    ReportCompleted(userDataAccountId: string): void;
+    readonly ContentKinds: number;
+    readonly PartnerAccountInfos: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.UserDataAccounts.Provider.UserDataAccountPartnerAccountInfo> | Windows.ApplicationModel.UserDataAccounts.Provider.UserDataAccountPartnerAccountInfo[];
+  }
+  var IUserDataAccountProviderAddAccountOperation: abstract new (...args: any[]) => IUserDataAccountProviderAddAccountOperation;
+
+  interface IUserDataAccountProviderOperation {
+    readonly Kind: number;
+  }
+  var IUserDataAccountProviderOperation: abstract new (...args: any[]) => IUserDataAccountProviderOperation;
+
+  interface IUserDataAccountProviderResolveErrorsOperation extends Windows.ApplicationModel.UserDataAccounts.Provider.IUserDataAccountProviderOperation {
+    ReportCompleted(): void;
+    readonly UserDataAccountId: string;
+  }
+  var IUserDataAccountProviderResolveErrorsOperation: abstract new (...args: any[]) => IUserDataAccountProviderResolveErrorsOperation;
+
+  interface IUserDataAccountProviderSettingsOperation extends Windows.ApplicationModel.UserDataAccounts.Provider.IUserDataAccountProviderOperation {
+    ReportCompleted(): void;
+    readonly UserDataAccountId: string;
+  }
+  var IUserDataAccountProviderSettingsOperation: abstract new (...args: any[]) => IUserDataAccountProviderSettingsOperation;
+
+}
+
+declare namespace Windows.ApplicationModel.UserDataAccounts.SystemAccess {
+  class DeviceAccountConfiguration implements Windows.ApplicationModel.UserDataAccounts.SystemAccess.IDeviceAccountConfiguration, Windows.ApplicationModel.UserDataAccounts.SystemAccess.IDeviceAccountConfiguration2 {
+    constructor();
+    AccountIconId: number;
+    AccountName: string;
+    AlwaysDownloadFullMessage: boolean;
+    AuthenticationCertificateId: string;
+    AuthenticationType: number;
+    AutoSelectAuthenticationCertificate: boolean;
+    CalDavRequiresSsl: boolean;
+    CalDavServerUrl: Windows.Foundation.Uri;
+    CalDavSyncScheduleKind: number;
+    CalendarSyncEnabled: boolean;
+    CardDavRequiresSsl: boolean;
+    CardDavServerUrl: Windows.Foundation.Uri;
+    CardDavSyncScheduleKind: number;
+    ContactsSyncEnabled: boolean;
+    DeviceAccountTypeId: string;
+    readonly DoesPolicyAllowMailSync: boolean;
+    Domain: string;
+    EmailAddress: string;
+    EmailSyncEnabled: boolean;
+    IncomingServerAddress: string;
+    IncomingServerCertificateHash: string;
+    IncomingServerCredential: Windows.Security.Credentials.PasswordCredential;
+    IncomingServerPort: number;
+    IncomingServerRequiresSsl: boolean;
+    IncomingServerUsername: string;
+    IsClientAuthenticationCertificateRequired: boolean;
+    IsExternallyManaged: boolean;
+    IsOutgoingServerAuthenticationEnabled: boolean;
+    IsOutgoingServerAuthenticationRequired: boolean;
+    readonly IsSsoAuthenticationSupported: boolean;
+    IsSyncScheduleManagedBySystem: boolean;
+    MailAgeFilter: number;
+    OAuthRefreshToken: string;
+    OutgoingServerAddress: string;
+    OutgoingServerCertificateHash: string;
+    OutgoingServerCredential: Windows.Security.Credentials.PasswordCredential;
+    OutgoingServerPort: number;
+    OutgoingServerRequiresSsl: boolean;
+    OutgoingServerUsername: string;
+    ServerType: number;
+    SsoAccountId: string;
+    SyncScheduleKind: number;
+    WasIncomingServerCertificateHashConfirmed: boolean;
+    WasModifiedByUser: boolean;
+    WasOutgoingServerCertificateHashConfirmed: boolean;
+  }
+
+  class UserDataAccountSystemAccessManager {
+    static AddAndShowDeviceAccountsAsync(accounts: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.UserDataAccounts.SystemAccess.DeviceAccountConfiguration> | Windows.ApplicationModel.UserDataAccounts.SystemAccess.DeviceAccountConfiguration[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    static CreateDeviceAccountAsync(account: Windows.ApplicationModel.UserDataAccounts.SystemAccess.DeviceAccountConfiguration): Windows.Foundation.IAsyncOperation<string>;
+    static DeleteDeviceAccountAsync(accountId: string): Windows.Foundation.IAsyncAction;
+    static GetDeviceAccountConfigurationAsync(accountId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataAccounts.SystemAccess.DeviceAccountConfiguration>;
+    static SuppressLocalAccountWithAccountAsync(userDataAccountId: string): Windows.Foundation.IAsyncAction;
+  }
+
+  enum DeviceAccountAuthenticationType {
+    Basic = 0,
+    OAuth = 1,
+    SingleSignOn = 2,
+  }
+
+  enum DeviceAccountIconId {
+    Exchange = 0,
+    Msa = 1,
+    Outlook = 2,
+    Generic = 3,
+  }
+
+  enum DeviceAccountMailAgeFilter {
+    All = 0,
+    Last1Day = 1,
+    Last3Days = 2,
+    Last7Days = 3,
+    Last14Days = 4,
+    Last30Days = 5,
+    Last90Days = 6,
+  }
+
+  enum DeviceAccountServerType {
+    Exchange = 0,
+    Pop = 1,
+    Imap = 2,
+  }
+
+  enum DeviceAccountSyncScheduleKind {
+    Manual = 0,
+    Every15Minutes = 1,
+    Every30Minutes = 2,
+    Every60Minutes = 3,
+    Every2Hours = 4,
+    Daily = 5,
+    AsItemsArrive = 6,
+  }
+
+  interface IDeviceAccountConfiguration {
+    AccountName: string;
+    CalendarSyncEnabled: boolean;
+    ContactsSyncEnabled: boolean;
+    DeviceAccountTypeId: string;
+    Domain: string;
+    EmailAddress: string;
+    EmailSyncEnabled: boolean;
+    IncomingServerAddress: string;
+    IncomingServerPort: number;
+    IncomingServerRequiresSsl: boolean;
+    IncomingServerUsername: string;
+    OutgoingServerAddress: string;
+    OutgoingServerPort: number;
+    OutgoingServerRequiresSsl: boolean;
+    OutgoingServerUsername: string;
+    ServerType: number;
+  }
+  var IDeviceAccountConfiguration: abstract new (...args: any[]) => IDeviceAccountConfiguration;
+
+  interface IDeviceAccountConfiguration2 {
+    AccountIconId: number;
+    AlwaysDownloadFullMessage: boolean;
+    AuthenticationCertificateId: string;
+    AuthenticationType: number;
+    AutoSelectAuthenticationCertificate: boolean;
+    CalDavRequiresSsl: boolean;
+    CalDavServerUrl: Windows.Foundation.Uri;
+    CalDavSyncScheduleKind: number;
+    CardDavRequiresSsl: boolean;
+    CardDavServerUrl: Windows.Foundation.Uri;
+    CardDavSyncScheduleKind: number;
+    readonly DoesPolicyAllowMailSync: boolean;
+    IncomingServerCertificateHash: string;
+    IncomingServerCredential: Windows.Security.Credentials.PasswordCredential;
+    IsClientAuthenticationCertificateRequired: boolean;
+    IsExternallyManaged: boolean;
+    IsOutgoingServerAuthenticationEnabled: boolean;
+    IsOutgoingServerAuthenticationRequired: boolean;
+    readonly IsSsoAuthenticationSupported: boolean;
+    IsSyncScheduleManagedBySystem: boolean;
+    MailAgeFilter: number;
+    OAuthRefreshToken: string;
+    OutgoingServerCertificateHash: string;
+    OutgoingServerCredential: Windows.Security.Credentials.PasswordCredential;
+    SsoAccountId: string;
+    SyncScheduleKind: number;
+    WasIncomingServerCertificateHashConfirmed: boolean;
+    WasModifiedByUser: boolean;
+    WasOutgoingServerCertificateHashConfirmed: boolean;
+  }
+  var IDeviceAccountConfiguration2: abstract new (...args: any[]) => IDeviceAccountConfiguration2;
+
+  interface IUserDataAccountSystemAccessManagerStatics {
+    AddAndShowDeviceAccountsAsync(accounts: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.UserDataAccounts.SystemAccess.DeviceAccountConfiguration> | Windows.ApplicationModel.UserDataAccounts.SystemAccess.DeviceAccountConfiguration[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+  }
+  var IUserDataAccountSystemAccessManagerStatics: abstract new (...args: any[]) => IUserDataAccountSystemAccessManagerStatics;
+
+  interface IUserDataAccountSystemAccessManagerStatics2 {
+    CreateDeviceAccountAsync(account: Windows.ApplicationModel.UserDataAccounts.SystemAccess.DeviceAccountConfiguration): Windows.Foundation.IAsyncOperation<string>;
+    DeleteDeviceAccountAsync(accountId: string): Windows.Foundation.IAsyncAction;
+    GetDeviceAccountConfigurationAsync(accountId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataAccounts.SystemAccess.DeviceAccountConfiguration>;
+    SuppressLocalAccountWithAccountAsync(userDataAccountId: string): Windows.Foundation.IAsyncAction;
+  }
+  var IUserDataAccountSystemAccessManagerStatics2: abstract new (...args: any[]) => IUserDataAccountSystemAccessManagerStatics2;
+
+}
+
+declare namespace Windows.ApplicationModel.UserDataTasks {
+  class UserDataTask implements Windows.ApplicationModel.UserDataTasks.IUserDataTask {
+    constructor();
+    CompletedDate: Windows.Foundation.DateTime | null;
+    Details: string;
+    DetailsKind: number;
+    DueDate: Windows.Foundation.DateTime | null;
+    readonly Id: string;
+    readonly Kind: number;
+    readonly ListId: string;
+    Priority: number;
+    RecurrenceProperties: Windows.ApplicationModel.UserDataTasks.UserDataTaskRecurrenceProperties;
+    RegenerationProperties: Windows.ApplicationModel.UserDataTasks.UserDataTaskRegenerationProperties;
+    Reminder: Windows.Foundation.DateTime | null;
+    RemoteId: string;
+    Sensitivity: number;
+    StartDate: Windows.Foundation.DateTime | null;
+    Subject: string;
+  }
+
+  class UserDataTaskBatch implements Windows.ApplicationModel.UserDataTasks.IUserDataTaskBatch {
+    readonly Tasks: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.UserDataTasks.UserDataTask> | Windows.ApplicationModel.UserDataTasks.UserDataTask[];
+  }
+
+  class UserDataTaskList implements Windows.ApplicationModel.UserDataTasks.IUserDataTaskList {
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    DeleteTaskAsync(userDataTaskId: string): Windows.Foundation.IAsyncAction;
+    GetTaskAsync(userDataTask: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataTasks.UserDataTask>;
+    GetTaskReader(): Windows.ApplicationModel.UserDataTasks.UserDataTaskReader;
+    GetTaskReader(options: Windows.ApplicationModel.UserDataTasks.UserDataTaskQueryOptions): Windows.ApplicationModel.UserDataTasks.UserDataTaskReader;
+    RegisterSyncManagerAsync(): Windows.Foundation.IAsyncAction;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    SaveTaskAsync(userDataTask: Windows.ApplicationModel.UserDataTasks.UserDataTask): Windows.Foundation.IAsyncAction;
+    DisplayName: string;
+    readonly Id: string;
+    readonly LimitedWriteOperations: Windows.ApplicationModel.UserDataTasks.UserDataTaskListLimitedWriteOperations;
+    OtherAppReadAccess: number;
+    OtherAppWriteAccess: number;
+    readonly SourceDisplayName: string;
+    readonly SyncManager: Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager;
+    readonly UserDataAccountId: string;
+  }
+
+  class UserDataTaskListLimitedWriteOperations implements Windows.ApplicationModel.UserDataTasks.IUserDataTaskListLimitedWriteOperations {
+    TryCompleteTaskAsync(userDataTaskId: string): Windows.Foundation.IAsyncOperation<string>;
+    TryCreateOrUpdateTaskAsync(userDataTask: Windows.ApplicationModel.UserDataTasks.UserDataTask): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDeleteTaskAsync(userDataTaskId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySkipOccurrenceAsync(userDataTaskId: string): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+
+  class UserDataTaskListSyncManager implements Windows.ApplicationModel.UserDataTasks.IUserDataTaskListSyncManager {
+    SyncAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    LastAttemptedSyncTime: Windows.Foundation.DateTime;
+    LastSuccessfulSyncTime: Windows.Foundation.DateTime;
+    Status: number;
+    SyncStatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager, Object> | null;
+  }
+
+  class UserDataTaskManager implements Windows.ApplicationModel.UserDataTasks.IUserDataTaskManager {
+    static GetDefault(): Windows.ApplicationModel.UserDataTasks.UserDataTaskManager;
+    static GetForUser(user: Windows.System.User): Windows.ApplicationModel.UserDataTasks.UserDataTaskManager;
+    RequestStoreAsync(accessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataTasks.UserDataTaskStore>;
+    readonly User: Windows.System.User;
+  }
+
+  class UserDataTaskQueryOptions implements Windows.ApplicationModel.UserDataTasks.IUserDataTaskQueryOptions {
+    constructor();
+    Kind: number;
+    SortProperty: number;
+  }
+
+  class UserDataTaskReader implements Windows.ApplicationModel.UserDataTasks.IUserDataTaskReader {
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataTasks.UserDataTaskBatch>;
+  }
+
+  class UserDataTaskRecurrenceProperties implements Windows.ApplicationModel.UserDataTasks.IUserDataTaskRecurrenceProperties {
+    constructor();
+    Day: number | null;
+    DaysOfWeek: number | null;
+    Interval: number;
+    Month: number | null;
+    Occurrences: number | null;
+    Unit: number;
+    Until: Windows.Foundation.DateTime | null;
+    WeekOfMonth: number | null;
+  }
+
+  class UserDataTaskRegenerationProperties implements Windows.ApplicationModel.UserDataTasks.IUserDataTaskRegenerationProperties {
+    constructor();
+    Interval: number;
+    Occurrences: number | null;
+    Unit: number;
+    Until: Windows.Foundation.DateTime | null;
+  }
+
+  class UserDataTaskStore implements Windows.ApplicationModel.UserDataTasks.IUserDataTaskStore {
+    CreateListAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataTasks.UserDataTaskList>;
+    CreateListAsync(name: string, userDataAccountId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataTasks.UserDataTaskList>;
+    FindListsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.UserDataTasks.UserDataTaskList> | Windows.ApplicationModel.UserDataTasks.UserDataTaskList[]>;
+    GetListAsync(taskListId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataTasks.UserDataTaskList>;
+  }
+
+  enum UserDataTaskDaysOfWeek {
+    None = 0,
+    Sunday = 1,
+    Monday = 2,
+    Tuesday = 4,
+    Wednesday = 8,
+    Thursday = 16,
+    Friday = 32,
+    Saturday = 64,
+  }
+
+  enum UserDataTaskDetailsKind {
+    PlainText = 0,
+    Html = 1,
+  }
+
+  enum UserDataTaskKind {
+    Single = 0,
+    Recurring = 1,
+    Regenerating = 2,
+  }
+
+  enum UserDataTaskListOtherAppReadAccess {
+    Full = 0,
+    SystemOnly = 1,
+    None = 2,
+  }
+
+  enum UserDataTaskListOtherAppWriteAccess {
+    Limited = 0,
+    None = 1,
+  }
+
+  enum UserDataTaskListSyncStatus {
+    Idle = 0,
+    Syncing = 1,
+    UpToDate = 2,
+    AuthenticationError = 3,
+    PolicyError = 4,
+    UnknownError = 5,
+  }
+
+  enum UserDataTaskPriority {
+    Normal = 0,
+    Low = -1,
+    High = 1,
+  }
+
+  enum UserDataTaskQueryKind {
+    All = 0,
+    Incomplete = 1,
+    Complete = 2,
+  }
+
+  enum UserDataTaskQuerySortProperty {
+    DueDate = 0,
+  }
+
+  enum UserDataTaskRecurrenceUnit {
+    Daily = 0,
+    Weekly = 1,
+    Monthly = 2,
+    MonthlyOnDay = 3,
+    Yearly = 4,
+    YearlyOnDay = 5,
+  }
+
+  enum UserDataTaskRegenerationUnit {
+    Daily = 0,
+    Weekly = 1,
+    Monthly = 2,
+    Yearly = 4,
+  }
+
+  enum UserDataTaskSensitivity {
+    Public = 0,
+    Private = 1,
+  }
+
+  enum UserDataTaskStoreAccessType {
+    AppTasksReadWrite = 0,
+    AllTasksLimitedReadWrite = 1,
+  }
+
+  enum UserDataTaskWeekOfMonth {
+    First = 0,
+    Second = 1,
+    Third = 2,
+    Fourth = 3,
+    Last = 4,
+  }
+
+  interface IUserDataTask {
+    CompletedDate: Windows.Foundation.DateTime | null;
+    Details: string;
+    DetailsKind: number;
+    DueDate: Windows.Foundation.DateTime | null;
+    readonly Id: string;
+    readonly Kind: number;
+    readonly ListId: string;
+    Priority: number;
+    RecurrenceProperties: Windows.ApplicationModel.UserDataTasks.UserDataTaskRecurrenceProperties;
+    RegenerationProperties: Windows.ApplicationModel.UserDataTasks.UserDataTaskRegenerationProperties;
+    Reminder: Windows.Foundation.DateTime | null;
+    RemoteId: string;
+    Sensitivity: number;
+    StartDate: Windows.Foundation.DateTime | null;
+    Subject: string;
+  }
+  var IUserDataTask: abstract new (...args: any[]) => IUserDataTask;
+
+  interface IUserDataTaskBatch {
+    readonly Tasks: Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.UserDataTasks.UserDataTask> | Windows.ApplicationModel.UserDataTasks.UserDataTask[];
+  }
+  var IUserDataTaskBatch: abstract new (...args: any[]) => IUserDataTaskBatch;
+
+  interface IUserDataTaskList {
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    DeleteTaskAsync(userDataTaskId: string): Windows.Foundation.IAsyncAction;
+    GetTaskAsync(userDataTask: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataTasks.UserDataTask>;
+    GetTaskReader(): Windows.ApplicationModel.UserDataTasks.UserDataTaskReader;
+    GetTaskReader(options: Windows.ApplicationModel.UserDataTasks.UserDataTaskQueryOptions): Windows.ApplicationModel.UserDataTasks.UserDataTaskReader;
+    RegisterSyncManagerAsync(): Windows.Foundation.IAsyncAction;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    SaveTaskAsync(userDataTask: Windows.ApplicationModel.UserDataTasks.UserDataTask): Windows.Foundation.IAsyncAction;
+    DisplayName: string;
+    readonly Id: string;
+    readonly LimitedWriteOperations: Windows.ApplicationModel.UserDataTasks.UserDataTaskListLimitedWriteOperations;
+    OtherAppReadAccess: number;
+    OtherAppWriteAccess: number;
+    readonly SourceDisplayName: string;
+    readonly SyncManager: Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager;
+    readonly UserDataAccountId: string;
+  }
+  var IUserDataTaskList: abstract new (...args: any[]) => IUserDataTaskList;
+
+  interface IUserDataTaskListLimitedWriteOperations {
+    TryCompleteTaskAsync(userDataTaskId: string): Windows.Foundation.IAsyncOperation<string>;
+    TryCreateOrUpdateTaskAsync(userDataTask: Windows.ApplicationModel.UserDataTasks.UserDataTask): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDeleteTaskAsync(userDataTaskId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySkipOccurrenceAsync(userDataTaskId: string): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IUserDataTaskListLimitedWriteOperations: abstract new (...args: any[]) => IUserDataTaskListLimitedWriteOperations;
+
+  interface IUserDataTaskListSyncManager {
+    SyncAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    LastAttemptedSyncTime: Windows.Foundation.DateTime;
+    LastSuccessfulSyncTime: Windows.Foundation.DateTime;
+    Status: number;
+    SyncStatusChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.UserDataTasks.UserDataTaskListSyncManager, Object> | null;
+  }
+  var IUserDataTaskListSyncManager: abstract new (...args: any[]) => IUserDataTaskListSyncManager;
+
+  interface IUserDataTaskManager {
+    RequestStoreAsync(accessType: number): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataTasks.UserDataTaskStore>;
+    readonly User: Windows.System.User;
+  }
+  var IUserDataTaskManager: abstract new (...args: any[]) => IUserDataTaskManager;
+
+  interface IUserDataTaskManagerStatics {
+    GetDefault(): Windows.ApplicationModel.UserDataTasks.UserDataTaskManager;
+    GetForUser(user: Windows.System.User): Windows.ApplicationModel.UserDataTasks.UserDataTaskManager;
+  }
+  var IUserDataTaskManagerStatics: abstract new (...args: any[]) => IUserDataTaskManagerStatics;
+
+  interface IUserDataTaskQueryOptions {
+    Kind: number;
+    SortProperty: number;
+  }
+  var IUserDataTaskQueryOptions: abstract new (...args: any[]) => IUserDataTaskQueryOptions;
+
+  interface IUserDataTaskReader {
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataTasks.UserDataTaskBatch>;
+  }
+  var IUserDataTaskReader: abstract new (...args: any[]) => IUserDataTaskReader;
+
+  interface IUserDataTaskRecurrenceProperties {
+    Day: number | null;
+    DaysOfWeek: number | null;
+    Interval: number;
+    Month: number | null;
+    Occurrences: number | null;
+    Unit: number;
+    Until: Windows.Foundation.DateTime | null;
+    WeekOfMonth: number | null;
+  }
+  var IUserDataTaskRecurrenceProperties: abstract new (...args: any[]) => IUserDataTaskRecurrenceProperties;
+
+  interface IUserDataTaskRegenerationProperties {
+    Interval: number;
+    Occurrences: number | null;
+    Unit: number;
+    Until: Windows.Foundation.DateTime | null;
+  }
+  var IUserDataTaskRegenerationProperties: abstract new (...args: any[]) => IUserDataTaskRegenerationProperties;
+
+  interface IUserDataTaskStore {
+    CreateListAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataTasks.UserDataTaskList>;
+    CreateListAsync(name: string, userDataAccountId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataTasks.UserDataTaskList>;
+    FindListsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.UserDataTasks.UserDataTaskList> | Windows.ApplicationModel.UserDataTasks.UserDataTaskList[]>;
+    GetListAsync(taskListId: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.UserDataTasks.UserDataTaskList>;
+  }
+  var IUserDataTaskStore: abstract new (...args: any[]) => IUserDataTaskStore;
+
+}
+
+declare namespace Windows.ApplicationModel.UserDataTasks.DataProvider {
+  class UserDataTaskDataProviderConnection implements Windows.ApplicationModel.UserDataTasks.DataProvider.IUserDataTaskDataProviderConnection {
+    Start(): void;
+    CompleteTaskRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection, Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequestEventArgs> | null;
+    CreateOrUpdateTaskRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection, Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequestEventArgs> | null;
+    DeleteTaskRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection, Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequestEventArgs> | null;
+    SkipOccurrenceRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection, Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequestEventArgs> | null;
+    SyncRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection, Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequestEventArgs> | null;
+  }
+
+  class UserDataTaskDataProviderTriggerDetails implements Windows.ApplicationModel.UserDataTasks.DataProvider.IUserDataTaskDataProviderTriggerDetails {
+    readonly Connection: Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection;
+  }
+
+  class UserDataTaskListCompleteTaskRequest implements Windows.ApplicationModel.UserDataTasks.DataProvider.IUserDataTaskListCompleteTaskRequest {
+    ReportCompletedAsync(completedTaskId: string): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly TaskId: string;
+    readonly TaskListId: string;
+  }
+
+  class UserDataTaskListCompleteTaskRequestEventArgs implements Windows.ApplicationModel.UserDataTasks.DataProvider.IUserDataTaskListCompleteTaskRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequest;
+  }
+
+  class UserDataTaskListCreateOrUpdateTaskRequest implements Windows.ApplicationModel.UserDataTasks.DataProvider.IUserDataTaskListCreateOrUpdateTaskRequest {
+    ReportCompletedAsync(createdOrUpdatedUserDataTask: Windows.ApplicationModel.UserDataTasks.UserDataTask): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly Task: Windows.ApplicationModel.UserDataTasks.UserDataTask;
+    readonly TaskListId: string;
+  }
+
+  class UserDataTaskListCreateOrUpdateTaskRequestEventArgs implements Windows.ApplicationModel.UserDataTasks.DataProvider.IUserDataTaskListCreateOrUpdateTaskRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequest;
+  }
+
+  class UserDataTaskListDeleteTaskRequest implements Windows.ApplicationModel.UserDataTasks.DataProvider.IUserDataTaskListDeleteTaskRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly TaskId: string;
+    readonly TaskListId: string;
+  }
+
+  class UserDataTaskListDeleteTaskRequestEventArgs implements Windows.ApplicationModel.UserDataTasks.DataProvider.IUserDataTaskListDeleteTaskRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequest;
+  }
+
+  class UserDataTaskListSkipOccurrenceRequest implements Windows.ApplicationModel.UserDataTasks.DataProvider.IUserDataTaskListSkipOccurrenceRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly TaskId: string;
+    readonly TaskListId: string;
+  }
+
+  class UserDataTaskListSkipOccurrenceRequestEventArgs implements Windows.ApplicationModel.UserDataTasks.DataProvider.IUserDataTaskListSkipOccurrenceRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequest;
+  }
+
+  class UserDataTaskListSyncManagerSyncRequest implements Windows.ApplicationModel.UserDataTasks.DataProvider.IUserDataTaskListSyncManagerSyncRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly TaskListId: string;
+  }
+
+  class UserDataTaskListSyncManagerSyncRequestEventArgs implements Windows.ApplicationModel.UserDataTasks.DataProvider.IUserDataTaskListSyncManagerSyncRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequest;
+  }
+
+  interface IUserDataTaskDataProviderConnection {
+    Start(): void;
+    CompleteTaskRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection, Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequestEventArgs> | null;
+    CreateOrUpdateTaskRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection, Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequestEventArgs> | null;
+    DeleteTaskRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection, Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequestEventArgs> | null;
+    SkipOccurrenceRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection, Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequestEventArgs> | null;
+    SyncRequested: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection, Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequestEventArgs> | null;
+  }
+  var IUserDataTaskDataProviderConnection: abstract new (...args: any[]) => IUserDataTaskDataProviderConnection;
+
+  interface IUserDataTaskDataProviderTriggerDetails {
+    readonly Connection: Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskDataProviderConnection;
+  }
+  var IUserDataTaskDataProviderTriggerDetails: abstract new (...args: any[]) => IUserDataTaskDataProviderTriggerDetails;
+
+  interface IUserDataTaskListCompleteTaskRequest {
+    ReportCompletedAsync(completedTaskId: string): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly TaskId: string;
+    readonly TaskListId: string;
+  }
+  var IUserDataTaskListCompleteTaskRequest: abstract new (...args: any[]) => IUserDataTaskListCompleteTaskRequest;
+
+  interface IUserDataTaskListCompleteTaskRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCompleteTaskRequest;
+  }
+  var IUserDataTaskListCompleteTaskRequestEventArgs: abstract new (...args: any[]) => IUserDataTaskListCompleteTaskRequestEventArgs;
+
+  interface IUserDataTaskListCreateOrUpdateTaskRequest {
+    ReportCompletedAsync(createdOrUpdatedUserDataTask: Windows.ApplicationModel.UserDataTasks.UserDataTask): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly Task: Windows.ApplicationModel.UserDataTasks.UserDataTask;
+    readonly TaskListId: string;
+  }
+  var IUserDataTaskListCreateOrUpdateTaskRequest: abstract new (...args: any[]) => IUserDataTaskListCreateOrUpdateTaskRequest;
+
+  interface IUserDataTaskListCreateOrUpdateTaskRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListCreateOrUpdateTaskRequest;
+  }
+  var IUserDataTaskListCreateOrUpdateTaskRequestEventArgs: abstract new (...args: any[]) => IUserDataTaskListCreateOrUpdateTaskRequestEventArgs;
+
+  interface IUserDataTaskListDeleteTaskRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly TaskId: string;
+    readonly TaskListId: string;
+  }
+  var IUserDataTaskListDeleteTaskRequest: abstract new (...args: any[]) => IUserDataTaskListDeleteTaskRequest;
+
+  interface IUserDataTaskListDeleteTaskRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListDeleteTaskRequest;
+  }
+  var IUserDataTaskListDeleteTaskRequestEventArgs: abstract new (...args: any[]) => IUserDataTaskListDeleteTaskRequestEventArgs;
+
+  interface IUserDataTaskListSkipOccurrenceRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly TaskId: string;
+    readonly TaskListId: string;
+  }
+  var IUserDataTaskListSkipOccurrenceRequest: abstract new (...args: any[]) => IUserDataTaskListSkipOccurrenceRequest;
+
+  interface IUserDataTaskListSkipOccurrenceRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSkipOccurrenceRequest;
+  }
+  var IUserDataTaskListSkipOccurrenceRequestEventArgs: abstract new (...args: any[]) => IUserDataTaskListSkipOccurrenceRequestEventArgs;
+
+  interface IUserDataTaskListSyncManagerSyncRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly TaskListId: string;
+  }
+  var IUserDataTaskListSyncManagerSyncRequest: abstract new (...args: any[]) => IUserDataTaskListSyncManagerSyncRequest;
+
+  interface IUserDataTaskListSyncManagerSyncRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.ApplicationModel.UserDataTasks.DataProvider.UserDataTaskListSyncManagerSyncRequest;
+  }
+  var IUserDataTaskListSyncManagerSyncRequestEventArgs: abstract new (...args: any[]) => IUserDataTaskListSyncManagerSyncRequestEventArgs;
+
+}
+
+declare namespace Windows.ApplicationModel.VoiceCommands {
+  class VoiceCommand implements Windows.ApplicationModel.VoiceCommands.IVoiceCommand {
+    readonly CommandName: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    readonly SpeechRecognitionResult: Windows.Media.SpeechRecognition.SpeechRecognitionResult;
+  }
+
+  class VoiceCommandCompletedEventArgs implements Windows.ApplicationModel.VoiceCommands.IVoiceCommandCompletedEventArgs {
+    readonly Reason: number;
+  }
+
+  class VoiceCommandConfirmationResult implements Windows.ApplicationModel.VoiceCommands.IVoiceCommandConfirmationResult {
+    readonly Confirmed: boolean;
+  }
+
+  class VoiceCommandContentTile implements Windows.ApplicationModel.VoiceCommands.IVoiceCommandContentTile {
+    constructor();
+    AppContext: Object;
+    AppLaunchArgument: string;
+    ContentTileType: number;
+    Image: Windows.Storage.IStorageFile;
+    TextLine1: string;
+    TextLine2: string;
+    TextLine3: string;
+    Title: string;
+  }
+
+  class VoiceCommandDefinition implements Windows.ApplicationModel.VoiceCommands.IVoiceCommandDefinition {
+    SetPhraseListAsync(phraseListName: string, phraseList: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    readonly Language: string;
+    readonly Name: string;
+  }
+
+  class VoiceCommandDefinitionManager {
+    static InstallCommandDefinitionsFromStorageFileAsync(file: Windows.Storage.StorageFile): Windows.Foundation.IAsyncAction;
+    static readonly InstalledCommandDefinitions: Windows.Foundation.Collections.IMapView<string, Windows.ApplicationModel.VoiceCommands.VoiceCommandDefinition>;
+  }
+
+  class VoiceCommandDisambiguationResult implements Windows.ApplicationModel.VoiceCommands.IVoiceCommandDisambiguationResult {
+    readonly SelectedItem: Windows.ApplicationModel.VoiceCommands.VoiceCommandContentTile;
+  }
+
+  class VoiceCommandResponse implements Windows.ApplicationModel.VoiceCommands.IVoiceCommandResponse {
+    static CreateResponse(userMessage: Windows.ApplicationModel.VoiceCommands.VoiceCommandUserMessage): Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse;
+    static CreateResponse(message: Windows.ApplicationModel.VoiceCommands.VoiceCommandUserMessage, contentTiles: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.VoiceCommands.VoiceCommandContentTile> | Windows.ApplicationModel.VoiceCommands.VoiceCommandContentTile[]): Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse;
+    static CreateResponseForPrompt(message: Windows.ApplicationModel.VoiceCommands.VoiceCommandUserMessage, repeatMessage: Windows.ApplicationModel.VoiceCommands.VoiceCommandUserMessage): Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse;
+    static CreateResponseForPrompt(message: Windows.ApplicationModel.VoiceCommands.VoiceCommandUserMessage, repeatMessage: Windows.ApplicationModel.VoiceCommands.VoiceCommandUserMessage, contentTiles: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.VoiceCommands.VoiceCommandContentTile> | Windows.ApplicationModel.VoiceCommands.VoiceCommandContentTile[]): Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse;
+    AppLaunchArgument: string;
+    static readonly MaxSupportedVoiceCommandContentTiles: number;
+    Message: Windows.ApplicationModel.VoiceCommands.VoiceCommandUserMessage;
+    RepeatMessage: Windows.ApplicationModel.VoiceCommands.VoiceCommandUserMessage;
+    readonly VoiceCommandContentTiles: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.VoiceCommands.VoiceCommandContentTile> | Windows.ApplicationModel.VoiceCommands.VoiceCommandContentTile[];
+  }
+
+  class VoiceCommandServiceConnection implements Windows.ApplicationModel.VoiceCommands.IVoiceCommandServiceConnection {
+    static FromAppServiceTriggerDetails(triggerDetails: Windows.ApplicationModel.AppService.AppServiceTriggerDetails): Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection;
+    GetVoiceCommandAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.VoiceCommands.VoiceCommand>;
+    ReportFailureAsync(response: Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse): Windows.Foundation.IAsyncAction;
+    ReportProgressAsync(response: Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse): Windows.Foundation.IAsyncAction;
+    ReportSuccessAsync(response: Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse): Windows.Foundation.IAsyncAction;
+    RequestAppLaunchAsync(response: Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse): Windows.Foundation.IAsyncAction;
+    RequestConfirmationAsync(response: Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.VoiceCommands.VoiceCommandConfirmationResult>;
+    RequestDisambiguationAsync(response: Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.VoiceCommands.VoiceCommandDisambiguationResult>;
+    readonly Language: Windows.Globalization.Language;
+    VoiceCommandCompleted: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection, Windows.ApplicationModel.VoiceCommands.VoiceCommandCompletedEventArgs> | null;
+  }
+
+  class VoiceCommandUserMessage implements Windows.ApplicationModel.VoiceCommands.IVoiceCommandUserMessage {
+    constructor();
+    DisplayMessage: string;
+    SpokenMessage: string;
+  }
+
+  enum VoiceCommandCompletionReason {
+    Unknown = 0,
+    CommunicationFailed = 1,
+    ResourceLimitsExceeded = 2,
+    Canceled = 3,
+    TimeoutExceeded = 4,
+    AppLaunched = 5,
+    Completed = 6,
+  }
+
+  enum VoiceCommandContentTileType {
+    TitleOnly = 0,
+    TitleWithText = 1,
+    TitleWith68x68Icon = 2,
+    TitleWith68x68IconAndText = 3,
+    TitleWith68x92Icon = 4,
+    TitleWith68x92IconAndText = 5,
+    TitleWith280x140Icon = 6,
+    TitleWith280x140IconAndText = 7,
+  }
+
+  interface IVoiceCommand {
+    readonly CommandName: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    readonly SpeechRecognitionResult: Windows.Media.SpeechRecognition.SpeechRecognitionResult;
+  }
+  var IVoiceCommand: abstract new (...args: any[]) => IVoiceCommand;
+
+  interface IVoiceCommandCompletedEventArgs {
+    readonly Reason: number;
+  }
+  var IVoiceCommandCompletedEventArgs: abstract new (...args: any[]) => IVoiceCommandCompletedEventArgs;
+
+  interface IVoiceCommandConfirmationResult {
+    readonly Confirmed: boolean;
+  }
+  var IVoiceCommandConfirmationResult: abstract new (...args: any[]) => IVoiceCommandConfirmationResult;
+
+  interface IVoiceCommandContentTile {
+    AppContext: Object;
+    AppLaunchArgument: string;
+    ContentTileType: number;
+    Image: Windows.Storage.IStorageFile;
+    TextLine1: string;
+    TextLine2: string;
+    TextLine3: string;
+    Title: string;
+  }
+  var IVoiceCommandContentTile: abstract new (...args: any[]) => IVoiceCommandContentTile;
+
+  interface IVoiceCommandDefinition {
+    SetPhraseListAsync(phraseListName: string, phraseList: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    readonly Language: string;
+    readonly Name: string;
+  }
+  var IVoiceCommandDefinition: abstract new (...args: any[]) => IVoiceCommandDefinition;
+
+  interface IVoiceCommandDefinitionManagerStatics {
+    InstallCommandDefinitionsFromStorageFileAsync(file: Windows.Storage.StorageFile): Windows.Foundation.IAsyncAction;
+    readonly InstalledCommandDefinitions: Windows.Foundation.Collections.IMapView<string, Windows.ApplicationModel.VoiceCommands.VoiceCommandDefinition>;
+  }
+  var IVoiceCommandDefinitionManagerStatics: abstract new (...args: any[]) => IVoiceCommandDefinitionManagerStatics;
+
+  interface IVoiceCommandDisambiguationResult {
+    readonly SelectedItem: Windows.ApplicationModel.VoiceCommands.VoiceCommandContentTile;
+  }
+  var IVoiceCommandDisambiguationResult: abstract new (...args: any[]) => IVoiceCommandDisambiguationResult;
+
+  interface IVoiceCommandResponse {
+    AppLaunchArgument: string;
+    Message: Windows.ApplicationModel.VoiceCommands.VoiceCommandUserMessage;
+    RepeatMessage: Windows.ApplicationModel.VoiceCommands.VoiceCommandUserMessage;
+    readonly VoiceCommandContentTiles: Windows.Foundation.Collections.IVector<Windows.ApplicationModel.VoiceCommands.VoiceCommandContentTile> | Windows.ApplicationModel.VoiceCommands.VoiceCommandContentTile[];
+  }
+  var IVoiceCommandResponse: abstract new (...args: any[]) => IVoiceCommandResponse;
+
+  interface IVoiceCommandResponseStatics {
+    CreateResponse(userMessage: Windows.ApplicationModel.VoiceCommands.VoiceCommandUserMessage): Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse;
+    CreateResponse(message: Windows.ApplicationModel.VoiceCommands.VoiceCommandUserMessage, contentTiles: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.VoiceCommands.VoiceCommandContentTile> | Windows.ApplicationModel.VoiceCommands.VoiceCommandContentTile[]): Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse;
+    CreateResponseForPrompt(message: Windows.ApplicationModel.VoiceCommands.VoiceCommandUserMessage, repeatMessage: Windows.ApplicationModel.VoiceCommands.VoiceCommandUserMessage): Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse;
+    CreateResponseForPrompt(message: Windows.ApplicationModel.VoiceCommands.VoiceCommandUserMessage, repeatMessage: Windows.ApplicationModel.VoiceCommands.VoiceCommandUserMessage, contentTiles: Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.VoiceCommands.VoiceCommandContentTile> | Windows.ApplicationModel.VoiceCommands.VoiceCommandContentTile[]): Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse;
+    readonly MaxSupportedVoiceCommandContentTiles: number;
+  }
+  var IVoiceCommandResponseStatics: abstract new (...args: any[]) => IVoiceCommandResponseStatics;
+
+  interface IVoiceCommandServiceConnection {
+    GetVoiceCommandAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.VoiceCommands.VoiceCommand>;
+    ReportFailureAsync(response: Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse): Windows.Foundation.IAsyncAction;
+    ReportProgressAsync(response: Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse): Windows.Foundation.IAsyncAction;
+    ReportSuccessAsync(response: Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse): Windows.Foundation.IAsyncAction;
+    RequestAppLaunchAsync(response: Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse): Windows.Foundation.IAsyncAction;
+    RequestConfirmationAsync(response: Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.VoiceCommands.VoiceCommandConfirmationResult>;
+    RequestDisambiguationAsync(response: Windows.ApplicationModel.VoiceCommands.VoiceCommandResponse): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.VoiceCommands.VoiceCommandDisambiguationResult>;
+    readonly Language: Windows.Globalization.Language;
+    VoiceCommandCompleted: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection, Windows.ApplicationModel.VoiceCommands.VoiceCommandCompletedEventArgs> | null;
+  }
+  var IVoiceCommandServiceConnection: abstract new (...args: any[]) => IVoiceCommandServiceConnection;
+
+  interface IVoiceCommandServiceConnectionStatics {
+    FromAppServiceTriggerDetails(triggerDetails: Windows.ApplicationModel.AppService.AppServiceTriggerDetails): Windows.ApplicationModel.VoiceCommands.VoiceCommandServiceConnection;
+  }
+  var IVoiceCommandServiceConnectionStatics: abstract new (...args: any[]) => IVoiceCommandServiceConnectionStatics;
+
+  interface IVoiceCommandUserMessage {
+    DisplayMessage: string;
+    SpokenMessage: string;
+  }
+  var IVoiceCommandUserMessage: abstract new (...args: any[]) => IVoiceCommandUserMessage;
+
+}
+
+declare namespace Windows.ApplicationModel.Wallet {
+  class WalletBarcode implements Windows.ApplicationModel.Wallet.IWalletBarcode {
+    constructor(symbology: number, value: string);
+    constructor(streamToBarcodeImage: Windows.Storage.Streams.IRandomAccessStreamReference);
+    GetImageAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamReference>;
+    readonly Symbology: number;
+    readonly Value: string;
+  }
+
+  class WalletItem implements Windows.ApplicationModel.Wallet.IWalletItem {
+    constructor(kind: number, displayName: string);
+    Barcode: Windows.ApplicationModel.Wallet.WalletBarcode;
+    BodyBackgroundImage: Windows.Storage.Streams.IRandomAccessStreamReference;
+    BodyColor: Windows.UI.Color;
+    BodyFontColor: Windows.UI.Color;
+    DisplayMessage: string;
+    DisplayName: string;
+    readonly DisplayProperties: Windows.Foundation.Collections.IMap<string, Windows.ApplicationModel.Wallet.WalletItemCustomProperty> | Record<string, Windows.ApplicationModel.Wallet.WalletItemCustomProperty>;
+    ExpirationDate: Windows.Foundation.DateTime | null;
+    HeaderBackgroundImage: Windows.Storage.Streams.IRandomAccessStreamReference;
+    HeaderColor: Windows.UI.Color;
+    HeaderFontColor: Windows.UI.Color;
+    readonly Id: string;
+    IsAcknowledged: boolean;
+    IsDisplayMessageLaunchable: boolean;
+    IsMoreTransactionHistoryLaunchable: boolean;
+    IssuerDisplayName: string;
+    readonly Kind: number;
+    LastUpdated: Windows.Foundation.DateTime | null;
+    Logo159x159: Windows.Storage.Streams.IRandomAccessStreamReference;
+    Logo336x336: Windows.Storage.Streams.IRandomAccessStreamReference;
+    Logo99x99: Windows.Storage.Streams.IRandomAccessStreamReference;
+    LogoImage: Windows.Storage.Streams.IRandomAccessStreamReference;
+    LogoText: string;
+    PromotionalImage: Windows.Storage.Streams.IRandomAccessStreamReference;
+    RelevantDate: Windows.Foundation.DateTime | null;
+    RelevantDateDisplayMessage: string;
+    readonly RelevantLocations: Windows.Foundation.Collections.IMap<string, Windows.ApplicationModel.Wallet.WalletRelevantLocation> | Record<string, Windows.ApplicationModel.Wallet.WalletRelevantLocation>;
+    readonly TransactionHistory: Windows.Foundation.Collections.IMap<string, Windows.ApplicationModel.Wallet.WalletTransaction> | Record<string, Windows.ApplicationModel.Wallet.WalletTransaction>;
+    readonly Verbs: Windows.Foundation.Collections.IMap<string, Windows.ApplicationModel.Wallet.WalletVerb> | Record<string, Windows.ApplicationModel.Wallet.WalletVerb>;
+  }
+
+  class WalletItemCustomProperty implements Windows.ApplicationModel.Wallet.IWalletItemCustomProperty {
+    constructor(name: string, value: string);
+    AutoDetectLinks: boolean;
+    DetailViewPosition: number;
+    Name: string;
+    SummaryViewPosition: number;
+    Value: string;
+  }
+
+  class WalletItemStore implements Windows.ApplicationModel.Wallet.IWalletItemStore {
+    AddAsync(id: string, item: Windows.ApplicationModel.Wallet.WalletItem): Windows.Foundation.IAsyncAction;
+    ClearAsync(): Windows.Foundation.IAsyncAction;
+    DeleteAsync(id: string): Windows.Foundation.IAsyncAction;
+    GetItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Wallet.WalletItem> | Windows.ApplicationModel.Wallet.WalletItem[]>;
+    GetItemsAsync(kind: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Wallet.WalletItem> | Windows.ApplicationModel.Wallet.WalletItem[]>;
+    GetWalletItemAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Wallet.WalletItem>;
+    ImportItemAsync(stream: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Wallet.WalletItem>;
+    ShowAsync(): Windows.Foundation.IAsyncAction;
+    ShowAsync(id: string): Windows.Foundation.IAsyncAction;
+    UpdateAsync(item: Windows.ApplicationModel.Wallet.WalletItem): Windows.Foundation.IAsyncAction;
+  }
+
+  class WalletManager {
+    static RequestStoreAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Wallet.WalletItemStore>;
+  }
+
+  class WalletRelevantLocation implements Windows.ApplicationModel.Wallet.IWalletRelevantLocation {
+    constructor();
+    DisplayMessage: string;
+    Position: Windows.Devices.Geolocation.BasicGeoposition;
+  }
+
+  class WalletTransaction implements Windows.ApplicationModel.Wallet.IWalletTransaction {
+    constructor();
+    Description: string;
+    DisplayAmount: string;
+    DisplayLocation: string;
+    IgnoreTimeOfDay: boolean;
+    IsLaunchable: boolean;
+    TransactionDate: Windows.Foundation.DateTime | null;
+  }
+
+  class WalletVerb implements Windows.ApplicationModel.Wallet.IWalletVerb {
+    constructor(name: string);
+    Name: string;
+  }
+
+  enum WalletActionKind {
+    OpenItem = 0,
+    Transaction = 1,
+    MoreTransactions = 2,
+    Message = 3,
+    Verb = 4,
+  }
+
+  enum WalletBarcodeSymbology {
+    Invalid = 0,
+    Upca = 1,
+    Upce = 2,
+    Ean13 = 3,
+    Ean8 = 4,
+    Itf = 5,
+    Code39 = 6,
+    Code128 = 7,
+    Qr = 8,
+    Pdf417 = 9,
+    Aztec = 10,
+    Custom = 100000,
+  }
+
+  enum WalletDetailViewPosition {
+    Hidden = 0,
+    HeaderField1 = 1,
+    HeaderField2 = 2,
+    PrimaryField1 = 3,
+    PrimaryField2 = 4,
+    SecondaryField1 = 5,
+    SecondaryField2 = 6,
+    SecondaryField3 = 7,
+    SecondaryField4 = 8,
+    SecondaryField5 = 9,
+    CenterField1 = 10,
+    FooterField1 = 11,
+    FooterField2 = 12,
+    FooterField3 = 13,
+    FooterField4 = 14,
+  }
+
+  enum WalletItemKind {
+    Invalid = 0,
+    Deal = 1,
+    General = 2,
+    PaymentInstrument = 3,
+    Ticket = 4,
+    BoardingPass = 5,
+    MembershipCard = 6,
+  }
+
+  enum WalletSummaryViewPosition {
+    Hidden = 0,
+    Field1 = 1,
+    Field2 = 2,
+  }
+
+  interface IWalletBarcode {
+    GetImageAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamReference>;
+    readonly Symbology: number;
+    readonly Value: string;
+  }
+  var IWalletBarcode: abstract new (...args: any[]) => IWalletBarcode;
+
+  interface IWalletBarcodeFactory {
+    CreateCustomWalletBarcode(streamToBarcodeImage: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.ApplicationModel.Wallet.WalletBarcode;
+    CreateWalletBarcode(symbology: number, value: string): Windows.ApplicationModel.Wallet.WalletBarcode;
+  }
+  var IWalletBarcodeFactory: abstract new (...args: any[]) => IWalletBarcodeFactory;
+
+  interface IWalletItem {
+    Barcode: Windows.ApplicationModel.Wallet.WalletBarcode;
+    BodyBackgroundImage: Windows.Storage.Streams.IRandomAccessStreamReference;
+    BodyColor: Windows.UI.Color;
+    BodyFontColor: Windows.UI.Color;
+    DisplayMessage: string;
+    DisplayName: string;
+    readonly DisplayProperties: Windows.Foundation.Collections.IMap<string, Windows.ApplicationModel.Wallet.WalletItemCustomProperty> | Record<string, Windows.ApplicationModel.Wallet.WalletItemCustomProperty>;
+    ExpirationDate: Windows.Foundation.DateTime | null;
+    HeaderBackgroundImage: Windows.Storage.Streams.IRandomAccessStreamReference;
+    HeaderColor: Windows.UI.Color;
+    HeaderFontColor: Windows.UI.Color;
+    readonly Id: string;
+    IsAcknowledged: boolean;
+    IsDisplayMessageLaunchable: boolean;
+    IsMoreTransactionHistoryLaunchable: boolean;
+    IssuerDisplayName: string;
+    readonly Kind: number;
+    LastUpdated: Windows.Foundation.DateTime | null;
+    Logo159x159: Windows.Storage.Streams.IRandomAccessStreamReference;
+    Logo336x336: Windows.Storage.Streams.IRandomAccessStreamReference;
+    Logo99x99: Windows.Storage.Streams.IRandomAccessStreamReference;
+    LogoImage: Windows.Storage.Streams.IRandomAccessStreamReference;
+    LogoText: string;
+    PromotionalImage: Windows.Storage.Streams.IRandomAccessStreamReference;
+    RelevantDate: Windows.Foundation.DateTime | null;
+    RelevantDateDisplayMessage: string;
+    readonly RelevantLocations: Windows.Foundation.Collections.IMap<string, Windows.ApplicationModel.Wallet.WalletRelevantLocation> | Record<string, Windows.ApplicationModel.Wallet.WalletRelevantLocation>;
+    readonly TransactionHistory: Windows.Foundation.Collections.IMap<string, Windows.ApplicationModel.Wallet.WalletTransaction> | Record<string, Windows.ApplicationModel.Wallet.WalletTransaction>;
+    readonly Verbs: Windows.Foundation.Collections.IMap<string, Windows.ApplicationModel.Wallet.WalletVerb> | Record<string, Windows.ApplicationModel.Wallet.WalletVerb>;
+  }
+  var IWalletItem: abstract new (...args: any[]) => IWalletItem;
+
+  interface IWalletItemCustomProperty {
+    AutoDetectLinks: boolean;
+    DetailViewPosition: number;
+    Name: string;
+    SummaryViewPosition: number;
+    Value: string;
+  }
+  var IWalletItemCustomProperty: abstract new (...args: any[]) => IWalletItemCustomProperty;
+
+  interface IWalletItemCustomPropertyFactory {
+    CreateWalletItemCustomProperty(name: string, value: string): Windows.ApplicationModel.Wallet.WalletItemCustomProperty;
+  }
+  var IWalletItemCustomPropertyFactory: abstract new (...args: any[]) => IWalletItemCustomPropertyFactory;
+
+  interface IWalletItemFactory {
+    CreateWalletItem(kind: number, displayName: string): Windows.ApplicationModel.Wallet.WalletItem;
+  }
+  var IWalletItemFactory: abstract new (...args: any[]) => IWalletItemFactory;
+
+  interface IWalletItemStore {
+    AddAsync(id: string, item: Windows.ApplicationModel.Wallet.WalletItem): Windows.Foundation.IAsyncAction;
+    ClearAsync(): Windows.Foundation.IAsyncAction;
+    DeleteAsync(id: string): Windows.Foundation.IAsyncAction;
+    GetItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Wallet.WalletItem> | Windows.ApplicationModel.Wallet.WalletItem[]>;
+    GetItemsAsync(kind: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Wallet.WalletItem> | Windows.ApplicationModel.Wallet.WalletItem[]>;
+    GetWalletItemAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Wallet.WalletItem>;
+    ImportItemAsync(stream: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Wallet.WalletItem>;
+    ShowAsync(): Windows.Foundation.IAsyncAction;
+    ShowAsync(id: string): Windows.Foundation.IAsyncAction;
+    UpdateAsync(item: Windows.ApplicationModel.Wallet.WalletItem): Windows.Foundation.IAsyncAction;
+  }
+  var IWalletItemStore: abstract new (...args: any[]) => IWalletItemStore;
+
+  interface IWalletItemStore2 {
+    ItemsChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Wallet.WalletItemStore, Object> | null;
+  }
+  var IWalletItemStore2: abstract new (...args: any[]) => IWalletItemStore2;
+
+  interface IWalletManagerStatics {
+    RequestStoreAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Wallet.WalletItemStore>;
+  }
+  var IWalletManagerStatics: abstract new (...args: any[]) => IWalletManagerStatics;
+
+  interface IWalletRelevantLocation {
+    DisplayMessage: string;
+    Position: Windows.Devices.Geolocation.BasicGeoposition;
+  }
+  var IWalletRelevantLocation: abstract new (...args: any[]) => IWalletRelevantLocation;
+
+  interface IWalletTransaction {
+    Description: string;
+    DisplayAmount: string;
+    DisplayLocation: string;
+    IgnoreTimeOfDay: boolean;
+    IsLaunchable: boolean;
+    TransactionDate: Windows.Foundation.DateTime | null;
+  }
+  var IWalletTransaction: abstract new (...args: any[]) => IWalletTransaction;
+
+  interface IWalletVerb {
+    Name: string;
+  }
+  var IWalletVerb: abstract new (...args: any[]) => IWalletVerb;
+
+  interface IWalletVerbFactory {
+    CreateWalletVerb(name: string): Windows.ApplicationModel.Wallet.WalletVerb;
+  }
+  var IWalletVerbFactory: abstract new (...args: any[]) => IWalletVerbFactory;
+
+  interface WalletContract {
+  }
+  var WalletContract: {
+    new(fields: {  }): WalletContract;
+  };
+
+}
+
+declare namespace Windows.ApplicationModel.Wallet.System {
+  class WalletItemSystemStore implements Windows.ApplicationModel.Wallet.System.IWalletItemSystemStore, Windows.ApplicationModel.Wallet.System.IWalletItemSystemStore2 {
+    DeleteAsync(item: Windows.ApplicationModel.Wallet.WalletItem): Windows.Foundation.IAsyncAction;
+    GetAppStatusForItem(item: Windows.ApplicationModel.Wallet.WalletItem): number;
+    GetItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Wallet.WalletItem> | Windows.ApplicationModel.Wallet.WalletItem[]>;
+    ImportItemAsync(stream: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Wallet.WalletItem>;
+    LaunchAppForItemAsync(item: Windows.ApplicationModel.Wallet.WalletItem): Windows.Foundation.IAsyncOperation<boolean>;
+    ItemsChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Wallet.System.WalletItemSystemStore, Object> | null;
+  }
+
+  class WalletManagerSystem {
+    static RequestStoreAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Wallet.System.WalletItemSystemStore>;
+  }
+
+  enum WalletItemAppAssociation {
+    None = 0,
+    AppInstalled = 1,
+    AppNotInstalled = 2,
+  }
+
+  interface IWalletItemSystemStore {
+    DeleteAsync(item: Windows.ApplicationModel.Wallet.WalletItem): Windows.Foundation.IAsyncAction;
+    GetAppStatusForItem(item: Windows.ApplicationModel.Wallet.WalletItem): number;
+    GetItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.Wallet.WalletItem> | Windows.ApplicationModel.Wallet.WalletItem[]>;
+    ImportItemAsync(stream: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Wallet.WalletItem>;
+    LaunchAppForItemAsync(item: Windows.ApplicationModel.Wallet.WalletItem): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IWalletItemSystemStore: abstract new (...args: any[]) => IWalletItemSystemStore;
+
+  interface IWalletItemSystemStore2 {
+    ItemsChanged: Windows.Foundation.TypedEventHandler<Windows.ApplicationModel.Wallet.System.WalletItemSystemStore, Object> | null;
+  }
+  var IWalletItemSystemStore2: abstract new (...args: any[]) => IWalletItemSystemStore2;
+
+  interface IWalletManagerSystemStatics {
+    RequestStoreAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.Wallet.System.WalletItemSystemStore>;
+  }
+  var IWalletManagerSystemStatics: abstract new (...args: any[]) => IWalletManagerSystemStatics;
+
+}
+
+declare namespace Windows.Data.Html {
+  class HtmlUtilities {
+    static ConvertToText(html: string): string;
+  }
+
+  interface IHtmlUtilities {
+    ConvertToText(html: string): string;
+  }
+  var IHtmlUtilities: abstract new (...args: any[]) => IHtmlUtilities;
+
+}
+
+declare namespace Windows.Data.Json {
+  class JsonArray implements Windows.Data.Json.IJsonArray, Windows.Data.Json.IJsonValue, Windows.Foundation.IStringable {
+    constructor();
+    Append(value: Windows.Data.Json.IJsonValue): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Data.Json.IJsonValue>;
+    GetArray(): Windows.Data.Json.JsonArray;
+    GetArrayAt(index: number): Windows.Data.Json.JsonArray;
+    GetAt(index: number): Windows.Data.Json.IJsonValue;
+    GetBoolean(): boolean;
+    GetBooleanAt(index: number): boolean;
+    GetMany(startIndex: number, items: Windows.Data.Json.IJsonValue[]): number;
+    GetNumber(): number;
+    GetNumberAt(index: number): number;
+    GetObject(): Windows.Data.Json.JsonObject;
+    GetObjectAt(index: number): Windows.Data.Json.JsonObject;
+    GetString(): string;
+    GetStringAt(index: number): string;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.Data.Json.IJsonValue> | Windows.Data.Json.IJsonValue[];
+    IndexOf(value: Windows.Data.Json.IJsonValue, index: number): boolean;
+    InsertAt(index: number, value: Windows.Data.Json.IJsonValue): void;
+    static Parse(input: string): Windows.Data.Json.JsonArray;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.Data.Json.IJsonValue[]): void;
+    SetAt(index: number, value: Windows.Data.Json.IJsonValue): void;
+    Stringify(): string;
+    ToString(): string;
+    static TryParse(input: string, result: Windows.Data.Json.JsonArray): boolean;
+    readonly Size: number;
+    readonly ValueType: number;
+  }
+
+  class JsonError {
+    static GetJsonStatus(hresult: number): number;
+  }
+
+  class JsonObject implements Windows.Data.Json.IJsonObject, Windows.Data.Json.IJsonObjectWithDefaultValues, Windows.Data.Json.IJsonValue, Windows.Foundation.IStringable {
+    constructor();
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Data.Json.IJsonValue>>;
+    GetArray(): Windows.Data.Json.JsonArray;
+    GetBoolean(): boolean;
+    GetNamedArray(name: string): Windows.Data.Json.JsonArray;
+    GetNamedArray(name: string, defaultValue: Windows.Data.Json.JsonArray): Windows.Data.Json.JsonArray;
+    GetNamedBoolean(name: string): boolean;
+    GetNamedBoolean(name: string, defaultValue: boolean): boolean;
+    GetNamedNumber(name: string): number;
+    GetNamedNumber(name: string, defaultValue: number): number;
+    GetNamedObject(name: string): Windows.Data.Json.JsonObject;
+    GetNamedObject(name: string, defaultValue: Windows.Data.Json.JsonObject): Windows.Data.Json.JsonObject;
+    GetNamedString(name: string): string;
+    GetNamedString(name: string, defaultValue: string): string;
+    GetNamedValue(name: string): Windows.Data.Json.JsonValue;
+    GetNamedValue(name: string, defaultValue: Windows.Data.Json.JsonValue): Windows.Data.Json.JsonValue;
+    GetNumber(): number;
+    GetObject(): Windows.Data.Json.JsonObject;
+    GetString(): string;
+    GetView(): Windows.Foundation.Collections.IMapView<string, Windows.Data.Json.IJsonValue>;
+    HasKey(key: string): boolean;
+    Insert(key: string, value: Windows.Data.Json.IJsonValue): boolean;
+    Lookup(key: string): Windows.Data.Json.IJsonValue;
+    static Parse(input: string): Windows.Data.Json.JsonObject;
+    Remove(key: string): void;
+    SetNamedValue(name: string, value: Windows.Data.Json.IJsonValue): void;
+    Stringify(): string;
+    ToString(): string;
+    static TryParse(input: string, result: Windows.Data.Json.JsonObject): boolean;
+    readonly Size: number;
+    readonly ValueType: number;
+  }
+
+  class JsonValue implements Windows.Data.Json.IJsonValue, Windows.Foundation.IStringable {
+    static CreateBooleanValue(input: boolean): Windows.Data.Json.JsonValue;
+    static CreateNullValue(): Windows.Data.Json.JsonValue;
+    static CreateNumberValue(input: number): Windows.Data.Json.JsonValue;
+    static CreateStringValue(input: string): Windows.Data.Json.JsonValue;
+    GetArray(): Windows.Data.Json.JsonArray;
+    GetBoolean(): boolean;
+    GetNumber(): number;
+    GetObject(): Windows.Data.Json.JsonObject;
+    GetString(): string;
+    static Parse(input: string): Windows.Data.Json.JsonValue;
+    Stringify(): string;
+    ToString(): string;
+    static TryParse(input: string, result: Windows.Data.Json.JsonValue): boolean;
+    readonly ValueType: number;
+  }
+
+  enum JsonErrorStatus {
+    Unknown = 0,
+    InvalidJsonString = 1,
+    InvalidJsonNumber = 2,
+    JsonValueNotFound = 3,
+    ImplementationLimit = 4,
+  }
+
+  enum JsonValueType {
+    Null = 0,
+    Boolean = 1,
+    Number = 2,
+    String = 3,
+    Array = 4,
+    Object = 5,
+  }
+
+  interface IJsonArray extends Windows.Data.Json.IJsonValue {
+    GetArray(): Windows.Data.Json.JsonArray;
+    GetArrayAt(index: number): Windows.Data.Json.JsonArray;
+    GetBoolean(): boolean;
+    GetBooleanAt(index: number): boolean;
+    GetNumber(): number;
+    GetNumberAt(index: number): number;
+    GetObject(): Windows.Data.Json.JsonObject;
+    GetObjectAt(index: number): Windows.Data.Json.JsonObject;
+    GetString(): string;
+    GetStringAt(index: number): string;
+    Stringify(): string;
+  }
+  var IJsonArray: abstract new (...args: any[]) => IJsonArray;
+
+  interface IJsonArrayStatics {
+    Parse(input: string): Windows.Data.Json.JsonArray;
+    TryParse(input: string, result: Windows.Data.Json.JsonArray): boolean;
+  }
+  var IJsonArrayStatics: abstract new (...args: any[]) => IJsonArrayStatics;
+
+  interface IJsonErrorStatics2 {
+    GetJsonStatus(hresult: number): number;
+  }
+  var IJsonErrorStatics2: abstract new (...args: any[]) => IJsonErrorStatics2;
+
+  interface IJsonObject extends Windows.Data.Json.IJsonValue {
+    GetArray(): Windows.Data.Json.JsonArray;
+    GetBoolean(): boolean;
+    GetNamedArray(name: string): Windows.Data.Json.JsonArray;
+    GetNamedBoolean(name: string): boolean;
+    GetNamedNumber(name: string): number;
+    GetNamedObject(name: string): Windows.Data.Json.JsonObject;
+    GetNamedString(name: string): string;
+    GetNamedValue(name: string): Windows.Data.Json.JsonValue;
+    GetNumber(): number;
+    GetObject(): Windows.Data.Json.JsonObject;
+    GetString(): string;
+    SetNamedValue(name: string, value: Windows.Data.Json.IJsonValue): void;
+    Stringify(): string;
+  }
+  var IJsonObject: abstract new (...args: any[]) => IJsonObject;
+
+  interface IJsonObjectStatics {
+    Parse(input: string): Windows.Data.Json.JsonObject;
+    TryParse(input: string, result: Windows.Data.Json.JsonObject): boolean;
+  }
+  var IJsonObjectStatics: abstract new (...args: any[]) => IJsonObjectStatics;
+
+  interface IJsonObjectWithDefaultValues extends Windows.Data.Json.IJsonObject, Windows.Data.Json.IJsonValue {
+    GetArray(): Windows.Data.Json.JsonArray;
+    GetBoolean(): boolean;
+    GetNamedArray(name: string, defaultValue: Windows.Data.Json.JsonArray): Windows.Data.Json.JsonArray;
+    GetNamedArray(name: string): Windows.Data.Json.JsonArray;
+    GetNamedBoolean(name: string, defaultValue: boolean): boolean;
+    GetNamedBoolean(name: string): boolean;
+    GetNamedNumber(name: string, defaultValue: number): number;
+    GetNamedNumber(name: string): number;
+    GetNamedObject(name: string, defaultValue: Windows.Data.Json.JsonObject): Windows.Data.Json.JsonObject;
+    GetNamedObject(name: string): Windows.Data.Json.JsonObject;
+    GetNamedString(name: string, defaultValue: string): string;
+    GetNamedString(name: string): string;
+    GetNamedValue(name: string, defaultValue: Windows.Data.Json.JsonValue): Windows.Data.Json.JsonValue;
+    GetNamedValue(name: string): Windows.Data.Json.JsonValue;
+    GetNumber(): number;
+    GetObject(): Windows.Data.Json.JsonObject;
+    GetString(): string;
+    SetNamedValue(name: string, value: Windows.Data.Json.IJsonValue): void;
+    Stringify(): string;
+  }
+  var IJsonObjectWithDefaultValues: abstract new (...args: any[]) => IJsonObjectWithDefaultValues;
+
+  interface IJsonValue {
+    GetArray(): Windows.Data.Json.JsonArray;
+    GetBoolean(): boolean;
+    GetNumber(): number;
+    GetObject(): Windows.Data.Json.JsonObject;
+    GetString(): string;
+    Stringify(): string;
+    readonly ValueType: number;
+  }
+  var IJsonValue: abstract new (...args: any[]) => IJsonValue;
+
+  interface IJsonValueStatics {
+    CreateBooleanValue(input: boolean): Windows.Data.Json.JsonValue;
+    CreateNumberValue(input: number): Windows.Data.Json.JsonValue;
+    CreateStringValue(input: string): Windows.Data.Json.JsonValue;
+    Parse(input: string): Windows.Data.Json.JsonValue;
+    TryParse(input: string, result: Windows.Data.Json.JsonValue): boolean;
+  }
+  var IJsonValueStatics: abstract new (...args: any[]) => IJsonValueStatics;
+
+  interface IJsonValueStatics2 {
+    CreateNullValue(): Windows.Data.Json.JsonValue;
+  }
+  var IJsonValueStatics2: abstract new (...args: any[]) => IJsonValueStatics2;
+
+}
+
+declare namespace Windows.Data.Pdf {
+  class PdfDocument implements Windows.Data.Pdf.IPdfDocument {
+    GetPage(pageIndex: number): Windows.Data.Pdf.PdfPage;
+    static LoadFromFileAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Data.Pdf.PdfDocument>;
+    static LoadFromFileAsync(file: Windows.Storage.IStorageFile, password: string): Windows.Foundation.IAsyncOperation<Windows.Data.Pdf.PdfDocument>;
+    static LoadFromStreamAsync(inputStream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<Windows.Data.Pdf.PdfDocument>;
+    static LoadFromStreamAsync(inputStream: Windows.Storage.Streams.IRandomAccessStream, password: string): Windows.Foundation.IAsyncOperation<Windows.Data.Pdf.PdfDocument>;
+    readonly IsPasswordProtected: boolean;
+    readonly PageCount: number;
+  }
+
+  class PdfPage implements Windows.Data.Pdf.IPdfPage, Windows.Foundation.IClosable {
+    Close(): void;
+    PreparePageAsync(): Windows.Foundation.IAsyncAction;
+    RenderToStreamAsync(outputStream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    RenderToStreamAsync(outputStream: Windows.Storage.Streams.IRandomAccessStream, options: Windows.Data.Pdf.PdfPageRenderOptions): Windows.Foundation.IAsyncAction;
+    readonly Dimensions: Windows.Data.Pdf.PdfPageDimensions;
+    readonly Index: number;
+    readonly PreferredZoom: number;
+    readonly Rotation: number;
+    readonly Size: Windows.Foundation.Size;
+  }
+
+  class PdfPageDimensions implements Windows.Data.Pdf.IPdfPageDimensions {
+    readonly ArtBox: Windows.Foundation.Rect;
+    readonly BleedBox: Windows.Foundation.Rect;
+    readonly CropBox: Windows.Foundation.Rect;
+    readonly MediaBox: Windows.Foundation.Rect;
+    readonly TrimBox: Windows.Foundation.Rect;
+  }
+
+  class PdfPageRenderOptions implements Windows.Data.Pdf.IPdfPageRenderOptions {
+    constructor();
+    BackgroundColor: Windows.UI.Color;
+    BitmapEncoderId: Guid;
+    DestinationHeight: number;
+    DestinationWidth: number;
+    IsIgnoringHighContrast: boolean;
+    SourceRect: Windows.Foundation.Rect;
+  }
+
+  enum PdfPageRotation {
+    Normal = 0,
+    Rotate90 = 1,
+    Rotate180 = 2,
+    Rotate270 = 3,
+  }
+
+  interface IPdfDocument {
+    GetPage(pageIndex: number): Windows.Data.Pdf.PdfPage;
+    readonly IsPasswordProtected: boolean;
+    readonly PageCount: number;
+  }
+  var IPdfDocument: abstract new (...args: any[]) => IPdfDocument;
+
+  interface IPdfDocumentStatics {
+    LoadFromFileAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Data.Pdf.PdfDocument>;
+    LoadFromFileAsync(file: Windows.Storage.IStorageFile, password: string): Windows.Foundation.IAsyncOperation<Windows.Data.Pdf.PdfDocument>;
+    LoadFromStreamAsync(inputStream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<Windows.Data.Pdf.PdfDocument>;
+    LoadFromStreamAsync(inputStream: Windows.Storage.Streams.IRandomAccessStream, password: string): Windows.Foundation.IAsyncOperation<Windows.Data.Pdf.PdfDocument>;
+  }
+  var IPdfDocumentStatics: abstract new (...args: any[]) => IPdfDocumentStatics;
+
+  interface IPdfPage {
+    PreparePageAsync(): Windows.Foundation.IAsyncAction;
+    RenderToStreamAsync(outputStream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    RenderToStreamAsync(outputStream: Windows.Storage.Streams.IRandomAccessStream, options: Windows.Data.Pdf.PdfPageRenderOptions): Windows.Foundation.IAsyncAction;
+    readonly Dimensions: Windows.Data.Pdf.PdfPageDimensions;
+    readonly Index: number;
+    readonly PreferredZoom: number;
+    readonly Rotation: number;
+    readonly Size: Windows.Foundation.Size;
+  }
+  var IPdfPage: abstract new (...args: any[]) => IPdfPage;
+
+  interface IPdfPageDimensions {
+    readonly ArtBox: Windows.Foundation.Rect;
+    readonly BleedBox: Windows.Foundation.Rect;
+    readonly CropBox: Windows.Foundation.Rect;
+    readonly MediaBox: Windows.Foundation.Rect;
+    readonly TrimBox: Windows.Foundation.Rect;
+  }
+  var IPdfPageDimensions: abstract new (...args: any[]) => IPdfPageDimensions;
+
+  interface IPdfPageRenderOptions {
+    BackgroundColor: Windows.UI.Color;
+    BitmapEncoderId: Guid;
+    DestinationHeight: number;
+    DestinationWidth: number;
+    IsIgnoringHighContrast: boolean;
+    SourceRect: Windows.Foundation.Rect;
+  }
+  var IPdfPageRenderOptions: abstract new (...args: any[]) => IPdfPageRenderOptions;
+
+}
+
+declare namespace Windows.Data.Text {
+  class AlternateWordForm implements Windows.Data.Text.IAlternateWordForm {
+    readonly AlternateText: string;
+    readonly NormalizationFormat: number;
+    readonly SourceTextSegment: Windows.Data.Text.TextSegment;
+  }
+
+  class SelectableWordSegment implements Windows.Data.Text.ISelectableWordSegment {
+    readonly SourceTextSegment: Windows.Data.Text.TextSegment;
+    readonly Text: string;
+  }
+
+  class SelectableWordsSegmenter implements Windows.Data.Text.ISelectableWordsSegmenter {
+    constructor(language: string);
+    GetTokenAt(text: string, startIndex: number): Windows.Data.Text.SelectableWordSegment;
+    GetTokens(text: string): Windows.Foundation.Collections.IVectorView<Windows.Data.Text.SelectableWordSegment> | Windows.Data.Text.SelectableWordSegment[];
+    Tokenize(text: string, startIndex: number, handler: Windows.Data.Text.SelectableWordSegmentsTokenizingHandler): void;
+    readonly ResolvedLanguage: string;
+  }
+
+  class SemanticTextQuery implements Windows.Data.Text.ISemanticTextQuery {
+    constructor(aqsFilter: string);
+    constructor(aqsFilter: string, filterLanguage: string);
+    Find(content: string): Windows.Foundation.Collections.IVectorView<Windows.Data.Text.TextSegment> | Windows.Data.Text.TextSegment[];
+    FindInProperty(propertyContent: string, propertyName: string): Windows.Foundation.Collections.IVectorView<Windows.Data.Text.TextSegment> | Windows.Data.Text.TextSegment[];
+  }
+
+  class TextConversionGenerator implements Windows.Data.Text.ITextConversionGenerator {
+    constructor(languageTag: string);
+    GetCandidatesAsync(input: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    GetCandidatesAsync(input: string, maxCandidates: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    readonly LanguageAvailableButNotInstalled: boolean;
+    readonly ResolvedLanguage: string;
+  }
+
+  class TextPhoneme implements Windows.Data.Text.ITextPhoneme {
+    readonly DisplayText: string;
+    readonly ReadingText: string;
+  }
+
+  class TextPredictionGenerator implements Windows.Data.Text.ITextPredictionGenerator, Windows.Data.Text.ITextPredictionGenerator2 {
+    constructor(languageTag: string);
+    GetCandidatesAsync(input: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    GetCandidatesAsync(input: string, maxCandidates: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    GetCandidatesAsync(input: string, maxCandidates: number, predictionOptions: number, previousStrings: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    GetNextWordCandidatesAsync(maxCandidates: number, previousStrings: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    InputScope: number;
+    readonly LanguageAvailableButNotInstalled: boolean;
+    readonly ResolvedLanguage: string;
+  }
+
+  class TextReverseConversionGenerator implements Windows.Data.Text.ITextReverseConversionGenerator, Windows.Data.Text.ITextReverseConversionGenerator2 {
+    constructor(languageTag: string);
+    ConvertBackAsync(input: string): Windows.Foundation.IAsyncOperation<string>;
+    GetPhonemesAsync(input: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Data.Text.TextPhoneme> | Windows.Data.Text.TextPhoneme[]>;
+    readonly LanguageAvailableButNotInstalled: boolean;
+    readonly ResolvedLanguage: string;
+  }
+
+  class UnicodeCharacters {
+    static GetCodepointFromSurrogatePair(highSurrogate: number, lowSurrogate: number): number;
+    static GetGeneralCategory(codepoint: number): number;
+    static GetNumericType(codepoint: number): number;
+    static GetSurrogatePairFromCodepoint(codepoint: number, highSurrogate: string, lowSurrogate: string): void;
+    static IsAlphabetic(codepoint: number): boolean;
+    static IsCased(codepoint: number): boolean;
+    static IsGraphemeBase(codepoint: number): boolean;
+    static IsGraphemeExtend(codepoint: number): boolean;
+    static IsHighSurrogate(codepoint: number): boolean;
+    static IsIdContinue(codepoint: number): boolean;
+    static IsIdStart(codepoint: number): boolean;
+    static IsLowSurrogate(codepoint: number): boolean;
+    static IsLowercase(codepoint: number): boolean;
+    static IsNoncharacter(codepoint: number): boolean;
+    static IsSupplementary(codepoint: number): boolean;
+    static IsUppercase(codepoint: number): boolean;
+    static IsWhitespace(codepoint: number): boolean;
+  }
+
+  class WordSegment implements Windows.Data.Text.IWordSegment {
+    readonly AlternateForms: Windows.Foundation.Collections.IVectorView<Windows.Data.Text.AlternateWordForm> | Windows.Data.Text.AlternateWordForm[];
+    readonly SourceTextSegment: Windows.Data.Text.TextSegment;
+    readonly Text: string;
+  }
+
+  class WordsSegmenter implements Windows.Data.Text.IWordsSegmenter {
+    constructor(language: string);
+    GetTokenAt(text: string, startIndex: number): Windows.Data.Text.WordSegment;
+    GetTokens(text: string): Windows.Foundation.Collections.IVectorView<Windows.Data.Text.WordSegment> | Windows.Data.Text.WordSegment[];
+    Tokenize(text: string, startIndex: number, handler: Windows.Data.Text.WordSegmentsTokenizingHandler): void;
+    readonly ResolvedLanguage: string;
+  }
+
+  enum AlternateNormalizationFormat {
+    NotNormalized = 0,
+    Number = 1,
+    Currency = 3,
+    Date = 4,
+    Time = 5,
+  }
+
+  enum TextPredictionOptions {
+    None = 0,
+    Predictions = 1,
+    Corrections = 2,
+  }
+
+  enum UnicodeGeneralCategory {
+    UppercaseLetter = 0,
+    LowercaseLetter = 1,
+    TitlecaseLetter = 2,
+    ModifierLetter = 3,
+    OtherLetter = 4,
+    NonspacingMark = 5,
+    SpacingCombiningMark = 6,
+    EnclosingMark = 7,
+    DecimalDigitNumber = 8,
+    LetterNumber = 9,
+    OtherNumber = 10,
+    SpaceSeparator = 11,
+    LineSeparator = 12,
+    ParagraphSeparator = 13,
+    Control = 14,
+    Format = 15,
+    Surrogate = 16,
+    PrivateUse = 17,
+    ConnectorPunctuation = 18,
+    DashPunctuation = 19,
+    OpenPunctuation = 20,
+    ClosePunctuation = 21,
+    InitialQuotePunctuation = 22,
+    FinalQuotePunctuation = 23,
+    OtherPunctuation = 24,
+    MathSymbol = 25,
+    CurrencySymbol = 26,
+    ModifierSymbol = 27,
+    OtherSymbol = 28,
+    NotAssigned = 29,
+  }
+
+  enum UnicodeNumericType {
+    None = 0,
+    Decimal = 1,
+    Digit = 2,
+    Numeric = 3,
+  }
+
+  interface IAlternateWordForm {
+    readonly AlternateText: string;
+    readonly NormalizationFormat: number;
+    readonly SourceTextSegment: Windows.Data.Text.TextSegment;
+  }
+  var IAlternateWordForm: abstract new (...args: any[]) => IAlternateWordForm;
+
+  interface ISelectableWordSegment {
+    readonly SourceTextSegment: Windows.Data.Text.TextSegment;
+    readonly Text: string;
+  }
+  var ISelectableWordSegment: abstract new (...args: any[]) => ISelectableWordSegment;
+
+  interface ISelectableWordsSegmenter {
+    GetTokenAt(text: string, startIndex: number): Windows.Data.Text.SelectableWordSegment;
+    GetTokens(text: string): Windows.Foundation.Collections.IVectorView<Windows.Data.Text.SelectableWordSegment> | Windows.Data.Text.SelectableWordSegment[];
+    Tokenize(text: string, startIndex: number, handler: Windows.Data.Text.SelectableWordSegmentsTokenizingHandler): void;
+    readonly ResolvedLanguage: string;
+  }
+  var ISelectableWordsSegmenter: abstract new (...args: any[]) => ISelectableWordsSegmenter;
+
+  interface ISelectableWordsSegmenterFactory {
+    CreateWithLanguage(language: string): Windows.Data.Text.SelectableWordsSegmenter;
+  }
+  var ISelectableWordsSegmenterFactory: abstract new (...args: any[]) => ISelectableWordsSegmenterFactory;
+
+  interface ISemanticTextQuery {
+    Find(content: string): Windows.Foundation.Collections.IVectorView<Windows.Data.Text.TextSegment> | Windows.Data.Text.TextSegment[];
+    FindInProperty(propertyContent: string, propertyName: string): Windows.Foundation.Collections.IVectorView<Windows.Data.Text.TextSegment> | Windows.Data.Text.TextSegment[];
+  }
+  var ISemanticTextQuery: abstract new (...args: any[]) => ISemanticTextQuery;
+
+  interface ISemanticTextQueryFactory {
+    Create(aqsFilter: string): Windows.Data.Text.SemanticTextQuery;
+    CreateWithLanguage(aqsFilter: string, filterLanguage: string): Windows.Data.Text.SemanticTextQuery;
+  }
+  var ISemanticTextQueryFactory: abstract new (...args: any[]) => ISemanticTextQueryFactory;
+
+  interface ITextConversionGenerator {
+    GetCandidatesAsync(input: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    GetCandidatesAsync(input: string, maxCandidates: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    readonly LanguageAvailableButNotInstalled: boolean;
+    readonly ResolvedLanguage: string;
+  }
+  var ITextConversionGenerator: abstract new (...args: any[]) => ITextConversionGenerator;
+
+  interface ITextConversionGeneratorFactory {
+    Create(languageTag: string): Windows.Data.Text.TextConversionGenerator;
+  }
+  var ITextConversionGeneratorFactory: abstract new (...args: any[]) => ITextConversionGeneratorFactory;
+
+  interface ITextPhoneme {
+    readonly DisplayText: string;
+    readonly ReadingText: string;
+  }
+  var ITextPhoneme: abstract new (...args: any[]) => ITextPhoneme;
+
+  interface ITextPredictionGenerator {
+    GetCandidatesAsync(input: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    GetCandidatesAsync(input: string, maxCandidates: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    readonly LanguageAvailableButNotInstalled: boolean;
+    readonly ResolvedLanguage: string;
+  }
+  var ITextPredictionGenerator: abstract new (...args: any[]) => ITextPredictionGenerator;
+
+  interface ITextPredictionGenerator2 {
+    GetCandidatesAsync(input: string, maxCandidates: number, predictionOptions: number, previousStrings: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    GetNextWordCandidatesAsync(maxCandidates: number, previousStrings: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    InputScope: number;
+  }
+  var ITextPredictionGenerator2: abstract new (...args: any[]) => ITextPredictionGenerator2;
+
+  interface ITextPredictionGeneratorFactory {
+    Create(languageTag: string): Windows.Data.Text.TextPredictionGenerator;
+  }
+  var ITextPredictionGeneratorFactory: abstract new (...args: any[]) => ITextPredictionGeneratorFactory;
+
+  interface ITextReverseConversionGenerator {
+    ConvertBackAsync(input: string): Windows.Foundation.IAsyncOperation<string>;
+    readonly LanguageAvailableButNotInstalled: boolean;
+    readonly ResolvedLanguage: string;
+  }
+  var ITextReverseConversionGenerator: abstract new (...args: any[]) => ITextReverseConversionGenerator;
+
+  interface ITextReverseConversionGenerator2 {
+    GetPhonemesAsync(input: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Data.Text.TextPhoneme> | Windows.Data.Text.TextPhoneme[]>;
+  }
+  var ITextReverseConversionGenerator2: abstract new (...args: any[]) => ITextReverseConversionGenerator2;
+
+  interface ITextReverseConversionGeneratorFactory {
+    Create(languageTag: string): Windows.Data.Text.TextReverseConversionGenerator;
+  }
+  var ITextReverseConversionGeneratorFactory: abstract new (...args: any[]) => ITextReverseConversionGeneratorFactory;
+
+  interface IUnicodeCharactersStatics {
+    GetCodepointFromSurrogatePair(highSurrogate: number, lowSurrogate: number): number;
+    GetGeneralCategory(codepoint: number): number;
+    GetNumericType(codepoint: number): number;
+    GetSurrogatePairFromCodepoint(codepoint: number, highSurrogate: string, lowSurrogate: string): void;
+    IsAlphabetic(codepoint: number): boolean;
+    IsCased(codepoint: number): boolean;
+    IsGraphemeBase(codepoint: number): boolean;
+    IsGraphemeExtend(codepoint: number): boolean;
+    IsHighSurrogate(codepoint: number): boolean;
+    IsIdContinue(codepoint: number): boolean;
+    IsIdStart(codepoint: number): boolean;
+    IsLowSurrogate(codepoint: number): boolean;
+    IsLowercase(codepoint: number): boolean;
+    IsNoncharacter(codepoint: number): boolean;
+    IsSupplementary(codepoint: number): boolean;
+    IsUppercase(codepoint: number): boolean;
+    IsWhitespace(codepoint: number): boolean;
+  }
+  var IUnicodeCharactersStatics: abstract new (...args: any[]) => IUnicodeCharactersStatics;
+
+  interface IWordSegment {
+    readonly AlternateForms: Windows.Foundation.Collections.IVectorView<Windows.Data.Text.AlternateWordForm> | Windows.Data.Text.AlternateWordForm[];
+    readonly SourceTextSegment: Windows.Data.Text.TextSegment;
+    readonly Text: string;
+  }
+  var IWordSegment: abstract new (...args: any[]) => IWordSegment;
+
+  interface IWordsSegmenter {
+    GetTokenAt(text: string, startIndex: number): Windows.Data.Text.WordSegment;
+    GetTokens(text: string): Windows.Foundation.Collections.IVectorView<Windows.Data.Text.WordSegment> | Windows.Data.Text.WordSegment[];
+    Tokenize(text: string, startIndex: number, handler: Windows.Data.Text.WordSegmentsTokenizingHandler): void;
+    readonly ResolvedLanguage: string;
+  }
+  var IWordsSegmenter: abstract new (...args: any[]) => IWordsSegmenter;
+
+  interface IWordsSegmenterFactory {
+    CreateWithLanguage(language: string): Windows.Data.Text.WordsSegmenter;
+  }
+  var IWordsSegmenterFactory: abstract new (...args: any[]) => IWordsSegmenterFactory;
+
+  interface SelectableWordSegmentsTokenizingHandler {
+    (precedingWords: Windows.Foundation.Collections.IIterable<Windows.Data.Text.SelectableWordSegment> | Windows.Data.Text.SelectableWordSegment[], words: Windows.Foundation.Collections.IIterable<Windows.Data.Text.SelectableWordSegment> | Windows.Data.Text.SelectableWordSegment[]): void;
+  }
+  var SelectableWordSegmentsTokenizingHandler: {
+    new(callback: (precedingWords: Windows.Foundation.Collections.IIterable<Windows.Data.Text.SelectableWordSegment> | Windows.Data.Text.SelectableWordSegment[], words: Windows.Foundation.Collections.IIterable<Windows.Data.Text.SelectableWordSegment> | Windows.Data.Text.SelectableWordSegment[]) => void): SelectableWordSegmentsTokenizingHandler;
+  };
+
+  interface TextSegment {
+    StartPosition: number;
+    Length: number;
+  }
+  var TextSegment: {
+    new(startPosition: number, length: number): TextSegment;
+    new(fields: { StartPosition?: number; Length?: number }): TextSegment;
+  };
+
+  interface WordSegmentsTokenizingHandler {
+    (precedingWords: Windows.Foundation.Collections.IIterable<Windows.Data.Text.WordSegment> | Windows.Data.Text.WordSegment[], words: Windows.Foundation.Collections.IIterable<Windows.Data.Text.WordSegment> | Windows.Data.Text.WordSegment[]): void;
+  }
+  var WordSegmentsTokenizingHandler: {
+    new(callback: (precedingWords: Windows.Foundation.Collections.IIterable<Windows.Data.Text.WordSegment> | Windows.Data.Text.WordSegment[], words: Windows.Foundation.Collections.IIterable<Windows.Data.Text.WordSegment> | Windows.Data.Text.WordSegment[]) => void): WordSegmentsTokenizingHandler;
+  };
+
+}
+
+declare namespace Windows.Data.Xml.Dom {
+  class DtdEntity implements Windows.Data.Xml.Dom.IDtdEntity, Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    readonly Attributes: Windows.Data.Xml.Dom.XmlNamedNodeMap;
+    readonly ChildNodes: Windows.Data.Xml.Dom.XmlNodeList;
+    readonly FirstChild: Windows.Data.Xml.Dom.IXmlNode;
+    InnerText: string;
+    readonly LastChild: Windows.Data.Xml.Dom.IXmlNode;
+    readonly LocalName: Object;
+    readonly NamespaceUri: Object;
+    readonly NextSibling: Windows.Data.Xml.Dom.IXmlNode;
+    readonly NodeName: string;
+    readonly NodeType: number;
+    NodeValue: Object;
+    readonly NotationName: Object;
+    readonly OwnerDocument: Windows.Data.Xml.Dom.XmlDocument;
+    readonly ParentNode: Windows.Data.Xml.Dom.IXmlNode;
+    Prefix: Object;
+    readonly PreviousSibling: Windows.Data.Xml.Dom.IXmlNode;
+    readonly PublicId: Object;
+    readonly SystemId: Object;
+  }
+
+  class DtdNotation implements Windows.Data.Xml.Dom.IDtdNotation, Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    readonly Attributes: Windows.Data.Xml.Dom.XmlNamedNodeMap;
+    readonly ChildNodes: Windows.Data.Xml.Dom.XmlNodeList;
+    readonly FirstChild: Windows.Data.Xml.Dom.IXmlNode;
+    InnerText: string;
+    readonly LastChild: Windows.Data.Xml.Dom.IXmlNode;
+    readonly LocalName: Object;
+    readonly NamespaceUri: Object;
+    readonly NextSibling: Windows.Data.Xml.Dom.IXmlNode;
+    readonly NodeName: string;
+    readonly NodeType: number;
+    NodeValue: Object;
+    readonly OwnerDocument: Windows.Data.Xml.Dom.XmlDocument;
+    readonly ParentNode: Windows.Data.Xml.Dom.IXmlNode;
+    Prefix: Object;
+    readonly PreviousSibling: Windows.Data.Xml.Dom.IXmlNode;
+    readonly PublicId: Object;
+    readonly SystemId: Object;
+  }
+
+  class XmlAttribute implements Windows.Data.Xml.Dom.IXmlAttribute, Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    readonly Attributes: Windows.Data.Xml.Dom.XmlNamedNodeMap;
+    readonly ChildNodes: Windows.Data.Xml.Dom.XmlNodeList;
+    readonly FirstChild: Windows.Data.Xml.Dom.IXmlNode;
+    InnerText: string;
+    readonly LastChild: Windows.Data.Xml.Dom.IXmlNode;
+    readonly LocalName: Object;
+    readonly Name: string;
+    readonly NamespaceUri: Object;
+    readonly NextSibling: Windows.Data.Xml.Dom.IXmlNode;
+    readonly NodeName: string;
+    readonly NodeType: number;
+    NodeValue: Object;
+    readonly OwnerDocument: Windows.Data.Xml.Dom.XmlDocument;
+    readonly ParentNode: Windows.Data.Xml.Dom.IXmlNode;
+    Prefix: Object;
+    readonly PreviousSibling: Windows.Data.Xml.Dom.IXmlNode;
+    readonly Specified: boolean;
+    Value: string;
+  }
+
+  class XmlCDataSection implements Windows.Data.Xml.Dom.IXmlCDataSection, Windows.Data.Xml.Dom.IXmlCharacterData, Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer, Windows.Data.Xml.Dom.IXmlText {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    AppendData(data: string): void;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    DeleteData(offset: number, count: number): void;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    InsertData(offset: number, data: string): void;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceData(offset: number, count: number, data: string): void;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    SplitText(offset: number): Windows.Data.Xml.Dom.IXmlText;
+    SubstringData(offset: number, count: number): string;
+    readonly Attributes: Windows.Data.Xml.Dom.XmlNamedNodeMap;
+    readonly ChildNodes: Windows.Data.Xml.Dom.XmlNodeList;
+    Data: string;
+    readonly FirstChild: Windows.Data.Xml.Dom.IXmlNode;
+    InnerText: string;
+    readonly LastChild: Windows.Data.Xml.Dom.IXmlNode;
+    readonly Length: number;
+    readonly LocalName: Object;
+    readonly NamespaceUri: Object;
+    readonly NextSibling: Windows.Data.Xml.Dom.IXmlNode;
+    readonly NodeName: string;
+    readonly NodeType: number;
+    NodeValue: Object;
+    readonly OwnerDocument: Windows.Data.Xml.Dom.XmlDocument;
+    readonly ParentNode: Windows.Data.Xml.Dom.IXmlNode;
+    Prefix: Object;
+    readonly PreviousSibling: Windows.Data.Xml.Dom.IXmlNode;
+  }
+
+  class XmlComment implements Windows.Data.Xml.Dom.IXmlCharacterData, Windows.Data.Xml.Dom.IXmlComment, Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    AppendData(data: string): void;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    DeleteData(offset: number, count: number): void;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    InsertData(offset: number, data: string): void;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceData(offset: number, count: number, data: string): void;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    SubstringData(offset: number, count: number): string;
+    readonly Attributes: Windows.Data.Xml.Dom.XmlNamedNodeMap;
+    readonly ChildNodes: Windows.Data.Xml.Dom.XmlNodeList;
+    Data: string;
+    readonly FirstChild: Windows.Data.Xml.Dom.IXmlNode;
+    InnerText: string;
+    readonly LastChild: Windows.Data.Xml.Dom.IXmlNode;
+    readonly Length: number;
+    readonly LocalName: Object;
+    readonly NamespaceUri: Object;
+    readonly NextSibling: Windows.Data.Xml.Dom.IXmlNode;
+    readonly NodeName: string;
+    readonly NodeType: number;
+    NodeValue: Object;
+    readonly OwnerDocument: Windows.Data.Xml.Dom.XmlDocument;
+    readonly ParentNode: Windows.Data.Xml.Dom.IXmlNode;
+    Prefix: Object;
+    readonly PreviousSibling: Windows.Data.Xml.Dom.IXmlNode;
+  }
+
+  class XmlDocument implements Windows.Data.Xml.Dom.IXmlDocument, Windows.Data.Xml.Dom.IXmlDocumentIO, Windows.Data.Xml.Dom.IXmlDocumentIO2, Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    constructor();
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    CreateAttribute(name: string): Windows.Data.Xml.Dom.XmlAttribute;
+    CreateAttributeNS(namespaceUri: Object, qualifiedName: string): Windows.Data.Xml.Dom.XmlAttribute;
+    CreateCDataSection(data: string): Windows.Data.Xml.Dom.XmlCDataSection;
+    CreateComment(data: string): Windows.Data.Xml.Dom.XmlComment;
+    CreateDocumentFragment(): Windows.Data.Xml.Dom.XmlDocumentFragment;
+    CreateElement(tagName: string): Windows.Data.Xml.Dom.XmlElement;
+    CreateElementNS(namespaceUri: Object, qualifiedName: string): Windows.Data.Xml.Dom.XmlElement;
+    CreateEntityReference(name: string): Windows.Data.Xml.Dom.XmlEntityReference;
+    CreateProcessingInstruction(target: string, data: string): Windows.Data.Xml.Dom.XmlProcessingInstruction;
+    CreateTextNode(data: string): Windows.Data.Xml.Dom.XmlText;
+    GetElementById(elementId: string): Windows.Data.Xml.Dom.XmlElement;
+    GetElementsByTagName(tagName: string): Windows.Data.Xml.Dom.XmlNodeList;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    ImportNode(node: Windows.Data.Xml.Dom.IXmlNode, deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    static LoadFromFileAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Data.Xml.Dom.XmlDocument>;
+    static LoadFromFileAsync(file: Windows.Storage.IStorageFile, loadSettings: Windows.Data.Xml.Dom.XmlLoadSettings): Windows.Foundation.IAsyncOperation<Windows.Data.Xml.Dom.XmlDocument>;
+    static LoadFromUriAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Data.Xml.Dom.XmlDocument>;
+    static LoadFromUriAsync(uri: Windows.Foundation.Uri, loadSettings: Windows.Data.Xml.Dom.XmlLoadSettings): Windows.Foundation.IAsyncOperation<Windows.Data.Xml.Dom.XmlDocument>;
+    LoadXml(xml: string): void;
+    LoadXml(xml: string, loadSettings: Windows.Data.Xml.Dom.XmlLoadSettings): void;
+    LoadXmlFromBuffer(buffer: Windows.Storage.Streams.IBuffer): void;
+    LoadXmlFromBuffer(buffer: Windows.Storage.Streams.IBuffer, loadSettings: Windows.Data.Xml.Dom.XmlLoadSettings): void;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SaveToFileAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncAction;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    readonly Attributes: Windows.Data.Xml.Dom.XmlNamedNodeMap;
+    readonly ChildNodes: Windows.Data.Xml.Dom.XmlNodeList;
+    readonly Doctype: Windows.Data.Xml.Dom.XmlDocumentType;
+    readonly DocumentElement: Windows.Data.Xml.Dom.XmlElement;
+    readonly DocumentUri: string;
+    readonly FirstChild: Windows.Data.Xml.Dom.IXmlNode;
+    readonly Implementation: Windows.Data.Xml.Dom.XmlDomImplementation;
+    InnerText: string;
+    readonly LastChild: Windows.Data.Xml.Dom.IXmlNode;
+    readonly LocalName: Object;
+    readonly NamespaceUri: Object;
+    readonly NextSibling: Windows.Data.Xml.Dom.IXmlNode;
+    readonly NodeName: string;
+    readonly NodeType: number;
+    NodeValue: Object;
+    readonly OwnerDocument: Windows.Data.Xml.Dom.XmlDocument;
+    readonly ParentNode: Windows.Data.Xml.Dom.IXmlNode;
+    Prefix: Object;
+    readonly PreviousSibling: Windows.Data.Xml.Dom.IXmlNode;
+  }
+
+  class XmlDocumentFragment implements Windows.Data.Xml.Dom.IXmlDocumentFragment, Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    readonly Attributes: Windows.Data.Xml.Dom.XmlNamedNodeMap;
+    readonly ChildNodes: Windows.Data.Xml.Dom.XmlNodeList;
+    readonly FirstChild: Windows.Data.Xml.Dom.IXmlNode;
+    InnerText: string;
+    readonly LastChild: Windows.Data.Xml.Dom.IXmlNode;
+    readonly LocalName: Object;
+    readonly NamespaceUri: Object;
+    readonly NextSibling: Windows.Data.Xml.Dom.IXmlNode;
+    readonly NodeName: string;
+    readonly NodeType: number;
+    NodeValue: Object;
+    readonly OwnerDocument: Windows.Data.Xml.Dom.XmlDocument;
+    readonly ParentNode: Windows.Data.Xml.Dom.IXmlNode;
+    Prefix: Object;
+    readonly PreviousSibling: Windows.Data.Xml.Dom.IXmlNode;
+  }
+
+  class XmlDocumentType implements Windows.Data.Xml.Dom.IXmlDocumentType, Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    readonly Attributes: Windows.Data.Xml.Dom.XmlNamedNodeMap;
+    readonly ChildNodes: Windows.Data.Xml.Dom.XmlNodeList;
+    readonly Entities: Windows.Data.Xml.Dom.XmlNamedNodeMap;
+    readonly FirstChild: Windows.Data.Xml.Dom.IXmlNode;
+    InnerText: string;
+    readonly LastChild: Windows.Data.Xml.Dom.IXmlNode;
+    readonly LocalName: Object;
+    readonly Name: string;
+    readonly NamespaceUri: Object;
+    readonly NextSibling: Windows.Data.Xml.Dom.IXmlNode;
+    readonly NodeName: string;
+    readonly NodeType: number;
+    NodeValue: Object;
+    readonly Notations: Windows.Data.Xml.Dom.XmlNamedNodeMap;
+    readonly OwnerDocument: Windows.Data.Xml.Dom.XmlDocument;
+    readonly ParentNode: Windows.Data.Xml.Dom.IXmlNode;
+    Prefix: Object;
+    readonly PreviousSibling: Windows.Data.Xml.Dom.IXmlNode;
+  }
+
+  class XmlDomImplementation implements Windows.Data.Xml.Dom.IXmlDomImplementation {
+    HasFeature(feature: string, version: Object): boolean;
+  }
+
+  class XmlElement implements Windows.Data.Xml.Dom.IXmlElement, Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    GetAttribute(attributeName: string): string;
+    GetAttributeNS(namespaceUri: Object, localName: string): string;
+    GetAttributeNode(attributeName: string): Windows.Data.Xml.Dom.XmlAttribute;
+    GetAttributeNodeNS(namespaceUri: Object, localName: string): Windows.Data.Xml.Dom.XmlAttribute;
+    GetElementsByTagName(tagName: string): Windows.Data.Xml.Dom.XmlNodeList;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    Normalize(): void;
+    RemoveAttribute(attributeName: string): void;
+    RemoveAttributeNS(namespaceUri: Object, localName: string): void;
+    RemoveAttributeNode(attributeNode: Windows.Data.Xml.Dom.XmlAttribute): Windows.Data.Xml.Dom.XmlAttribute;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    SetAttribute(attributeName: string, attributeValue: string): void;
+    SetAttributeNS(namespaceUri: Object, qualifiedName: string, value: string): void;
+    SetAttributeNode(newAttribute: Windows.Data.Xml.Dom.XmlAttribute): Windows.Data.Xml.Dom.XmlAttribute;
+    SetAttributeNodeNS(newAttribute: Windows.Data.Xml.Dom.XmlAttribute): Windows.Data.Xml.Dom.XmlAttribute;
+    readonly Attributes: Windows.Data.Xml.Dom.XmlNamedNodeMap;
+    readonly ChildNodes: Windows.Data.Xml.Dom.XmlNodeList;
+    readonly FirstChild: Windows.Data.Xml.Dom.IXmlNode;
+    InnerText: string;
+    readonly LastChild: Windows.Data.Xml.Dom.IXmlNode;
+    readonly LocalName: Object;
+    readonly NamespaceUri: Object;
+    readonly NextSibling: Windows.Data.Xml.Dom.IXmlNode;
+    readonly NodeName: string;
+    readonly NodeType: number;
+    NodeValue: Object;
+    readonly OwnerDocument: Windows.Data.Xml.Dom.XmlDocument;
+    readonly ParentNode: Windows.Data.Xml.Dom.IXmlNode;
+    Prefix: Object;
+    readonly PreviousSibling: Windows.Data.Xml.Dom.IXmlNode;
+    readonly TagName: string;
+  }
+
+  class XmlEntityReference implements Windows.Data.Xml.Dom.IXmlEntityReference, Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    readonly Attributes: Windows.Data.Xml.Dom.XmlNamedNodeMap;
+    readonly ChildNodes: Windows.Data.Xml.Dom.XmlNodeList;
+    readonly FirstChild: Windows.Data.Xml.Dom.IXmlNode;
+    InnerText: string;
+    readonly LastChild: Windows.Data.Xml.Dom.IXmlNode;
+    readonly LocalName: Object;
+    readonly NamespaceUri: Object;
+    readonly NextSibling: Windows.Data.Xml.Dom.IXmlNode;
+    readonly NodeName: string;
+    readonly NodeType: number;
+    NodeValue: Object;
+    readonly OwnerDocument: Windows.Data.Xml.Dom.XmlDocument;
+    readonly ParentNode: Windows.Data.Xml.Dom.IXmlNode;
+    Prefix: Object;
+    readonly PreviousSibling: Windows.Data.Xml.Dom.IXmlNode;
+  }
+
+  class XmlLoadSettings implements Windows.Data.Xml.Dom.IXmlLoadSettings {
+    constructor();
+    ElementContentWhiteSpace: boolean;
+    MaxElementDepth: number;
+    ProhibitDtd: boolean;
+    ResolveExternals: boolean;
+    ValidateOnParse: boolean;
+  }
+
+  class XmlNamedNodeMap implements Windows.Data.Xml.Dom.IXmlNamedNodeMap {
+    First(): Windows.Foundation.Collections.IIterator<Windows.Data.Xml.Dom.IXmlNode>;
+    GetAt(index: number): Windows.Data.Xml.Dom.IXmlNode;
+    GetMany(startIndex: number, items: Windows.Data.Xml.Dom.IXmlNode[]): number;
+    GetNamedItem(name: string): Windows.Data.Xml.Dom.IXmlNode;
+    GetNamedItemNS(namespaceUri: Object, name: string): Windows.Data.Xml.Dom.IXmlNode;
+    IndexOf(value: Windows.Data.Xml.Dom.IXmlNode, index: number): boolean;
+    Item(index: number): Windows.Data.Xml.Dom.IXmlNode;
+    RemoveNamedItem(name: string): Windows.Data.Xml.Dom.IXmlNode;
+    RemoveNamedItemNS(namespaceUri: Object, name: string): Windows.Data.Xml.Dom.IXmlNode;
+    SetNamedItem(node: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SetNamedItemNS(node: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    readonly Length: number;
+    readonly Size: number;
+  }
+
+  class XmlNodeList implements Windows.Data.Xml.Dom.IXmlNodeList {
+    First(): Windows.Foundation.Collections.IIterator<Windows.Data.Xml.Dom.IXmlNode>;
+    GetAt(index: number): Windows.Data.Xml.Dom.IXmlNode;
+    GetMany(startIndex: number, items: Windows.Data.Xml.Dom.IXmlNode[]): number;
+    IndexOf(value: Windows.Data.Xml.Dom.IXmlNode, index: number): boolean;
+    Item(index: number): Windows.Data.Xml.Dom.IXmlNode;
+    readonly Length: number;
+    readonly Size: number;
+  }
+
+  class XmlProcessingInstruction implements Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer, Windows.Data.Xml.Dom.IXmlProcessingInstruction {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    readonly Attributes: Windows.Data.Xml.Dom.XmlNamedNodeMap;
+    readonly ChildNodes: Windows.Data.Xml.Dom.XmlNodeList;
+    Data: string;
+    readonly FirstChild: Windows.Data.Xml.Dom.IXmlNode;
+    InnerText: string;
+    readonly LastChild: Windows.Data.Xml.Dom.IXmlNode;
+    readonly LocalName: Object;
+    readonly NamespaceUri: Object;
+    readonly NextSibling: Windows.Data.Xml.Dom.IXmlNode;
+    readonly NodeName: string;
+    readonly NodeType: number;
+    NodeValue: Object;
+    readonly OwnerDocument: Windows.Data.Xml.Dom.XmlDocument;
+    readonly ParentNode: Windows.Data.Xml.Dom.IXmlNode;
+    Prefix: Object;
+    readonly PreviousSibling: Windows.Data.Xml.Dom.IXmlNode;
+    readonly Target: string;
+  }
+
+  class XmlText implements Windows.Data.Xml.Dom.IXmlCharacterData, Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer, Windows.Data.Xml.Dom.IXmlText {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    AppendData(data: string): void;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    DeleteData(offset: number, count: number): void;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    InsertData(offset: number, data: string): void;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceData(offset: number, count: number, data: string): void;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    SplitText(offset: number): Windows.Data.Xml.Dom.IXmlText;
+    SubstringData(offset: number, count: number): string;
+    readonly Attributes: Windows.Data.Xml.Dom.XmlNamedNodeMap;
+    readonly ChildNodes: Windows.Data.Xml.Dom.XmlNodeList;
+    Data: string;
+    readonly FirstChild: Windows.Data.Xml.Dom.IXmlNode;
+    InnerText: string;
+    readonly LastChild: Windows.Data.Xml.Dom.IXmlNode;
+    readonly Length: number;
+    readonly LocalName: Object;
+    readonly NamespaceUri: Object;
+    readonly NextSibling: Windows.Data.Xml.Dom.IXmlNode;
+    readonly NodeName: string;
+    readonly NodeType: number;
+    NodeValue: Object;
+    readonly OwnerDocument: Windows.Data.Xml.Dom.XmlDocument;
+    readonly ParentNode: Windows.Data.Xml.Dom.IXmlNode;
+    Prefix: Object;
+    readonly PreviousSibling: Windows.Data.Xml.Dom.IXmlNode;
+  }
+
+  enum NodeType {
+    Invalid = 0,
+    ElementNode = 1,
+    AttributeNode = 2,
+    TextNode = 3,
+    DataSectionNode = 4,
+    EntityReferenceNode = 5,
+    EntityNode = 6,
+    ProcessingInstructionNode = 7,
+    CommentNode = 8,
+    DocumentNode = 9,
+    DocumentTypeNode = 10,
+    DocumentFragmentNode = 11,
+    NotationNode = 12,
+  }
+
+  interface IDtdEntity extends Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    readonly NotationName: Object;
+    readonly PublicId: Object;
+    readonly SystemId: Object;
+  }
+  var IDtdEntity: abstract new (...args: any[]) => IDtdEntity;
+
+  interface IDtdNotation extends Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    readonly PublicId: Object;
+    readonly SystemId: Object;
+  }
+  var IDtdNotation: abstract new (...args: any[]) => IDtdNotation;
+
+  interface IXmlAttribute extends Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    readonly Name: string;
+    readonly Specified: boolean;
+    Value: string;
+  }
+  var IXmlAttribute: abstract new (...args: any[]) => IXmlAttribute;
+
+  interface IXmlCDataSection extends Windows.Data.Xml.Dom.IXmlCharacterData, Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer, Windows.Data.Xml.Dom.IXmlText {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    AppendData(data: string): void;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    DeleteData(offset: number, count: number): void;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    InsertData(offset: number, data: string): void;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceData(offset: number, count: number, data: string): void;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    SplitText(offset: number): Windows.Data.Xml.Dom.IXmlText;
+    SubstringData(offset: number, count: number): string;
+  }
+  var IXmlCDataSection: abstract new (...args: any[]) => IXmlCDataSection;
+
+  interface IXmlCharacterData extends Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    AppendData(data: string): void;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    DeleteData(offset: number, count: number): void;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    InsertData(offset: number, data: string): void;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceData(offset: number, count: number, data: string): void;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    SubstringData(offset: number, count: number): string;
+    Data: string;
+    readonly Length: number;
+  }
+  var IXmlCharacterData: abstract new (...args: any[]) => IXmlCharacterData;
+
+  interface IXmlComment extends Windows.Data.Xml.Dom.IXmlCharacterData, Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    AppendData(data: string): void;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    DeleteData(offset: number, count: number): void;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    InsertData(offset: number, data: string): void;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceData(offset: number, count: number, data: string): void;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    SubstringData(offset: number, count: number): string;
+  }
+  var IXmlComment: abstract new (...args: any[]) => IXmlComment;
+
+  interface IXmlDocument extends Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    CreateAttribute(name: string): Windows.Data.Xml.Dom.XmlAttribute;
+    CreateAttributeNS(namespaceUri: Object, qualifiedName: string): Windows.Data.Xml.Dom.XmlAttribute;
+    CreateCDataSection(data: string): Windows.Data.Xml.Dom.XmlCDataSection;
+    CreateComment(data: string): Windows.Data.Xml.Dom.XmlComment;
+    CreateDocumentFragment(): Windows.Data.Xml.Dom.XmlDocumentFragment;
+    CreateElement(tagName: string): Windows.Data.Xml.Dom.XmlElement;
+    CreateElementNS(namespaceUri: Object, qualifiedName: string): Windows.Data.Xml.Dom.XmlElement;
+    CreateEntityReference(name: string): Windows.Data.Xml.Dom.XmlEntityReference;
+    CreateProcessingInstruction(target: string, data: string): Windows.Data.Xml.Dom.XmlProcessingInstruction;
+    CreateTextNode(data: string): Windows.Data.Xml.Dom.XmlText;
+    GetElementById(elementId: string): Windows.Data.Xml.Dom.XmlElement;
+    GetElementsByTagName(tagName: string): Windows.Data.Xml.Dom.XmlNodeList;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    ImportNode(node: Windows.Data.Xml.Dom.IXmlNode, deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    readonly Doctype: Windows.Data.Xml.Dom.XmlDocumentType;
+    readonly DocumentElement: Windows.Data.Xml.Dom.XmlElement;
+    readonly DocumentUri: string;
+    readonly Implementation: Windows.Data.Xml.Dom.XmlDomImplementation;
+  }
+  var IXmlDocument: abstract new (...args: any[]) => IXmlDocument;
+
+  interface IXmlDocumentFragment extends Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+  }
+  var IXmlDocumentFragment: abstract new (...args: any[]) => IXmlDocumentFragment;
+
+  interface IXmlDocumentIO {
+    LoadXml(xml: string): void;
+    LoadXml(xml: string, loadSettings: Windows.Data.Xml.Dom.XmlLoadSettings): void;
+    SaveToFileAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncAction;
+  }
+  var IXmlDocumentIO: abstract new (...args: any[]) => IXmlDocumentIO;
+
+  interface IXmlDocumentIO2 {
+    LoadXmlFromBuffer(buffer: Windows.Storage.Streams.IBuffer): void;
+    LoadXmlFromBuffer(buffer: Windows.Storage.Streams.IBuffer, loadSettings: Windows.Data.Xml.Dom.XmlLoadSettings): void;
+  }
+  var IXmlDocumentIO2: abstract new (...args: any[]) => IXmlDocumentIO2;
+
+  interface IXmlDocumentStatics {
+    LoadFromFileAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Data.Xml.Dom.XmlDocument>;
+    LoadFromFileAsync(file: Windows.Storage.IStorageFile, loadSettings: Windows.Data.Xml.Dom.XmlLoadSettings): Windows.Foundation.IAsyncOperation<Windows.Data.Xml.Dom.XmlDocument>;
+    LoadFromUriAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Data.Xml.Dom.XmlDocument>;
+    LoadFromUriAsync(uri: Windows.Foundation.Uri, loadSettings: Windows.Data.Xml.Dom.XmlLoadSettings): Windows.Foundation.IAsyncOperation<Windows.Data.Xml.Dom.XmlDocument>;
+  }
+  var IXmlDocumentStatics: abstract new (...args: any[]) => IXmlDocumentStatics;
+
+  interface IXmlDocumentType extends Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    readonly Entities: Windows.Data.Xml.Dom.XmlNamedNodeMap;
+    readonly Name: string;
+    readonly Notations: Windows.Data.Xml.Dom.XmlNamedNodeMap;
+  }
+  var IXmlDocumentType: abstract new (...args: any[]) => IXmlDocumentType;
+
+  interface IXmlDomImplementation {
+    HasFeature(feature: string, version: Object): boolean;
+  }
+  var IXmlDomImplementation: abstract new (...args: any[]) => IXmlDomImplementation;
+
+  interface IXmlElement extends Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    GetAttribute(attributeName: string): string;
+    GetAttributeNS(namespaceUri: Object, localName: string): string;
+    GetAttributeNode(attributeName: string): Windows.Data.Xml.Dom.XmlAttribute;
+    GetAttributeNodeNS(namespaceUri: Object, localName: string): Windows.Data.Xml.Dom.XmlAttribute;
+    GetElementsByTagName(tagName: string): Windows.Data.Xml.Dom.XmlNodeList;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    Normalize(): void;
+    RemoveAttribute(attributeName: string): void;
+    RemoveAttributeNS(namespaceUri: Object, localName: string): void;
+    RemoveAttributeNode(attributeNode: Windows.Data.Xml.Dom.XmlAttribute): Windows.Data.Xml.Dom.XmlAttribute;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    SetAttribute(attributeName: string, attributeValue: string): void;
+    SetAttributeNS(namespaceUri: Object, qualifiedName: string, value: string): void;
+    SetAttributeNode(newAttribute: Windows.Data.Xml.Dom.XmlAttribute): Windows.Data.Xml.Dom.XmlAttribute;
+    SetAttributeNodeNS(newAttribute: Windows.Data.Xml.Dom.XmlAttribute): Windows.Data.Xml.Dom.XmlAttribute;
+    readonly TagName: string;
+  }
+  var IXmlElement: abstract new (...args: any[]) => IXmlElement;
+
+  interface IXmlEntityReference extends Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+  }
+  var IXmlEntityReference: abstract new (...args: any[]) => IXmlEntityReference;
+
+  interface IXmlLoadSettings {
+    ElementContentWhiteSpace: boolean;
+    MaxElementDepth: number;
+    ProhibitDtd: boolean;
+    ResolveExternals: boolean;
+    ValidateOnParse: boolean;
+  }
+  var IXmlLoadSettings: abstract new (...args: any[]) => IXmlLoadSettings;
+
+  interface IXmlNamedNodeMap {
+    GetNamedItem(name: string): Windows.Data.Xml.Dom.IXmlNode;
+    GetNamedItemNS(namespaceUri: Object, name: string): Windows.Data.Xml.Dom.IXmlNode;
+    Item(index: number): Windows.Data.Xml.Dom.IXmlNode;
+    RemoveNamedItem(name: string): Windows.Data.Xml.Dom.IXmlNode;
+    RemoveNamedItemNS(namespaceUri: Object, name: string): Windows.Data.Xml.Dom.IXmlNode;
+    SetNamedItem(node: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SetNamedItemNS(node: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    readonly Length: number;
+  }
+  var IXmlNamedNodeMap: abstract new (...args: any[]) => IXmlNamedNodeMap;
+
+  interface IXmlNode extends Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    readonly Attributes: Windows.Data.Xml.Dom.XmlNamedNodeMap;
+    readonly ChildNodes: Windows.Data.Xml.Dom.XmlNodeList;
+    readonly FirstChild: Windows.Data.Xml.Dom.IXmlNode;
+    readonly LastChild: Windows.Data.Xml.Dom.IXmlNode;
+    readonly LocalName: Object;
+    readonly NamespaceUri: Object;
+    readonly NextSibling: Windows.Data.Xml.Dom.IXmlNode;
+    readonly NodeName: string;
+    readonly NodeType: number;
+    NodeValue: Object;
+    readonly OwnerDocument: Windows.Data.Xml.Dom.XmlDocument;
+    readonly ParentNode: Windows.Data.Xml.Dom.IXmlNode;
+    Prefix: Object;
+    readonly PreviousSibling: Windows.Data.Xml.Dom.IXmlNode;
+  }
+  var IXmlNode: abstract new (...args: any[]) => IXmlNode;
+
+  interface IXmlNodeList {
+    Item(index: number): Windows.Data.Xml.Dom.IXmlNode;
+    readonly Length: number;
+  }
+  var IXmlNodeList: abstract new (...args: any[]) => IXmlNodeList;
+
+  interface IXmlNodeSelector {
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+  }
+  var IXmlNodeSelector: abstract new (...args: any[]) => IXmlNodeSelector;
+
+  interface IXmlNodeSerializer {
+    GetXml(): string;
+    InnerText: string;
+  }
+  var IXmlNodeSerializer: abstract new (...args: any[]) => IXmlNodeSerializer;
+
+  interface IXmlProcessingInstruction extends Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    Data: string;
+    readonly Target: string;
+  }
+  var IXmlProcessingInstruction: abstract new (...args: any[]) => IXmlProcessingInstruction;
+
+  interface IXmlText extends Windows.Data.Xml.Dom.IXmlCharacterData, Windows.Data.Xml.Dom.IXmlNode, Windows.Data.Xml.Dom.IXmlNodeSelector, Windows.Data.Xml.Dom.IXmlNodeSerializer {
+    AppendChild(newChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    AppendData(data: string): void;
+    CloneNode(deep: boolean): Windows.Data.Xml.Dom.IXmlNode;
+    DeleteData(offset: number, count: number): void;
+    GetXml(): string;
+    HasChildNodes(): boolean;
+    InsertBefore(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    InsertData(offset: number, data: string): void;
+    Normalize(): void;
+    RemoveChild(childNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceChild(newChild: Windows.Data.Xml.Dom.IXmlNode, referenceChild: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.IXmlNode;
+    ReplaceData(offset: number, count: number, data: string): void;
+    SelectNodes(xpath: string): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectNodesNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.XmlNodeList;
+    SelectSingleNode(xpath: string): Windows.Data.Xml.Dom.IXmlNode;
+    SelectSingleNodeNS(xpath: string, namespaces: Object): Windows.Data.Xml.Dom.IXmlNode;
+    SplitText(offset: number): Windows.Data.Xml.Dom.IXmlText;
+    SubstringData(offset: number, count: number): string;
+  }
+  var IXmlText: abstract new (...args: any[]) => IXmlText;
+
+}
+
+declare namespace Windows.Data.Xml.Xsl {
+  class XsltProcessor implements Windows.Data.Xml.Xsl.IXsltProcessor, Windows.Data.Xml.Xsl.IXsltProcessor2 {
+    constructor(document: Windows.Data.Xml.Dom.XmlDocument);
+    TransformToDocument(inputNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.XmlDocument;
+    TransformToString(inputNode: Windows.Data.Xml.Dom.IXmlNode): string;
+  }
+
+  interface IXsltProcessor {
+    TransformToString(inputNode: Windows.Data.Xml.Dom.IXmlNode): string;
+  }
+  var IXsltProcessor: abstract new (...args: any[]) => IXsltProcessor;
+
+  interface IXsltProcessor2 {
+    TransformToDocument(inputNode: Windows.Data.Xml.Dom.IXmlNode): Windows.Data.Xml.Dom.XmlDocument;
+  }
+  var IXsltProcessor2: abstract new (...args: any[]) => IXsltProcessor2;
+
+  interface IXsltProcessorFactory {
+    CreateInstance(document: Windows.Data.Xml.Dom.XmlDocument): Windows.Data.Xml.Xsl.XsltProcessor;
+  }
+  var IXsltProcessorFactory: abstract new (...args: any[]) => IXsltProcessorFactory;
+
+}
+
+declare namespace Windows.Devices {
+  class LowLevelDevicesAggregateProvider implements Windows.Devices.ILowLevelDevicesAggregateProvider {
+    constructor(adc: Windows.Devices.Adc.Provider.IAdcControllerProvider, pwm: Windows.Devices.Pwm.Provider.IPwmControllerProvider, gpio: Windows.Devices.Gpio.Provider.IGpioControllerProvider, i2c: Windows.Devices.I2c.Provider.II2cControllerProvider, spi: Windows.Devices.Spi.Provider.ISpiControllerProvider);
+    readonly AdcControllerProvider: Windows.Devices.Adc.Provider.IAdcControllerProvider;
+    readonly GpioControllerProvider: Windows.Devices.Gpio.Provider.IGpioControllerProvider;
+    readonly I2cControllerProvider: Windows.Devices.I2c.Provider.II2cControllerProvider;
+    readonly PwmControllerProvider: Windows.Devices.Pwm.Provider.IPwmControllerProvider;
+    readonly SpiControllerProvider: Windows.Devices.Spi.Provider.ISpiControllerProvider;
+  }
+
+  class LowLevelDevicesController implements Windows.Devices.ILowLevelDevicesController {
+    static DefaultProvider: Windows.Devices.ILowLevelDevicesAggregateProvider;
+  }
+
+  interface DevicesLowLevelContract {
+  }
+  var DevicesLowLevelContract: {
+    new(fields: {  }): DevicesLowLevelContract;
+  };
+
+  interface ILowLevelDevicesAggregateProvider {
+    readonly AdcControllerProvider: Windows.Devices.Adc.Provider.IAdcControllerProvider;
+    readonly GpioControllerProvider: Windows.Devices.Gpio.Provider.IGpioControllerProvider;
+    readonly I2cControllerProvider: Windows.Devices.I2c.Provider.II2cControllerProvider;
+    readonly PwmControllerProvider: Windows.Devices.Pwm.Provider.IPwmControllerProvider;
+    readonly SpiControllerProvider: Windows.Devices.Spi.Provider.ISpiControllerProvider;
+  }
+  var ILowLevelDevicesAggregateProvider: abstract new (...args: any[]) => ILowLevelDevicesAggregateProvider;
+
+  interface ILowLevelDevicesAggregateProviderFactory {
+    Create(adc: Windows.Devices.Adc.Provider.IAdcControllerProvider, pwm: Windows.Devices.Pwm.Provider.IPwmControllerProvider, gpio: Windows.Devices.Gpio.Provider.IGpioControllerProvider, i2c: Windows.Devices.I2c.Provider.II2cControllerProvider, spi: Windows.Devices.Spi.Provider.ISpiControllerProvider): Windows.Devices.LowLevelDevicesAggregateProvider;
+  }
+  var ILowLevelDevicesAggregateProviderFactory: abstract new (...args: any[]) => ILowLevelDevicesAggregateProviderFactory;
+
+  interface ILowLevelDevicesController {
+  }
+  var ILowLevelDevicesController: abstract new (...args: any[]) => ILowLevelDevicesController;
+
+  interface ILowLevelDevicesControllerStatics {
+    DefaultProvider: Windows.Devices.ILowLevelDevicesAggregateProvider;
+  }
+  var ILowLevelDevicesControllerStatics: abstract new (...args: any[]) => ILowLevelDevicesControllerStatics;
+
+}
+
+declare namespace Windows.Devices.Adc {
+  class AdcChannel implements Windows.Devices.Adc.IAdcChannel, Windows.Foundation.IClosable {
+    Close(): void;
+    ReadRatio(): number;
+    ReadValue(): number;
+    readonly Controller: Windows.Devices.Adc.AdcController;
+  }
+
+  class AdcController implements Windows.Devices.Adc.IAdcController {
+    static GetControllersAsync(provider: Windows.Devices.Adc.Provider.IAdcProvider): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Adc.AdcController> | Windows.Devices.Adc.AdcController[]>;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Adc.AdcController>;
+    IsChannelModeSupported(channelMode: number): boolean;
+    OpenChannel(channelNumber: number): Windows.Devices.Adc.AdcChannel;
+    readonly ChannelCount: number;
+    ChannelMode: number;
+    readonly MaxValue: number;
+    readonly MinValue: number;
+    readonly ResolutionInBits: number;
+  }
+
+  enum AdcChannelMode {
+    SingleEnded = 0,
+    Differential = 1,
+  }
+
+  interface IAdcChannel extends Windows.Foundation.IClosable {
+    Close(): void;
+    ReadRatio(): number;
+    ReadValue(): number;
+    readonly Controller: Windows.Devices.Adc.AdcController;
+  }
+  var IAdcChannel: abstract new (...args: any[]) => IAdcChannel;
+
+  interface IAdcController {
+    IsChannelModeSupported(channelMode: number): boolean;
+    OpenChannel(channelNumber: number): Windows.Devices.Adc.AdcChannel;
+    readonly ChannelCount: number;
+    ChannelMode: number;
+    readonly MaxValue: number;
+    readonly MinValue: number;
+    readonly ResolutionInBits: number;
+  }
+  var IAdcController: abstract new (...args: any[]) => IAdcController;
+
+  interface IAdcControllerStatics {
+    GetControllersAsync(provider: Windows.Devices.Adc.Provider.IAdcProvider): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Adc.AdcController> | Windows.Devices.Adc.AdcController[]>;
+  }
+  var IAdcControllerStatics: abstract new (...args: any[]) => IAdcControllerStatics;
+
+  interface IAdcControllerStatics2 {
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Adc.AdcController>;
+  }
+  var IAdcControllerStatics2: abstract new (...args: any[]) => IAdcControllerStatics2;
+
+}
+
+declare namespace Windows.Devices.Adc.Provider {
+  enum ProviderAdcChannelMode {
+    SingleEnded = 0,
+    Differential = 1,
+  }
+
+  interface IAdcControllerProvider {
+    AcquireChannel(channel: number): void;
+    IsChannelModeSupported(channelMode: number): boolean;
+    ReadValue(channelNumber: number): number;
+    ReleaseChannel(channel: number): void;
+    readonly ChannelCount: number;
+    ChannelMode: number;
+    readonly MaxValue: number;
+    readonly MinValue: number;
+    readonly ResolutionInBits: number;
+  }
+  var IAdcControllerProvider: abstract new (...args: any[]) => IAdcControllerProvider;
+
+  interface IAdcProvider {
+    GetControllers(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Adc.Provider.IAdcControllerProvider> | Windows.Devices.Adc.Provider.IAdcControllerProvider[];
+  }
+  var IAdcProvider: abstract new (...args: any[]) => IAdcProvider;
+
+}
+
+declare namespace Windows.Devices.Background {
+  class DeviceServicingDetails implements Windows.Devices.Background.IDeviceServicingDetails {
+    readonly Arguments: string;
+    readonly DeviceId: string;
+    readonly ExpectedDuration: Windows.Foundation.TimeSpan;
+  }
+
+  class DeviceUseDetails implements Windows.Devices.Background.IDeviceUseDetails {
+    readonly Arguments: string;
+    readonly DeviceId: string;
+  }
+
+  interface IDeviceServicingDetails {
+    readonly Arguments: string;
+    readonly DeviceId: string;
+    readonly ExpectedDuration: Windows.Foundation.TimeSpan;
+  }
+  var IDeviceServicingDetails: abstract new (...args: any[]) => IDeviceServicingDetails;
+
+  interface IDeviceUseDetails {
+    readonly Arguments: string;
+    readonly DeviceId: string;
+  }
+  var IDeviceUseDetails: abstract new (...args: any[]) => IDeviceUseDetails;
+
+}
+
+declare namespace Windows.Devices.Bluetooth {
+  class BluetoothAdapter implements Windows.Devices.Bluetooth.IBluetoothAdapter, Windows.Devices.Bluetooth.IBluetoothAdapter2, Windows.Devices.Bluetooth.IBluetoothAdapter3, Windows.Devices.Bluetooth.IBluetoothAdapter4 {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.BluetoothAdapter>;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.BluetoothAdapter>;
+    static GetDeviceSelector(): string;
+    GetRadioAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Radios.Radio>;
+    readonly AreClassicSecureConnectionsSupported: boolean;
+    readonly AreLowEnergySecureConnectionsSupported: boolean;
+    readonly BluetoothAddress: number | bigint;
+    readonly DeviceId: string;
+    readonly IsAdvertisementOffloadSupported: boolean;
+    readonly IsCentralRoleSupported: boolean;
+    readonly IsClassicSupported: boolean;
+    readonly IsExtendedAdvertisingSupported: boolean;
+    readonly IsLowEnergyCodedPhySupported: boolean;
+    readonly IsLowEnergySupported: boolean;
+    readonly IsLowEnergyUncoded2MPhySupported: boolean;
+    readonly IsPeripheralRoleSupported: boolean;
+    readonly MaxAdvertisementDataLength: number;
+  }
+
+  class BluetoothClassOfDevice implements Windows.Devices.Bluetooth.IBluetoothClassOfDevice {
+    static FromParts(majorClass: number, minorClass: number, serviceCapabilities: number): Windows.Devices.Bluetooth.BluetoothClassOfDevice;
+    static FromRawValue(rawValue: number): Windows.Devices.Bluetooth.BluetoothClassOfDevice;
+    readonly MajorClass: number;
+    readonly MinorClass: number;
+    readonly RawValue: number;
+    readonly ServiceCapabilities: number;
+  }
+
+  class BluetoothDevice implements Windows.Devices.Bluetooth.IBluetoothDevice, Windows.Devices.Bluetooth.IBluetoothDevice2, Windows.Devices.Bluetooth.IBluetoothDevice3, Windows.Devices.Bluetooth.IBluetoothDevice4, Windows.Devices.Bluetooth.IBluetoothDevice5, Windows.Foundation.IClosable {
+    Close(): void;
+    static FromBluetoothAddressAsync(address: number | bigint): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.BluetoothDevice>;
+    static FromHostNameAsync(hostName: Windows.Networking.HostName): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.BluetoothDevice>;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.BluetoothDevice>;
+    static GetDeviceSelector(): string;
+    static GetDeviceSelectorFromBluetoothAddress(bluetoothAddress: number | bigint): string;
+    static GetDeviceSelectorFromClassOfDevice(classOfDevice: Windows.Devices.Bluetooth.BluetoothClassOfDevice): string;
+    static GetDeviceSelectorFromConnectionStatus(connectionStatus: number): string;
+    static GetDeviceSelectorFromDeviceName(deviceName: string): string;
+    static GetDeviceSelectorFromPairingState(pairingState: boolean): string;
+    GetRfcommServicesAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceServicesResult>;
+    GetRfcommServicesAsync(cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceServicesResult>;
+    GetRfcommServicesForIdAsync(serviceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceServicesResult>;
+    GetRfcommServicesForIdAsync(serviceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId, cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceServicesResult>;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly BluetoothAddress: number | bigint;
+    readonly BluetoothDeviceId: Windows.Devices.Bluetooth.BluetoothDeviceId;
+    readonly ClassOfDevice: Windows.Devices.Bluetooth.BluetoothClassOfDevice;
+    readonly ConnectionStatus: number;
+    readonly DeviceAccessInformation: Windows.Devices.Enumeration.DeviceAccessInformation;
+    readonly DeviceId: string;
+    readonly DeviceInformation: Windows.Devices.Enumeration.DeviceInformation;
+    readonly HostName: Windows.Networking.HostName;
+    readonly Name: string;
+    readonly RfcommServices: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceService> | Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceService[];
+    readonly SdpRecords: Windows.Foundation.Collections.IVectorView<Windows.Storage.Streams.IBuffer> | Windows.Storage.Streams.IBuffer[];
+    readonly WasSecureConnectionUsedForPairing: boolean;
+    ConnectionStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.BluetoothDevice, Object> | null;
+    NameChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.BluetoothDevice, Object> | null;
+    SdpRecordsChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.BluetoothDevice, Object> | null;
+  }
+
+  class BluetoothDeviceId implements Windows.Devices.Bluetooth.IBluetoothDeviceId {
+    static FromId(deviceId: string): Windows.Devices.Bluetooth.BluetoothDeviceId;
+    readonly Id: string;
+    readonly IsClassicDevice: boolean;
+    readonly IsLowEnergyDevice: boolean;
+  }
+
+  class BluetoothLEAppearance implements Windows.Devices.Bluetooth.IBluetoothLEAppearance {
+    static FromParts(appearanceCategory: number, appearanceSubCategory: number): Windows.Devices.Bluetooth.BluetoothLEAppearance;
+    static FromRawValue(rawValue: number): Windows.Devices.Bluetooth.BluetoothLEAppearance;
+    readonly Category: number;
+    readonly RawValue: number;
+    readonly SubCategory: number;
+  }
+
+  class BluetoothLEAppearanceCategories {
+    static readonly BarcodeScanner: number;
+    static readonly BloodPressure: number;
+    static readonly Clock: number;
+    static readonly Computer: number;
+    static readonly Cycling: number;
+    static readonly Display: number;
+    static readonly EyeGlasses: number;
+    static readonly GlucoseMeter: number;
+    static readonly HeartRate: number;
+    static readonly HumanInterfaceDevice: number;
+    static readonly Keyring: number;
+    static readonly MediaPlayer: number;
+    static readonly OutdoorSportActivity: number;
+    static readonly Phone: number;
+    static readonly PulseOximeter: number;
+    static readonly RemoteControl: number;
+    static readonly RunningWalking: number;
+    static readonly Tag: number;
+    static readonly Thermometer: number;
+    static readonly Uncategorized: number;
+    static readonly Watch: number;
+    static readonly WeightScale: number;
+  }
+
+  class BluetoothLEAppearanceSubcategories {
+    static readonly BarcodeScanner: number;
+    static readonly BloodPressureArm: number;
+    static readonly BloodPressureWrist: number;
+    static readonly CardReader: number;
+    static readonly CyclingCadenceSensor: number;
+    static readonly CyclingComputer: number;
+    static readonly CyclingPowerSensor: number;
+    static readonly CyclingSpeedCadenceSensor: number;
+    static readonly CyclingSpeedSensor: number;
+    static readonly DigitalPen: number;
+    static readonly DigitizerTablet: number;
+    static readonly Gamepad: number;
+    static readonly Generic: number;
+    static readonly HeartRateBelt: number;
+    static readonly Joystick: number;
+    static readonly Keyboard: number;
+    static readonly LocationDisplay: number;
+    static readonly LocationNavigationDisplay: number;
+    static readonly LocationNavigationPod: number;
+    static readonly LocationPod: number;
+    static readonly Mouse: number;
+    static readonly OximeterFingertip: number;
+    static readonly OximeterWristWorn: number;
+    static readonly RunningWalkingInShoe: number;
+    static readonly RunningWalkingOnHip: number;
+    static readonly RunningWalkingOnShoe: number;
+    static readonly SportsWatch: number;
+    static readonly ThermometerEar: number;
+  }
+
+  class BluetoothLEConnectionParameters implements Windows.Devices.Bluetooth.IBluetoothLEConnectionParameters {
+    readonly ConnectionInterval: number;
+    readonly ConnectionLatency: number;
+    readonly LinkTimeout: number;
+  }
+
+  class BluetoothLEConnectionPhy implements Windows.Devices.Bluetooth.IBluetoothLEConnectionPhy {
+    readonly ReceiveInfo: Windows.Devices.Bluetooth.BluetoothLEConnectionPhyInfo;
+    readonly TransmitInfo: Windows.Devices.Bluetooth.BluetoothLEConnectionPhyInfo;
+  }
+
+  class BluetoothLEConnectionPhyInfo implements Windows.Devices.Bluetooth.IBluetoothLEConnectionPhyInfo {
+    readonly IsCodedPhy: boolean;
+    readonly IsUncoded1MPhy: boolean;
+    readonly IsUncoded2MPhy: boolean;
+  }
+
+  class BluetoothLEDevice implements Windows.Devices.Bluetooth.IBluetoothLEDevice, Windows.Devices.Bluetooth.IBluetoothLEDevice2, Windows.Devices.Bluetooth.IBluetoothLEDevice3, Windows.Devices.Bluetooth.IBluetoothLEDevice4, Windows.Devices.Bluetooth.IBluetoothLEDevice5, Windows.Devices.Bluetooth.IBluetoothLEDevice6, Windows.Foundation.IClosable {
+    Close(): void;
+    static FromBluetoothAddressAsync(bluetoothAddress: number | bigint, bluetoothAddressType: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.BluetoothLEDevice>;
+    static FromBluetoothAddressAsync(bluetoothAddress: number | bigint): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.BluetoothLEDevice>;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.BluetoothLEDevice>;
+    GetConnectionParameters(): Windows.Devices.Bluetooth.BluetoothLEConnectionParameters;
+    GetConnectionPhy(): Windows.Devices.Bluetooth.BluetoothLEConnectionPhy;
+    static GetDeviceSelector(): string;
+    static GetDeviceSelectorFromAppearance(appearance: Windows.Devices.Bluetooth.BluetoothLEAppearance): string;
+    static GetDeviceSelectorFromBluetoothAddress(bluetoothAddress: number | bigint): string;
+    static GetDeviceSelectorFromBluetoothAddress(bluetoothAddress: number | bigint, bluetoothAddressType: number): string;
+    static GetDeviceSelectorFromConnectionStatus(connectionStatus: number): string;
+    static GetDeviceSelectorFromDeviceName(deviceName: string): string;
+    static GetDeviceSelectorFromPairingState(pairingState: boolean): string;
+    GetGattService(serviceUuid: Guid): Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService;
+    GetGattServicesAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceServicesResult>;
+    GetGattServicesAsync(cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceServicesResult>;
+    GetGattServicesForUuidAsync(serviceUuid: Guid): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceServicesResult>;
+    GetGattServicesForUuidAsync(serviceUuid: Guid, cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceServicesResult>;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    RequestPreferredConnectionParameters(preferredConnectionParameters: Windows.Devices.Bluetooth.BluetoothLEPreferredConnectionParameters): Windows.Devices.Bluetooth.BluetoothLEPreferredConnectionParametersRequest;
+    readonly Appearance: Windows.Devices.Bluetooth.BluetoothLEAppearance;
+    readonly BluetoothAddress: number | bigint;
+    readonly BluetoothAddressType: number;
+    readonly BluetoothDeviceId: Windows.Devices.Bluetooth.BluetoothDeviceId;
+    readonly ConnectionStatus: number;
+    readonly DeviceAccessInformation: Windows.Devices.Enumeration.DeviceAccessInformation;
+    readonly DeviceId: string;
+    readonly DeviceInformation: Windows.Devices.Enumeration.DeviceInformation;
+    readonly GattServices: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService[];
+    readonly Name: string;
+    readonly WasSecureConnectionUsedForPairing: boolean;
+    ConnectionStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.BluetoothLEDevice, Object> | null;
+    GattServicesChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.BluetoothLEDevice, Object> | null;
+    NameChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.BluetoothLEDevice, Object> | null;
+    ConnectionParametersChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.BluetoothLEDevice, Object> | null;
+    ConnectionPhyChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.BluetoothLEDevice, Object> | null;
+  }
+
+  class BluetoothLEPreferredConnectionParameters implements Windows.Devices.Bluetooth.IBluetoothLEPreferredConnectionParameters {
+    static readonly Balanced: Windows.Devices.Bluetooth.BluetoothLEPreferredConnectionParameters;
+    readonly ConnectionLatency: number;
+    readonly LinkTimeout: number;
+    readonly MaxConnectionInterval: number;
+    readonly MinConnectionInterval: number;
+    static readonly PowerOptimized: Windows.Devices.Bluetooth.BluetoothLEPreferredConnectionParameters;
+    static readonly ThroughputOptimized: Windows.Devices.Bluetooth.BluetoothLEPreferredConnectionParameters;
+  }
+
+  class BluetoothLEPreferredConnectionParametersRequest implements Windows.Devices.Bluetooth.IBluetoothLEPreferredConnectionParametersRequest, Windows.Foundation.IClosable {
+    Close(): void;
+    readonly Status: number;
+  }
+
+  class BluetoothSignalStrengthFilter implements Windows.Devices.Bluetooth.IBluetoothSignalStrengthFilter {
+    constructor();
+    InRangeThresholdInDBm: number | null;
+    OutOfRangeThresholdInDBm: number | null;
+    OutOfRangeTimeout: Windows.Foundation.TimeSpan | null;
+    SamplingInterval: Windows.Foundation.TimeSpan | null;
+  }
+
+  class BluetoothUuidHelper {
+    static FromShortId(shortId: number): Guid;
+    static TryGetShortId(uuid: Guid): number | null;
+  }
+
+  enum BluetoothAddressType {
+    Public = 0,
+    Random = 1,
+    Unspecified = 2,
+  }
+
+  enum BluetoothCacheMode {
+    Cached = 0,
+    Uncached = 1,
+  }
+
+  enum BluetoothConnectionStatus {
+    Disconnected = 0,
+    Connected = 1,
+  }
+
+  enum BluetoothError {
+    Success = 0,
+    RadioNotAvailable = 1,
+    ResourceInUse = 2,
+    DeviceNotConnected = 3,
+    OtherError = 4,
+    DisabledByPolicy = 5,
+    NotSupported = 6,
+    DisabledByUser = 7,
+    ConsentRequired = 8,
+    TransportNotSupported = 9,
+  }
+
+  enum BluetoothLEPreferredConnectionParametersRequestStatus {
+    Unspecified = 0,
+    Success = 1,
+    DeviceNotAvailable = 2,
+    AccessDenied = 3,
+  }
+
+  enum BluetoothMajorClass {
+    Miscellaneous = 0,
+    Computer = 1,
+    Phone = 2,
+    NetworkAccessPoint = 3,
+    AudioVideo = 4,
+    Peripheral = 5,
+    Imaging = 6,
+    Wearable = 7,
+    Toy = 8,
+    Health = 9,
+  }
+
+  enum BluetoothMinorClass {
+    Uncategorized = 0,
+    ComputerDesktop = 1,
+    ComputerServer = 2,
+    ComputerLaptop = 3,
+    ComputerHandheld = 4,
+    ComputerPalmSize = 5,
+    ComputerWearable = 6,
+    ComputerTablet = 7,
+    PhoneCellular = 1,
+    PhoneCordless = 2,
+    PhoneSmartPhone = 3,
+    PhoneWired = 4,
+    PhoneIsdn = 5,
+    NetworkFullyAvailable = 0,
+    NetworkUsed01To17Percent = 8,
+    NetworkUsed17To33Percent = 16,
+    NetworkUsed33To50Percent = 24,
+    NetworkUsed50To67Percent = 32,
+    NetworkUsed67To83Percent = 40,
+    NetworkUsed83To99Percent = 48,
+    NetworkNoServiceAvailable = 56,
+    AudioVideoWearableHeadset = 1,
+    AudioVideoHandsFree = 2,
+    AudioVideoMicrophone = 4,
+    AudioVideoLoudspeaker = 5,
+    AudioVideoHeadphones = 6,
+    AudioVideoPortableAudio = 7,
+    AudioVideoCarAudio = 8,
+    AudioVideoSetTopBox = 9,
+    AudioVideoHifiAudioDevice = 10,
+    AudioVideoVcr = 11,
+    AudioVideoVideoCamera = 12,
+    AudioVideoCamcorder = 13,
+    AudioVideoVideoMonitor = 14,
+    AudioVideoVideoDisplayAndLoudspeaker = 15,
+    AudioVideoVideoConferencing = 16,
+    AudioVideoGamingOrToy = 18,
+    PeripheralJoystick = 1,
+    PeripheralGamepad = 2,
+    PeripheralRemoteControl = 3,
+    PeripheralSensing = 4,
+    PeripheralDigitizerTablet = 5,
+    PeripheralCardReader = 6,
+    PeripheralDigitalPen = 7,
+    PeripheralHandheldScanner = 8,
+    PeripheralHandheldGesture = 9,
+    WearableWristwatch = 1,
+    WearablePager = 2,
+    WearableJacket = 3,
+    WearableHelmet = 4,
+    WearableGlasses = 5,
+    ToyRobot = 1,
+    ToyVehicle = 2,
+    ToyDoll = 3,
+    ToyController = 4,
+    ToyGame = 5,
+    HealthBloodPressureMonitor = 1,
+    HealthThermometer = 2,
+    HealthWeighingScale = 3,
+    HealthGlucoseMeter = 4,
+    HealthPulseOximeter = 5,
+    HealthHeartRateMonitor = 6,
+    HealthHealthDataDisplay = 7,
+    HealthStepCounter = 8,
+    HealthBodyCompositionAnalyzer = 9,
+    HealthPeakFlowMonitor = 10,
+    HealthMedicationMonitor = 11,
+    HealthKneeProsthesis = 12,
+    HealthAnkleProsthesis = 13,
+    HealthGenericHealthManager = 14,
+    HealthPersonalMobilityDevice = 15,
+  }
+
+  enum BluetoothServiceCapabilities {
+    None = 0,
+    LimitedDiscoverableMode = 1,
+    PositioningService = 8,
+    NetworkingService = 16,
+    RenderingService = 32,
+    CapturingService = 64,
+    ObjectTransferService = 128,
+    AudioService = 256,
+    TelephoneService = 512,
+    InformationService = 1024,
+  }
+
+  interface IBluetoothAdapter {
+    GetRadioAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Radios.Radio>;
+    readonly BluetoothAddress: number | bigint;
+    readonly DeviceId: string;
+    readonly IsAdvertisementOffloadSupported: boolean;
+    readonly IsCentralRoleSupported: boolean;
+    readonly IsClassicSupported: boolean;
+    readonly IsLowEnergySupported: boolean;
+    readonly IsPeripheralRoleSupported: boolean;
+  }
+  var IBluetoothAdapter: abstract new (...args: any[]) => IBluetoothAdapter;
+
+  interface IBluetoothAdapter2 {
+    readonly AreClassicSecureConnectionsSupported: boolean;
+    readonly AreLowEnergySecureConnectionsSupported: boolean;
+  }
+  var IBluetoothAdapter2: abstract new (...args: any[]) => IBluetoothAdapter2;
+
+  interface IBluetoothAdapter3 {
+    readonly IsExtendedAdvertisingSupported: boolean;
+    readonly MaxAdvertisementDataLength: number;
+  }
+  var IBluetoothAdapter3: abstract new (...args: any[]) => IBluetoothAdapter3;
+
+  interface IBluetoothAdapter4 {
+    readonly IsLowEnergyCodedPhySupported: boolean;
+    readonly IsLowEnergyUncoded2MPhySupported: boolean;
+  }
+  var IBluetoothAdapter4: abstract new (...args: any[]) => IBluetoothAdapter4;
+
+  interface IBluetoothAdapterStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.BluetoothAdapter>;
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.BluetoothAdapter>;
+    GetDeviceSelector(): string;
+  }
+  var IBluetoothAdapterStatics: abstract new (...args: any[]) => IBluetoothAdapterStatics;
+
+  interface IBluetoothClassOfDevice {
+    readonly MajorClass: number;
+    readonly MinorClass: number;
+    readonly RawValue: number;
+    readonly ServiceCapabilities: number;
+  }
+  var IBluetoothClassOfDevice: abstract new (...args: any[]) => IBluetoothClassOfDevice;
+
+  interface IBluetoothClassOfDeviceStatics {
+    FromParts(majorClass: number, minorClass: number, serviceCapabilities: number): Windows.Devices.Bluetooth.BluetoothClassOfDevice;
+    FromRawValue(rawValue: number): Windows.Devices.Bluetooth.BluetoothClassOfDevice;
+  }
+  var IBluetoothClassOfDeviceStatics: abstract new (...args: any[]) => IBluetoothClassOfDeviceStatics;
+
+  interface IBluetoothDevice {
+    readonly BluetoothAddress: number | bigint;
+    readonly ClassOfDevice: Windows.Devices.Bluetooth.BluetoothClassOfDevice;
+    readonly ConnectionStatus: number;
+    readonly DeviceId: string;
+    readonly HostName: Windows.Networking.HostName;
+    readonly Name: string;
+    readonly RfcommServices: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceService> | Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceService[];
+    readonly SdpRecords: Windows.Foundation.Collections.IVectorView<Windows.Storage.Streams.IBuffer> | Windows.Storage.Streams.IBuffer[];
+    ConnectionStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.BluetoothDevice, Object> | null;
+    NameChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.BluetoothDevice, Object> | null;
+    SdpRecordsChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.BluetoothDevice, Object> | null;
+  }
+  var IBluetoothDevice: abstract new (...args: any[]) => IBluetoothDevice;
+
+  interface IBluetoothDevice2 {
+    readonly DeviceInformation: Windows.Devices.Enumeration.DeviceInformation;
+  }
+  var IBluetoothDevice2: abstract new (...args: any[]) => IBluetoothDevice2;
+
+  interface IBluetoothDevice3 {
+    GetRfcommServicesAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceServicesResult>;
+    GetRfcommServicesAsync(cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceServicesResult>;
+    GetRfcommServicesForIdAsync(serviceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceServicesResult>;
+    GetRfcommServicesForIdAsync(serviceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId, cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceServicesResult>;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly DeviceAccessInformation: Windows.Devices.Enumeration.DeviceAccessInformation;
+  }
+  var IBluetoothDevice3: abstract new (...args: any[]) => IBluetoothDevice3;
+
+  interface IBluetoothDevice4 {
+    readonly BluetoothDeviceId: Windows.Devices.Bluetooth.BluetoothDeviceId;
+  }
+  var IBluetoothDevice4: abstract new (...args: any[]) => IBluetoothDevice4;
+
+  interface IBluetoothDevice5 {
+    readonly WasSecureConnectionUsedForPairing: boolean;
+  }
+  var IBluetoothDevice5: abstract new (...args: any[]) => IBluetoothDevice5;
+
+  interface IBluetoothDeviceId {
+    readonly Id: string;
+    readonly IsClassicDevice: boolean;
+    readonly IsLowEnergyDevice: boolean;
+  }
+  var IBluetoothDeviceId: abstract new (...args: any[]) => IBluetoothDeviceId;
+
+  interface IBluetoothDeviceIdStatics {
+    FromId(deviceId: string): Windows.Devices.Bluetooth.BluetoothDeviceId;
+  }
+  var IBluetoothDeviceIdStatics: abstract new (...args: any[]) => IBluetoothDeviceIdStatics;
+
+  interface IBluetoothDeviceStatics {
+    FromBluetoothAddressAsync(address: number | bigint): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.BluetoothDevice>;
+    FromHostNameAsync(hostName: Windows.Networking.HostName): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.BluetoothDevice>;
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.BluetoothDevice>;
+    GetDeviceSelector(): string;
+  }
+  var IBluetoothDeviceStatics: abstract new (...args: any[]) => IBluetoothDeviceStatics;
+
+  interface IBluetoothDeviceStatics2 {
+    GetDeviceSelectorFromBluetoothAddress(bluetoothAddress: number | bigint): string;
+    GetDeviceSelectorFromClassOfDevice(classOfDevice: Windows.Devices.Bluetooth.BluetoothClassOfDevice): string;
+    GetDeviceSelectorFromConnectionStatus(connectionStatus: number): string;
+    GetDeviceSelectorFromDeviceName(deviceName: string): string;
+    GetDeviceSelectorFromPairingState(pairingState: boolean): string;
+  }
+  var IBluetoothDeviceStatics2: abstract new (...args: any[]) => IBluetoothDeviceStatics2;
+
+  interface IBluetoothLEAppearance {
+    readonly Category: number;
+    readonly RawValue: number;
+    readonly SubCategory: number;
+  }
+  var IBluetoothLEAppearance: abstract new (...args: any[]) => IBluetoothLEAppearance;
+
+  interface IBluetoothLEAppearanceCategoriesStatics {
+    readonly BarcodeScanner: number;
+    readonly BloodPressure: number;
+    readonly Clock: number;
+    readonly Computer: number;
+    readonly Cycling: number;
+    readonly Display: number;
+    readonly EyeGlasses: number;
+    readonly GlucoseMeter: number;
+    readonly HeartRate: number;
+    readonly HumanInterfaceDevice: number;
+    readonly Keyring: number;
+    readonly MediaPlayer: number;
+    readonly OutdoorSportActivity: number;
+    readonly Phone: number;
+    readonly PulseOximeter: number;
+    readonly RemoteControl: number;
+    readonly RunningWalking: number;
+    readonly Tag: number;
+    readonly Thermometer: number;
+    readonly Uncategorized: number;
+    readonly Watch: number;
+    readonly WeightScale: number;
+  }
+  var IBluetoothLEAppearanceCategoriesStatics: abstract new (...args: any[]) => IBluetoothLEAppearanceCategoriesStatics;
+
+  interface IBluetoothLEAppearanceStatics {
+    FromParts(appearanceCategory: number, appearanceSubCategory: number): Windows.Devices.Bluetooth.BluetoothLEAppearance;
+    FromRawValue(rawValue: number): Windows.Devices.Bluetooth.BluetoothLEAppearance;
+  }
+  var IBluetoothLEAppearanceStatics: abstract new (...args: any[]) => IBluetoothLEAppearanceStatics;
+
+  interface IBluetoothLEAppearanceSubcategoriesStatics {
+    readonly BarcodeScanner: number;
+    readonly BloodPressureArm: number;
+    readonly BloodPressureWrist: number;
+    readonly CardReader: number;
+    readonly CyclingCadenceSensor: number;
+    readonly CyclingComputer: number;
+    readonly CyclingPowerSensor: number;
+    readonly CyclingSpeedCadenceSensor: number;
+    readonly CyclingSpeedSensor: number;
+    readonly DigitalPen: number;
+    readonly DigitizerTablet: number;
+    readonly Gamepad: number;
+    readonly Generic: number;
+    readonly HeartRateBelt: number;
+    readonly Joystick: number;
+    readonly Keyboard: number;
+    readonly LocationDisplay: number;
+    readonly LocationNavigationDisplay: number;
+    readonly LocationNavigationPod: number;
+    readonly LocationPod: number;
+    readonly Mouse: number;
+    readonly OximeterFingertip: number;
+    readonly OximeterWristWorn: number;
+    readonly RunningWalkingInShoe: number;
+    readonly RunningWalkingOnHip: number;
+    readonly RunningWalkingOnShoe: number;
+    readonly SportsWatch: number;
+    readonly ThermometerEar: number;
+  }
+  var IBluetoothLEAppearanceSubcategoriesStatics: abstract new (...args: any[]) => IBluetoothLEAppearanceSubcategoriesStatics;
+
+  interface IBluetoothLEConnectionParameters {
+    readonly ConnectionInterval: number;
+    readonly ConnectionLatency: number;
+    readonly LinkTimeout: number;
+  }
+  var IBluetoothLEConnectionParameters: abstract new (...args: any[]) => IBluetoothLEConnectionParameters;
+
+  interface IBluetoothLEConnectionPhy {
+    readonly ReceiveInfo: Windows.Devices.Bluetooth.BluetoothLEConnectionPhyInfo;
+    readonly TransmitInfo: Windows.Devices.Bluetooth.BluetoothLEConnectionPhyInfo;
+  }
+  var IBluetoothLEConnectionPhy: abstract new (...args: any[]) => IBluetoothLEConnectionPhy;
+
+  interface IBluetoothLEConnectionPhyInfo {
+    readonly IsCodedPhy: boolean;
+    readonly IsUncoded1MPhy: boolean;
+    readonly IsUncoded2MPhy: boolean;
+  }
+  var IBluetoothLEConnectionPhyInfo: abstract new (...args: any[]) => IBluetoothLEConnectionPhyInfo;
+
+  interface IBluetoothLEDevice {
+    GetGattService(serviceUuid: Guid): Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService;
+    readonly BluetoothAddress: number | bigint;
+    readonly ConnectionStatus: number;
+    readonly DeviceId: string;
+    readonly GattServices: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService[];
+    readonly Name: string;
+    ConnectionStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.BluetoothLEDevice, Object> | null;
+    GattServicesChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.BluetoothLEDevice, Object> | null;
+    NameChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.BluetoothLEDevice, Object> | null;
+  }
+  var IBluetoothLEDevice: abstract new (...args: any[]) => IBluetoothLEDevice;
+
+  interface IBluetoothLEDevice2 {
+    readonly Appearance: Windows.Devices.Bluetooth.BluetoothLEAppearance;
+    readonly BluetoothAddressType: number;
+    readonly DeviceInformation: Windows.Devices.Enumeration.DeviceInformation;
+  }
+  var IBluetoothLEDevice2: abstract new (...args: any[]) => IBluetoothLEDevice2;
+
+  interface IBluetoothLEDevice3 {
+    GetGattServicesAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceServicesResult>;
+    GetGattServicesAsync(cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceServicesResult>;
+    GetGattServicesForUuidAsync(serviceUuid: Guid): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceServicesResult>;
+    GetGattServicesForUuidAsync(serviceUuid: Guid, cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceServicesResult>;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly DeviceAccessInformation: Windows.Devices.Enumeration.DeviceAccessInformation;
+  }
+  var IBluetoothLEDevice3: abstract new (...args: any[]) => IBluetoothLEDevice3;
+
+  interface IBluetoothLEDevice4 {
+    readonly BluetoothDeviceId: Windows.Devices.Bluetooth.BluetoothDeviceId;
+  }
+  var IBluetoothLEDevice4: abstract new (...args: any[]) => IBluetoothLEDevice4;
+
+  interface IBluetoothLEDevice5 {
+    readonly WasSecureConnectionUsedForPairing: boolean;
+  }
+  var IBluetoothLEDevice5: abstract new (...args: any[]) => IBluetoothLEDevice5;
+
+  interface IBluetoothLEDevice6 {
+    GetConnectionParameters(): Windows.Devices.Bluetooth.BluetoothLEConnectionParameters;
+    GetConnectionPhy(): Windows.Devices.Bluetooth.BluetoothLEConnectionPhy;
+    RequestPreferredConnectionParameters(preferredConnectionParameters: Windows.Devices.Bluetooth.BluetoothLEPreferredConnectionParameters): Windows.Devices.Bluetooth.BluetoothLEPreferredConnectionParametersRequest;
+    ConnectionParametersChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.BluetoothLEDevice, Object> | null;
+    ConnectionPhyChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.BluetoothLEDevice, Object> | null;
+  }
+  var IBluetoothLEDevice6: abstract new (...args: any[]) => IBluetoothLEDevice6;
+
+  interface IBluetoothLEDeviceStatics {
+    FromBluetoothAddressAsync(bluetoothAddress: number | bigint): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.BluetoothLEDevice>;
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.BluetoothLEDevice>;
+    GetDeviceSelector(): string;
+  }
+  var IBluetoothLEDeviceStatics: abstract new (...args: any[]) => IBluetoothLEDeviceStatics;
+
+  interface IBluetoothLEDeviceStatics2 {
+    FromBluetoothAddressAsync(bluetoothAddress: number | bigint, bluetoothAddressType: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.BluetoothLEDevice>;
+    GetDeviceSelectorFromAppearance(appearance: Windows.Devices.Bluetooth.BluetoothLEAppearance): string;
+    GetDeviceSelectorFromBluetoothAddress(bluetoothAddress: number | bigint): string;
+    GetDeviceSelectorFromBluetoothAddress(bluetoothAddress: number | bigint, bluetoothAddressType: number): string;
+    GetDeviceSelectorFromConnectionStatus(connectionStatus: number): string;
+    GetDeviceSelectorFromDeviceName(deviceName: string): string;
+    GetDeviceSelectorFromPairingState(pairingState: boolean): string;
+  }
+  var IBluetoothLEDeviceStatics2: abstract new (...args: any[]) => IBluetoothLEDeviceStatics2;
+
+  interface IBluetoothLEPreferredConnectionParameters {
+    readonly ConnectionLatency: number;
+    readonly LinkTimeout: number;
+    readonly MaxConnectionInterval: number;
+    readonly MinConnectionInterval: number;
+  }
+  var IBluetoothLEPreferredConnectionParameters: abstract new (...args: any[]) => IBluetoothLEPreferredConnectionParameters;
+
+  interface IBluetoothLEPreferredConnectionParametersRequest {
+    readonly Status: number;
+  }
+  var IBluetoothLEPreferredConnectionParametersRequest: abstract new (...args: any[]) => IBluetoothLEPreferredConnectionParametersRequest;
+
+  interface IBluetoothLEPreferredConnectionParametersStatics {
+    readonly Balanced: Windows.Devices.Bluetooth.BluetoothLEPreferredConnectionParameters;
+    readonly PowerOptimized: Windows.Devices.Bluetooth.BluetoothLEPreferredConnectionParameters;
+    readonly ThroughputOptimized: Windows.Devices.Bluetooth.BluetoothLEPreferredConnectionParameters;
+  }
+  var IBluetoothLEPreferredConnectionParametersStatics: abstract new (...args: any[]) => IBluetoothLEPreferredConnectionParametersStatics;
+
+  interface IBluetoothSignalStrengthFilter {
+    InRangeThresholdInDBm: number | null;
+    OutOfRangeThresholdInDBm: number | null;
+    OutOfRangeTimeout: Windows.Foundation.TimeSpan | null;
+    SamplingInterval: Windows.Foundation.TimeSpan | null;
+  }
+  var IBluetoothSignalStrengthFilter: abstract new (...args: any[]) => IBluetoothSignalStrengthFilter;
+
+  interface IBluetoothUuidHelperStatics {
+    FromShortId(shortId: number): Guid;
+    TryGetShortId(uuid: Guid): number | null;
+  }
+  var IBluetoothUuidHelperStatics: abstract new (...args: any[]) => IBluetoothUuidHelperStatics;
+
+}
+
+declare namespace Windows.Devices.Bluetooth.Advertisement {
+  class BluetoothLEAdvertisement implements Windows.Devices.Bluetooth.Advertisement.IBluetoothLEAdvertisement {
+    constructor();
+    GetManufacturerDataByCompanyId(companyId: number): Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.Advertisement.BluetoothLEManufacturerData> | Windows.Devices.Bluetooth.Advertisement.BluetoothLEManufacturerData[];
+    GetSectionsByType(type: number): Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementDataSection> | Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementDataSection[];
+    readonly DataSections: Windows.Foundation.Collections.IVector<Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementDataSection> | Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementDataSection[];
+    Flags: number | null;
+    LocalName: string;
+    readonly ManufacturerData: Windows.Foundation.Collections.IVector<Windows.Devices.Bluetooth.Advertisement.BluetoothLEManufacturerData> | Windows.Devices.Bluetooth.Advertisement.BluetoothLEManufacturerData[];
+    readonly ServiceUuids: Windows.Foundation.Collections.IVector<Guid> | Guid[];
+  }
+
+  class BluetoothLEAdvertisementBytePattern implements Windows.Devices.Bluetooth.Advertisement.IBluetoothLEAdvertisementBytePattern {
+    constructor();
+    constructor(dataType: number, offset: number, data: Windows.Storage.Streams.IBuffer);
+    Data: Windows.Storage.Streams.IBuffer;
+    DataType: number;
+    Offset: number;
+  }
+
+  class BluetoothLEAdvertisementDataSection implements Windows.Devices.Bluetooth.Advertisement.IBluetoothLEAdvertisementDataSection {
+    constructor();
+    constructor(dataType: number, data: Windows.Storage.Streams.IBuffer);
+    Data: Windows.Storage.Streams.IBuffer;
+    DataType: number;
+  }
+
+  class BluetoothLEAdvertisementDataTypes {
+    static readonly AdvertisingInterval: number;
+    static readonly Appearance: number;
+    static readonly CompleteLocalName: number;
+    static readonly CompleteService128BitUuids: number;
+    static readonly CompleteService16BitUuids: number;
+    static readonly CompleteService32BitUuids: number;
+    static readonly Flags: number;
+    static readonly IncompleteService128BitUuids: number;
+    static readonly IncompleteService16BitUuids: number;
+    static readonly IncompleteService32BitUuids: number;
+    static readonly ManufacturerSpecificData: number;
+    static readonly PeripheralConnectionIntervalRange: number;
+    static readonly PublicTargetAddress: number;
+    static readonly RandomTargetAddress: number;
+    static readonly ServiceData128BitUuids: number;
+    static readonly ServiceData16BitUuids: number;
+    static readonly ServiceData32BitUuids: number;
+    static readonly ServiceSolicitation128BitUuids: number;
+    static readonly ServiceSolicitation16BitUuids: number;
+    static readonly ServiceSolicitation32BitUuids: number;
+    static readonly ShortenedLocalName: number;
+    static readonly TxPowerLevel: number;
+  }
+
+  class BluetoothLEAdvertisementFilter implements Windows.Devices.Bluetooth.Advertisement.IBluetoothLEAdvertisementFilter {
+    constructor();
+    Advertisement: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisement;
+    readonly BytePatterns: Windows.Foundation.Collections.IVector<Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementBytePattern> | Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementBytePattern[];
+  }
+
+  class BluetoothLEAdvertisementPublisher implements Windows.Devices.Bluetooth.Advertisement.IBluetoothLEAdvertisementPublisher, Windows.Devices.Bluetooth.Advertisement.IBluetoothLEAdvertisementPublisher2, Windows.Devices.Bluetooth.Advertisement.IBluetoothLEAdvertisementPublisher3 {
+    constructor();
+    constructor(advertisement: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisement);
+    Start(): void;
+    Stop(): void;
+    readonly Advertisement: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisement;
+    IncludeTransmitPowerLevel: boolean;
+    IsAnonymous: boolean;
+    PreferredTransmitPowerLevelInDBm: number | null;
+    PrimaryPhy: number;
+    SecondaryPhy: number;
+    readonly Status: number;
+    UseExtendedAdvertisement: boolean;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher, Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs> | null;
+  }
+
+  class BluetoothLEAdvertisementPublisherStatusChangedEventArgs implements Windows.Devices.Bluetooth.Advertisement.IBluetoothLEAdvertisementPublisherStatusChangedEventArgs, Windows.Devices.Bluetooth.Advertisement.IBluetoothLEAdvertisementPublisherStatusChangedEventArgs2 {
+    readonly Error: number;
+    readonly SelectedTransmitPowerLevelInDBm: number | null;
+    readonly Status: number;
+  }
+
+  class BluetoothLEAdvertisementReceivedEventArgs implements Windows.Devices.Bluetooth.Advertisement.IBluetoothLEAdvertisementReceivedEventArgs, Windows.Devices.Bluetooth.Advertisement.IBluetoothLEAdvertisementReceivedEventArgs2, Windows.Devices.Bluetooth.Advertisement.IBluetoothLEAdvertisementReceivedEventArgs3 {
+    readonly Advertisement: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisement;
+    readonly AdvertisementType: number;
+    readonly BluetoothAddress: number | bigint;
+    readonly BluetoothAddressType: number;
+    readonly IsAnonymous: boolean;
+    readonly IsConnectable: boolean;
+    readonly IsDirected: boolean;
+    readonly IsScanResponse: boolean;
+    readonly IsScannable: boolean;
+    readonly PrimaryPhy: number;
+    readonly RawSignalStrengthInDBm: number;
+    readonly SecondaryPhy: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+    readonly TransmitPowerLevelInDBm: number | null;
+  }
+
+  class BluetoothLEAdvertisementScanParameters implements Windows.Devices.Bluetooth.Advertisement.IBluetoothLEAdvertisementScanParameters {
+    static CoexistenceOptimized(): Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementScanParameters;
+    static LowLatency(): Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementScanParameters;
+    readonly ScanInterval: number;
+    readonly ScanWindow: number;
+  }
+
+  class BluetoothLEAdvertisementWatcher implements Windows.Devices.Bluetooth.Advertisement.IBluetoothLEAdvertisementWatcher, Windows.Devices.Bluetooth.Advertisement.IBluetoothLEAdvertisementWatcher2, Windows.Devices.Bluetooth.Advertisement.IBluetoothLEAdvertisementWatcher3 {
+    constructor();
+    constructor(advertisementFilter: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementFilter);
+    Start(): void;
+    Stop(): void;
+    AdvertisementFilter: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementFilter;
+    AllowExtendedAdvertisements: boolean;
+    readonly MaxOutOfRangeTimeout: Windows.Foundation.TimeSpan;
+    readonly MaxSamplingInterval: Windows.Foundation.TimeSpan;
+    readonly MinOutOfRangeTimeout: Windows.Foundation.TimeSpan;
+    readonly MinSamplingInterval: Windows.Foundation.TimeSpan;
+    ScanParameters: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementScanParameters;
+    ScanningMode: number;
+    SignalStrengthFilter: Windows.Devices.Bluetooth.BluetoothSignalStrengthFilter;
+    readonly Status: number;
+    UseCodedPhy: boolean;
+    UseHardwareFilter: boolean;
+    UseUncoded1MPhy: boolean;
+    Received: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher, Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher, Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs> | null;
+  }
+
+  class BluetoothLEAdvertisementWatcherStoppedEventArgs implements Windows.Devices.Bluetooth.Advertisement.IBluetoothLEAdvertisementWatcherStoppedEventArgs {
+    readonly Error: number;
+  }
+
+  class BluetoothLEManufacturerData implements Windows.Devices.Bluetooth.Advertisement.IBluetoothLEManufacturerData {
+    constructor();
+    constructor(companyId: number, data: Windows.Storage.Streams.IBuffer);
+    CompanyId: number;
+    Data: Windows.Storage.Streams.IBuffer;
+  }
+
+  enum BluetoothLEAdvertisementFlags {
+    None = 0,
+    LimitedDiscoverableMode = 1,
+    GeneralDiscoverableMode = 2,
+    ClassicNotSupported = 4,
+    DualModeControllerCapable = 8,
+    DualModeHostCapable = 16,
+  }
+
+  enum BluetoothLEAdvertisementPhyType {
+    Unspecified = 0,
+    Uncoded1MPhy = 1,
+    Uncoded2MPhy = 2,
+    CodedPhy = 3,
+  }
+
+  enum BluetoothLEAdvertisementPublisherStatus {
+    Created = 0,
+    Waiting = 1,
+    Started = 2,
+    Stopping = 3,
+    Stopped = 4,
+    Aborted = 5,
+  }
+
+  enum BluetoothLEAdvertisementType {
+    ConnectableUndirected = 0,
+    ConnectableDirected = 1,
+    ScannableUndirected = 2,
+    NonConnectableUndirected = 3,
+    ScanResponse = 4,
+    Extended = 5,
+  }
+
+  enum BluetoothLEAdvertisementWatcherStatus {
+    Created = 0,
+    Started = 1,
+    Stopping = 2,
+    Stopped = 3,
+    Aborted = 4,
+  }
+
+  enum BluetoothLEScanningMode {
+    Passive = 0,
+    Active = 1,
+    None = 2,
+  }
+
+  interface IBluetoothLEAdvertisement {
+    GetManufacturerDataByCompanyId(companyId: number): Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.Advertisement.BluetoothLEManufacturerData> | Windows.Devices.Bluetooth.Advertisement.BluetoothLEManufacturerData[];
+    GetSectionsByType(type: number): Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementDataSection> | Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementDataSection[];
+    readonly DataSections: Windows.Foundation.Collections.IVector<Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementDataSection> | Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementDataSection[];
+    Flags: number | null;
+    LocalName: string;
+    readonly ManufacturerData: Windows.Foundation.Collections.IVector<Windows.Devices.Bluetooth.Advertisement.BluetoothLEManufacturerData> | Windows.Devices.Bluetooth.Advertisement.BluetoothLEManufacturerData[];
+    readonly ServiceUuids: Windows.Foundation.Collections.IVector<Guid> | Guid[];
+  }
+  var IBluetoothLEAdvertisement: abstract new (...args: any[]) => IBluetoothLEAdvertisement;
+
+  interface IBluetoothLEAdvertisementBytePattern {
+    Data: Windows.Storage.Streams.IBuffer;
+    DataType: number;
+    Offset: number;
+  }
+  var IBluetoothLEAdvertisementBytePattern: abstract new (...args: any[]) => IBluetoothLEAdvertisementBytePattern;
+
+  interface IBluetoothLEAdvertisementBytePatternFactory {
+    Create(dataType: number, offset: number, data: Windows.Storage.Streams.IBuffer): Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementBytePattern;
+  }
+  var IBluetoothLEAdvertisementBytePatternFactory: abstract new (...args: any[]) => IBluetoothLEAdvertisementBytePatternFactory;
+
+  interface IBluetoothLEAdvertisementDataSection {
+    Data: Windows.Storage.Streams.IBuffer;
+    DataType: number;
+  }
+  var IBluetoothLEAdvertisementDataSection: abstract new (...args: any[]) => IBluetoothLEAdvertisementDataSection;
+
+  interface IBluetoothLEAdvertisementDataSectionFactory {
+    Create(dataType: number, data: Windows.Storage.Streams.IBuffer): Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementDataSection;
+  }
+  var IBluetoothLEAdvertisementDataSectionFactory: abstract new (...args: any[]) => IBluetoothLEAdvertisementDataSectionFactory;
+
+  interface IBluetoothLEAdvertisementDataTypesStatics {
+    readonly AdvertisingInterval: number;
+    readonly Appearance: number;
+    readonly CompleteLocalName: number;
+    readonly CompleteService128BitUuids: number;
+    readonly CompleteService16BitUuids: number;
+    readonly CompleteService32BitUuids: number;
+    readonly Flags: number;
+    readonly IncompleteService128BitUuids: number;
+    readonly IncompleteService16BitUuids: number;
+    readonly IncompleteService32BitUuids: number;
+    readonly ManufacturerSpecificData: number;
+    readonly PeripheralConnectionIntervalRange: number;
+    readonly PublicTargetAddress: number;
+    readonly RandomTargetAddress: number;
+    readonly ServiceData128BitUuids: number;
+    readonly ServiceData16BitUuids: number;
+    readonly ServiceData32BitUuids: number;
+    readonly ServiceSolicitation128BitUuids: number;
+    readonly ServiceSolicitation16BitUuids: number;
+    readonly ServiceSolicitation32BitUuids: number;
+    readonly ShortenedLocalName: number;
+    readonly TxPowerLevel: number;
+  }
+  var IBluetoothLEAdvertisementDataTypesStatics: abstract new (...args: any[]) => IBluetoothLEAdvertisementDataTypesStatics;
+
+  interface IBluetoothLEAdvertisementFilter {
+    Advertisement: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisement;
+    readonly BytePatterns: Windows.Foundation.Collections.IVector<Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementBytePattern> | Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementBytePattern[];
+  }
+  var IBluetoothLEAdvertisementFilter: abstract new (...args: any[]) => IBluetoothLEAdvertisementFilter;
+
+  interface IBluetoothLEAdvertisementPublisher {
+    Start(): void;
+    Stop(): void;
+    readonly Advertisement: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisement;
+    readonly Status: number;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher, Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisherStatusChangedEventArgs> | null;
+  }
+  var IBluetoothLEAdvertisementPublisher: abstract new (...args: any[]) => IBluetoothLEAdvertisementPublisher;
+
+  interface IBluetoothLEAdvertisementPublisher2 {
+    IncludeTransmitPowerLevel: boolean;
+    IsAnonymous: boolean;
+    PreferredTransmitPowerLevelInDBm: number | null;
+    UseExtendedAdvertisement: boolean;
+  }
+  var IBluetoothLEAdvertisementPublisher2: abstract new (...args: any[]) => IBluetoothLEAdvertisementPublisher2;
+
+  interface IBluetoothLEAdvertisementPublisher3 {
+    PrimaryPhy: number;
+    SecondaryPhy: number;
+  }
+  var IBluetoothLEAdvertisementPublisher3: abstract new (...args: any[]) => IBluetoothLEAdvertisementPublisher3;
+
+  interface IBluetoothLEAdvertisementPublisherFactory {
+    Create(advertisement: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisement): Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementPublisher;
+  }
+  var IBluetoothLEAdvertisementPublisherFactory: abstract new (...args: any[]) => IBluetoothLEAdvertisementPublisherFactory;
+
+  interface IBluetoothLEAdvertisementPublisherStatusChangedEventArgs {
+    readonly Error: number;
+    readonly Status: number;
+  }
+  var IBluetoothLEAdvertisementPublisherStatusChangedEventArgs: abstract new (...args: any[]) => IBluetoothLEAdvertisementPublisherStatusChangedEventArgs;
+
+  interface IBluetoothLEAdvertisementPublisherStatusChangedEventArgs2 {
+    readonly SelectedTransmitPowerLevelInDBm: number | null;
+  }
+  var IBluetoothLEAdvertisementPublisherStatusChangedEventArgs2: abstract new (...args: any[]) => IBluetoothLEAdvertisementPublisherStatusChangedEventArgs2;
+
+  interface IBluetoothLEAdvertisementReceivedEventArgs {
+    readonly Advertisement: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisement;
+    readonly AdvertisementType: number;
+    readonly BluetoothAddress: number | bigint;
+    readonly RawSignalStrengthInDBm: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IBluetoothLEAdvertisementReceivedEventArgs: abstract new (...args: any[]) => IBluetoothLEAdvertisementReceivedEventArgs;
+
+  interface IBluetoothLEAdvertisementReceivedEventArgs2 {
+    readonly BluetoothAddressType: number;
+    readonly IsAnonymous: boolean;
+    readonly IsConnectable: boolean;
+    readonly IsDirected: boolean;
+    readonly IsScanResponse: boolean;
+    readonly IsScannable: boolean;
+    readonly TransmitPowerLevelInDBm: number | null;
+  }
+  var IBluetoothLEAdvertisementReceivedEventArgs2: abstract new (...args: any[]) => IBluetoothLEAdvertisementReceivedEventArgs2;
+
+  interface IBluetoothLEAdvertisementReceivedEventArgs3 {
+    readonly PrimaryPhy: number;
+    readonly SecondaryPhy: number;
+  }
+  var IBluetoothLEAdvertisementReceivedEventArgs3: abstract new (...args: any[]) => IBluetoothLEAdvertisementReceivedEventArgs3;
+
+  interface IBluetoothLEAdvertisementScanParameters {
+    readonly ScanInterval: number;
+    readonly ScanWindow: number;
+  }
+  var IBluetoothLEAdvertisementScanParameters: abstract new (...args: any[]) => IBluetoothLEAdvertisementScanParameters;
+
+  interface IBluetoothLEAdvertisementScanParametersStatics {
+    CoexistenceOptimized(): Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementScanParameters;
+    LowLatency(): Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementScanParameters;
+  }
+  var IBluetoothLEAdvertisementScanParametersStatics: abstract new (...args: any[]) => IBluetoothLEAdvertisementScanParametersStatics;
+
+  interface IBluetoothLEAdvertisementWatcher {
+    Start(): void;
+    Stop(): void;
+    AdvertisementFilter: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementFilter;
+    readonly MaxOutOfRangeTimeout: Windows.Foundation.TimeSpan;
+    readonly MaxSamplingInterval: Windows.Foundation.TimeSpan;
+    readonly MinOutOfRangeTimeout: Windows.Foundation.TimeSpan;
+    readonly MinSamplingInterval: Windows.Foundation.TimeSpan;
+    ScanningMode: number;
+    SignalStrengthFilter: Windows.Devices.Bluetooth.BluetoothSignalStrengthFilter;
+    readonly Status: number;
+    Received: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher, Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher, Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcherStoppedEventArgs> | null;
+  }
+  var IBluetoothLEAdvertisementWatcher: abstract new (...args: any[]) => IBluetoothLEAdvertisementWatcher;
+
+  interface IBluetoothLEAdvertisementWatcher2 {
+    AllowExtendedAdvertisements: boolean;
+  }
+  var IBluetoothLEAdvertisementWatcher2: abstract new (...args: any[]) => IBluetoothLEAdvertisementWatcher2;
+
+  interface IBluetoothLEAdvertisementWatcher3 {
+    ScanParameters: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementScanParameters;
+    UseCodedPhy: boolean;
+    UseHardwareFilter: boolean;
+    UseUncoded1MPhy: boolean;
+  }
+  var IBluetoothLEAdvertisementWatcher3: abstract new (...args: any[]) => IBluetoothLEAdvertisementWatcher3;
+
+  interface IBluetoothLEAdvertisementWatcherFactory {
+    Create(advertisementFilter: Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementFilter): Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementWatcher;
+  }
+  var IBluetoothLEAdvertisementWatcherFactory: abstract new (...args: any[]) => IBluetoothLEAdvertisementWatcherFactory;
+
+  interface IBluetoothLEAdvertisementWatcherStoppedEventArgs {
+    readonly Error: number;
+  }
+  var IBluetoothLEAdvertisementWatcherStoppedEventArgs: abstract new (...args: any[]) => IBluetoothLEAdvertisementWatcherStoppedEventArgs;
+
+  interface IBluetoothLEManufacturerData {
+    CompanyId: number;
+    Data: Windows.Storage.Streams.IBuffer;
+  }
+  var IBluetoothLEManufacturerData: abstract new (...args: any[]) => IBluetoothLEManufacturerData;
+
+  interface IBluetoothLEManufacturerDataFactory {
+    Create(companyId: number, data: Windows.Storage.Streams.IBuffer): Windows.Devices.Bluetooth.Advertisement.BluetoothLEManufacturerData;
+  }
+  var IBluetoothLEManufacturerDataFactory: abstract new (...args: any[]) => IBluetoothLEManufacturerDataFactory;
+
+}
+
+declare namespace Windows.Devices.Bluetooth.Background {
+  class BluetoothLEAdvertisementPublisherTriggerDetails implements Windows.Devices.Bluetooth.Background.IBluetoothLEAdvertisementPublisherTriggerDetails, Windows.Devices.Bluetooth.Background.IBluetoothLEAdvertisementPublisherTriggerDetails2 {
+    readonly Error: number;
+    readonly SelectedTransmitPowerLevelInDBm: number | null;
+    readonly Status: number;
+  }
+
+  class BluetoothLEAdvertisementWatcherTriggerDetails implements Windows.Devices.Bluetooth.Background.IBluetoothLEAdvertisementWatcherTriggerDetails {
+    readonly Advertisements: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs> | Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs[];
+    readonly Error: number;
+    readonly SignalStrengthFilter: Windows.Devices.Bluetooth.BluetoothSignalStrengthFilter;
+  }
+
+  class GattCharacteristicNotificationTriggerDetails implements Windows.Devices.Bluetooth.Background.IGattCharacteristicNotificationTriggerDetails, Windows.Devices.Bluetooth.Background.IGattCharacteristicNotificationTriggerDetails2 {
+    readonly Characteristic: Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic;
+    readonly Error: number;
+    readonly EventTriggeringMode: number;
+    readonly Value: Windows.Storage.Streams.IBuffer;
+    readonly ValueChangedEvents: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs[];
+  }
+
+  class GattServiceProviderConnection implements Windows.Devices.Bluetooth.Background.IGattServiceProviderConnection, Windows.Devices.Bluetooth.Background.IGattServiceProviderConnection2 {
+    Start(): void;
+    UpdateAdvertisingParameters(parameters: Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisingParameters): void;
+    static readonly AllServices: Windows.Foundation.Collections.IMapView<string, Windows.Devices.Bluetooth.Background.GattServiceProviderConnection>;
+    readonly Service: Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalService;
+    readonly TriggerId: string;
+  }
+
+  class GattServiceProviderTriggerDetails implements Windows.Devices.Bluetooth.Background.IGattServiceProviderTriggerDetails {
+    readonly Connection: Windows.Devices.Bluetooth.Background.GattServiceProviderConnection;
+  }
+
+  class RfcommConnectionTriggerDetails implements Windows.Devices.Bluetooth.Background.IRfcommConnectionTriggerDetails {
+    readonly Incoming: boolean;
+    readonly RemoteDevice: Windows.Devices.Bluetooth.BluetoothDevice;
+    readonly Socket: Windows.Networking.Sockets.StreamSocket;
+  }
+
+  class RfcommInboundConnectionInformation implements Windows.Devices.Bluetooth.Background.IRfcommInboundConnectionInformation {
+    LocalServiceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+    SdpRecord: Windows.Storage.Streams.IBuffer;
+    ServiceCapabilities: number;
+  }
+
+  class RfcommOutboundConnectionInformation implements Windows.Devices.Bluetooth.Background.IRfcommOutboundConnectionInformation {
+    RemoteServiceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+  }
+
+  enum BluetoothEventTriggeringMode {
+    Serial = 0,
+    Batch = 1,
+    KeepLatest = 2,
+  }
+
+  interface IBluetoothLEAdvertisementPublisherTriggerDetails {
+    readonly Error: number;
+    readonly Status: number;
+  }
+  var IBluetoothLEAdvertisementPublisherTriggerDetails: abstract new (...args: any[]) => IBluetoothLEAdvertisementPublisherTriggerDetails;
+
+  interface IBluetoothLEAdvertisementPublisherTriggerDetails2 {
+    readonly SelectedTransmitPowerLevelInDBm: number | null;
+  }
+  var IBluetoothLEAdvertisementPublisherTriggerDetails2: abstract new (...args: any[]) => IBluetoothLEAdvertisementPublisherTriggerDetails2;
+
+  interface IBluetoothLEAdvertisementWatcherTriggerDetails {
+    readonly Advertisements: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs> | Windows.Devices.Bluetooth.Advertisement.BluetoothLEAdvertisementReceivedEventArgs[];
+    readonly Error: number;
+    readonly SignalStrengthFilter: Windows.Devices.Bluetooth.BluetoothSignalStrengthFilter;
+  }
+  var IBluetoothLEAdvertisementWatcherTriggerDetails: abstract new (...args: any[]) => IBluetoothLEAdvertisementWatcherTriggerDetails;
+
+  interface IGattCharacteristicNotificationTriggerDetails {
+    readonly Characteristic: Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic;
+    readonly Value: Windows.Storage.Streams.IBuffer;
+  }
+  var IGattCharacteristicNotificationTriggerDetails: abstract new (...args: any[]) => IGattCharacteristicNotificationTriggerDetails;
+
+  interface IGattCharacteristicNotificationTriggerDetails2 {
+    readonly Error: number;
+    readonly EventTriggeringMode: number;
+    readonly ValueChangedEvents: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs[];
+  }
+  var IGattCharacteristicNotificationTriggerDetails2: abstract new (...args: any[]) => IGattCharacteristicNotificationTriggerDetails2;
+
+  interface IGattServiceProviderConnection {
+    Start(): void;
+    readonly Service: Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalService;
+    readonly TriggerId: string;
+  }
+  var IGattServiceProviderConnection: abstract new (...args: any[]) => IGattServiceProviderConnection;
+
+  interface IGattServiceProviderConnection2 {
+    UpdateAdvertisingParameters(parameters: Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisingParameters): void;
+  }
+  var IGattServiceProviderConnection2: abstract new (...args: any[]) => IGattServiceProviderConnection2;
+
+  interface IGattServiceProviderConnectionStatics {
+    readonly AllServices: Windows.Foundation.Collections.IMapView<string, Windows.Devices.Bluetooth.Background.GattServiceProviderConnection>;
+  }
+  var IGattServiceProviderConnectionStatics: abstract new (...args: any[]) => IGattServiceProviderConnectionStatics;
+
+  interface IGattServiceProviderTriggerDetails {
+    readonly Connection: Windows.Devices.Bluetooth.Background.GattServiceProviderConnection;
+  }
+  var IGattServiceProviderTriggerDetails: abstract new (...args: any[]) => IGattServiceProviderTriggerDetails;
+
+  interface IRfcommConnectionTriggerDetails {
+    readonly Incoming: boolean;
+    readonly RemoteDevice: Windows.Devices.Bluetooth.BluetoothDevice;
+    readonly Socket: Windows.Networking.Sockets.StreamSocket;
+  }
+  var IRfcommConnectionTriggerDetails: abstract new (...args: any[]) => IRfcommConnectionTriggerDetails;
+
+  interface IRfcommInboundConnectionInformation {
+    LocalServiceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+    SdpRecord: Windows.Storage.Streams.IBuffer;
+    ServiceCapabilities: number;
+  }
+  var IRfcommInboundConnectionInformation: abstract new (...args: any[]) => IRfcommInboundConnectionInformation;
+
+  interface IRfcommOutboundConnectionInformation {
+    RemoteServiceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+  }
+  var IRfcommOutboundConnectionInformation: abstract new (...args: any[]) => IRfcommOutboundConnectionInformation;
+
+}
+
+declare namespace Windows.Devices.Bluetooth.GenericAttributeProfile {
+  class GattCharacteristic implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattCharacteristic, Windows.Devices.Bluetooth.GenericAttributeProfile.IGattCharacteristic2, Windows.Devices.Bluetooth.GenericAttributeProfile.IGattCharacteristic3 {
+    static ConvertShortIdToUuid(shortId: number): Guid;
+    GetAllDescriptors(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptor> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptor[];
+    GetDescriptors(descriptorUuid: Guid): Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptor> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptor[];
+    GetDescriptorsAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptorsResult>;
+    GetDescriptorsAsync(cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptorsResult>;
+    GetDescriptorsForUuidAsync(descriptorUuid: Guid): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptorsResult>;
+    GetDescriptorsForUuidAsync(descriptorUuid: Guid, cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptorsResult>;
+    ReadClientCharacteristicConfigurationDescriptorAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadClientCharacteristicConfigurationDescriptorResult>;
+    ReadValueAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadResult>;
+    ReadValueAsync(cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadResult>;
+    WriteClientCharacteristicConfigurationDescriptorAsync(clientCharacteristicConfigurationDescriptorValue: number): Windows.Foundation.IAsyncOperation<number>;
+    WriteClientCharacteristicConfigurationDescriptorWithResultAsync(clientCharacteristicConfigurationDescriptorValue: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteResult>;
+    WriteValueAsync(value: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<number>;
+    WriteValueAsync(value: Windows.Storage.Streams.IBuffer, writeOption: number): Windows.Foundation.IAsyncOperation<number>;
+    WriteValueWithResultAsync(value: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteResult>;
+    WriteValueWithResultAsync(value: Windows.Storage.Streams.IBuffer, writeOption: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteResult>;
+    readonly AttributeHandle: number;
+    readonly CharacteristicProperties: number;
+    readonly PresentationFormats: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattPresentationFormat> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattPresentationFormat[];
+    ProtectionLevel: number;
+    readonly Service: Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService;
+    readonly UserDescription: string;
+    readonly Uuid: Guid;
+    ValueChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic, Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs> | null;
+  }
+
+  class GattCharacteristicUuids {
+    static readonly AlertCategoryId: Guid;
+    static readonly AlertCategoryIdBitMask: Guid;
+    static readonly AlertLevel: Guid;
+    static readonly AlertNotificationControlPoint: Guid;
+    static readonly AlertStatus: Guid;
+    static readonly BatteryLevel: Guid;
+    static readonly BloodPressureFeature: Guid;
+    static readonly BloodPressureMeasurement: Guid;
+    static readonly BodySensorLocation: Guid;
+    static readonly BootKeyboardInputReport: Guid;
+    static readonly BootKeyboardOutputReport: Guid;
+    static readonly BootMouseInputReport: Guid;
+    static readonly CscFeature: Guid;
+    static readonly CscMeasurement: Guid;
+    static readonly CurrentTime: Guid;
+    static readonly CyclingPowerControlPoint: Guid;
+    static readonly CyclingPowerFeature: Guid;
+    static readonly CyclingPowerMeasurement: Guid;
+    static readonly CyclingPowerVector: Guid;
+    static readonly DateTime: Guid;
+    static readonly DayDateTime: Guid;
+    static readonly DayOfWeek: Guid;
+    static readonly DstOffset: Guid;
+    static readonly ExactTime256: Guid;
+    static readonly FirmwareRevisionString: Guid;
+    static readonly GapAppearance: Guid;
+    static readonly GapDeviceName: Guid;
+    static readonly GapPeripheralPreferredConnectionParameters: Guid;
+    static readonly GapPeripheralPrivacyFlag: Guid;
+    static readonly GapReconnectionAddress: Guid;
+    static readonly GattServiceChanged: Guid;
+    static readonly GlucoseFeature: Guid;
+    static readonly GlucoseMeasurement: Guid;
+    static readonly GlucoseMeasurementContext: Guid;
+    static readonly HardwareRevisionString: Guid;
+    static readonly HeartRateControlPoint: Guid;
+    static readonly HeartRateMeasurement: Guid;
+    static readonly HidControlPoint: Guid;
+    static readonly HidInformation: Guid;
+    static readonly Ieee1107320601RegulatoryCertificationDataList: Guid;
+    static readonly IntermediateCuffPressure: Guid;
+    static readonly IntermediateTemperature: Guid;
+    static readonly LnControlPoint: Guid;
+    static readonly LnFeature: Guid;
+    static readonly LocalTimeInformation: Guid;
+    static readonly LocationAndSpeed: Guid;
+    static readonly ManufacturerNameString: Guid;
+    static readonly MeasurementInterval: Guid;
+    static readonly ModelNumberString: Guid;
+    static readonly Navigation: Guid;
+    static readonly NewAlert: Guid;
+    static readonly PnpId: Guid;
+    static readonly PositionQuality: Guid;
+    static readonly ProtocolMode: Guid;
+    static readonly RecordAccessControlPoint: Guid;
+    static readonly ReferenceTimeInformation: Guid;
+    static readonly Report: Guid;
+    static readonly ReportMap: Guid;
+    static readonly RingerControlPoint: Guid;
+    static readonly RingerSetting: Guid;
+    static readonly RscFeature: Guid;
+    static readonly RscMeasurement: Guid;
+    static readonly SCControlPoint: Guid;
+    static readonly ScanIntervalWindow: Guid;
+    static readonly ScanRefresh: Guid;
+    static readonly SensorLocation: Guid;
+    static readonly SerialNumberString: Guid;
+    static readonly SoftwareRevisionString: Guid;
+    static readonly SupportUnreadAlertCategory: Guid;
+    static readonly SupportedNewAlertCategory: Guid;
+    static readonly SystemId: Guid;
+    static readonly TemperatureMeasurement: Guid;
+    static readonly TemperatureType: Guid;
+    static readonly TimeAccuracy: Guid;
+    static readonly TimeSource: Guid;
+    static readonly TimeUpdateControlPoint: Guid;
+    static readonly TimeUpdateState: Guid;
+    static readonly TimeWithDst: Guid;
+    static readonly TimeZone: Guid;
+    static readonly TxPowerLevel: Guid;
+    static readonly UnreadAlertStatus: Guid;
+  }
+
+  class GattCharacteristicsResult implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattCharacteristicsResult {
+    readonly Characteristics: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic[];
+    readonly ProtocolError: number | null;
+    readonly Status: number;
+  }
+
+  class GattClientNotificationResult implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattClientNotificationResult, Windows.Devices.Bluetooth.GenericAttributeProfile.IGattClientNotificationResult2 {
+    readonly BytesSent: number;
+    readonly ProtocolError: number | null;
+    readonly Status: number;
+    readonly SubscribedClient: Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient;
+  }
+
+  class GattDescriptor implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattDescriptor, Windows.Devices.Bluetooth.GenericAttributeProfile.IGattDescriptor2 {
+    static ConvertShortIdToUuid(shortId: number): Guid;
+    ReadValueAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadResult>;
+    ReadValueAsync(cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadResult>;
+    WriteValueAsync(value: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<number>;
+    WriteValueWithResultAsync(value: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteResult>;
+    readonly AttributeHandle: number;
+    ProtectionLevel: number;
+    readonly Uuid: Guid;
+  }
+
+  class GattDescriptorUuids {
+    static readonly CharacteristicAggregateFormat: Guid;
+    static readonly CharacteristicExtendedProperties: Guid;
+    static readonly CharacteristicPresentationFormat: Guid;
+    static readonly CharacteristicUserDescription: Guid;
+    static readonly ClientCharacteristicConfiguration: Guid;
+    static readonly ServerCharacteristicConfiguration: Guid;
+  }
+
+  class GattDescriptorsResult implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattDescriptorsResult {
+    readonly Descriptors: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptor> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptor[];
+    readonly ProtocolError: number | null;
+    readonly Status: number;
+  }
+
+  class GattDeviceService implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattDeviceService, Windows.Devices.Bluetooth.GenericAttributeProfile.IGattDeviceService2, Windows.Devices.Bluetooth.GenericAttributeProfile.IGattDeviceService3, Windows.Foundation.IClosable {
+    Close(): void;
+    static ConvertShortIdToUuid(shortId: number): Guid;
+    static FromIdAsync(deviceId: string, sharingMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService>;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService>;
+    GetAllCharacteristics(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic[];
+    GetAllIncludedServices(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService[];
+    GetCharacteristics(characteristicUuid: Guid): Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic[];
+    GetCharacteristicsAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristicsResult>;
+    GetCharacteristicsAsync(cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristicsResult>;
+    GetCharacteristicsForUuidAsync(characteristicUuid: Guid): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristicsResult>;
+    GetCharacteristicsForUuidAsync(characteristicUuid: Guid, cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristicsResult>;
+    static GetDeviceSelectorForBluetoothDeviceId(bluetoothDeviceId: Windows.Devices.Bluetooth.BluetoothDeviceId): string;
+    static GetDeviceSelectorForBluetoothDeviceId(bluetoothDeviceId: Windows.Devices.Bluetooth.BluetoothDeviceId, cacheMode: number): string;
+    static GetDeviceSelectorForBluetoothDeviceIdAndUuid(bluetoothDeviceId: Windows.Devices.Bluetooth.BluetoothDeviceId, serviceUuid: Guid): string;
+    static GetDeviceSelectorForBluetoothDeviceIdAndUuid(bluetoothDeviceId: Windows.Devices.Bluetooth.BluetoothDeviceId, serviceUuid: Guid, cacheMode: number): string;
+    static GetDeviceSelectorFromShortId(serviceShortId: number): string;
+    static GetDeviceSelectorFromUuid(serviceUuid: Guid): string;
+    GetIncludedServices(serviceUuid: Guid): Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService[];
+    GetIncludedServicesAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceServicesResult>;
+    GetIncludedServicesAsync(cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceServicesResult>;
+    GetIncludedServicesForUuidAsync(serviceUuid: Guid): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceServicesResult>;
+    GetIncludedServicesForUuidAsync(serviceUuid: Guid, cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceServicesResult>;
+    OpenAsync(sharingMode: number): Windows.Foundation.IAsyncOperation<number>;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly AttributeHandle: number;
+    readonly Device: Windows.Devices.Bluetooth.BluetoothLEDevice;
+    readonly DeviceAccessInformation: Windows.Devices.Enumeration.DeviceAccessInformation;
+    readonly DeviceId: string;
+    readonly ParentServices: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService[];
+    readonly Session: Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession;
+    readonly SharingMode: number;
+    readonly Uuid: Guid;
+  }
+
+  class GattDeviceServicesResult implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattDeviceServicesResult {
+    readonly ProtocolError: number | null;
+    readonly Services: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService[];
+    readonly Status: number;
+  }
+
+  class GattLocalCharacteristic implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattLocalCharacteristic {
+    CreateDescriptorAsync(descriptorUuid: Guid, parameters: Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptorParameters): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptorResult>;
+    NotifyValueAsync(value: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattClientNotificationResult> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattClientNotificationResult[]>;
+    NotifyValueAsync(value: Windows.Storage.Streams.IBuffer, subscribedClient: Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattClientNotificationResult>;
+    readonly CharacteristicProperties: number;
+    readonly Descriptors: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor[];
+    readonly PresentationFormats: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattPresentationFormat> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattPresentationFormat[];
+    readonly ReadProtectionLevel: number;
+    readonly StaticValue: Windows.Storage.Streams.IBuffer;
+    readonly SubscribedClients: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient[];
+    readonly UserDescription: string;
+    readonly Uuid: Guid;
+    readonly WriteProtectionLevel: number;
+    ReadRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic, Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs> | null;
+    SubscribedClientsChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic, Object> | null;
+    WriteRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic, Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs> | null;
+  }
+
+  class GattLocalCharacteristicParameters implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattLocalCharacteristicParameters {
+    constructor();
+    CharacteristicProperties: number;
+    readonly PresentationFormats: Windows.Foundation.Collections.IVector<Windows.Devices.Bluetooth.GenericAttributeProfile.GattPresentationFormat> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattPresentationFormat[];
+    ReadProtectionLevel: number;
+    StaticValue: Windows.Storage.Streams.IBuffer;
+    UserDescription: string;
+    WriteProtectionLevel: number;
+  }
+
+  class GattLocalCharacteristicResult implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattLocalCharacteristicResult {
+    readonly Characteristic: Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic;
+    readonly Error: number;
+  }
+
+  class GattLocalDescriptor implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattLocalDescriptor {
+    readonly ReadProtectionLevel: number;
+    readonly StaticValue: Windows.Storage.Streams.IBuffer;
+    readonly Uuid: Guid;
+    readonly WriteProtectionLevel: number;
+    ReadRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor, Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs> | null;
+    WriteRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor, Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs> | null;
+  }
+
+  class GattLocalDescriptorParameters implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattLocalDescriptorParameters {
+    constructor();
+    ReadProtectionLevel: number;
+    StaticValue: Windows.Storage.Streams.IBuffer;
+    WriteProtectionLevel: number;
+  }
+
+  class GattLocalDescriptorResult implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattLocalDescriptorResult {
+    readonly Descriptor: Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor;
+    readonly Error: number;
+  }
+
+  class GattLocalService implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattLocalService {
+    CreateCharacteristicAsync(characteristicUuid: Guid, parameters: Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristicParameters): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristicResult>;
+    readonly Characteristics: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic[];
+    readonly Uuid: Guid;
+  }
+
+  class GattPresentationFormat implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattPresentationFormat {
+    static FromParts(formatType: number, exponent: number, unit: number, namespaceId: number, description: number): Windows.Devices.Bluetooth.GenericAttributeProfile.GattPresentationFormat;
+    static readonly BluetoothSigAssignedNumbers: number;
+    readonly Description: number;
+    readonly Exponent: number;
+    readonly FormatType: number;
+    readonly Namespace: number;
+    readonly Unit: number;
+  }
+
+  class GattPresentationFormatTypes {
+    static readonly Bit2: number;
+    static readonly Boolean: number;
+    static readonly DUInt16: number;
+    static readonly Float: number;
+    static readonly Float32: number;
+    static readonly Float64: number;
+    static readonly Nibble: number;
+    static readonly SFloat: number;
+    static readonly SInt12: number;
+    static readonly SInt128: number;
+    static readonly SInt16: number;
+    static readonly SInt24: number;
+    static readonly SInt32: number;
+    static readonly SInt48: number;
+    static readonly SInt64: number;
+    static readonly SInt8: number;
+    static readonly Struct: number;
+    static readonly UInt12: number;
+    static readonly UInt128: number;
+    static readonly UInt16: number;
+    static readonly UInt24: number;
+    static readonly UInt32: number;
+    static readonly UInt48: number;
+    static readonly UInt64: number;
+    static readonly UInt8: number;
+    static readonly Utf16: number;
+    static readonly Utf8: number;
+  }
+
+  class GattProtocolError {
+    static readonly AttributeNotFound: number;
+    static readonly AttributeNotLong: number;
+    static readonly InsufficientAuthentication: number;
+    static readonly InsufficientAuthorization: number;
+    static readonly InsufficientEncryption: number;
+    static readonly InsufficientEncryptionKeySize: number;
+    static readonly InsufficientResources: number;
+    static readonly InvalidAttributeValueLength: number;
+    static readonly InvalidHandle: number;
+    static readonly InvalidOffset: number;
+    static readonly InvalidPdu: number;
+    static readonly PrepareQueueFull: number;
+    static readonly ReadNotPermitted: number;
+    static readonly RequestNotSupported: number;
+    static readonly UnlikelyError: number;
+    static readonly UnsupportedGroupType: number;
+    static readonly WriteNotPermitted: number;
+  }
+
+  class GattReadClientCharacteristicConfigurationDescriptorResult implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattReadClientCharacteristicConfigurationDescriptorResult, Windows.Devices.Bluetooth.GenericAttributeProfile.IGattReadClientCharacteristicConfigurationDescriptorResult2 {
+    readonly ClientCharacteristicConfigurationDescriptor: number;
+    readonly ProtocolError: number | null;
+    readonly Status: number;
+  }
+
+  class GattReadRequest implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattReadRequest {
+    RespondWithProtocolError(protocolError: number): void;
+    RespondWithValue(value: Windows.Storage.Streams.IBuffer): void;
+    readonly Length: number;
+    readonly Offset: number;
+    readonly State: number;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest, Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs> | null;
+  }
+
+  class GattReadRequestedEventArgs implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattReadRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    GetRequestAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest>;
+    readonly Session: Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession;
+  }
+
+  class GattReadResult implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattReadResult, Windows.Devices.Bluetooth.GenericAttributeProfile.IGattReadResult2 {
+    readonly ProtocolError: number | null;
+    readonly Status: number;
+    readonly Value: Windows.Storage.Streams.IBuffer;
+  }
+
+  class GattReliableWriteTransaction implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattReliableWriteTransaction, Windows.Devices.Bluetooth.GenericAttributeProfile.IGattReliableWriteTransaction2 {
+    constructor();
+    CommitAsync(): Windows.Foundation.IAsyncOperation<number>;
+    CommitWithResultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteResult>;
+    WriteValue(characteristic: Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic, value: Windows.Storage.Streams.IBuffer): void;
+  }
+
+  class GattRequestStateChangedEventArgs implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattRequestStateChangedEventArgs {
+    readonly Error: number;
+    readonly State: number;
+  }
+
+  class GattServiceProvider implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattServiceProvider, Windows.Devices.Bluetooth.GenericAttributeProfile.IGattServiceProvider2 {
+    static CreateAsync(serviceUuid: Guid): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderResult>;
+    StartAdvertising(): void;
+    StartAdvertising(parameters: Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisingParameters): void;
+    StopAdvertising(): void;
+    UpdateAdvertisingParameters(parameters: Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisingParameters): void;
+    readonly AdvertisementStatus: number;
+    readonly Service: Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalService;
+    AdvertisementStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider, Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisementStatusChangedEventArgs> | null;
+  }
+
+  class GattServiceProviderAdvertisementStatusChangedEventArgs implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattServiceProviderAdvertisementStatusChangedEventArgs {
+    readonly Error: number;
+    readonly Status: number;
+  }
+
+  class GattServiceProviderAdvertisingParameters implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattServiceProviderAdvertisingParameters, Windows.Devices.Bluetooth.GenericAttributeProfile.IGattServiceProviderAdvertisingParameters2, Windows.Devices.Bluetooth.GenericAttributeProfile.IGattServiceProviderAdvertisingParameters3 {
+    constructor();
+    IsConnectable: boolean;
+    IsDiscoverable: boolean;
+    ServiceData: Windows.Storage.Streams.IBuffer;
+    UseLowEnergyUncoded1MPhyAsSecondaryPhy: boolean;
+    UseLowEnergyUncoded2MPhyAsSecondaryPhy: boolean;
+  }
+
+  class GattServiceProviderResult implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattServiceProviderResult {
+    readonly Error: number;
+    readonly ServiceProvider: Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider;
+  }
+
+  class GattServiceUuids {
+    static readonly AlertNotification: Guid;
+    static readonly Battery: Guid;
+    static readonly BloodPressure: Guid;
+    static readonly CurrentTime: Guid;
+    static readonly CyclingPower: Guid;
+    static readonly CyclingSpeedAndCadence: Guid;
+    static readonly DeviceInformation: Guid;
+    static readonly GenericAccess: Guid;
+    static readonly GenericAttribute: Guid;
+    static readonly Glucose: Guid;
+    static readonly HealthThermometer: Guid;
+    static readonly HeartRate: Guid;
+    static readonly HumanInterfaceDevice: Guid;
+    static readonly ImmediateAlert: Guid;
+    static readonly LinkLoss: Guid;
+    static readonly LocationAndNavigation: Guid;
+    static readonly NextDstChange: Guid;
+    static readonly PhoneAlertStatus: Guid;
+    static readonly ReferenceTimeUpdate: Guid;
+    static readonly RunningSpeedAndCadence: Guid;
+    static readonly ScanParameters: Guid;
+    static readonly TxPower: Guid;
+  }
+
+  class GattSession implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattSession, Windows.Foundation.IClosable {
+    Close(): void;
+    static FromDeviceIdAsync(deviceId: Windows.Devices.Bluetooth.BluetoothDeviceId): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession>;
+    readonly CanMaintainConnection: boolean;
+    readonly DeviceId: Windows.Devices.Bluetooth.BluetoothDeviceId;
+    MaintainConnection: boolean;
+    readonly MaxPduSize: number;
+    readonly SessionStatus: number;
+    MaxPduSizeChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession, Object> | null;
+    SessionStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession, Windows.Devices.Bluetooth.GenericAttributeProfile.GattSessionStatusChangedEventArgs> | null;
+  }
+
+  class GattSessionStatusChangedEventArgs implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattSessionStatusChangedEventArgs {
+    readonly Error: number;
+    readonly Status: number;
+  }
+
+  class GattSubscribedClient implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattSubscribedClient {
+    readonly MaxNotificationSize: number;
+    readonly Session: Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession;
+    MaxNotificationSizeChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient, Object> | null;
+  }
+
+  class GattValueChangedEventArgs implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattValueChangedEventArgs {
+    readonly CharacteristicValue: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class GattWriteRequest implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattWriteRequest {
+    Respond(): void;
+    RespondWithProtocolError(protocolError: number): void;
+    readonly Offset: number;
+    readonly Option: number;
+    readonly State: number;
+    readonly Value: Windows.Storage.Streams.IBuffer;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest, Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs> | null;
+  }
+
+  class GattWriteRequestedEventArgs implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattWriteRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    GetRequestAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest>;
+    readonly Session: Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession;
+  }
+
+  class GattWriteResult implements Windows.Devices.Bluetooth.GenericAttributeProfile.IGattWriteResult {
+    readonly ProtocolError: number | null;
+    readonly Status: number;
+  }
+
+  enum GattCharacteristicProperties {
+    None = 0,
+    Broadcast = 1,
+    Read = 2,
+    WriteWithoutResponse = 4,
+    Write = 8,
+    Notify = 16,
+    Indicate = 32,
+    AuthenticatedSignedWrites = 64,
+    ExtendedProperties = 128,
+    ReliableWrites = 256,
+    WritableAuxiliaries = 512,
+  }
+
+  enum GattClientCharacteristicConfigurationDescriptorValue {
+    None = 0,
+    Notify = 1,
+    Indicate = 2,
+  }
+
+  enum GattCommunicationStatus {
+    Success = 0,
+    Unreachable = 1,
+    ProtocolError = 2,
+    AccessDenied = 3,
+  }
+
+  enum GattOpenStatus {
+    Unspecified = 0,
+    Success = 1,
+    AlreadyOpened = 2,
+    NotFound = 3,
+    SharingViolation = 4,
+    AccessDenied = 5,
+  }
+
+  enum GattProtectionLevel {
+    Plain = 0,
+    AuthenticationRequired = 1,
+    EncryptionRequired = 2,
+    EncryptionAndAuthenticationRequired = 3,
+  }
+
+  enum GattRequestState {
+    Pending = 0,
+    Completed = 1,
+    Canceled = 2,
+  }
+
+  enum GattServiceProviderAdvertisementStatus {
+    Created = 0,
+    Stopped = 1,
+    Started = 2,
+    Aborted = 3,
+    StartedWithoutAllAdvertisementData = 4,
+  }
+
+  enum GattSessionStatus {
+    Closed = 0,
+    Active = 1,
+  }
+
+  enum GattSharingMode {
+    Unspecified = 0,
+    Exclusive = 1,
+    SharedReadOnly = 2,
+    SharedReadAndWrite = 3,
+  }
+
+  enum GattWriteOption {
+    WriteWithResponse = 0,
+    WriteWithoutResponse = 1,
+  }
+
+  interface IGattCharacteristic {
+    GetDescriptors(descriptorUuid: Guid): Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptor> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptor[];
+    ReadClientCharacteristicConfigurationDescriptorAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadClientCharacteristicConfigurationDescriptorResult>;
+    ReadValueAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadResult>;
+    ReadValueAsync(cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadResult>;
+    WriteClientCharacteristicConfigurationDescriptorAsync(clientCharacteristicConfigurationDescriptorValue: number): Windows.Foundation.IAsyncOperation<number>;
+    WriteValueAsync(value: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<number>;
+    WriteValueAsync(value: Windows.Storage.Streams.IBuffer, writeOption: number): Windows.Foundation.IAsyncOperation<number>;
+    readonly AttributeHandle: number;
+    readonly CharacteristicProperties: number;
+    readonly PresentationFormats: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattPresentationFormat> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattPresentationFormat[];
+    ProtectionLevel: number;
+    readonly UserDescription: string;
+    readonly Uuid: Guid;
+    ValueChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic, Windows.Devices.Bluetooth.GenericAttributeProfile.GattValueChangedEventArgs> | null;
+  }
+  var IGattCharacteristic: abstract new (...args: any[]) => IGattCharacteristic;
+
+  interface IGattCharacteristic2 extends Windows.Devices.Bluetooth.GenericAttributeProfile.IGattCharacteristic {
+    GetAllDescriptors(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptor> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptor[];
+    GetDescriptors(descriptorUuid: Guid): Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptor> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptor[];
+    ReadClientCharacteristicConfigurationDescriptorAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadClientCharacteristicConfigurationDescriptorResult>;
+    ReadValueAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadResult>;
+    ReadValueAsync(cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadResult>;
+    WriteClientCharacteristicConfigurationDescriptorAsync(clientCharacteristicConfigurationDescriptorValue: number): Windows.Foundation.IAsyncOperation<number>;
+    WriteValueAsync(value: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<number>;
+    WriteValueAsync(value: Windows.Storage.Streams.IBuffer, writeOption: number): Windows.Foundation.IAsyncOperation<number>;
+    readonly Service: Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService;
+  }
+  var IGattCharacteristic2: abstract new (...args: any[]) => IGattCharacteristic2;
+
+  interface IGattCharacteristic3 {
+    GetDescriptorsAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptorsResult>;
+    GetDescriptorsAsync(cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptorsResult>;
+    GetDescriptorsForUuidAsync(descriptorUuid: Guid): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptorsResult>;
+    GetDescriptorsForUuidAsync(descriptorUuid: Guid, cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptorsResult>;
+    WriteClientCharacteristicConfigurationDescriptorWithResultAsync(clientCharacteristicConfigurationDescriptorValue: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteResult>;
+    WriteValueWithResultAsync(value: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteResult>;
+    WriteValueWithResultAsync(value: Windows.Storage.Streams.IBuffer, writeOption: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteResult>;
+  }
+  var IGattCharacteristic3: abstract new (...args: any[]) => IGattCharacteristic3;
+
+  interface IGattCharacteristicStatics {
+    ConvertShortIdToUuid(shortId: number): Guid;
+  }
+  var IGattCharacteristicStatics: abstract new (...args: any[]) => IGattCharacteristicStatics;
+
+  interface IGattCharacteristicUuidsStatics {
+    readonly BatteryLevel: Guid;
+    readonly BloodPressureFeature: Guid;
+    readonly BloodPressureMeasurement: Guid;
+    readonly BodySensorLocation: Guid;
+    readonly CscFeature: Guid;
+    readonly CscMeasurement: Guid;
+    readonly GlucoseFeature: Guid;
+    readonly GlucoseMeasurement: Guid;
+    readonly GlucoseMeasurementContext: Guid;
+    readonly HeartRateControlPoint: Guid;
+    readonly HeartRateMeasurement: Guid;
+    readonly IntermediateCuffPressure: Guid;
+    readonly IntermediateTemperature: Guid;
+    readonly MeasurementInterval: Guid;
+    readonly RecordAccessControlPoint: Guid;
+    readonly RscFeature: Guid;
+    readonly RscMeasurement: Guid;
+    readonly SCControlPoint: Guid;
+    readonly SensorLocation: Guid;
+    readonly TemperatureMeasurement: Guid;
+    readonly TemperatureType: Guid;
+  }
+  var IGattCharacteristicUuidsStatics: abstract new (...args: any[]) => IGattCharacteristicUuidsStatics;
+
+  interface IGattCharacteristicUuidsStatics2 {
+    readonly AlertCategoryId: Guid;
+    readonly AlertCategoryIdBitMask: Guid;
+    readonly AlertLevel: Guid;
+    readonly AlertNotificationControlPoint: Guid;
+    readonly AlertStatus: Guid;
+    readonly BootKeyboardInputReport: Guid;
+    readonly BootKeyboardOutputReport: Guid;
+    readonly BootMouseInputReport: Guid;
+    readonly CurrentTime: Guid;
+    readonly CyclingPowerControlPoint: Guid;
+    readonly CyclingPowerFeature: Guid;
+    readonly CyclingPowerMeasurement: Guid;
+    readonly CyclingPowerVector: Guid;
+    readonly DateTime: Guid;
+    readonly DayDateTime: Guid;
+    readonly DayOfWeek: Guid;
+    readonly DstOffset: Guid;
+    readonly ExactTime256: Guid;
+    readonly FirmwareRevisionString: Guid;
+    readonly GapAppearance: Guid;
+    readonly GapDeviceName: Guid;
+    readonly GapPeripheralPreferredConnectionParameters: Guid;
+    readonly GapPeripheralPrivacyFlag: Guid;
+    readonly GapReconnectionAddress: Guid;
+    readonly GattServiceChanged: Guid;
+    readonly HardwareRevisionString: Guid;
+    readonly HidControlPoint: Guid;
+    readonly HidInformation: Guid;
+    readonly Ieee1107320601RegulatoryCertificationDataList: Guid;
+    readonly LnControlPoint: Guid;
+    readonly LnFeature: Guid;
+    readonly LocalTimeInformation: Guid;
+    readonly LocationAndSpeed: Guid;
+    readonly ManufacturerNameString: Guid;
+    readonly ModelNumberString: Guid;
+    readonly Navigation: Guid;
+    readonly NewAlert: Guid;
+    readonly PnpId: Guid;
+    readonly PositionQuality: Guid;
+    readonly ProtocolMode: Guid;
+    readonly ReferenceTimeInformation: Guid;
+    readonly Report: Guid;
+    readonly ReportMap: Guid;
+    readonly RingerControlPoint: Guid;
+    readonly RingerSetting: Guid;
+    readonly ScanIntervalWindow: Guid;
+    readonly ScanRefresh: Guid;
+    readonly SerialNumberString: Guid;
+    readonly SoftwareRevisionString: Guid;
+    readonly SupportUnreadAlertCategory: Guid;
+    readonly SupportedNewAlertCategory: Guid;
+    readonly SystemId: Guid;
+    readonly TimeAccuracy: Guid;
+    readonly TimeSource: Guid;
+    readonly TimeUpdateControlPoint: Guid;
+    readonly TimeUpdateState: Guid;
+    readonly TimeWithDst: Guid;
+    readonly TimeZone: Guid;
+    readonly TxPowerLevel: Guid;
+    readonly UnreadAlertStatus: Guid;
+  }
+  var IGattCharacteristicUuidsStatics2: abstract new (...args: any[]) => IGattCharacteristicUuidsStatics2;
+
+  interface IGattCharacteristicsResult {
+    readonly Characteristics: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic[];
+    readonly ProtocolError: number | null;
+    readonly Status: number;
+  }
+  var IGattCharacteristicsResult: abstract new (...args: any[]) => IGattCharacteristicsResult;
+
+  interface IGattClientNotificationResult {
+    readonly ProtocolError: number | null;
+    readonly Status: number;
+    readonly SubscribedClient: Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient;
+  }
+  var IGattClientNotificationResult: abstract new (...args: any[]) => IGattClientNotificationResult;
+
+  interface IGattClientNotificationResult2 {
+    readonly BytesSent: number;
+  }
+  var IGattClientNotificationResult2: abstract new (...args: any[]) => IGattClientNotificationResult2;
+
+  interface IGattDescriptor {
+    ReadValueAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadResult>;
+    ReadValueAsync(cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadResult>;
+    WriteValueAsync(value: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<number>;
+    readonly AttributeHandle: number;
+    ProtectionLevel: number;
+    readonly Uuid: Guid;
+  }
+  var IGattDescriptor: abstract new (...args: any[]) => IGattDescriptor;
+
+  interface IGattDescriptor2 {
+    WriteValueWithResultAsync(value: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteResult>;
+  }
+  var IGattDescriptor2: abstract new (...args: any[]) => IGattDescriptor2;
+
+  interface IGattDescriptorStatics {
+    ConvertShortIdToUuid(shortId: number): Guid;
+  }
+  var IGattDescriptorStatics: abstract new (...args: any[]) => IGattDescriptorStatics;
+
+  interface IGattDescriptorUuidsStatics {
+    readonly CharacteristicAggregateFormat: Guid;
+    readonly CharacteristicExtendedProperties: Guid;
+    readonly CharacteristicPresentationFormat: Guid;
+    readonly CharacteristicUserDescription: Guid;
+    readonly ClientCharacteristicConfiguration: Guid;
+    readonly ServerCharacteristicConfiguration: Guid;
+  }
+  var IGattDescriptorUuidsStatics: abstract new (...args: any[]) => IGattDescriptorUuidsStatics;
+
+  interface IGattDescriptorsResult {
+    readonly Descriptors: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptor> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattDescriptor[];
+    readonly ProtocolError: number | null;
+    readonly Status: number;
+  }
+  var IGattDescriptorsResult: abstract new (...args: any[]) => IGattDescriptorsResult;
+
+  interface IGattDeviceService extends Windows.Foundation.IClosable {
+    Close(): void;
+    GetCharacteristics(characteristicUuid: Guid): Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic[];
+    GetIncludedServices(serviceUuid: Guid): Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService[];
+    readonly AttributeHandle: number;
+    readonly DeviceId: string;
+    readonly Uuid: Guid;
+  }
+  var IGattDeviceService: abstract new (...args: any[]) => IGattDeviceService;
+
+  interface IGattDeviceService2 extends Windows.Devices.Bluetooth.GenericAttributeProfile.IGattDeviceService, Windows.Foundation.IClosable {
+    Close(): void;
+    GetAllCharacteristics(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic[];
+    GetAllIncludedServices(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService[];
+    GetCharacteristics(characteristicUuid: Guid): Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic[];
+    GetIncludedServices(serviceUuid: Guid): Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService[];
+    readonly Device: Windows.Devices.Bluetooth.BluetoothLEDevice;
+    readonly ParentServices: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService[];
+  }
+  var IGattDeviceService2: abstract new (...args: any[]) => IGattDeviceService2;
+
+  interface IGattDeviceService3 {
+    GetCharacteristicsAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristicsResult>;
+    GetCharacteristicsAsync(cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristicsResult>;
+    GetCharacteristicsForUuidAsync(characteristicUuid: Guid): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristicsResult>;
+    GetCharacteristicsForUuidAsync(characteristicUuid: Guid, cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristicsResult>;
+    GetIncludedServicesAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceServicesResult>;
+    GetIncludedServicesAsync(cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceServicesResult>;
+    GetIncludedServicesForUuidAsync(serviceUuid: Guid): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceServicesResult>;
+    GetIncludedServicesForUuidAsync(serviceUuid: Guid, cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceServicesResult>;
+    OpenAsync(sharingMode: number): Windows.Foundation.IAsyncOperation<number>;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly DeviceAccessInformation: Windows.Devices.Enumeration.DeviceAccessInformation;
+    readonly Session: Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession;
+    readonly SharingMode: number;
+  }
+  var IGattDeviceService3: abstract new (...args: any[]) => IGattDeviceService3;
+
+  interface IGattDeviceServiceStatics {
+    ConvertShortIdToUuid(shortId: number): Guid;
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService>;
+    GetDeviceSelectorFromShortId(serviceShortId: number): string;
+    GetDeviceSelectorFromUuid(serviceUuid: Guid): string;
+  }
+  var IGattDeviceServiceStatics: abstract new (...args: any[]) => IGattDeviceServiceStatics;
+
+  interface IGattDeviceServiceStatics2 {
+    FromIdAsync(deviceId: string, sharingMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService>;
+    GetDeviceSelectorForBluetoothDeviceId(bluetoothDeviceId: Windows.Devices.Bluetooth.BluetoothDeviceId): string;
+    GetDeviceSelectorForBluetoothDeviceId(bluetoothDeviceId: Windows.Devices.Bluetooth.BluetoothDeviceId, cacheMode: number): string;
+    GetDeviceSelectorForBluetoothDeviceIdAndUuid(bluetoothDeviceId: Windows.Devices.Bluetooth.BluetoothDeviceId, serviceUuid: Guid): string;
+    GetDeviceSelectorForBluetoothDeviceIdAndUuid(bluetoothDeviceId: Windows.Devices.Bluetooth.BluetoothDeviceId, serviceUuid: Guid, cacheMode: number): string;
+  }
+  var IGattDeviceServiceStatics2: abstract new (...args: any[]) => IGattDeviceServiceStatics2;
+
+  interface IGattDeviceServicesResult {
+    readonly ProtocolError: number | null;
+    readonly Services: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattDeviceService[];
+    readonly Status: number;
+  }
+  var IGattDeviceServicesResult: abstract new (...args: any[]) => IGattDeviceServicesResult;
+
+  interface IGattLocalCharacteristic {
+    CreateDescriptorAsync(descriptorUuid: Guid, parameters: Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptorParameters): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptorResult>;
+    NotifyValueAsync(value: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattClientNotificationResult> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattClientNotificationResult[]>;
+    NotifyValueAsync(value: Windows.Storage.Streams.IBuffer, subscribedClient: Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattClientNotificationResult>;
+    readonly CharacteristicProperties: number;
+    readonly Descriptors: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor[];
+    readonly PresentationFormats: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattPresentationFormat> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattPresentationFormat[];
+    readonly ReadProtectionLevel: number;
+    readonly StaticValue: Windows.Storage.Streams.IBuffer;
+    readonly SubscribedClients: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient[];
+    readonly UserDescription: string;
+    readonly Uuid: Guid;
+    readonly WriteProtectionLevel: number;
+    ReadRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic, Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs> | null;
+    SubscribedClientsChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic, Object> | null;
+    WriteRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic, Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs> | null;
+  }
+  var IGattLocalCharacteristic: abstract new (...args: any[]) => IGattLocalCharacteristic;
+
+  interface IGattLocalCharacteristicParameters {
+    CharacteristicProperties: number;
+    readonly PresentationFormats: Windows.Foundation.Collections.IVector<Windows.Devices.Bluetooth.GenericAttributeProfile.GattPresentationFormat> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattPresentationFormat[];
+    ReadProtectionLevel: number;
+    StaticValue: Windows.Storage.Streams.IBuffer;
+    UserDescription: string;
+    WriteProtectionLevel: number;
+  }
+  var IGattLocalCharacteristicParameters: abstract new (...args: any[]) => IGattLocalCharacteristicParameters;
+
+  interface IGattLocalCharacteristicResult {
+    readonly Characteristic: Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic;
+    readonly Error: number;
+  }
+  var IGattLocalCharacteristicResult: abstract new (...args: any[]) => IGattLocalCharacteristicResult;
+
+  interface IGattLocalDescriptor {
+    readonly ReadProtectionLevel: number;
+    readonly StaticValue: Windows.Storage.Streams.IBuffer;
+    readonly Uuid: Guid;
+    readonly WriteProtectionLevel: number;
+    ReadRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor, Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequestedEventArgs> | null;
+    WriteRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor, Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequestedEventArgs> | null;
+  }
+  var IGattLocalDescriptor: abstract new (...args: any[]) => IGattLocalDescriptor;
+
+  interface IGattLocalDescriptorParameters {
+    ReadProtectionLevel: number;
+    StaticValue: Windows.Storage.Streams.IBuffer;
+    WriteProtectionLevel: number;
+  }
+  var IGattLocalDescriptorParameters: abstract new (...args: any[]) => IGattLocalDescriptorParameters;
+
+  interface IGattLocalDescriptorResult {
+    readonly Descriptor: Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalDescriptor;
+    readonly Error: number;
+  }
+  var IGattLocalDescriptorResult: abstract new (...args: any[]) => IGattLocalDescriptorResult;
+
+  interface IGattLocalService {
+    CreateCharacteristicAsync(characteristicUuid: Guid, parameters: Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristicParameters): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristicResult>;
+    readonly Characteristics: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic> | Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalCharacteristic[];
+    readonly Uuid: Guid;
+  }
+  var IGattLocalService: abstract new (...args: any[]) => IGattLocalService;
+
+  interface IGattPresentationFormat {
+    readonly Description: number;
+    readonly Exponent: number;
+    readonly FormatType: number;
+    readonly Namespace: number;
+    readonly Unit: number;
+  }
+  var IGattPresentationFormat: abstract new (...args: any[]) => IGattPresentationFormat;
+
+  interface IGattPresentationFormatStatics {
+    readonly BluetoothSigAssignedNumbers: number;
+  }
+  var IGattPresentationFormatStatics: abstract new (...args: any[]) => IGattPresentationFormatStatics;
+
+  interface IGattPresentationFormatStatics2 extends Windows.Devices.Bluetooth.GenericAttributeProfile.IGattPresentationFormatStatics {
+    FromParts(formatType: number, exponent: number, unit: number, namespaceId: number, description: number): Windows.Devices.Bluetooth.GenericAttributeProfile.GattPresentationFormat;
+  }
+  var IGattPresentationFormatStatics2: abstract new (...args: any[]) => IGattPresentationFormatStatics2;
+
+  interface IGattPresentationFormatTypesStatics {
+    readonly Bit2: number;
+    readonly Boolean: number;
+    readonly DUInt16: number;
+    readonly Float: number;
+    readonly Float32: number;
+    readonly Float64: number;
+    readonly Nibble: number;
+    readonly SFloat: number;
+    readonly SInt12: number;
+    readonly SInt128: number;
+    readonly SInt16: number;
+    readonly SInt24: number;
+    readonly SInt32: number;
+    readonly SInt48: number;
+    readonly SInt64: number;
+    readonly SInt8: number;
+    readonly Struct: number;
+    readonly UInt12: number;
+    readonly UInt128: number;
+    readonly UInt16: number;
+    readonly UInt24: number;
+    readonly UInt32: number;
+    readonly UInt48: number;
+    readonly UInt64: number;
+    readonly UInt8: number;
+    readonly Utf16: number;
+    readonly Utf8: number;
+  }
+  var IGattPresentationFormatTypesStatics: abstract new (...args: any[]) => IGattPresentationFormatTypesStatics;
+
+  interface IGattProtocolErrorStatics {
+    readonly AttributeNotFound: number;
+    readonly AttributeNotLong: number;
+    readonly InsufficientAuthentication: number;
+    readonly InsufficientAuthorization: number;
+    readonly InsufficientEncryption: number;
+    readonly InsufficientEncryptionKeySize: number;
+    readonly InsufficientResources: number;
+    readonly InvalidAttributeValueLength: number;
+    readonly InvalidHandle: number;
+    readonly InvalidOffset: number;
+    readonly InvalidPdu: number;
+    readonly PrepareQueueFull: number;
+    readonly ReadNotPermitted: number;
+    readonly RequestNotSupported: number;
+    readonly UnlikelyError: number;
+    readonly UnsupportedGroupType: number;
+    readonly WriteNotPermitted: number;
+  }
+  var IGattProtocolErrorStatics: abstract new (...args: any[]) => IGattProtocolErrorStatics;
+
+  interface IGattReadClientCharacteristicConfigurationDescriptorResult {
+    readonly ClientCharacteristicConfigurationDescriptor: number;
+    readonly Status: number;
+  }
+  var IGattReadClientCharacteristicConfigurationDescriptorResult: abstract new (...args: any[]) => IGattReadClientCharacteristicConfigurationDescriptorResult;
+
+  interface IGattReadClientCharacteristicConfigurationDescriptorResult2 {
+    readonly ProtocolError: number | null;
+  }
+  var IGattReadClientCharacteristicConfigurationDescriptorResult2: abstract new (...args: any[]) => IGattReadClientCharacteristicConfigurationDescriptorResult2;
+
+  interface IGattReadRequest {
+    RespondWithProtocolError(protocolError: number): void;
+    RespondWithValue(value: Windows.Storage.Streams.IBuffer): void;
+    readonly Length: number;
+    readonly Offset: number;
+    readonly State: number;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest, Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs> | null;
+  }
+  var IGattReadRequest: abstract new (...args: any[]) => IGattReadRequest;
+
+  interface IGattReadRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    GetRequestAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattReadRequest>;
+    readonly Session: Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession;
+  }
+  var IGattReadRequestedEventArgs: abstract new (...args: any[]) => IGattReadRequestedEventArgs;
+
+  interface IGattReadResult {
+    readonly Status: number;
+    readonly Value: Windows.Storage.Streams.IBuffer;
+  }
+  var IGattReadResult: abstract new (...args: any[]) => IGattReadResult;
+
+  interface IGattReadResult2 {
+    readonly ProtocolError: number | null;
+  }
+  var IGattReadResult2: abstract new (...args: any[]) => IGattReadResult2;
+
+  interface IGattReliableWriteTransaction {
+    CommitAsync(): Windows.Foundation.IAsyncOperation<number>;
+    WriteValue(characteristic: Windows.Devices.Bluetooth.GenericAttributeProfile.GattCharacteristic, value: Windows.Storage.Streams.IBuffer): void;
+  }
+  var IGattReliableWriteTransaction: abstract new (...args: any[]) => IGattReliableWriteTransaction;
+
+  interface IGattReliableWriteTransaction2 {
+    CommitWithResultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteResult>;
+  }
+  var IGattReliableWriteTransaction2: abstract new (...args: any[]) => IGattReliableWriteTransaction2;
+
+  interface IGattRequestStateChangedEventArgs {
+    readonly Error: number;
+    readonly State: number;
+  }
+  var IGattRequestStateChangedEventArgs: abstract new (...args: any[]) => IGattRequestStateChangedEventArgs;
+
+  interface IGattServiceProvider {
+    StartAdvertising(): void;
+    StartAdvertising(parameters: Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisingParameters): void;
+    StopAdvertising(): void;
+    readonly AdvertisementStatus: number;
+    readonly Service: Windows.Devices.Bluetooth.GenericAttributeProfile.GattLocalService;
+    AdvertisementStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider, Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisementStatusChangedEventArgs> | null;
+  }
+  var IGattServiceProvider: abstract new (...args: any[]) => IGattServiceProvider;
+
+  interface IGattServiceProvider2 {
+    UpdateAdvertisingParameters(parameters: Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderAdvertisingParameters): void;
+  }
+  var IGattServiceProvider2: abstract new (...args: any[]) => IGattServiceProvider2;
+
+  interface IGattServiceProviderAdvertisementStatusChangedEventArgs {
+    readonly Error: number;
+    readonly Status: number;
+  }
+  var IGattServiceProviderAdvertisementStatusChangedEventArgs: abstract new (...args: any[]) => IGattServiceProviderAdvertisementStatusChangedEventArgs;
+
+  interface IGattServiceProviderAdvertisingParameters {
+    IsConnectable: boolean;
+    IsDiscoverable: boolean;
+  }
+  var IGattServiceProviderAdvertisingParameters: abstract new (...args: any[]) => IGattServiceProviderAdvertisingParameters;
+
+  interface IGattServiceProviderAdvertisingParameters2 {
+    ServiceData: Windows.Storage.Streams.IBuffer;
+  }
+  var IGattServiceProviderAdvertisingParameters2: abstract new (...args: any[]) => IGattServiceProviderAdvertisingParameters2;
+
+  interface IGattServiceProviderAdvertisingParameters3 {
+    UseLowEnergyUncoded1MPhyAsSecondaryPhy: boolean;
+    UseLowEnergyUncoded2MPhyAsSecondaryPhy: boolean;
+  }
+  var IGattServiceProviderAdvertisingParameters3: abstract new (...args: any[]) => IGattServiceProviderAdvertisingParameters3;
+
+  interface IGattServiceProviderResult {
+    readonly Error: number;
+    readonly ServiceProvider: Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProvider;
+  }
+  var IGattServiceProviderResult: abstract new (...args: any[]) => IGattServiceProviderResult;
+
+  interface IGattServiceProviderStatics {
+    CreateAsync(serviceUuid: Guid): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattServiceProviderResult>;
+  }
+  var IGattServiceProviderStatics: abstract new (...args: any[]) => IGattServiceProviderStatics;
+
+  interface IGattServiceUuidsStatics {
+    readonly Battery: Guid;
+    readonly BloodPressure: Guid;
+    readonly CyclingSpeedAndCadence: Guid;
+    readonly GenericAccess: Guid;
+    readonly GenericAttribute: Guid;
+    readonly Glucose: Guid;
+    readonly HealthThermometer: Guid;
+    readonly HeartRate: Guid;
+    readonly RunningSpeedAndCadence: Guid;
+  }
+  var IGattServiceUuidsStatics: abstract new (...args: any[]) => IGattServiceUuidsStatics;
+
+  interface IGattServiceUuidsStatics2 {
+    readonly AlertNotification: Guid;
+    readonly CurrentTime: Guid;
+    readonly CyclingPower: Guid;
+    readonly DeviceInformation: Guid;
+    readonly HumanInterfaceDevice: Guid;
+    readonly ImmediateAlert: Guid;
+    readonly LinkLoss: Guid;
+    readonly LocationAndNavigation: Guid;
+    readonly NextDstChange: Guid;
+    readonly PhoneAlertStatus: Guid;
+    readonly ReferenceTimeUpdate: Guid;
+    readonly ScanParameters: Guid;
+    readonly TxPower: Guid;
+  }
+  var IGattServiceUuidsStatics2: abstract new (...args: any[]) => IGattServiceUuidsStatics2;
+
+  interface IGattSession {
+    readonly CanMaintainConnection: boolean;
+    readonly DeviceId: Windows.Devices.Bluetooth.BluetoothDeviceId;
+    MaintainConnection: boolean;
+    readonly MaxPduSize: number;
+    readonly SessionStatus: number;
+    MaxPduSizeChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession, Object> | null;
+    SessionStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession, Windows.Devices.Bluetooth.GenericAttributeProfile.GattSessionStatusChangedEventArgs> | null;
+  }
+  var IGattSession: abstract new (...args: any[]) => IGattSession;
+
+  interface IGattSessionStatics {
+    FromDeviceIdAsync(deviceId: Windows.Devices.Bluetooth.BluetoothDeviceId): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession>;
+  }
+  var IGattSessionStatics: abstract new (...args: any[]) => IGattSessionStatics;
+
+  interface IGattSessionStatusChangedEventArgs {
+    readonly Error: number;
+    readonly Status: number;
+  }
+  var IGattSessionStatusChangedEventArgs: abstract new (...args: any[]) => IGattSessionStatusChangedEventArgs;
+
+  interface IGattSubscribedClient {
+    readonly MaxNotificationSize: number;
+    readonly Session: Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession;
+    MaxNotificationSizeChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattSubscribedClient, Object> | null;
+  }
+  var IGattSubscribedClient: abstract new (...args: any[]) => IGattSubscribedClient;
+
+  interface IGattValueChangedEventArgs {
+    readonly CharacteristicValue: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IGattValueChangedEventArgs: abstract new (...args: any[]) => IGattValueChangedEventArgs;
+
+  interface IGattWriteRequest {
+    Respond(): void;
+    RespondWithProtocolError(protocolError: number): void;
+    readonly Offset: number;
+    readonly Option: number;
+    readonly State: number;
+    readonly Value: Windows.Storage.Streams.IBuffer;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest, Windows.Devices.Bluetooth.GenericAttributeProfile.GattRequestStateChangedEventArgs> | null;
+  }
+  var IGattWriteRequest: abstract new (...args: any[]) => IGattWriteRequest;
+
+  interface IGattWriteRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    GetRequestAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.GenericAttributeProfile.GattWriteRequest>;
+    readonly Session: Windows.Devices.Bluetooth.GenericAttributeProfile.GattSession;
+  }
+  var IGattWriteRequestedEventArgs: abstract new (...args: any[]) => IGattWriteRequestedEventArgs;
+
+  interface IGattWriteResult {
+    readonly ProtocolError: number | null;
+    readonly Status: number;
+  }
+  var IGattWriteResult: abstract new (...args: any[]) => IGattWriteResult;
+
+}
+
+declare namespace Windows.Devices.Bluetooth.Rfcomm {
+  class RfcommDeviceService implements Windows.Devices.Bluetooth.Rfcomm.IRfcommDeviceService, Windows.Devices.Bluetooth.Rfcomm.IRfcommDeviceService2, Windows.Devices.Bluetooth.Rfcomm.IRfcommDeviceService3, Windows.Foundation.IClosable {
+    Close(): void;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceService>;
+    static GetDeviceSelector(serviceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId): string;
+    static GetDeviceSelectorForBluetoothDevice(bluetoothDevice: Windows.Devices.Bluetooth.BluetoothDevice): string;
+    static GetDeviceSelectorForBluetoothDevice(bluetoothDevice: Windows.Devices.Bluetooth.BluetoothDevice, cacheMode: number): string;
+    static GetDeviceSelectorForBluetoothDeviceAndServiceId(bluetoothDevice: Windows.Devices.Bluetooth.BluetoothDevice, serviceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId): string;
+    static GetDeviceSelectorForBluetoothDeviceAndServiceId(bluetoothDevice: Windows.Devices.Bluetooth.BluetoothDevice, serviceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId, cacheMode: number): string;
+    GetSdpRawAttributesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<number, Windows.Storage.Streams.IBuffer>>;
+    GetSdpRawAttributesAsync(cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<number, Windows.Storage.Streams.IBuffer>>;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly ConnectionHostName: Windows.Networking.HostName;
+    readonly ConnectionServiceName: string;
+    readonly Device: Windows.Devices.Bluetooth.BluetoothDevice;
+    readonly DeviceAccessInformation: Windows.Devices.Enumeration.DeviceAccessInformation;
+    readonly MaxProtectionLevel: number;
+    readonly ProtectionLevel: number;
+    readonly ServiceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+  }
+
+  class RfcommDeviceServicesResult implements Windows.Devices.Bluetooth.Rfcomm.IRfcommDeviceServicesResult {
+    readonly Error: number;
+    readonly Services: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceService> | Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceService[];
+  }
+
+  class RfcommServiceId implements Windows.Devices.Bluetooth.Rfcomm.IRfcommServiceId {
+    AsShortId(): number;
+    AsString(): string;
+    static FromShortId(shortId: number): Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+    static FromUuid(uuid: Guid): Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+    static readonly GenericFileTransfer: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+    static readonly ObexFileTransfer: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+    static readonly ObexObjectPush: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+    static readonly PhoneBookAccessPce: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+    static readonly PhoneBookAccessPse: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+    static readonly SerialPort: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+    readonly Uuid: Guid;
+  }
+
+  class RfcommServiceProvider implements Windows.Devices.Bluetooth.Rfcomm.IRfcommServiceProvider, Windows.Devices.Bluetooth.Rfcomm.IRfcommServiceProvider2 {
+    static CreateAsync(serviceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.Rfcomm.RfcommServiceProvider>;
+    StartAdvertising(listener: Windows.Networking.Sockets.StreamSocketListener): void;
+    StartAdvertising(listener: Windows.Networking.Sockets.StreamSocketListener, radioDiscoverable: boolean): void;
+    StopAdvertising(): void;
+    readonly SdpRawAttributes: Windows.Foundation.Collections.IMap<number, Windows.Storage.Streams.IBuffer>;
+    readonly ServiceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+  }
+
+  interface IRfcommDeviceService {
+    GetSdpRawAttributesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<number, Windows.Storage.Streams.IBuffer>>;
+    GetSdpRawAttributesAsync(cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<number, Windows.Storage.Streams.IBuffer>>;
+    readonly ConnectionHostName: Windows.Networking.HostName;
+    readonly ConnectionServiceName: string;
+    readonly MaxProtectionLevel: number;
+    readonly ProtectionLevel: number;
+    readonly ServiceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+  }
+  var IRfcommDeviceService: abstract new (...args: any[]) => IRfcommDeviceService;
+
+  interface IRfcommDeviceService2 extends Windows.Devices.Bluetooth.Rfcomm.IRfcommDeviceService {
+    GetSdpRawAttributesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<number, Windows.Storage.Streams.IBuffer>>;
+    GetSdpRawAttributesAsync(cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<number, Windows.Storage.Streams.IBuffer>>;
+    readonly Device: Windows.Devices.Bluetooth.BluetoothDevice;
+  }
+  var IRfcommDeviceService2: abstract new (...args: any[]) => IRfcommDeviceService2;
+
+  interface IRfcommDeviceService3 extends Windows.Devices.Bluetooth.Rfcomm.IRfcommDeviceService, Windows.Devices.Bluetooth.Rfcomm.IRfcommDeviceService2 {
+    GetSdpRawAttributesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<number, Windows.Storage.Streams.IBuffer>>;
+    GetSdpRawAttributesAsync(cacheMode: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<number, Windows.Storage.Streams.IBuffer>>;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly DeviceAccessInformation: Windows.Devices.Enumeration.DeviceAccessInformation;
+  }
+  var IRfcommDeviceService3: abstract new (...args: any[]) => IRfcommDeviceService3;
+
+  interface IRfcommDeviceServiceStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceService>;
+    GetDeviceSelector(serviceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId): string;
+  }
+  var IRfcommDeviceServiceStatics: abstract new (...args: any[]) => IRfcommDeviceServiceStatics;
+
+  interface IRfcommDeviceServiceStatics2 extends Windows.Devices.Bluetooth.Rfcomm.IRfcommDeviceServiceStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceService>;
+    GetDeviceSelector(serviceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId): string;
+    GetDeviceSelectorForBluetoothDevice(bluetoothDevice: Windows.Devices.Bluetooth.BluetoothDevice): string;
+    GetDeviceSelectorForBluetoothDevice(bluetoothDevice: Windows.Devices.Bluetooth.BluetoothDevice, cacheMode: number): string;
+    GetDeviceSelectorForBluetoothDeviceAndServiceId(bluetoothDevice: Windows.Devices.Bluetooth.BluetoothDevice, serviceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId): string;
+    GetDeviceSelectorForBluetoothDeviceAndServiceId(bluetoothDevice: Windows.Devices.Bluetooth.BluetoothDevice, serviceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId, cacheMode: number): string;
+  }
+  var IRfcommDeviceServiceStatics2: abstract new (...args: any[]) => IRfcommDeviceServiceStatics2;
+
+  interface IRfcommDeviceServicesResult {
+    readonly Error: number;
+    readonly Services: Windows.Foundation.Collections.IVectorView<Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceService> | Windows.Devices.Bluetooth.Rfcomm.RfcommDeviceService[];
+  }
+  var IRfcommDeviceServicesResult: abstract new (...args: any[]) => IRfcommDeviceServicesResult;
+
+  interface IRfcommServiceId {
+    AsShortId(): number;
+    AsString(): string;
+    readonly Uuid: Guid;
+  }
+  var IRfcommServiceId: abstract new (...args: any[]) => IRfcommServiceId;
+
+  interface IRfcommServiceIdStatics {
+    FromShortId(shortId: number): Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+    FromUuid(uuid: Guid): Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+    readonly GenericFileTransfer: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+    readonly ObexFileTransfer: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+    readonly ObexObjectPush: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+    readonly PhoneBookAccessPce: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+    readonly PhoneBookAccessPse: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+    readonly SerialPort: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+  }
+  var IRfcommServiceIdStatics: abstract new (...args: any[]) => IRfcommServiceIdStatics;
+
+  interface IRfcommServiceProvider {
+    StartAdvertising(listener: Windows.Networking.Sockets.StreamSocketListener): void;
+    StopAdvertising(): void;
+    readonly SdpRawAttributes: Windows.Foundation.Collections.IMap<number, Windows.Storage.Streams.IBuffer>;
+    readonly ServiceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId;
+  }
+  var IRfcommServiceProvider: abstract new (...args: any[]) => IRfcommServiceProvider;
+
+  interface IRfcommServiceProvider2 extends Windows.Devices.Bluetooth.Rfcomm.IRfcommServiceProvider {
+    StartAdvertising(listener: Windows.Networking.Sockets.StreamSocketListener, radioDiscoverable: boolean): void;
+    StartAdvertising(listener: Windows.Networking.Sockets.StreamSocketListener): void;
+    StopAdvertising(): void;
+  }
+  var IRfcommServiceProvider2: abstract new (...args: any[]) => IRfcommServiceProvider2;
+
+  interface IRfcommServiceProviderStatics {
+    CreateAsync(serviceId: Windows.Devices.Bluetooth.Rfcomm.RfcommServiceId): Windows.Foundation.IAsyncOperation<Windows.Devices.Bluetooth.Rfcomm.RfcommServiceProvider>;
+  }
+  var IRfcommServiceProviderStatics: abstract new (...args: any[]) => IRfcommServiceProviderStatics;
+
+}
+
+declare namespace Windows.Devices.Custom {
+  class CustomDevice implements Windows.Devices.Custom.ICustomDevice {
+    static FromIdAsync(deviceId: string, desiredAccess: number, sharingMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Custom.CustomDevice>;
+    static GetDeviceSelector(classGuid: Guid): string;
+    SendIOControlAsync(ioControlCode: Windows.Devices.Custom.IIOControlCode, inputBuffer: Windows.Storage.Streams.IBuffer, outputBuffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<number>;
+    TrySendIOControlAsync(ioControlCode: Windows.Devices.Custom.IIOControlCode, inputBuffer: Windows.Storage.Streams.IBuffer, outputBuffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly InputStream: Windows.Storage.Streams.IInputStream;
+    readonly OutputStream: Windows.Storage.Streams.IOutputStream;
+  }
+
+  class IOControlCode implements Windows.Devices.Custom.IIOControlCode {
+    constructor(deviceType: number, function_: number, accessMode: number, bufferingMethod: number);
+    readonly AccessMode: number;
+    readonly BufferingMethod: number;
+    readonly ControlCode: number;
+    readonly DeviceType: number;
+    readonly Function: number;
+  }
+
+  class KnownDeviceTypes {
+    static readonly Unknown: number;
+  }
+
+  enum DeviceAccessMode {
+    Read = 0,
+    Write = 1,
+    ReadWrite = 2,
+  }
+
+  enum DeviceSharingMode {
+    Shared = 0,
+    Exclusive = 1,
+  }
+
+  enum IOControlAccessMode {
+    Any = 0,
+    Read = 1,
+    Write = 2,
+    ReadWrite = 3,
+  }
+
+  enum IOControlBufferingMethod {
+    Buffered = 0,
+    DirectInput = 1,
+    DirectOutput = 2,
+    Neither = 3,
+  }
+
+  interface CustomDeviceContract {
+  }
+  var CustomDeviceContract: {
+    new(fields: {  }): CustomDeviceContract;
+  };
+
+  interface ICustomDevice {
+    SendIOControlAsync(ioControlCode: Windows.Devices.Custom.IIOControlCode, inputBuffer: Windows.Storage.Streams.IBuffer, outputBuffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<number>;
+    TrySendIOControlAsync(ioControlCode: Windows.Devices.Custom.IIOControlCode, inputBuffer: Windows.Storage.Streams.IBuffer, outputBuffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly InputStream: Windows.Storage.Streams.IInputStream;
+    readonly OutputStream: Windows.Storage.Streams.IOutputStream;
+  }
+  var ICustomDevice: abstract new (...args: any[]) => ICustomDevice;
+
+  interface ICustomDeviceStatics {
+    FromIdAsync(deviceId: string, desiredAccess: number, sharingMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Custom.CustomDevice>;
+    GetDeviceSelector(classGuid: Guid): string;
+  }
+  var ICustomDeviceStatics: abstract new (...args: any[]) => ICustomDeviceStatics;
+
+  interface IIOControlCode {
+    readonly AccessMode: number;
+    readonly BufferingMethod: number;
+    readonly ControlCode: number;
+    readonly DeviceType: number;
+    readonly Function: number;
+  }
+  var IIOControlCode: abstract new (...args: any[]) => IIOControlCode;
+
+  interface IIOControlCodeFactory {
+    CreateIOControlCode(deviceType: number, function_: number, accessMode: number, bufferingMethod: number): Windows.Devices.Custom.IOControlCode;
+  }
+  var IIOControlCodeFactory: abstract new (...args: any[]) => IIOControlCodeFactory;
+
+  interface IKnownDeviceTypesStatics {
+    readonly Unknown: number;
+  }
+  var IKnownDeviceTypesStatics: abstract new (...args: any[]) => IKnownDeviceTypesStatics;
+
+}
+
+declare namespace Windows.Devices.Display {
+  class DisplayMonitor implements Windows.Devices.Display.IDisplayMonitor, Windows.Devices.Display.IDisplayMonitor2 {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Display.DisplayMonitor>;
+    static FromInterfaceIdAsync(deviceInterfaceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Display.DisplayMonitor>;
+    GetDescriptor(descriptorKind: number): number[];
+    static GetDeviceSelector(): string;
+    readonly BluePrimary: Windows.Foundation.Point;
+    readonly ConnectionKind: number;
+    readonly DeviceId: string;
+    readonly DisplayAdapterDeviceId: string;
+    readonly DisplayAdapterId: Windows.Graphics.DisplayAdapterId;
+    readonly DisplayAdapterTargetId: number;
+    readonly DisplayName: string;
+    readonly GreenPrimary: Windows.Foundation.Point;
+    readonly IsDolbyVisionSupportedInHdrMode: boolean;
+    readonly MaxAverageFullFrameLuminanceInNits: number;
+    readonly MaxLuminanceInNits: number;
+    readonly MinLuminanceInNits: number;
+    readonly NativeResolutionInRawPixels: Windows.Graphics.SizeInt32;
+    readonly PhysicalConnector: number;
+    readonly PhysicalSizeInInches: Windows.Foundation.Size | null;
+    readonly RawDpiX: number;
+    readonly RawDpiY: number;
+    readonly RedPrimary: Windows.Foundation.Point;
+    readonly UsageKind: number;
+    readonly WhitePoint: Windows.Foundation.Point;
+  }
+
+  enum DisplayMonitorConnectionKind {
+    Internal = 0,
+    Wired = 1,
+    Wireless = 2,
+    Virtual = 3,
+  }
+
+  enum DisplayMonitorDescriptorKind {
+    Edid = 0,
+    DisplayId = 1,
+  }
+
+  enum DisplayMonitorPhysicalConnectorKind {
+    Unknown = 0,
+    HD15 = 1,
+    AnalogTV = 2,
+    Dvi = 3,
+    Hdmi = 4,
+    Lvds = 5,
+    Sdi = 6,
+    DisplayPort = 7,
+  }
+
+  enum DisplayMonitorUsageKind {
+    Standard = 0,
+    HeadMounted = 1,
+    SpecialPurpose = 2,
+  }
+
+  interface IDisplayMonitor {
+    GetDescriptor(descriptorKind: number): number[];
+    readonly BluePrimary: Windows.Foundation.Point;
+    readonly ConnectionKind: number;
+    readonly DeviceId: string;
+    readonly DisplayAdapterDeviceId: string;
+    readonly DisplayAdapterId: Windows.Graphics.DisplayAdapterId;
+    readonly DisplayAdapterTargetId: number;
+    readonly DisplayName: string;
+    readonly GreenPrimary: Windows.Foundation.Point;
+    readonly MaxAverageFullFrameLuminanceInNits: number;
+    readonly MaxLuminanceInNits: number;
+    readonly MinLuminanceInNits: number;
+    readonly NativeResolutionInRawPixels: Windows.Graphics.SizeInt32;
+    readonly PhysicalConnector: number;
+    readonly PhysicalSizeInInches: Windows.Foundation.Size | null;
+    readonly RawDpiX: number;
+    readonly RawDpiY: number;
+    readonly RedPrimary: Windows.Foundation.Point;
+    readonly UsageKind: number;
+    readonly WhitePoint: Windows.Foundation.Point;
+  }
+  var IDisplayMonitor: abstract new (...args: any[]) => IDisplayMonitor;
+
+  interface IDisplayMonitor2 {
+    readonly IsDolbyVisionSupportedInHdrMode: boolean;
+  }
+  var IDisplayMonitor2: abstract new (...args: any[]) => IDisplayMonitor2;
+
+  interface IDisplayMonitorStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Display.DisplayMonitor>;
+    FromInterfaceIdAsync(deviceInterfaceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Display.DisplayMonitor>;
+    GetDeviceSelector(): string;
+  }
+  var IDisplayMonitorStatics: abstract new (...args: any[]) => IDisplayMonitorStatics;
+
+}
+
+declare namespace Windows.Devices.Display.Core {
+  class DisplayAdapter implements Windows.Devices.Display.Core.IDisplayAdapter, Windows.Devices.Display.Core.IDisplayAdapter2 {
+    static FromId(id: Windows.Graphics.DisplayAdapterId): Windows.Devices.Display.Core.DisplayAdapter;
+    readonly DeviceInterfacePath: string;
+    readonly Id: Windows.Graphics.DisplayAdapterId;
+    readonly IsIndirectDisplayDevice: boolean;
+    readonly PciDeviceId: number;
+    readonly PciRevision: number;
+    readonly PciSubSystemId: number;
+    readonly PciVendorId: number;
+    readonly PreferredRenderAdapter: Windows.Devices.Display.Core.DisplayAdapter;
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+    readonly SourceCount: number;
+  }
+
+  class DisplayDevice implements Windows.Devices.Display.Core.IDisplayDevice, Windows.Devices.Display.Core.IDisplayDevice2, Windows.Devices.Display.Core.IDisplayDeviceRenderAdapter {
+    CreatePeriodicFence(target: Windows.Devices.Display.Core.DisplayTarget, offsetFromVBlank: Windows.Foundation.TimeSpan): Windows.Devices.Display.Core.DisplayFence;
+    CreatePrimary(target: Windows.Devices.Display.Core.DisplayTarget, desc: Windows.Devices.Display.Core.DisplayPrimaryDescription): Windows.Devices.Display.Core.DisplaySurface;
+    CreateScanoutSource(target: Windows.Devices.Display.Core.DisplayTarget): Windows.Devices.Display.Core.DisplaySource;
+    CreateSimpleScanout(pSource: Windows.Devices.Display.Core.DisplaySource, pSurface: Windows.Devices.Display.Core.DisplaySurface, SubResourceIndex: number, SyncInterval: number): Windows.Devices.Display.Core.DisplayScanout;
+    CreateSimpleScanoutWithDirtyRectsAndOptions(source: Windows.Devices.Display.Core.DisplaySource, surface: Windows.Devices.Display.Core.DisplaySurface, subresourceIndex: number, syncInterval: number, dirtyRects: Windows.Foundation.Collections.IIterable<Windows.Graphics.RectInt32> | Windows.Graphics.RectInt32[], options: number): Windows.Devices.Display.Core.DisplayScanout;
+    CreateTaskPool(): Windows.Devices.Display.Core.DisplayTaskPool;
+    IsCapabilitySupported(capability: number): boolean;
+    WaitForVBlank(source: Windows.Devices.Display.Core.DisplaySource): void;
+    readonly RenderAdapterId: Windows.Graphics.DisplayAdapterId;
+  }
+
+  class DisplayFence implements Windows.Devices.Display.Core.IDisplayFence {
+  }
+
+  class DisplayManager implements Windows.Devices.Display.Core.IDisplayManager, Windows.Devices.Display.Core.IDisplayManager2, Windows.Devices.Display.Core.IDisplayManager3, Windows.Foundation.IClosable {
+    Close(): void;
+    static Create(options: number): Windows.Devices.Display.Core.DisplayManager;
+    CreateDisplayDevice(adapter: Windows.Devices.Display.Core.DisplayAdapter): Windows.Devices.Display.Core.DisplayDevice;
+    CreateDisplayDeviceForIndirectAdapter(indirectAdapter: Windows.Devices.Display.Core.DisplayAdapter, renderAdapter: Windows.Devices.Display.Core.DisplayAdapter): Windows.Devices.Display.Core.DisplayDevice;
+    GetCurrentAdapters(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Display.Core.DisplayAdapter> | Windows.Devices.Display.Core.DisplayAdapter[];
+    GetCurrentTargets(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Display.Core.DisplayTarget> | Windows.Devices.Display.Core.DisplayTarget[];
+    ReleaseTarget(target: Windows.Devices.Display.Core.DisplayTarget): void;
+    Start(): void;
+    Stop(): void;
+    TryAcquireTarget(target: Windows.Devices.Display.Core.DisplayTarget): number;
+    TryAcquireTargetsAndCreateEmptyState(targets: Windows.Foundation.Collections.IIterable<Windows.Devices.Display.Core.DisplayTarget> | Windows.Devices.Display.Core.DisplayTarget[]): Windows.Devices.Display.Core.DisplayManagerResultWithState;
+    TryAcquireTargetsAndCreateSubstate(existingState: Windows.Devices.Display.Core.DisplayState, targets: Windows.Foundation.Collections.IIterable<Windows.Devices.Display.Core.DisplayTarget> | Windows.Devices.Display.Core.DisplayTarget[]): Windows.Devices.Display.Core.DisplayManagerResultWithState;
+    TryAcquireTargetsAndReadCurrentState(targets: Windows.Foundation.Collections.IIterable<Windows.Devices.Display.Core.DisplayTarget> | Windows.Devices.Display.Core.DisplayTarget[]): Windows.Devices.Display.Core.DisplayManagerResultWithState;
+    TryReadCurrentStateForAllTargets(): Windows.Devices.Display.Core.DisplayManagerResultWithState;
+    TryReadCurrentStateForModeQuery(): Windows.Devices.Display.Core.DisplayManagerResultWithState;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.Devices.Display.Core.DisplayManager, Windows.Devices.Display.Core.DisplayManagerChangedEventArgs> | null;
+    Disabled: Windows.Foundation.TypedEventHandler<Windows.Devices.Display.Core.DisplayManager, Windows.Devices.Display.Core.DisplayManagerDisabledEventArgs> | null;
+    Enabled: Windows.Foundation.TypedEventHandler<Windows.Devices.Display.Core.DisplayManager, Windows.Devices.Display.Core.DisplayManagerEnabledEventArgs> | null;
+    PathsFailedOrInvalidated: Windows.Foundation.TypedEventHandler<Windows.Devices.Display.Core.DisplayManager, Windows.Devices.Display.Core.DisplayManagerPathsFailedOrInvalidatedEventArgs> | null;
+  }
+
+  class DisplayManagerChangedEventArgs implements Windows.Devices.Display.Core.IDisplayManagerChangedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+
+  class DisplayManagerDisabledEventArgs implements Windows.Devices.Display.Core.IDisplayManagerDisabledEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+
+  class DisplayManagerEnabledEventArgs implements Windows.Devices.Display.Core.IDisplayManagerEnabledEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+
+  class DisplayManagerPathsFailedOrInvalidatedEventArgs implements Windows.Devices.Display.Core.IDisplayManagerPathsFailedOrInvalidatedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+
+  class DisplayManagerResultWithState implements Windows.Devices.Display.Core.IDisplayManagerResultWithState {
+    readonly ErrorCode: number;
+    readonly ExtendedErrorCode: Windows.Foundation.HResult;
+    readonly State: Windows.Devices.Display.Core.DisplayState;
+  }
+
+  class DisplayModeInfo implements Windows.Devices.Display.Core.IDisplayModeInfo, Windows.Devices.Display.Core.IDisplayModeInfo2 {
+    GetWireFormatSupportedBitsPerChannel(encoding: number): number;
+    IsWireFormatSupported(wireFormat: Windows.Devices.Display.Core.DisplayWireFormat): boolean;
+    readonly IsInterlaced: boolean;
+    readonly IsStereo: boolean;
+    readonly PhysicalPresentationRate: Windows.Devices.Display.Core.DisplayPresentationRate;
+    readonly PresentationRate: Windows.Devices.Display.Core.DisplayPresentationRate;
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+    readonly SourcePixelFormat: number;
+    readonly SourceResolution: Windows.Graphics.SizeInt32;
+    readonly TargetResolution: Windows.Graphics.SizeInt32;
+  }
+
+  class DisplayMuxDevice implements Windows.Devices.Display.Core.IDisplayMuxDevice, Windows.Foundation.IClosable {
+    Close(): void;
+    static FromIdAsync(deviceInterfaceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Display.Core.DisplayMuxDevice>;
+    GetAvailableMuxTargets(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Display.Core.DisplayTarget> | Windows.Devices.Display.Core.DisplayTarget[];
+    static GetDeviceSelector(): string;
+    SetAutomaticTargetSwitching(): Windows.Foundation.IAsyncAction;
+    SetPreferredTarget(target: Windows.Devices.Display.Core.DisplayTarget): Windows.Foundation.IAsyncAction;
+    readonly CurrentTarget: Windows.Devices.Display.Core.DisplayTarget;
+    readonly Id: string;
+    readonly IsActive: boolean;
+    readonly IsAutomaticTargetSwitchingEnabled: boolean;
+    readonly PreferredTarget: Windows.Devices.Display.Core.DisplayTarget;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.Devices.Display.Core.DisplayMuxDevice, Object> | null;
+  }
+
+  class DisplayPath implements Windows.Devices.Display.Core.IDisplayPath, Windows.Devices.Display.Core.IDisplayPath2 {
+    ApplyPropertiesFromMode(modeResult: Windows.Devices.Display.Core.DisplayModeInfo): void;
+    FindModes(flags: number): Windows.Foundation.Collections.IVectorView<Windows.Devices.Display.Core.DisplayModeInfo> | Windows.Devices.Display.Core.DisplayModeInfo[];
+    IsInterlaced: boolean | null;
+    IsStereo: boolean;
+    PhysicalPresentationRate: Windows.Devices.Display.Core.DisplayPresentationRate | null;
+    PresentationRate: Windows.Devices.Display.Core.DisplayPresentationRate | null;
+    readonly Properties: Windows.Foundation.Collections.IMap<Guid, Object>;
+    Rotation: number;
+    Scaling: number;
+    SourcePixelFormat: number;
+    SourceResolution: Windows.Graphics.SizeInt32 | null;
+    readonly Status: number;
+    readonly Target: Windows.Devices.Display.Core.DisplayTarget;
+    TargetResolution: Windows.Graphics.SizeInt32 | null;
+    readonly View: Windows.Devices.Display.Core.DisplayView;
+    WireFormat: Windows.Devices.Display.Core.DisplayWireFormat;
+  }
+
+  class DisplayPrimaryDescription implements Windows.Devices.Display.Core.IDisplayPrimaryDescription {
+    constructor(width: number, height: number, pixelFormat: number, colorSpace: number, isStereo: boolean, multisampleDescription: Windows.Graphics.DirectX.Direct3D11.Direct3DMultisampleDescription);
+    static CreateWithProperties(extraProperties: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<Guid, Object>> | Windows.Foundation.Collections.IKeyValuePair<Guid, Object>[], width: number, height: number, pixelFormat: number, colorSpace: number, isStereo: boolean, multisampleDescription: Windows.Graphics.DirectX.Direct3D11.Direct3DMultisampleDescription): Windows.Devices.Display.Core.DisplayPrimaryDescription;
+    readonly ColorSpace: number;
+    readonly Format: number;
+    readonly Height: number;
+    readonly IsStereo: boolean;
+    readonly MultisampleDescription: Windows.Graphics.DirectX.Direct3D11.Direct3DMultisampleDescription;
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+    readonly Width: number;
+  }
+
+  class DisplayScanout implements Windows.Devices.Display.Core.IDisplayScanout {
+  }
+
+  class DisplaySource implements Windows.Devices.Display.Core.IDisplaySource, Windows.Devices.Display.Core.IDisplaySource2 {
+    GetMetadata(Key: Guid): Windows.Storage.Streams.IBuffer;
+    readonly AdapterId: Windows.Graphics.DisplayAdapterId;
+    readonly SourceId: number;
+    readonly Status: number;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Display.Core.DisplaySource, Object> | null;
+  }
+
+  class DisplayState implements Windows.Devices.Display.Core.IDisplayState {
+    CanConnectTargetToView(target: Windows.Devices.Display.Core.DisplayTarget, view: Windows.Devices.Display.Core.DisplayView): boolean;
+    Clone(): Windows.Devices.Display.Core.DisplayState;
+    ConnectTarget(target: Windows.Devices.Display.Core.DisplayTarget): Windows.Devices.Display.Core.DisplayPath;
+    ConnectTarget(target: Windows.Devices.Display.Core.DisplayTarget, view: Windows.Devices.Display.Core.DisplayView): Windows.Devices.Display.Core.DisplayPath;
+    DisconnectTarget(target: Windows.Devices.Display.Core.DisplayTarget): void;
+    GetPathForTarget(target: Windows.Devices.Display.Core.DisplayTarget): Windows.Devices.Display.Core.DisplayPath;
+    GetViewForTarget(target: Windows.Devices.Display.Core.DisplayTarget): Windows.Devices.Display.Core.DisplayView;
+    TryApply(options: number): Windows.Devices.Display.Core.DisplayStateOperationResult;
+    TryFunctionalize(options: number): Windows.Devices.Display.Core.DisplayStateOperationResult;
+    readonly IsReadOnly: boolean;
+    readonly IsStale: boolean;
+    readonly Properties: Windows.Foundation.Collections.IMap<Guid, Object>;
+    readonly Targets: Windows.Foundation.Collections.IVectorView<Windows.Devices.Display.Core.DisplayTarget> | Windows.Devices.Display.Core.DisplayTarget[];
+    readonly Views: Windows.Foundation.Collections.IVectorView<Windows.Devices.Display.Core.DisplayView> | Windows.Devices.Display.Core.DisplayView[];
+  }
+
+  class DisplayStateOperationResult implements Windows.Devices.Display.Core.IDisplayStateOperationResult {
+    readonly ExtendedErrorCode: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+
+  class DisplaySurface implements Windows.Devices.Display.Core.IDisplaySurface {
+  }
+
+  class DisplayTarget implements Windows.Devices.Display.Core.IDisplayTarget {
+    IsEqual(otherTarget: Windows.Devices.Display.Core.DisplayTarget): boolean;
+    IsSame(otherTarget: Windows.Devices.Display.Core.DisplayTarget): boolean;
+    TryGetMonitor(): Windows.Devices.Display.DisplayMonitor;
+    readonly Adapter: Windows.Devices.Display.Core.DisplayAdapter;
+    readonly AdapterRelativeId: number;
+    readonly DeviceInterfacePath: string;
+    readonly IsConnected: boolean;
+    readonly IsStale: boolean;
+    readonly IsVirtualModeEnabled: boolean;
+    readonly IsVirtualTopologyEnabled: boolean;
+    readonly MonitorPersistence: number;
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+    readonly StableMonitorId: string;
+    readonly UsageKind: number;
+  }
+
+  class DisplayTask implements Windows.Devices.Display.Core.IDisplayTask, Windows.Devices.Display.Core.IDisplayTask2 {
+    SetScanout(scanout: Windows.Devices.Display.Core.DisplayScanout): void;
+    SetSignal(signalKind: number, fence: Windows.Devices.Display.Core.DisplayFence): void;
+    SetWait(readyFence: Windows.Devices.Display.Core.DisplayFence, readyFenceValue: number | bigint): void;
+  }
+
+  class DisplayTaskPool implements Windows.Devices.Display.Core.IDisplayTaskPool, Windows.Devices.Display.Core.IDisplayTaskPool2 {
+    CreateTask(): Windows.Devices.Display.Core.DisplayTask;
+    ExecuteTask(task: Windows.Devices.Display.Core.DisplayTask): void;
+    TryExecuteTask(task: Windows.Devices.Display.Core.DisplayTask): Windows.Devices.Display.Core.DisplayTaskResult;
+  }
+
+  class DisplayTaskResult implements Windows.Devices.Display.Core.IDisplayTaskResult {
+    readonly PresentId: number | bigint;
+    readonly PresentStatus: number;
+    readonly SourceStatus: number;
+  }
+
+  class DisplayView implements Windows.Devices.Display.Core.IDisplayView {
+    SetPrimaryPath(path: Windows.Devices.Display.Core.DisplayPath): void;
+    ContentResolution: Windows.Graphics.SizeInt32 | null;
+    readonly Paths: Windows.Foundation.Collections.IVectorView<Windows.Devices.Display.Core.DisplayPath> | Windows.Devices.Display.Core.DisplayPath[];
+    readonly Properties: Windows.Foundation.Collections.IMap<Guid, Object>;
+  }
+
+  class DisplayWireFormat implements Windows.Devices.Display.Core.IDisplayWireFormat {
+    constructor(pixelEncoding: number, bitsPerChannel: number, colorSpace: number, eotf: number, hdrMetadata: number);
+    static CreateWithProperties(extraProperties: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<Guid, Object>> | Windows.Foundation.Collections.IKeyValuePair<Guid, Object>[], pixelEncoding: number, bitsPerChannel: number, colorSpace: number, eotf: number, hdrMetadata: number): Windows.Devices.Display.Core.DisplayWireFormat;
+    readonly BitsPerChannel: number;
+    readonly ColorSpace: number;
+    readonly Eotf: number;
+    readonly HdrMetadata: number;
+    readonly PixelEncoding: number;
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+  }
+
+  enum DisplayBitsPerChannel {
+    None = 0,
+    Bpc6 = 1,
+    Bpc8 = 2,
+    Bpc10 = 4,
+    Bpc12 = 8,
+    Bpc14 = 16,
+    Bpc16 = 32,
+  }
+
+  enum DisplayDeviceCapability {
+    FlipOverride = 0,
+  }
+
+  enum DisplayManagerOptions {
+    None = 0,
+    EnforceSourceOwnership = 1,
+    VirtualRefreshRateAware = 2,
+  }
+
+  enum DisplayManagerResult {
+    Success = 0,
+    UnknownFailure = 1,
+    TargetAccessDenied = 2,
+    TargetStale = 3,
+    RemoteSessionNotSupported = 4,
+  }
+
+  enum DisplayModeQueryOptions {
+    None = 0,
+    OnlyPreferredResolution = 1,
+  }
+
+  enum DisplayPathScaling {
+    Identity = 0,
+    Centered = 1,
+    Stretched = 2,
+    AspectRatioStretched = 3,
+    Custom = 4,
+    DriverPreferred = 5,
+  }
+
+  enum DisplayPathStatus {
+    Unknown = 0,
+    Succeeded = 1,
+    Pending = 2,
+    Failed = 3,
+    FailedAsync = 4,
+    InvalidatedAsync = 5,
+  }
+
+  enum DisplayPresentStatus {
+    Success = 0,
+    SourceStatusPreventedPresent = 1,
+    ScanoutInvalid = 2,
+    SourceInvalid = 3,
+    DeviceInvalid = 4,
+    UnknownFailure = 5,
+  }
+
+  enum DisplayRotation {
+    None = 0,
+    Clockwise90Degrees = 1,
+    Clockwise180Degrees = 2,
+    Clockwise270Degrees = 3,
+  }
+
+  enum DisplayScanoutOptions {
+    None = 0,
+    AllowTearing = 2,
+  }
+
+  enum DisplaySourceStatus {
+    Active = 0,
+    PoweredOff = 1,
+    Invalid = 2,
+    OwnedByAnotherDevice = 3,
+    Unowned = 4,
+  }
+
+  enum DisplayStateApplyOptions {
+    None = 0,
+    FailIfStateChanged = 1,
+    ForceReapply = 2,
+    ForceModeEnumeration = 4,
+  }
+
+  enum DisplayStateFunctionalizeOptions {
+    None = 0,
+    FailIfStateChanged = 1,
+    ValidateTopologyOnly = 2,
+  }
+
+  enum DisplayStateOperationStatus {
+    Success = 0,
+    PartialFailure = 1,
+    UnknownFailure = 2,
+    TargetOwnershipLost = 3,
+    SystemStateChanged = 4,
+    TooManyPathsForAdapter = 5,
+    ModesNotSupported = 6,
+    RemoteSessionNotSupported = 7,
+  }
+
+  enum DisplayTargetPersistence {
+    None = 0,
+    BootPersisted = 1,
+    TemporaryPersisted = 2,
+    PathPersisted = 3,
+  }
+
+  enum DisplayTaskSignalKind {
+    OnPresentFlipAway = 0,
+    OnPresentFlipTo = 1,
+  }
+
+  enum DisplayWireFormatColorSpace {
+    BT709 = 0,
+    BT2020 = 1,
+    ProfileDefinedWideColorGamut = 2,
+  }
+
+  enum DisplayWireFormatEotf {
+    Sdr = 0,
+    HdrSmpte2084 = 1,
+  }
+
+  enum DisplayWireFormatHdrMetadata {
+    None = 0,
+    Hdr10 = 1,
+    Hdr10Plus = 2,
+    DolbyVisionLowLatency = 3,
+  }
+
+  enum DisplayWireFormatPixelEncoding {
+    Rgb444 = 0,
+    Ycc444 = 1,
+    Ycc422 = 2,
+    Ycc420 = 3,
+    Intensity = 4,
+  }
+
+  interface DisplayPresentationRate {
+    VerticalSyncRate: Windows.Foundation.Numerics.Rational;
+    VerticalSyncsPerPresentation: number;
+  }
+  var DisplayPresentationRate: {
+    new(verticalSyncRate: Windows.Foundation.Numerics.Rational, verticalSyncsPerPresentation: number): DisplayPresentationRate;
+    new(fields: { VerticalSyncRate?: Windows.Foundation.Numerics.Rational; VerticalSyncsPerPresentation?: number }): DisplayPresentationRate;
+  };
+
+  interface IDisplayAdapter {
+    readonly DeviceInterfacePath: string;
+    readonly Id: Windows.Graphics.DisplayAdapterId;
+    readonly PciDeviceId: number;
+    readonly PciRevision: number;
+    readonly PciSubSystemId: number;
+    readonly PciVendorId: number;
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+    readonly SourceCount: number;
+  }
+  var IDisplayAdapter: abstract new (...args: any[]) => IDisplayAdapter;
+
+  interface IDisplayAdapter2 {
+    readonly IsIndirectDisplayDevice: boolean;
+    readonly PreferredRenderAdapter: Windows.Devices.Display.Core.DisplayAdapter;
+  }
+  var IDisplayAdapter2: abstract new (...args: any[]) => IDisplayAdapter2;
+
+  interface IDisplayAdapterStatics {
+    FromId(id: Windows.Graphics.DisplayAdapterId): Windows.Devices.Display.Core.DisplayAdapter;
+  }
+  var IDisplayAdapterStatics: abstract new (...args: any[]) => IDisplayAdapterStatics;
+
+  interface IDisplayDevice {
+    CreatePeriodicFence(target: Windows.Devices.Display.Core.DisplayTarget, offsetFromVBlank: Windows.Foundation.TimeSpan): Windows.Devices.Display.Core.DisplayFence;
+    CreatePrimary(target: Windows.Devices.Display.Core.DisplayTarget, desc: Windows.Devices.Display.Core.DisplayPrimaryDescription): Windows.Devices.Display.Core.DisplaySurface;
+    CreateScanoutSource(target: Windows.Devices.Display.Core.DisplayTarget): Windows.Devices.Display.Core.DisplaySource;
+    CreateSimpleScanout(pSource: Windows.Devices.Display.Core.DisplaySource, pSurface: Windows.Devices.Display.Core.DisplaySurface, SubResourceIndex: number, SyncInterval: number): Windows.Devices.Display.Core.DisplayScanout;
+    CreateTaskPool(): Windows.Devices.Display.Core.DisplayTaskPool;
+    IsCapabilitySupported(capability: number): boolean;
+    WaitForVBlank(source: Windows.Devices.Display.Core.DisplaySource): void;
+  }
+  var IDisplayDevice: abstract new (...args: any[]) => IDisplayDevice;
+
+  interface IDisplayDevice2 {
+    CreateSimpleScanoutWithDirtyRectsAndOptions(source: Windows.Devices.Display.Core.DisplaySource, surface: Windows.Devices.Display.Core.DisplaySurface, subresourceIndex: number, syncInterval: number, dirtyRects: Windows.Foundation.Collections.IIterable<Windows.Graphics.RectInt32> | Windows.Graphics.RectInt32[], options: number): Windows.Devices.Display.Core.DisplayScanout;
+  }
+  var IDisplayDevice2: abstract new (...args: any[]) => IDisplayDevice2;
+
+  interface IDisplayDeviceRenderAdapter {
+    readonly RenderAdapterId: Windows.Graphics.DisplayAdapterId;
+  }
+  var IDisplayDeviceRenderAdapter: abstract new (...args: any[]) => IDisplayDeviceRenderAdapter;
+
+  interface IDisplayFence {
+  }
+  var IDisplayFence: abstract new (...args: any[]) => IDisplayFence;
+
+  interface IDisplayManager {
+    CreateDisplayDevice(adapter: Windows.Devices.Display.Core.DisplayAdapter): Windows.Devices.Display.Core.DisplayDevice;
+    GetCurrentAdapters(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Display.Core.DisplayAdapter> | Windows.Devices.Display.Core.DisplayAdapter[];
+    GetCurrentTargets(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Display.Core.DisplayTarget> | Windows.Devices.Display.Core.DisplayTarget[];
+    ReleaseTarget(target: Windows.Devices.Display.Core.DisplayTarget): void;
+    Start(): void;
+    Stop(): void;
+    TryAcquireTarget(target: Windows.Devices.Display.Core.DisplayTarget): number;
+    TryAcquireTargetsAndCreateEmptyState(targets: Windows.Foundation.Collections.IIterable<Windows.Devices.Display.Core.DisplayTarget> | Windows.Devices.Display.Core.DisplayTarget[]): Windows.Devices.Display.Core.DisplayManagerResultWithState;
+    TryAcquireTargetsAndCreateSubstate(existingState: Windows.Devices.Display.Core.DisplayState, targets: Windows.Foundation.Collections.IIterable<Windows.Devices.Display.Core.DisplayTarget> | Windows.Devices.Display.Core.DisplayTarget[]): Windows.Devices.Display.Core.DisplayManagerResultWithState;
+    TryAcquireTargetsAndReadCurrentState(targets: Windows.Foundation.Collections.IIterable<Windows.Devices.Display.Core.DisplayTarget> | Windows.Devices.Display.Core.DisplayTarget[]): Windows.Devices.Display.Core.DisplayManagerResultWithState;
+    TryReadCurrentStateForAllTargets(): Windows.Devices.Display.Core.DisplayManagerResultWithState;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.Devices.Display.Core.DisplayManager, Windows.Devices.Display.Core.DisplayManagerChangedEventArgs> | null;
+    Disabled: Windows.Foundation.TypedEventHandler<Windows.Devices.Display.Core.DisplayManager, Windows.Devices.Display.Core.DisplayManagerDisabledEventArgs> | null;
+    Enabled: Windows.Foundation.TypedEventHandler<Windows.Devices.Display.Core.DisplayManager, Windows.Devices.Display.Core.DisplayManagerEnabledEventArgs> | null;
+    PathsFailedOrInvalidated: Windows.Foundation.TypedEventHandler<Windows.Devices.Display.Core.DisplayManager, Windows.Devices.Display.Core.DisplayManagerPathsFailedOrInvalidatedEventArgs> | null;
+  }
+  var IDisplayManager: abstract new (...args: any[]) => IDisplayManager;
+
+  interface IDisplayManager2 {
+    TryReadCurrentStateForModeQuery(): Windows.Devices.Display.Core.DisplayManagerResultWithState;
+  }
+  var IDisplayManager2: abstract new (...args: any[]) => IDisplayManager2;
+
+  interface IDisplayManager3 {
+    CreateDisplayDeviceForIndirectAdapter(indirectAdapter: Windows.Devices.Display.Core.DisplayAdapter, renderAdapter: Windows.Devices.Display.Core.DisplayAdapter): Windows.Devices.Display.Core.DisplayDevice;
+  }
+  var IDisplayManager3: abstract new (...args: any[]) => IDisplayManager3;
+
+  interface IDisplayManagerChangedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+  var IDisplayManagerChangedEventArgs: abstract new (...args: any[]) => IDisplayManagerChangedEventArgs;
+
+  interface IDisplayManagerDisabledEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+  var IDisplayManagerDisabledEventArgs: abstract new (...args: any[]) => IDisplayManagerDisabledEventArgs;
+
+  interface IDisplayManagerEnabledEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+  var IDisplayManagerEnabledEventArgs: abstract new (...args: any[]) => IDisplayManagerEnabledEventArgs;
+
+  interface IDisplayManagerPathsFailedOrInvalidatedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+  var IDisplayManagerPathsFailedOrInvalidatedEventArgs: abstract new (...args: any[]) => IDisplayManagerPathsFailedOrInvalidatedEventArgs;
+
+  interface IDisplayManagerResultWithState {
+    readonly ErrorCode: number;
+    readonly ExtendedErrorCode: Windows.Foundation.HResult;
+    readonly State: Windows.Devices.Display.Core.DisplayState;
+  }
+  var IDisplayManagerResultWithState: abstract new (...args: any[]) => IDisplayManagerResultWithState;
+
+  interface IDisplayManagerStatics {
+    Create(options: number): Windows.Devices.Display.Core.DisplayManager;
+  }
+  var IDisplayManagerStatics: abstract new (...args: any[]) => IDisplayManagerStatics;
+
+  interface IDisplayModeInfo {
+    GetWireFormatSupportedBitsPerChannel(encoding: number): number;
+    IsWireFormatSupported(wireFormat: Windows.Devices.Display.Core.DisplayWireFormat): boolean;
+    readonly IsInterlaced: boolean;
+    readonly IsStereo: boolean;
+    readonly PresentationRate: Windows.Devices.Display.Core.DisplayPresentationRate;
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+    readonly SourcePixelFormat: number;
+    readonly SourceResolution: Windows.Graphics.SizeInt32;
+    readonly TargetResolution: Windows.Graphics.SizeInt32;
+  }
+  var IDisplayModeInfo: abstract new (...args: any[]) => IDisplayModeInfo;
+
+  interface IDisplayModeInfo2 {
+    readonly PhysicalPresentationRate: Windows.Devices.Display.Core.DisplayPresentationRate;
+  }
+  var IDisplayModeInfo2: abstract new (...args: any[]) => IDisplayModeInfo2;
+
+  interface IDisplayMuxDevice {
+    GetAvailableMuxTargets(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Display.Core.DisplayTarget> | Windows.Devices.Display.Core.DisplayTarget[];
+    SetAutomaticTargetSwitching(): Windows.Foundation.IAsyncAction;
+    SetPreferredTarget(target: Windows.Devices.Display.Core.DisplayTarget): Windows.Foundation.IAsyncAction;
+    readonly CurrentTarget: Windows.Devices.Display.Core.DisplayTarget;
+    readonly Id: string;
+    readonly IsActive: boolean;
+    readonly IsAutomaticTargetSwitchingEnabled: boolean;
+    readonly PreferredTarget: Windows.Devices.Display.Core.DisplayTarget;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.Devices.Display.Core.DisplayMuxDevice, Object> | null;
+  }
+  var IDisplayMuxDevice: abstract new (...args: any[]) => IDisplayMuxDevice;
+
+  interface IDisplayMuxDeviceStatics {
+    FromIdAsync(deviceInterfaceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Display.Core.DisplayMuxDevice>;
+    GetDeviceSelector(): string;
+  }
+  var IDisplayMuxDeviceStatics: abstract new (...args: any[]) => IDisplayMuxDeviceStatics;
+
+  interface IDisplayPath {
+    ApplyPropertiesFromMode(modeResult: Windows.Devices.Display.Core.DisplayModeInfo): void;
+    FindModes(flags: number): Windows.Foundation.Collections.IVectorView<Windows.Devices.Display.Core.DisplayModeInfo> | Windows.Devices.Display.Core.DisplayModeInfo[];
+    IsInterlaced: boolean | null;
+    IsStereo: boolean;
+    PresentationRate: Windows.Devices.Display.Core.DisplayPresentationRate | null;
+    readonly Properties: Windows.Foundation.Collections.IMap<Guid, Object>;
+    Rotation: number;
+    Scaling: number;
+    SourcePixelFormat: number;
+    SourceResolution: Windows.Graphics.SizeInt32 | null;
+    readonly Status: number;
+    readonly Target: Windows.Devices.Display.Core.DisplayTarget;
+    TargetResolution: Windows.Graphics.SizeInt32 | null;
+    readonly View: Windows.Devices.Display.Core.DisplayView;
+    WireFormat: Windows.Devices.Display.Core.DisplayWireFormat;
+  }
+  var IDisplayPath: abstract new (...args: any[]) => IDisplayPath;
+
+  interface IDisplayPath2 {
+    PhysicalPresentationRate: Windows.Devices.Display.Core.DisplayPresentationRate | null;
+  }
+  var IDisplayPath2: abstract new (...args: any[]) => IDisplayPath2;
+
+  interface IDisplayPrimaryDescription {
+    readonly ColorSpace: number;
+    readonly Format: number;
+    readonly Height: number;
+    readonly IsStereo: boolean;
+    readonly MultisampleDescription: Windows.Graphics.DirectX.Direct3D11.Direct3DMultisampleDescription;
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+    readonly Width: number;
+  }
+  var IDisplayPrimaryDescription: abstract new (...args: any[]) => IDisplayPrimaryDescription;
+
+  interface IDisplayPrimaryDescriptionFactory {
+    CreateInstance(width: number, height: number, pixelFormat: number, colorSpace: number, isStereo: boolean, multisampleDescription: Windows.Graphics.DirectX.Direct3D11.Direct3DMultisampleDescription): Windows.Devices.Display.Core.DisplayPrimaryDescription;
+  }
+  var IDisplayPrimaryDescriptionFactory: abstract new (...args: any[]) => IDisplayPrimaryDescriptionFactory;
+
+  interface IDisplayPrimaryDescriptionStatics {
+    CreateWithProperties(extraProperties: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<Guid, Object>> | Windows.Foundation.Collections.IKeyValuePair<Guid, Object>[], width: number, height: number, pixelFormat: number, colorSpace: number, isStereo: boolean, multisampleDescription: Windows.Graphics.DirectX.Direct3D11.Direct3DMultisampleDescription): Windows.Devices.Display.Core.DisplayPrimaryDescription;
+  }
+  var IDisplayPrimaryDescriptionStatics: abstract new (...args: any[]) => IDisplayPrimaryDescriptionStatics;
+
+  interface IDisplayScanout {
+  }
+  var IDisplayScanout: abstract new (...args: any[]) => IDisplayScanout;
+
+  interface IDisplaySource {
+    GetMetadata(Key: Guid): Windows.Storage.Streams.IBuffer;
+    readonly AdapterId: Windows.Graphics.DisplayAdapterId;
+    readonly SourceId: number;
+  }
+  var IDisplaySource: abstract new (...args: any[]) => IDisplaySource;
+
+  interface IDisplaySource2 {
+    readonly Status: number;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Display.Core.DisplaySource, Object> | null;
+  }
+  var IDisplaySource2: abstract new (...args: any[]) => IDisplaySource2;
+
+  interface IDisplayState {
+    CanConnectTargetToView(target: Windows.Devices.Display.Core.DisplayTarget, view: Windows.Devices.Display.Core.DisplayView): boolean;
+    Clone(): Windows.Devices.Display.Core.DisplayState;
+    ConnectTarget(target: Windows.Devices.Display.Core.DisplayTarget): Windows.Devices.Display.Core.DisplayPath;
+    ConnectTarget(target: Windows.Devices.Display.Core.DisplayTarget, view: Windows.Devices.Display.Core.DisplayView): Windows.Devices.Display.Core.DisplayPath;
+    DisconnectTarget(target: Windows.Devices.Display.Core.DisplayTarget): void;
+    GetPathForTarget(target: Windows.Devices.Display.Core.DisplayTarget): Windows.Devices.Display.Core.DisplayPath;
+    GetViewForTarget(target: Windows.Devices.Display.Core.DisplayTarget): Windows.Devices.Display.Core.DisplayView;
+    TryApply(options: number): Windows.Devices.Display.Core.DisplayStateOperationResult;
+    TryFunctionalize(options: number): Windows.Devices.Display.Core.DisplayStateOperationResult;
+    readonly IsReadOnly: boolean;
+    readonly IsStale: boolean;
+    readonly Properties: Windows.Foundation.Collections.IMap<Guid, Object>;
+    readonly Targets: Windows.Foundation.Collections.IVectorView<Windows.Devices.Display.Core.DisplayTarget> | Windows.Devices.Display.Core.DisplayTarget[];
+    readonly Views: Windows.Foundation.Collections.IVectorView<Windows.Devices.Display.Core.DisplayView> | Windows.Devices.Display.Core.DisplayView[];
+  }
+  var IDisplayState: abstract new (...args: any[]) => IDisplayState;
+
+  interface IDisplayStateOperationResult {
+    readonly ExtendedErrorCode: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+  var IDisplayStateOperationResult: abstract new (...args: any[]) => IDisplayStateOperationResult;
+
+  interface IDisplaySurface {
+  }
+  var IDisplaySurface: abstract new (...args: any[]) => IDisplaySurface;
+
+  interface IDisplayTarget {
+    IsEqual(otherTarget: Windows.Devices.Display.Core.DisplayTarget): boolean;
+    IsSame(otherTarget: Windows.Devices.Display.Core.DisplayTarget): boolean;
+    TryGetMonitor(): Windows.Devices.Display.DisplayMonitor;
+    readonly Adapter: Windows.Devices.Display.Core.DisplayAdapter;
+    readonly AdapterRelativeId: number;
+    readonly DeviceInterfacePath: string;
+    readonly IsConnected: boolean;
+    readonly IsStale: boolean;
+    readonly IsVirtualModeEnabled: boolean;
+    readonly IsVirtualTopologyEnabled: boolean;
+    readonly MonitorPersistence: number;
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+    readonly StableMonitorId: string;
+    readonly UsageKind: number;
+  }
+  var IDisplayTarget: abstract new (...args: any[]) => IDisplayTarget;
+
+  interface IDisplayTask {
+    SetScanout(scanout: Windows.Devices.Display.Core.DisplayScanout): void;
+    SetWait(readyFence: Windows.Devices.Display.Core.DisplayFence, readyFenceValue: number | bigint): void;
+  }
+  var IDisplayTask: abstract new (...args: any[]) => IDisplayTask;
+
+  interface IDisplayTask2 {
+    SetSignal(signalKind: number, fence: Windows.Devices.Display.Core.DisplayFence): void;
+  }
+  var IDisplayTask2: abstract new (...args: any[]) => IDisplayTask2;
+
+  interface IDisplayTaskPool {
+    CreateTask(): Windows.Devices.Display.Core.DisplayTask;
+    ExecuteTask(task: Windows.Devices.Display.Core.DisplayTask): void;
+  }
+  var IDisplayTaskPool: abstract new (...args: any[]) => IDisplayTaskPool;
+
+  interface IDisplayTaskPool2 {
+    TryExecuteTask(task: Windows.Devices.Display.Core.DisplayTask): Windows.Devices.Display.Core.DisplayTaskResult;
+  }
+  var IDisplayTaskPool2: abstract new (...args: any[]) => IDisplayTaskPool2;
+
+  interface IDisplayTaskResult {
+    readonly PresentId: number | bigint;
+    readonly PresentStatus: number;
+    readonly SourceStatus: number;
+  }
+  var IDisplayTaskResult: abstract new (...args: any[]) => IDisplayTaskResult;
+
+  interface IDisplayView {
+    SetPrimaryPath(path: Windows.Devices.Display.Core.DisplayPath): void;
+    ContentResolution: Windows.Graphics.SizeInt32 | null;
+    readonly Paths: Windows.Foundation.Collections.IVectorView<Windows.Devices.Display.Core.DisplayPath> | Windows.Devices.Display.Core.DisplayPath[];
+    readonly Properties: Windows.Foundation.Collections.IMap<Guid, Object>;
+  }
+  var IDisplayView: abstract new (...args: any[]) => IDisplayView;
+
+  interface IDisplayWireFormat {
+    readonly BitsPerChannel: number;
+    readonly ColorSpace: number;
+    readonly Eotf: number;
+    readonly HdrMetadata: number;
+    readonly PixelEncoding: number;
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+  }
+  var IDisplayWireFormat: abstract new (...args: any[]) => IDisplayWireFormat;
+
+  interface IDisplayWireFormatFactory {
+    CreateInstance(pixelEncoding: number, bitsPerChannel: number, colorSpace: number, eotf: number, hdrMetadata: number): Windows.Devices.Display.Core.DisplayWireFormat;
+  }
+  var IDisplayWireFormatFactory: abstract new (...args: any[]) => IDisplayWireFormatFactory;
+
+  interface IDisplayWireFormatStatics {
+    CreateWithProperties(extraProperties: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<Guid, Object>> | Windows.Foundation.Collections.IKeyValuePair<Guid, Object>[], pixelEncoding: number, bitsPerChannel: number, colorSpace: number, eotf: number, hdrMetadata: number): Windows.Devices.Display.Core.DisplayWireFormat;
+  }
+  var IDisplayWireFormatStatics: abstract new (...args: any[]) => IDisplayWireFormatStatics;
+
+}
+
+declare namespace Windows.Devices.Enumeration {
+  class DeviceAccessChangedEventArgs implements Windows.Devices.Enumeration.IDeviceAccessChangedEventArgs, Windows.Devices.Enumeration.IDeviceAccessChangedEventArgs2, Windows.Devices.Enumeration.IDeviceAccessChangedEventArgs3 {
+    readonly Id: string;
+    readonly Status: number;
+    readonly UserPromptRequired: boolean;
+  }
+
+  class DeviceAccessInformation implements Windows.Devices.Enumeration.IDeviceAccessInformation, Windows.Devices.Enumeration.IDeviceAccessInformation2 {
+    static CreateFromDeviceClass(deviceClass: number): Windows.Devices.Enumeration.DeviceAccessInformation;
+    static CreateFromDeviceClassId(deviceClassId: Guid): Windows.Devices.Enumeration.DeviceAccessInformation;
+    static CreateFromId(deviceId: string): Windows.Devices.Enumeration.DeviceAccessInformation;
+    readonly CurrentStatus: number;
+    readonly UserPromptRequired: boolean;
+    AccessChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DeviceAccessInformation, Windows.Devices.Enumeration.DeviceAccessChangedEventArgs> | null;
+  }
+
+  class DeviceConnectionChangeTriggerDetails implements Windows.Devices.Enumeration.IDeviceConnectionChangeTriggerDetails {
+    readonly DeviceId: string;
+  }
+
+  class DeviceDisconnectButtonClickedEventArgs implements Windows.Devices.Enumeration.IDeviceDisconnectButtonClickedEventArgs {
+    readonly Device: Windows.Devices.Enumeration.DeviceInformation;
+  }
+
+  class DeviceInformation implements Windows.Devices.Enumeration.IDeviceInformation, Windows.Devices.Enumeration.IDeviceInformation2 {
+    static CreateFromIdAsync(deviceId: string, additionalProperties: Windows.Foundation.Collections.IIterable<string> | string[], kind: number, settings: Windows.Devices.Enumeration.IDeviceEnumerationSettings): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformation>;
+    static CreateFromIdAsync(deviceId: string, additionalProperties: Windows.Foundation.Collections.IIterable<string> | string[], kind: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformation>;
+    static CreateFromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformation>;
+    static CreateFromIdAsync(deviceId: string, additionalProperties: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformation>;
+    static CreateWatcher(aqsFilter: string, additionalProperties: Windows.Foundation.Collections.IIterable<string> | string[], kind: number, settings: Windows.Devices.Enumeration.IDeviceEnumerationSettings): Windows.Devices.Enumeration.DeviceWatcher;
+    static CreateWatcher(aqsFilter: string, additionalProperties: Windows.Foundation.Collections.IIterable<string> | string[], kind: number): Windows.Devices.Enumeration.DeviceWatcher;
+    static CreateWatcher(): Windows.Devices.Enumeration.DeviceWatcher;
+    static CreateWatcher(deviceClass: number): Windows.Devices.Enumeration.DeviceWatcher;
+    static CreateWatcher(aqsFilter: string, additionalProperties: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Devices.Enumeration.DeviceWatcher;
+    static FindAllAsync(aqsFilter: string, additionalProperties: Windows.Foundation.Collections.IIterable<string> | string[], kind: number, settings: Windows.Devices.Enumeration.IDeviceEnumerationSettings): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformationCollection>;
+    static FindAllAsync(aqsFilter: string, additionalProperties: Windows.Foundation.Collections.IIterable<string> | string[], kind: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformationCollection>;
+    static FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformationCollection>;
+    static FindAllAsync(deviceClass: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformationCollection>;
+    static FindAllAsync(aqsFilter: string, additionalProperties: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformationCollection>;
+    static GetAqsFilterFromDeviceClass(deviceClass: number): string;
+    GetGlyphThumbnailAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceThumbnail>;
+    GetThumbnailAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceThumbnail>;
+    Update(updateInfo: Windows.Devices.Enumeration.DeviceInformationUpdate): void;
+    readonly EnclosureLocation: Windows.Devices.Enumeration.EnclosureLocation;
+    readonly Id: string;
+    readonly IsDefault: boolean;
+    readonly IsEnabled: boolean;
+    readonly Kind: number;
+    readonly Name: string;
+    readonly Pairing: Windows.Devices.Enumeration.DeviceInformationPairing;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+
+  class DeviceInformationCollection {
+    First(): Windows.Foundation.Collections.IIterator<Windows.Devices.Enumeration.DeviceInformation>;
+    GetAt(index: number): Windows.Devices.Enumeration.DeviceInformation;
+    GetMany(startIndex: number, items: Windows.Devices.Enumeration.DeviceInformation[]): number;
+    IndexOf(value: Windows.Devices.Enumeration.DeviceInformation, index: number): boolean;
+    readonly Size: number;
+  }
+
+  class DeviceInformationCustomPairing implements Windows.Devices.Enumeration.IDeviceInformationCustomPairing, Windows.Devices.Enumeration.IDeviceInformationCustomPairing2 {
+    AddPairingSetMember(device: Windows.Devices.Enumeration.DeviceInformation): void;
+    PairAsync(pairingKindsSupported: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DevicePairingResult>;
+    PairAsync(pairingKindsSupported: number, minProtectionLevel: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DevicePairingResult>;
+    PairAsync(pairingKindsSupported: number, minProtectionLevel: number, devicePairingSettings: Windows.Devices.Enumeration.IDevicePairingSettings): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DevicePairingResult>;
+    PairingRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DeviceInformationCustomPairing, Windows.Devices.Enumeration.DevicePairingRequestedEventArgs> | null;
+    PairingSetMembersRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DeviceInformationCustomPairing, Windows.Devices.Enumeration.DevicePairingSetMembersRequestedEventArgs> | null;
+  }
+
+  class DeviceInformationPairing implements Windows.Devices.Enumeration.IDeviceInformationPairing, Windows.Devices.Enumeration.IDeviceInformationPairing2 {
+    PairAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DevicePairingResult>;
+    PairAsync(minProtectionLevel: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DevicePairingResult>;
+    PairAsync(minProtectionLevel: number, devicePairingSettings: Windows.Devices.Enumeration.IDevicePairingSettings): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DevicePairingResult>;
+    static TryRegisterForAllInboundPairingRequests(pairingKindsSupported: number): boolean;
+    static TryRegisterForAllInboundPairingRequestsWithProtectionLevel(pairingKindsSupported: number, minProtectionLevel: number): boolean;
+    UnpairAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceUnpairingResult>;
+    readonly CanPair: boolean;
+    readonly Custom: Windows.Devices.Enumeration.DeviceInformationCustomPairing;
+    readonly IsPaired: boolean;
+    readonly ProtectionLevel: number;
+  }
+
+  class DeviceInformationUpdate implements Windows.Devices.Enumeration.IDeviceInformationUpdate, Windows.Devices.Enumeration.IDeviceInformationUpdate2 {
+    readonly Id: string;
+    readonly Kind: number;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+
+  class DevicePairingRequestedEventArgs implements Windows.Devices.Enumeration.IDevicePairingRequestedEventArgs, Windows.Devices.Enumeration.IDevicePairingRequestedEventArgs2, Windows.Devices.Enumeration.IDevicePairingRequestedEventArgs3 {
+    Accept(): void;
+    Accept(pin: string): void;
+    AcceptWithAddress(address: string): void;
+    AcceptWithPasswordCredential(passwordCredential: Windows.Security.Credentials.PasswordCredential): void;
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly DeviceInformation: Windows.Devices.Enumeration.DeviceInformation;
+    readonly PairingKind: number;
+    readonly Pin: string;
+  }
+
+  class DevicePairingResult implements Windows.Devices.Enumeration.IDevicePairingResult {
+    readonly ProtectionLevelUsed: number;
+    readonly Status: number;
+  }
+
+  class DevicePairingSetMembersRequestedEventArgs implements Windows.Devices.Enumeration.IDevicePairingSetMembersRequestedEventArgs {
+    readonly PairingSetMembers: Windows.Foundation.Collections.IVectorView<Windows.Devices.Enumeration.DeviceInformation> | Windows.Devices.Enumeration.DeviceInformation[];
+    readonly ParentDeviceInformation: Windows.Devices.Enumeration.DeviceInformation;
+    readonly Status: number;
+  }
+
+  class DevicePicker implements Windows.Devices.Enumeration.IDevicePicker {
+    constructor();
+    Hide(): void;
+    PickSingleDeviceAsync(selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformation>;
+    PickSingleDeviceAsync(selection: Windows.Foundation.Rect, placement: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformation>;
+    SetDisplayStatus(device: Windows.Devices.Enumeration.DeviceInformation, status: string, options: number): void;
+    Show(selection: Windows.Foundation.Rect): void;
+    Show(selection: Windows.Foundation.Rect, placement: number): void;
+    readonly Appearance: Windows.Devices.Enumeration.DevicePickerAppearance;
+    readonly Filter: Windows.Devices.Enumeration.DevicePickerFilter;
+    readonly RequestedProperties: Windows.Foundation.Collections.IVector<string> | string[];
+    DevicePickerDismissed: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DevicePicker, Object> | null;
+    DeviceSelected: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DevicePicker, Windows.Devices.Enumeration.DeviceSelectedEventArgs> | null;
+    DisconnectButtonClicked: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DevicePicker, Windows.Devices.Enumeration.DeviceDisconnectButtonClickedEventArgs> | null;
+  }
+
+  class DevicePickerAppearance implements Windows.Devices.Enumeration.IDevicePickerAppearance {
+    AccentColor: Windows.UI.Color;
+    BackgroundColor: Windows.UI.Color;
+    ForegroundColor: Windows.UI.Color;
+    SelectedAccentColor: Windows.UI.Color;
+    SelectedBackgroundColor: Windows.UI.Color;
+    SelectedForegroundColor: Windows.UI.Color;
+    Title: string;
+  }
+
+  class DevicePickerFilter implements Windows.Devices.Enumeration.IDevicePickerFilter {
+    readonly SupportedDeviceClasses: Windows.Foundation.Collections.IVector<number> | number[];
+    readonly SupportedDeviceSelectors: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+
+  class DeviceSelectedEventArgs implements Windows.Devices.Enumeration.IDeviceSelectedEventArgs {
+    readonly SelectedDevice: Windows.Devices.Enumeration.DeviceInformation;
+  }
+
+  class DeviceThumbnail implements Windows.Foundation.IClosable, Windows.Storage.Streams.IContentTypeProvider, Windows.Storage.Streams.IInputStream, Windows.Storage.Streams.IOutputStream, Windows.Storage.Streams.IRandomAccessStream, Windows.Storage.Streams.IRandomAccessStreamWithContentType {
+    CloneStream(): Windows.Storage.Streams.IRandomAccessStream;
+    Close(): void;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    GetInputStreamAt(position: number | bigint): Windows.Storage.Streams.IInputStream;
+    GetOutputStreamAt(position: number | bigint): Windows.Storage.Streams.IOutputStream;
+    ReadAsync(buffer: Windows.Storage.Streams.IBuffer, count: number, options: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number>;
+    Seek(position: number | bigint): void;
+    WriteAsync(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    readonly CanRead: boolean;
+    readonly CanWrite: boolean;
+    readonly ContentType: string;
+    readonly Position: number | bigint;
+    Size: number | bigint;
+  }
+
+  class DeviceUnpairingResult implements Windows.Devices.Enumeration.IDeviceUnpairingResult {
+    readonly Status: number;
+  }
+
+  class DeviceWatcher implements Windows.Devices.Enumeration.IDeviceWatcher, Windows.Devices.Enumeration.IDeviceWatcher2 {
+    GetBackgroundTrigger(requestedEventKinds: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.ApplicationModel.Background.DeviceWatcherTrigger;
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DeviceWatcher, Windows.Devices.Enumeration.DeviceInformation> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DeviceWatcher, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DeviceWatcher, Windows.Devices.Enumeration.DeviceInformationUpdate> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DeviceWatcher, Object> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DeviceWatcher, Windows.Devices.Enumeration.DeviceInformationUpdate> | null;
+  }
+
+  class DeviceWatcherEvent implements Windows.Devices.Enumeration.IDeviceWatcherEvent {
+    readonly DeviceInformation: Windows.Devices.Enumeration.DeviceInformation;
+    readonly DeviceInformationUpdate: Windows.Devices.Enumeration.DeviceInformationUpdate;
+    readonly Kind: number;
+  }
+
+  class DeviceWatcherTriggerDetails implements Windows.Devices.Enumeration.IDeviceWatcherTriggerDetails {
+    readonly DeviceWatcherEvents: Windows.Foundation.Collections.IVectorView<Windows.Devices.Enumeration.DeviceWatcherEvent> | Windows.Devices.Enumeration.DeviceWatcherEvent[];
+  }
+
+  class EnclosureLocation implements Windows.Devices.Enumeration.IEnclosureLocation, Windows.Devices.Enumeration.IEnclosureLocation2 {
+    readonly InDock: boolean;
+    readonly InLid: boolean;
+    readonly Panel: number;
+    readonly RotationAngleInDegreesClockwise: number;
+  }
+
+  enum DeviceAccessStatus {
+    Unspecified = 0,
+    Allowed = 1,
+    DeniedByUser = 2,
+    DeniedBySystem = 3,
+  }
+
+  enum DeviceClass {
+    All = 0,
+    AudioCapture = 1,
+    AudioRender = 2,
+    PortableStorageDevice = 3,
+    VideoCapture = 4,
+    ImageScanner = 5,
+    Location = 6,
+  }
+
+  enum DeviceInformationKind {
+    Unknown = 0,
+    DeviceInterface = 1,
+    DeviceContainer = 2,
+    Device = 3,
+    DeviceInterfaceClass = 4,
+    AssociationEndpoint = 5,
+    AssociationEndpointContainer = 6,
+    AssociationEndpointService = 7,
+    DevicePanel = 8,
+    AssociationEndpointProtocol = 9,
+  }
+
+  enum DevicePairingAddPairingSetMemberStatus {
+    AddedToSet = 0,
+    CouldNotBeAddedToSet = 1,
+    SetDiscoveryNotAttemptedByProtocol = 2,
+    SetDiscoveryCompletedByProtocol = 3,
+    SetDiscoveryPartiallyCompletedByProtocol = 4,
+    Failed = 5,
+  }
+
+  enum DevicePairingKinds {
+    None = 0,
+    ConfirmOnly = 1,
+    DisplayPin = 2,
+    ProvidePin = 4,
+    ConfirmPinMatch = 8,
+    ProvidePasswordCredential = 16,
+    ProvideAddress = 32,
+  }
+
+  enum DevicePairingProtectionLevel {
+    Default = 0,
+    None = 1,
+    Encryption = 2,
+    EncryptionAndAuthentication = 3,
+  }
+
+  enum DevicePairingResultStatus {
+    Paired = 0,
+    NotReadyToPair = 1,
+    NotPaired = 2,
+    AlreadyPaired = 3,
+    ConnectionRejected = 4,
+    TooManyConnections = 5,
+    HardwareFailure = 6,
+    AuthenticationTimeout = 7,
+    AuthenticationNotAllowed = 8,
+    AuthenticationFailure = 9,
+    NoSupportedProfiles = 10,
+    ProtectionLevelCouldNotBeMet = 11,
+    AccessDenied = 12,
+    InvalidCeremonyData = 13,
+    PairingCanceled = 14,
+    OperationAlreadyInProgress = 15,
+    RequiredHandlerNotRegistered = 16,
+    RejectedByHandler = 17,
+    RemoteDeviceHasAssociation = 18,
+    Failed = 19,
+  }
+
+  enum DevicePickerDisplayStatusOptions {
+    None = 0,
+    ShowProgress = 1,
+    ShowDisconnectButton = 2,
+    ShowRetryButton = 4,
+  }
+
+  enum DeviceUnpairingResultStatus {
+    Unpaired = 0,
+    AlreadyUnpaired = 1,
+    OperationAlreadyInProgress = 2,
+    AccessDenied = 3,
+    Failed = 4,
+  }
+
+  enum DeviceWatcherEventKind {
+    Add = 0,
+    Update = 1,
+    Remove = 2,
+  }
+
+  enum DeviceWatcherStatus {
+    Created = 0,
+    Started = 1,
+    EnumerationCompleted = 2,
+    Stopping = 3,
+    Stopped = 4,
+    Aborted = 5,
+  }
+
+  enum Panel {
+    Unknown = 0,
+    Front = 1,
+    Back = 2,
+    Top = 3,
+    Bottom = 4,
+    Left = 5,
+    Right = 6,
+  }
+
+  interface IDeviceAccessChangedEventArgs {
+    readonly Status: number;
+  }
+  var IDeviceAccessChangedEventArgs: abstract new (...args: any[]) => IDeviceAccessChangedEventArgs;
+
+  interface IDeviceAccessChangedEventArgs2 extends Windows.Devices.Enumeration.IDeviceAccessChangedEventArgs {
+    readonly Id: string;
+  }
+  var IDeviceAccessChangedEventArgs2: abstract new (...args: any[]) => IDeviceAccessChangedEventArgs2;
+
+  interface IDeviceAccessChangedEventArgs3 {
+    readonly UserPromptRequired: boolean;
+  }
+  var IDeviceAccessChangedEventArgs3: abstract new (...args: any[]) => IDeviceAccessChangedEventArgs3;
+
+  interface IDeviceAccessInformation {
+    readonly CurrentStatus: number;
+    AccessChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DeviceAccessInformation, Windows.Devices.Enumeration.DeviceAccessChangedEventArgs> | null;
+  }
+  var IDeviceAccessInformation: abstract new (...args: any[]) => IDeviceAccessInformation;
+
+  interface IDeviceAccessInformation2 {
+    readonly UserPromptRequired: boolean;
+  }
+  var IDeviceAccessInformation2: abstract new (...args: any[]) => IDeviceAccessInformation2;
+
+  interface IDeviceAccessInformationStatics {
+    CreateFromDeviceClass(deviceClass: number): Windows.Devices.Enumeration.DeviceAccessInformation;
+    CreateFromDeviceClassId(deviceClassId: Guid): Windows.Devices.Enumeration.DeviceAccessInformation;
+    CreateFromId(deviceId: string): Windows.Devices.Enumeration.DeviceAccessInformation;
+  }
+  var IDeviceAccessInformationStatics: abstract new (...args: any[]) => IDeviceAccessInformationStatics;
+
+  interface IDeviceConnectionChangeTriggerDetails {
+    readonly DeviceId: string;
+  }
+  var IDeviceConnectionChangeTriggerDetails: abstract new (...args: any[]) => IDeviceConnectionChangeTriggerDetails;
+
+  interface IDeviceDisconnectButtonClickedEventArgs {
+    readonly Device: Windows.Devices.Enumeration.DeviceInformation;
+  }
+  var IDeviceDisconnectButtonClickedEventArgs: abstract new (...args: any[]) => IDeviceDisconnectButtonClickedEventArgs;
+
+  interface IDeviceEnumerationSettings {
+  }
+  var IDeviceEnumerationSettings: abstract new (...args: any[]) => IDeviceEnumerationSettings;
+
+  interface IDeviceInformation {
+    GetGlyphThumbnailAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceThumbnail>;
+    GetThumbnailAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceThumbnail>;
+    Update(updateInfo: Windows.Devices.Enumeration.DeviceInformationUpdate): void;
+    readonly EnclosureLocation: Windows.Devices.Enumeration.EnclosureLocation;
+    readonly Id: string;
+    readonly IsDefault: boolean;
+    readonly IsEnabled: boolean;
+    readonly Name: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+  var IDeviceInformation: abstract new (...args: any[]) => IDeviceInformation;
+
+  interface IDeviceInformation2 {
+    readonly Kind: number;
+    readonly Pairing: Windows.Devices.Enumeration.DeviceInformationPairing;
+  }
+  var IDeviceInformation2: abstract new (...args: any[]) => IDeviceInformation2;
+
+  interface IDeviceInformationCustomPairing {
+    PairAsync(pairingKindsSupported: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DevicePairingResult>;
+    PairAsync(pairingKindsSupported: number, minProtectionLevel: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DevicePairingResult>;
+    PairAsync(pairingKindsSupported: number, minProtectionLevel: number, devicePairingSettings: Windows.Devices.Enumeration.IDevicePairingSettings): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DevicePairingResult>;
+    PairingRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DeviceInformationCustomPairing, Windows.Devices.Enumeration.DevicePairingRequestedEventArgs> | null;
+  }
+  var IDeviceInformationCustomPairing: abstract new (...args: any[]) => IDeviceInformationCustomPairing;
+
+  interface IDeviceInformationCustomPairing2 {
+    AddPairingSetMember(device: Windows.Devices.Enumeration.DeviceInformation): void;
+    PairingSetMembersRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DeviceInformationCustomPairing, Windows.Devices.Enumeration.DevicePairingSetMembersRequestedEventArgs> | null;
+  }
+  var IDeviceInformationCustomPairing2: abstract new (...args: any[]) => IDeviceInformationCustomPairing2;
+
+  interface IDeviceInformationPairing {
+    PairAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DevicePairingResult>;
+    PairAsync(minProtectionLevel: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DevicePairingResult>;
+    readonly CanPair: boolean;
+    readonly IsPaired: boolean;
+  }
+  var IDeviceInformationPairing: abstract new (...args: any[]) => IDeviceInformationPairing;
+
+  interface IDeviceInformationPairing2 {
+    PairAsync(minProtectionLevel: number, devicePairingSettings: Windows.Devices.Enumeration.IDevicePairingSettings): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DevicePairingResult>;
+    UnpairAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceUnpairingResult>;
+    readonly Custom: Windows.Devices.Enumeration.DeviceInformationCustomPairing;
+    readonly ProtectionLevel: number;
+  }
+  var IDeviceInformationPairing2: abstract new (...args: any[]) => IDeviceInformationPairing2;
+
+  interface IDeviceInformationPairingStatics {
+    TryRegisterForAllInboundPairingRequests(pairingKindsSupported: number): boolean;
+  }
+  var IDeviceInformationPairingStatics: abstract new (...args: any[]) => IDeviceInformationPairingStatics;
+
+  interface IDeviceInformationPairingStatics2 {
+    TryRegisterForAllInboundPairingRequestsWithProtectionLevel(pairingKindsSupported: number, minProtectionLevel: number): boolean;
+  }
+  var IDeviceInformationPairingStatics2: abstract new (...args: any[]) => IDeviceInformationPairingStatics2;
+
+  interface IDeviceInformationStatics {
+    CreateFromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformation>;
+    CreateFromIdAsync(deviceId: string, additionalProperties: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformation>;
+    CreateWatcher(): Windows.Devices.Enumeration.DeviceWatcher;
+    CreateWatcher(deviceClass: number): Windows.Devices.Enumeration.DeviceWatcher;
+    CreateWatcher(aqsFilter: string, additionalProperties: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Devices.Enumeration.DeviceWatcher;
+    FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformationCollection>;
+    FindAllAsync(deviceClass: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformationCollection>;
+    FindAllAsync(aqsFilter: string, additionalProperties: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformationCollection>;
+  }
+  var IDeviceInformationStatics: abstract new (...args: any[]) => IDeviceInformationStatics;
+
+  interface IDeviceInformationStatics2 {
+    CreateFromIdAsync(deviceId: string, additionalProperties: Windows.Foundation.Collections.IIterable<string> | string[], kind: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformation>;
+    CreateWatcher(aqsFilter: string, additionalProperties: Windows.Foundation.Collections.IIterable<string> | string[], kind: number): Windows.Devices.Enumeration.DeviceWatcher;
+    FindAllAsync(aqsFilter: string, additionalProperties: Windows.Foundation.Collections.IIterable<string> | string[], kind: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformationCollection>;
+    GetAqsFilterFromDeviceClass(deviceClass: number): string;
+  }
+  var IDeviceInformationStatics2: abstract new (...args: any[]) => IDeviceInformationStatics2;
+
+  interface IDeviceInformationStatics3 {
+    CreateFromIdAsync(deviceId: string, additionalProperties: Windows.Foundation.Collections.IIterable<string> | string[], kind: number, settings: Windows.Devices.Enumeration.IDeviceEnumerationSettings): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformation>;
+    CreateWatcher(aqsFilter: string, additionalProperties: Windows.Foundation.Collections.IIterable<string> | string[], kind: number, settings: Windows.Devices.Enumeration.IDeviceEnumerationSettings): Windows.Devices.Enumeration.DeviceWatcher;
+    FindAllAsync(aqsFilter: string, additionalProperties: Windows.Foundation.Collections.IIterable<string> | string[], kind: number, settings: Windows.Devices.Enumeration.IDeviceEnumerationSettings): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformationCollection>;
+  }
+  var IDeviceInformationStatics3: abstract new (...args: any[]) => IDeviceInformationStatics3;
+
+  interface IDeviceInformationUpdate {
+    readonly Id: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+  var IDeviceInformationUpdate: abstract new (...args: any[]) => IDeviceInformationUpdate;
+
+  interface IDeviceInformationUpdate2 {
+    readonly Kind: number;
+  }
+  var IDeviceInformationUpdate2: abstract new (...args: any[]) => IDeviceInformationUpdate2;
+
+  interface IDevicePairingRequestedEventArgs {
+    Accept(): void;
+    Accept(pin: string): void;
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly DeviceInformation: Windows.Devices.Enumeration.DeviceInformation;
+    readonly PairingKind: number;
+    readonly Pin: string;
+  }
+  var IDevicePairingRequestedEventArgs: abstract new (...args: any[]) => IDevicePairingRequestedEventArgs;
+
+  interface IDevicePairingRequestedEventArgs2 {
+    AcceptWithPasswordCredential(passwordCredential: Windows.Security.Credentials.PasswordCredential): void;
+  }
+  var IDevicePairingRequestedEventArgs2: abstract new (...args: any[]) => IDevicePairingRequestedEventArgs2;
+
+  interface IDevicePairingRequestedEventArgs3 {
+    AcceptWithAddress(address: string): void;
+  }
+  var IDevicePairingRequestedEventArgs3: abstract new (...args: any[]) => IDevicePairingRequestedEventArgs3;
+
+  interface IDevicePairingResult {
+    readonly ProtectionLevelUsed: number;
+    readonly Status: number;
+  }
+  var IDevicePairingResult: abstract new (...args: any[]) => IDevicePairingResult;
+
+  interface IDevicePairingSetMembersRequestedEventArgs {
+    readonly PairingSetMembers: Windows.Foundation.Collections.IVectorView<Windows.Devices.Enumeration.DeviceInformation> | Windows.Devices.Enumeration.DeviceInformation[];
+    readonly ParentDeviceInformation: Windows.Devices.Enumeration.DeviceInformation;
+    readonly Status: number;
+  }
+  var IDevicePairingSetMembersRequestedEventArgs: abstract new (...args: any[]) => IDevicePairingSetMembersRequestedEventArgs;
+
+  interface IDevicePairingSettings {
+  }
+  var IDevicePairingSettings: abstract new (...args: any[]) => IDevicePairingSettings;
+
+  interface IDevicePicker {
+    Hide(): void;
+    PickSingleDeviceAsync(selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformation>;
+    PickSingleDeviceAsync(selection: Windows.Foundation.Rect, placement: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.DeviceInformation>;
+    SetDisplayStatus(device: Windows.Devices.Enumeration.DeviceInformation, status: string, options: number): void;
+    Show(selection: Windows.Foundation.Rect): void;
+    Show(selection: Windows.Foundation.Rect, placement: number): void;
+    readonly Appearance: Windows.Devices.Enumeration.DevicePickerAppearance;
+    readonly Filter: Windows.Devices.Enumeration.DevicePickerFilter;
+    readonly RequestedProperties: Windows.Foundation.Collections.IVector<string> | string[];
+    DevicePickerDismissed: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DevicePicker, Object> | null;
+    DeviceSelected: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DevicePicker, Windows.Devices.Enumeration.DeviceSelectedEventArgs> | null;
+    DisconnectButtonClicked: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DevicePicker, Windows.Devices.Enumeration.DeviceDisconnectButtonClickedEventArgs> | null;
+  }
+  var IDevicePicker: abstract new (...args: any[]) => IDevicePicker;
+
+  interface IDevicePickerAppearance {
+    AccentColor: Windows.UI.Color;
+    BackgroundColor: Windows.UI.Color;
+    ForegroundColor: Windows.UI.Color;
+    SelectedAccentColor: Windows.UI.Color;
+    SelectedBackgroundColor: Windows.UI.Color;
+    SelectedForegroundColor: Windows.UI.Color;
+    Title: string;
+  }
+  var IDevicePickerAppearance: abstract new (...args: any[]) => IDevicePickerAppearance;
+
+  interface IDevicePickerFilter {
+    readonly SupportedDeviceClasses: Windows.Foundation.Collections.IVector<number> | number[];
+    readonly SupportedDeviceSelectors: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var IDevicePickerFilter: abstract new (...args: any[]) => IDevicePickerFilter;
+
+  interface IDeviceSelectedEventArgs {
+    readonly SelectedDevice: Windows.Devices.Enumeration.DeviceInformation;
+  }
+  var IDeviceSelectedEventArgs: abstract new (...args: any[]) => IDeviceSelectedEventArgs;
+
+  interface IDeviceUnpairingResult {
+    readonly Status: number;
+  }
+  var IDeviceUnpairingResult: abstract new (...args: any[]) => IDeviceUnpairingResult;
+
+  interface IDeviceWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DeviceWatcher, Windows.Devices.Enumeration.DeviceInformation> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DeviceWatcher, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DeviceWatcher, Windows.Devices.Enumeration.DeviceInformationUpdate> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DeviceWatcher, Object> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.DeviceWatcher, Windows.Devices.Enumeration.DeviceInformationUpdate> | null;
+  }
+  var IDeviceWatcher: abstract new (...args: any[]) => IDeviceWatcher;
+
+  interface IDeviceWatcher2 {
+    GetBackgroundTrigger(requestedEventKinds: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.ApplicationModel.Background.DeviceWatcherTrigger;
+  }
+  var IDeviceWatcher2: abstract new (...args: any[]) => IDeviceWatcher2;
+
+  interface IDeviceWatcherEvent {
+    readonly DeviceInformation: Windows.Devices.Enumeration.DeviceInformation;
+    readonly DeviceInformationUpdate: Windows.Devices.Enumeration.DeviceInformationUpdate;
+    readonly Kind: number;
+  }
+  var IDeviceWatcherEvent: abstract new (...args: any[]) => IDeviceWatcherEvent;
+
+  interface IDeviceWatcherTriggerDetails {
+    readonly DeviceWatcherEvents: Windows.Foundation.Collections.IVectorView<Windows.Devices.Enumeration.DeviceWatcherEvent> | Windows.Devices.Enumeration.DeviceWatcherEvent[];
+  }
+  var IDeviceWatcherTriggerDetails: abstract new (...args: any[]) => IDeviceWatcherTriggerDetails;
+
+  interface IEnclosureLocation {
+    readonly InDock: boolean;
+    readonly InLid: boolean;
+    readonly Panel: number;
+  }
+  var IEnclosureLocation: abstract new (...args: any[]) => IEnclosureLocation;
+
+  interface IEnclosureLocation2 extends Windows.Devices.Enumeration.IEnclosureLocation {
+    readonly RotationAngleInDegreesClockwise: number;
+  }
+  var IEnclosureLocation2: abstract new (...args: any[]) => IEnclosureLocation2;
+
+}
+
+declare namespace Windows.Devices.Enumeration.Pnp {
+  class PnpObject implements Windows.Devices.Enumeration.Pnp.IPnpObject {
+    static CreateFromIdAsync(type: number, id: string, requestedProperties: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.Pnp.PnpObject>;
+    static CreateWatcher(type: number, requestedProperties: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Devices.Enumeration.Pnp.PnpObjectWatcher;
+    static CreateWatcher(type: number, requestedProperties: Windows.Foundation.Collections.IIterable<string> | string[], aqsFilter: string): Windows.Devices.Enumeration.Pnp.PnpObjectWatcher;
+    static FindAllAsync(type: number, requestedProperties: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.Pnp.PnpObjectCollection>;
+    static FindAllAsync(type: number, requestedProperties: Windows.Foundation.Collections.IIterable<string> | string[], aqsFilter: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.Pnp.PnpObjectCollection>;
+    Update(updateInfo: Windows.Devices.Enumeration.Pnp.PnpObjectUpdate): void;
+    readonly Id: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Type: number;
+  }
+
+  class PnpObjectCollection {
+    First(): Windows.Foundation.Collections.IIterator<Windows.Devices.Enumeration.Pnp.PnpObject>;
+    GetAt(index: number): Windows.Devices.Enumeration.Pnp.PnpObject;
+    GetMany(startIndex: number, items: Windows.Devices.Enumeration.Pnp.PnpObject[]): number;
+    IndexOf(value: Windows.Devices.Enumeration.Pnp.PnpObject, index: number): boolean;
+    readonly Size: number;
+  }
+
+  class PnpObjectUpdate implements Windows.Devices.Enumeration.Pnp.IPnpObjectUpdate {
+    readonly Id: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Type: number;
+  }
+
+  class PnpObjectWatcher implements Windows.Devices.Enumeration.Pnp.IPnpObjectWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.Pnp.PnpObjectWatcher, Windows.Devices.Enumeration.Pnp.PnpObject> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.Pnp.PnpObjectWatcher, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.Pnp.PnpObjectWatcher, Windows.Devices.Enumeration.Pnp.PnpObjectUpdate> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.Pnp.PnpObjectWatcher, Object> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.Pnp.PnpObjectWatcher, Windows.Devices.Enumeration.Pnp.PnpObjectUpdate> | null;
+  }
+
+  enum PnpObjectType {
+    Unknown = 0,
+    DeviceInterface = 1,
+    DeviceContainer = 2,
+    Device = 3,
+    DeviceInterfaceClass = 4,
+    AssociationEndpoint = 5,
+    AssociationEndpointContainer = 6,
+    AssociationEndpointService = 7,
+    DevicePanel = 8,
+    AssociationEndpointProtocol = 9,
+  }
+
+  interface IPnpObject {
+    Update(updateInfo: Windows.Devices.Enumeration.Pnp.PnpObjectUpdate): void;
+    readonly Id: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Type: number;
+  }
+  var IPnpObject: abstract new (...args: any[]) => IPnpObject;
+
+  interface IPnpObjectStatics {
+    CreateFromIdAsync(type: number, id: string, requestedProperties: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.Pnp.PnpObject>;
+    CreateWatcher(type: number, requestedProperties: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Devices.Enumeration.Pnp.PnpObjectWatcher;
+    CreateWatcher(type: number, requestedProperties: Windows.Foundation.Collections.IIterable<string> | string[], aqsFilter: string): Windows.Devices.Enumeration.Pnp.PnpObjectWatcher;
+    FindAllAsync(type: number, requestedProperties: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.Pnp.PnpObjectCollection>;
+    FindAllAsync(type: number, requestedProperties: Windows.Foundation.Collections.IIterable<string> | string[], aqsFilter: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Enumeration.Pnp.PnpObjectCollection>;
+  }
+  var IPnpObjectStatics: abstract new (...args: any[]) => IPnpObjectStatics;
+
+  interface IPnpObjectUpdate {
+    readonly Id: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Type: number;
+  }
+  var IPnpObjectUpdate: abstract new (...args: any[]) => IPnpObjectUpdate;
+
+  interface IPnpObjectWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.Pnp.PnpObjectWatcher, Windows.Devices.Enumeration.Pnp.PnpObject> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.Pnp.PnpObjectWatcher, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.Pnp.PnpObjectWatcher, Windows.Devices.Enumeration.Pnp.PnpObjectUpdate> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.Pnp.PnpObjectWatcher, Object> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.Devices.Enumeration.Pnp.PnpObjectWatcher, Windows.Devices.Enumeration.Pnp.PnpObjectUpdate> | null;
+  }
+  var IPnpObjectWatcher: abstract new (...args: any[]) => IPnpObjectWatcher;
+
+}
+
+declare namespace Windows.Devices.Geolocation {
+  class CivicAddress implements Windows.Devices.Geolocation.ICivicAddress {
+    readonly City: string;
+    readonly Country: string;
+    readonly PostalCode: string;
+    readonly State: string;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class GeoboundingBox implements Windows.Devices.Geolocation.IGeoboundingBox, Windows.Devices.Geolocation.IGeoshape {
+    constructor(northwestCorner: Windows.Devices.Geolocation.BasicGeoposition, southeastCorner: Windows.Devices.Geolocation.BasicGeoposition);
+    constructor(northwestCorner: Windows.Devices.Geolocation.BasicGeoposition, southeastCorner: Windows.Devices.Geolocation.BasicGeoposition, altitudeReferenceSystem: number);
+    constructor(northwestCorner: Windows.Devices.Geolocation.BasicGeoposition, southeastCorner: Windows.Devices.Geolocation.BasicGeoposition, altitudeReferenceSystem: number, spatialReferenceId: number);
+    static TryCompute(positions: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.BasicGeoposition> | Windows.Devices.Geolocation.BasicGeoposition[]): Windows.Devices.Geolocation.GeoboundingBox;
+    static TryCompute(positions: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.BasicGeoposition> | Windows.Devices.Geolocation.BasicGeoposition[], altitudeRefSystem: number): Windows.Devices.Geolocation.GeoboundingBox;
+    static TryCompute(positions: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.BasicGeoposition> | Windows.Devices.Geolocation.BasicGeoposition[], altitudeRefSystem: number, spatialReferenceId: number): Windows.Devices.Geolocation.GeoboundingBox;
+    readonly AltitudeReferenceSystem: number;
+    readonly Center: Windows.Devices.Geolocation.BasicGeoposition;
+    readonly GeoshapeType: number;
+    readonly MaxAltitude: number;
+    readonly MinAltitude: number;
+    readonly NorthwestCorner: Windows.Devices.Geolocation.BasicGeoposition;
+    readonly SoutheastCorner: Windows.Devices.Geolocation.BasicGeoposition;
+    readonly SpatialReferenceId: number;
+  }
+
+  class Geocircle implements Windows.Devices.Geolocation.IGeocircle, Windows.Devices.Geolocation.IGeoshape {
+    constructor(position: Windows.Devices.Geolocation.BasicGeoposition, radius: number);
+    constructor(position: Windows.Devices.Geolocation.BasicGeoposition, radius: number, altitudeReferenceSystem: number);
+    constructor(position: Windows.Devices.Geolocation.BasicGeoposition, radius: number, altitudeReferenceSystem: number, spatialReferenceId: number);
+    readonly AltitudeReferenceSystem: number;
+    readonly Center: Windows.Devices.Geolocation.BasicGeoposition;
+    readonly GeoshapeType: number;
+    readonly Radius: number;
+    readonly SpatialReferenceId: number;
+  }
+
+  class Geocoordinate implements Windows.Devices.Geolocation.IGeocoordinate, Windows.Devices.Geolocation.IGeocoordinateWithPoint, Windows.Devices.Geolocation.IGeocoordinateWithPositionData, Windows.Devices.Geolocation.IGeocoordinateWithPositionSourceTimestamp, Windows.Devices.Geolocation.IGeocoordinateWithRemoteSource {
+    readonly Accuracy: number;
+    readonly Altitude: number | null;
+    readonly AltitudeAccuracy: number | null;
+    readonly Heading: number | null;
+    readonly IsRemoteSource: boolean;
+    readonly Latitude: number;
+    readonly Longitude: number;
+    readonly Point: Windows.Devices.Geolocation.Geopoint;
+    readonly PositionSource: number;
+    readonly PositionSourceTimestamp: Windows.Foundation.DateTime | null;
+    readonly SatelliteData: Windows.Devices.Geolocation.GeocoordinateSatelliteData;
+    readonly Speed: number | null;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class GeocoordinateSatelliteData implements Windows.Devices.Geolocation.IGeocoordinateSatelliteData, Windows.Devices.Geolocation.IGeocoordinateSatelliteData2 {
+    readonly GeometricDilutionOfPrecision: number | null;
+    readonly HorizontalDilutionOfPrecision: number | null;
+    readonly PositionDilutionOfPrecision: number | null;
+    readonly TimeDilutionOfPrecision: number | null;
+    readonly VerticalDilutionOfPrecision: number | null;
+  }
+
+  class Geolocator implements Windows.Devices.Geolocation.IGeolocator, Windows.Devices.Geolocation.IGeolocator2, Windows.Devices.Geolocation.IGeolocatorWithScalarAccuracy {
+    constructor();
+    AllowFallbackToConsentlessPositions(): void;
+    GetGeopositionAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Geolocation.Geoposition>;
+    GetGeopositionAsync(maximumAge: Windows.Foundation.TimeSpan, timeout: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Devices.Geolocation.Geoposition>;
+    static GetGeopositionHistoryAsync(startTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Geolocation.Geoposition> | Windows.Devices.Geolocation.Geoposition[]>;
+    static GetGeopositionHistoryAsync(startTime: Windows.Foundation.DateTime, duration: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Geolocation.Geoposition> | Windows.Devices.Geolocation.Geoposition[]>;
+    static RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    static DefaultGeoposition: Windows.Devices.Geolocation.BasicGeoposition | null;
+    DesiredAccuracy: number;
+    DesiredAccuracyInMeters: number | null;
+    static readonly IsDefaultGeopositionRecommended: boolean;
+    readonly LocationStatus: number;
+    MovementThreshold: number;
+    ReportInterval: number;
+    PositionChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Geolocation.Geolocator, Windows.Devices.Geolocation.PositionChangedEventArgs> | null;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Geolocation.Geolocator, Windows.Devices.Geolocation.StatusChangedEventArgs> | null;
+  }
+
+  class Geopath implements Windows.Devices.Geolocation.IGeopath, Windows.Devices.Geolocation.IGeoshape {
+    constructor(positions: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.BasicGeoposition> | Windows.Devices.Geolocation.BasicGeoposition[]);
+    constructor(positions: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.BasicGeoposition> | Windows.Devices.Geolocation.BasicGeoposition[], altitudeReferenceSystem: number);
+    constructor(positions: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.BasicGeoposition> | Windows.Devices.Geolocation.BasicGeoposition[], altitudeReferenceSystem: number, spatialReferenceId: number);
+    readonly AltitudeReferenceSystem: number;
+    readonly GeoshapeType: number;
+    readonly Positions: Windows.Foundation.Collections.IVectorView<Windows.Devices.Geolocation.BasicGeoposition> | Windows.Devices.Geolocation.BasicGeoposition[];
+    readonly SpatialReferenceId: number;
+  }
+
+  class Geopoint implements Windows.Devices.Geolocation.IGeopoint, Windows.Devices.Geolocation.IGeoshape {
+    constructor(position: Windows.Devices.Geolocation.BasicGeoposition);
+    constructor(position: Windows.Devices.Geolocation.BasicGeoposition, altitudeReferenceSystem: number);
+    constructor(position: Windows.Devices.Geolocation.BasicGeoposition, altitudeReferenceSystem: number, spatialReferenceId: number);
+    readonly AltitudeReferenceSystem: number;
+    readonly GeoshapeType: number;
+    readonly Position: Windows.Devices.Geolocation.BasicGeoposition;
+    readonly SpatialReferenceId: number;
+  }
+
+  class Geoposition implements Windows.Devices.Geolocation.IGeoposition, Windows.Devices.Geolocation.IGeoposition2 {
+    readonly CivicAddress: Windows.Devices.Geolocation.CivicAddress;
+    readonly Coordinate: Windows.Devices.Geolocation.Geocoordinate;
+    readonly VenueData: Windows.Devices.Geolocation.VenueData;
+  }
+
+  class Geovisit implements Windows.Devices.Geolocation.IGeovisit {
+    readonly Position: Windows.Devices.Geolocation.Geoposition;
+    readonly StateChange: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class GeovisitMonitor implements Windows.Devices.Geolocation.IGeovisitMonitor {
+    constructor();
+    static GetLastReportAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Geolocation.Geovisit>;
+    Start(value: number): void;
+    Stop(): void;
+    readonly MonitoringScope: number;
+    VisitStateChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Geolocation.GeovisitMonitor, Windows.Devices.Geolocation.GeovisitStateChangedEventArgs> | null;
+  }
+
+  class GeovisitStateChangedEventArgs implements Windows.Devices.Geolocation.IGeovisitStateChangedEventArgs {
+    readonly Visit: Windows.Devices.Geolocation.Geovisit;
+  }
+
+  class GeovisitTriggerDetails implements Windows.Devices.Geolocation.IGeovisitTriggerDetails {
+    ReadReports(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Geolocation.Geovisit> | Windows.Devices.Geolocation.Geovisit[];
+  }
+
+  class PositionChangedEventArgs implements Windows.Devices.Geolocation.IPositionChangedEventArgs {
+    readonly Position: Windows.Devices.Geolocation.Geoposition;
+  }
+
+  class StatusChangedEventArgs implements Windows.Devices.Geolocation.IStatusChangedEventArgs {
+    readonly Status: number;
+  }
+
+  class VenueData implements Windows.Devices.Geolocation.IVenueData {
+    readonly Id: string;
+    readonly Level: string;
+  }
+
+  enum AltitudeReferenceSystem {
+    Unspecified = 0,
+    Terrain = 1,
+    Ellipsoid = 2,
+    Geoid = 3,
+    Surface = 4,
+  }
+
+  enum GeolocationAccessStatus {
+    Unspecified = 0,
+    Allowed = 1,
+    Denied = 2,
+  }
+
+  enum GeoshapeType {
+    Geopoint = 0,
+    Geocircle = 1,
+    Geopath = 2,
+    GeoboundingBox = 3,
+  }
+
+  enum PositionAccuracy {
+    Default = 0,
+    High = 1,
+  }
+
+  enum PositionSource {
+    Cellular = 0,
+    Satellite = 1,
+    WiFi = 2,
+    IPAddress = 3,
+    Unknown = 4,
+    Default = 5,
+    Obfuscated = 6,
+  }
+
+  enum PositionStatus {
+    Ready = 0,
+    Initializing = 1,
+    NoData = 2,
+    Disabled = 3,
+    NotInitialized = 4,
+    NotAvailable = 5,
+  }
+
+  enum VisitMonitoringScope {
+    Venue = 0,
+    City = 1,
+  }
+
+  enum VisitStateChange {
+    TrackingLost = 0,
+    Arrived = 1,
+    Departed = 2,
+    OtherMovement = 3,
+  }
+
+  interface BasicGeoposition {
+    Latitude: number;
+    Longitude: number;
+    Altitude: number;
+  }
+  var BasicGeoposition: {
+    new(latitude: number, longitude: number, altitude: number): BasicGeoposition;
+    new(fields: { Latitude?: number; Longitude?: number; Altitude?: number }): BasicGeoposition;
+  };
+
+  interface ICivicAddress {
+    readonly City: string;
+    readonly Country: string;
+    readonly PostalCode: string;
+    readonly State: string;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var ICivicAddress: abstract new (...args: any[]) => ICivicAddress;
+
+  interface IGeoboundingBox extends Windows.Devices.Geolocation.IGeoshape {
+    readonly Center: Windows.Devices.Geolocation.BasicGeoposition;
+    readonly MaxAltitude: number;
+    readonly MinAltitude: number;
+    readonly NorthwestCorner: Windows.Devices.Geolocation.BasicGeoposition;
+    readonly SoutheastCorner: Windows.Devices.Geolocation.BasicGeoposition;
+  }
+  var IGeoboundingBox: abstract new (...args: any[]) => IGeoboundingBox;
+
+  interface IGeoboundingBoxFactory {
+    Create(northwestCorner: Windows.Devices.Geolocation.BasicGeoposition, southeastCorner: Windows.Devices.Geolocation.BasicGeoposition): Windows.Devices.Geolocation.GeoboundingBox;
+    CreateWithAltitudeReference(northwestCorner: Windows.Devices.Geolocation.BasicGeoposition, southeastCorner: Windows.Devices.Geolocation.BasicGeoposition, altitudeReferenceSystem: number): Windows.Devices.Geolocation.GeoboundingBox;
+    CreateWithAltitudeReferenceAndSpatialReference(northwestCorner: Windows.Devices.Geolocation.BasicGeoposition, southeastCorner: Windows.Devices.Geolocation.BasicGeoposition, altitudeReferenceSystem: number, spatialReferenceId: number): Windows.Devices.Geolocation.GeoboundingBox;
+  }
+  var IGeoboundingBoxFactory: abstract new (...args: any[]) => IGeoboundingBoxFactory;
+
+  interface IGeoboundingBoxStatics {
+    TryCompute(positions: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.BasicGeoposition> | Windows.Devices.Geolocation.BasicGeoposition[]): Windows.Devices.Geolocation.GeoboundingBox;
+    TryCompute(positions: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.BasicGeoposition> | Windows.Devices.Geolocation.BasicGeoposition[], altitudeRefSystem: number): Windows.Devices.Geolocation.GeoboundingBox;
+    TryCompute(positions: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.BasicGeoposition> | Windows.Devices.Geolocation.BasicGeoposition[], altitudeRefSystem: number, spatialReferenceId: number): Windows.Devices.Geolocation.GeoboundingBox;
+  }
+  var IGeoboundingBoxStatics: abstract new (...args: any[]) => IGeoboundingBoxStatics;
+
+  interface IGeocircle extends Windows.Devices.Geolocation.IGeoshape {
+    readonly Center: Windows.Devices.Geolocation.BasicGeoposition;
+    readonly Radius: number;
+  }
+  var IGeocircle: abstract new (...args: any[]) => IGeocircle;
+
+  interface IGeocircleFactory {
+    Create(position: Windows.Devices.Geolocation.BasicGeoposition, radius: number): Windows.Devices.Geolocation.Geocircle;
+    CreateWithAltitudeReferenceSystem(position: Windows.Devices.Geolocation.BasicGeoposition, radius: number, altitudeReferenceSystem: number): Windows.Devices.Geolocation.Geocircle;
+    CreateWithAltitudeReferenceSystemAndSpatialReferenceId(position: Windows.Devices.Geolocation.BasicGeoposition, radius: number, altitudeReferenceSystem: number, spatialReferenceId: number): Windows.Devices.Geolocation.Geocircle;
+  }
+  var IGeocircleFactory: abstract new (...args: any[]) => IGeocircleFactory;
+
+  interface IGeocoordinate {
+    readonly Accuracy: number;
+    readonly Altitude: number | null;
+    readonly AltitudeAccuracy: number | null;
+    readonly Heading: number | null;
+    readonly Latitude: number;
+    readonly Longitude: number;
+    readonly Speed: number | null;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IGeocoordinate: abstract new (...args: any[]) => IGeocoordinate;
+
+  interface IGeocoordinateSatelliteData {
+    readonly HorizontalDilutionOfPrecision: number | null;
+    readonly PositionDilutionOfPrecision: number | null;
+    readonly VerticalDilutionOfPrecision: number | null;
+  }
+  var IGeocoordinateSatelliteData: abstract new (...args: any[]) => IGeocoordinateSatelliteData;
+
+  interface IGeocoordinateSatelliteData2 {
+    readonly GeometricDilutionOfPrecision: number | null;
+    readonly TimeDilutionOfPrecision: number | null;
+  }
+  var IGeocoordinateSatelliteData2: abstract new (...args: any[]) => IGeocoordinateSatelliteData2;
+
+  interface IGeocoordinateWithPoint {
+    readonly Point: Windows.Devices.Geolocation.Geopoint;
+  }
+  var IGeocoordinateWithPoint: abstract new (...args: any[]) => IGeocoordinateWithPoint;
+
+  interface IGeocoordinateWithPositionData extends Windows.Devices.Geolocation.IGeocoordinate {
+    readonly PositionSource: number;
+    readonly SatelliteData: Windows.Devices.Geolocation.GeocoordinateSatelliteData;
+  }
+  var IGeocoordinateWithPositionData: abstract new (...args: any[]) => IGeocoordinateWithPositionData;
+
+  interface IGeocoordinateWithPositionSourceTimestamp {
+    readonly PositionSourceTimestamp: Windows.Foundation.DateTime | null;
+  }
+  var IGeocoordinateWithPositionSourceTimestamp: abstract new (...args: any[]) => IGeocoordinateWithPositionSourceTimestamp;
+
+  interface IGeocoordinateWithRemoteSource {
+    readonly IsRemoteSource: boolean;
+  }
+  var IGeocoordinateWithRemoteSource: abstract new (...args: any[]) => IGeocoordinateWithRemoteSource;
+
+  interface IGeolocator {
+    GetGeopositionAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Geolocation.Geoposition>;
+    GetGeopositionAsync(maximumAge: Windows.Foundation.TimeSpan, timeout: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Devices.Geolocation.Geoposition>;
+    DesiredAccuracy: number;
+    readonly LocationStatus: number;
+    MovementThreshold: number;
+    ReportInterval: number;
+    PositionChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Geolocation.Geolocator, Windows.Devices.Geolocation.PositionChangedEventArgs> | null;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Geolocation.Geolocator, Windows.Devices.Geolocation.StatusChangedEventArgs> | null;
+  }
+  var IGeolocator: abstract new (...args: any[]) => IGeolocator;
+
+  interface IGeolocator2 {
+    AllowFallbackToConsentlessPositions(): void;
+  }
+  var IGeolocator2: abstract new (...args: any[]) => IGeolocator2;
+
+  interface IGeolocatorStatics {
+    GetGeopositionHistoryAsync(startTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Geolocation.Geoposition> | Windows.Devices.Geolocation.Geoposition[]>;
+    GetGeopositionHistoryAsync(startTime: Windows.Foundation.DateTime, duration: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Geolocation.Geoposition> | Windows.Devices.Geolocation.Geoposition[]>;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IGeolocatorStatics: abstract new (...args: any[]) => IGeolocatorStatics;
+
+  interface IGeolocatorStatics2 {
+    DefaultGeoposition: Windows.Devices.Geolocation.BasicGeoposition | null;
+    readonly IsDefaultGeopositionRecommended: boolean;
+  }
+  var IGeolocatorStatics2: abstract new (...args: any[]) => IGeolocatorStatics2;
+
+  interface IGeolocatorWithScalarAccuracy extends Windows.Devices.Geolocation.IGeolocator {
+    GetGeopositionAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Geolocation.Geoposition>;
+    GetGeopositionAsync(maximumAge: Windows.Foundation.TimeSpan, timeout: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Devices.Geolocation.Geoposition>;
+    DesiredAccuracyInMeters: number | null;
+  }
+  var IGeolocatorWithScalarAccuracy: abstract new (...args: any[]) => IGeolocatorWithScalarAccuracy;
+
+  interface IGeopath extends Windows.Devices.Geolocation.IGeoshape {
+    readonly Positions: Windows.Foundation.Collections.IVectorView<Windows.Devices.Geolocation.BasicGeoposition> | Windows.Devices.Geolocation.BasicGeoposition[];
+  }
+  var IGeopath: abstract new (...args: any[]) => IGeopath;
+
+  interface IGeopathFactory {
+    Create(positions: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.BasicGeoposition> | Windows.Devices.Geolocation.BasicGeoposition[]): Windows.Devices.Geolocation.Geopath;
+    CreateWithAltitudeReference(positions: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.BasicGeoposition> | Windows.Devices.Geolocation.BasicGeoposition[], altitudeReferenceSystem: number): Windows.Devices.Geolocation.Geopath;
+    CreateWithAltitudeReferenceAndSpatialReference(positions: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.BasicGeoposition> | Windows.Devices.Geolocation.BasicGeoposition[], altitudeReferenceSystem: number, spatialReferenceId: number): Windows.Devices.Geolocation.Geopath;
+  }
+  var IGeopathFactory: abstract new (...args: any[]) => IGeopathFactory;
+
+  interface IGeopoint extends Windows.Devices.Geolocation.IGeoshape {
+    readonly Position: Windows.Devices.Geolocation.BasicGeoposition;
+  }
+  var IGeopoint: abstract new (...args: any[]) => IGeopoint;
+
+  interface IGeopointFactory {
+    Create(position: Windows.Devices.Geolocation.BasicGeoposition): Windows.Devices.Geolocation.Geopoint;
+    CreateWithAltitudeReferenceSystem(position: Windows.Devices.Geolocation.BasicGeoposition, altitudeReferenceSystem: number): Windows.Devices.Geolocation.Geopoint;
+    CreateWithAltitudeReferenceSystemAndSpatialReferenceId(position: Windows.Devices.Geolocation.BasicGeoposition, altitudeReferenceSystem: number, spatialReferenceId: number): Windows.Devices.Geolocation.Geopoint;
+  }
+  var IGeopointFactory: abstract new (...args: any[]) => IGeopointFactory;
+
+  interface IGeoposition {
+    readonly CivicAddress: Windows.Devices.Geolocation.CivicAddress;
+    readonly Coordinate: Windows.Devices.Geolocation.Geocoordinate;
+  }
+  var IGeoposition: abstract new (...args: any[]) => IGeoposition;
+
+  interface IGeoposition2 extends Windows.Devices.Geolocation.IGeoposition {
+    readonly VenueData: Windows.Devices.Geolocation.VenueData;
+  }
+  var IGeoposition2: abstract new (...args: any[]) => IGeoposition2;
+
+  interface IGeoshape {
+    readonly AltitudeReferenceSystem: number;
+    readonly GeoshapeType: number;
+    readonly SpatialReferenceId: number;
+  }
+  var IGeoshape: abstract new (...args: any[]) => IGeoshape;
+
+  interface IGeovisit {
+    readonly Position: Windows.Devices.Geolocation.Geoposition;
+    readonly StateChange: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IGeovisit: abstract new (...args: any[]) => IGeovisit;
+
+  interface IGeovisitMonitor {
+    Start(value: number): void;
+    Stop(): void;
+    readonly MonitoringScope: number;
+    VisitStateChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Geolocation.GeovisitMonitor, Windows.Devices.Geolocation.GeovisitStateChangedEventArgs> | null;
+  }
+  var IGeovisitMonitor: abstract new (...args: any[]) => IGeovisitMonitor;
+
+  interface IGeovisitMonitorStatics {
+    GetLastReportAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Geolocation.Geovisit>;
+  }
+  var IGeovisitMonitorStatics: abstract new (...args: any[]) => IGeovisitMonitorStatics;
+
+  interface IGeovisitStateChangedEventArgs {
+    readonly Visit: Windows.Devices.Geolocation.Geovisit;
+  }
+  var IGeovisitStateChangedEventArgs: abstract new (...args: any[]) => IGeovisitStateChangedEventArgs;
+
+  interface IGeovisitTriggerDetails {
+    ReadReports(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Geolocation.Geovisit> | Windows.Devices.Geolocation.Geovisit[];
+  }
+  var IGeovisitTriggerDetails: abstract new (...args: any[]) => IGeovisitTriggerDetails;
+
+  interface IPositionChangedEventArgs {
+    readonly Position: Windows.Devices.Geolocation.Geoposition;
+  }
+  var IPositionChangedEventArgs: abstract new (...args: any[]) => IPositionChangedEventArgs;
+
+  interface IStatusChangedEventArgs {
+    readonly Status: number;
+  }
+  var IStatusChangedEventArgs: abstract new (...args: any[]) => IStatusChangedEventArgs;
+
+  interface IVenueData {
+    readonly Id: string;
+    readonly Level: string;
+  }
+  var IVenueData: abstract new (...args: any[]) => IVenueData;
+
+}
+
+declare namespace Windows.Devices.Geolocation.Geofencing {
+  class Geofence implements Windows.Devices.Geolocation.Geofencing.IGeofence {
+    constructor(id: string, geoshape: Windows.Devices.Geolocation.IGeoshape);
+    constructor(id: string, geoshape: Windows.Devices.Geolocation.IGeoshape, monitoredStates: number, singleUse: boolean);
+    constructor(id: string, geoshape: Windows.Devices.Geolocation.IGeoshape, monitoredStates: number, singleUse: boolean, dwellTime: Windows.Foundation.TimeSpan);
+    constructor(id: string, geoshape: Windows.Devices.Geolocation.IGeoshape, monitoredStates: number, singleUse: boolean, dwellTime: Windows.Foundation.TimeSpan, startTime: Windows.Foundation.DateTime, duration: Windows.Foundation.TimeSpan);
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly DwellTime: Windows.Foundation.TimeSpan;
+    readonly Geoshape: Windows.Devices.Geolocation.IGeoshape;
+    readonly Id: string;
+    readonly MonitoredStates: number;
+    readonly SingleUse: boolean;
+    readonly StartTime: Windows.Foundation.DateTime;
+  }
+
+  class GeofenceMonitor implements Windows.Devices.Geolocation.Geofencing.IGeofenceMonitor {
+    ReadReports(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Geolocation.Geofencing.GeofenceStateChangeReport> | Windows.Devices.Geolocation.Geofencing.GeofenceStateChangeReport[];
+    static readonly Current: Windows.Devices.Geolocation.Geofencing.GeofenceMonitor;
+    readonly Geofences: Windows.Foundation.Collections.IVector<Windows.Devices.Geolocation.Geofencing.Geofence> | Windows.Devices.Geolocation.Geofencing.Geofence[];
+    readonly LastKnownGeoposition: Windows.Devices.Geolocation.Geoposition;
+    readonly Status: number;
+    GeofenceStateChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Geolocation.Geofencing.GeofenceMonitor, Object> | null;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Geolocation.Geofencing.GeofenceMonitor, Object> | null;
+  }
+
+  class GeofenceStateChangeReport implements Windows.Devices.Geolocation.Geofencing.IGeofenceStateChangeReport {
+    readonly Geofence: Windows.Devices.Geolocation.Geofencing.Geofence;
+    readonly Geoposition: Windows.Devices.Geolocation.Geoposition;
+    readonly NewState: number;
+    readonly RemovalReason: number;
+  }
+
+  enum GeofenceMonitorStatus {
+    Ready = 0,
+    Initializing = 1,
+    NoData = 2,
+    Disabled = 3,
+    NotInitialized = 4,
+    NotAvailable = 5,
+  }
+
+  enum GeofenceRemovalReason {
+    Used = 0,
+    Expired = 1,
+  }
+
+  enum GeofenceState {
+    None = 0,
+    Entered = 1,
+    Exited = 2,
+    Removed = 4,
+  }
+
+  enum MonitoredGeofenceStates {
+    None = 0,
+    Entered = 1,
+    Exited = 2,
+    Removed = 4,
+  }
+
+  interface IGeofence {
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly DwellTime: Windows.Foundation.TimeSpan;
+    readonly Geoshape: Windows.Devices.Geolocation.IGeoshape;
+    readonly Id: string;
+    readonly MonitoredStates: number;
+    readonly SingleUse: boolean;
+    readonly StartTime: Windows.Foundation.DateTime;
+  }
+  var IGeofence: abstract new (...args: any[]) => IGeofence;
+
+  interface IGeofenceFactory {
+    Create(id: string, geoshape: Windows.Devices.Geolocation.IGeoshape): Windows.Devices.Geolocation.Geofencing.Geofence;
+    CreateWithMonitorStates(id: string, geoshape: Windows.Devices.Geolocation.IGeoshape, monitoredStates: number, singleUse: boolean): Windows.Devices.Geolocation.Geofencing.Geofence;
+    CreateWithMonitorStatesAndDwellTime(id: string, geoshape: Windows.Devices.Geolocation.IGeoshape, monitoredStates: number, singleUse: boolean, dwellTime: Windows.Foundation.TimeSpan): Windows.Devices.Geolocation.Geofencing.Geofence;
+    CreateWithMonitorStatesDwellTimeStartTimeAndDuration(id: string, geoshape: Windows.Devices.Geolocation.IGeoshape, monitoredStates: number, singleUse: boolean, dwellTime: Windows.Foundation.TimeSpan, startTime: Windows.Foundation.DateTime, duration: Windows.Foundation.TimeSpan): Windows.Devices.Geolocation.Geofencing.Geofence;
+  }
+  var IGeofenceFactory: abstract new (...args: any[]) => IGeofenceFactory;
+
+  interface IGeofenceMonitor {
+    ReadReports(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Geolocation.Geofencing.GeofenceStateChangeReport> | Windows.Devices.Geolocation.Geofencing.GeofenceStateChangeReport[];
+    readonly Geofences: Windows.Foundation.Collections.IVector<Windows.Devices.Geolocation.Geofencing.Geofence> | Windows.Devices.Geolocation.Geofencing.Geofence[];
+    readonly LastKnownGeoposition: Windows.Devices.Geolocation.Geoposition;
+    readonly Status: number;
+    GeofenceStateChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Geolocation.Geofencing.GeofenceMonitor, Object> | null;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Geolocation.Geofencing.GeofenceMonitor, Object> | null;
+  }
+  var IGeofenceMonitor: abstract new (...args: any[]) => IGeofenceMonitor;
+
+  interface IGeofenceMonitorStatics {
+    readonly Current: Windows.Devices.Geolocation.Geofencing.GeofenceMonitor;
+  }
+  var IGeofenceMonitorStatics: abstract new (...args: any[]) => IGeofenceMonitorStatics;
+
+  interface IGeofenceStateChangeReport {
+    readonly Geofence: Windows.Devices.Geolocation.Geofencing.Geofence;
+    readonly Geoposition: Windows.Devices.Geolocation.Geoposition;
+    readonly NewState: number;
+    readonly RemovalReason: number;
+  }
+  var IGeofenceStateChangeReport: abstract new (...args: any[]) => IGeofenceStateChangeReport;
+
+}
+
+declare namespace Windows.Devices.Geolocation.Provider {
+  class GeolocationProvider implements Windows.Devices.Geolocation.Provider.IGeolocationProvider {
+    constructor();
+    ClearOverridePosition(): void;
+    SetOverridePosition(newPosition: Windows.Devices.Geolocation.BasicGeoposition, positionSource: number, accuracyInMeters: number): number;
+    readonly IsOverridden: boolean;
+    IsOverriddenChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  enum LocationOverrideStatus {
+    Success = 0,
+    AccessDenied = 1,
+    AlreadyStarted = 2,
+    Other = 3,
+  }
+
+  interface IGeolocationProvider {
+    ClearOverridePosition(): void;
+    SetOverridePosition(newPosition: Windows.Devices.Geolocation.BasicGeoposition, positionSource: number, accuracyInMeters: number): number;
+    readonly IsOverridden: boolean;
+    IsOverriddenChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IGeolocationProvider: abstract new (...args: any[]) => IGeolocationProvider;
+
+}
+
+declare namespace Windows.Devices.Gpio {
+  class GpioChangeCounter implements Windows.Devices.Gpio.IGpioChangeCounter, Windows.Foundation.IClosable {
+    constructor(pin: Windows.Devices.Gpio.GpioPin);
+    Close(): void;
+    Read(): Windows.Devices.Gpio.GpioChangeCount;
+    Reset(): Windows.Devices.Gpio.GpioChangeCount;
+    Start(): void;
+    Stop(): void;
+    readonly IsStarted: boolean;
+    Polarity: number;
+  }
+
+  class GpioChangeReader implements Windows.Devices.Gpio.IGpioChangeReader, Windows.Foundation.IClosable {
+    constructor(pin: Windows.Devices.Gpio.GpioPin);
+    constructor(pin: Windows.Devices.Gpio.GpioPin, minCapacity: number);
+    Clear(): void;
+    Close(): void;
+    GetAllItems(): Windows.Foundation.Collections.IVector<Windows.Devices.Gpio.GpioChangeRecord> | Windows.Devices.Gpio.GpioChangeRecord[];
+    GetNextItem(): Windows.Devices.Gpio.GpioChangeRecord;
+    PeekNextItem(): Windows.Devices.Gpio.GpioChangeRecord;
+    Start(): void;
+    Stop(): void;
+    WaitForItemsAsync(count: number): Windows.Foundation.IAsyncAction;
+    readonly Capacity: number;
+    readonly IsEmpty: boolean;
+    readonly IsOverflowed: boolean;
+    readonly IsStarted: boolean;
+    readonly Length: number;
+    Polarity: number;
+  }
+
+  class GpioController implements Windows.Devices.Gpio.IGpioController {
+    static GetControllersAsync(provider: Windows.Devices.Gpio.Provider.IGpioProvider): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Gpio.GpioController> | Windows.Devices.Gpio.GpioController[]>;
+    static GetDefault(): Windows.Devices.Gpio.GpioController;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Gpio.GpioController>;
+    OpenPin(pinNumber: number): Windows.Devices.Gpio.GpioPin;
+    OpenPin(pinNumber: number, sharingMode: number): Windows.Devices.Gpio.GpioPin;
+    TryOpenPin(pinNumber: number, sharingMode: number, pin: Windows.Devices.Gpio.GpioPin, openStatus: number): boolean;
+    readonly PinCount: number;
+  }
+
+  class GpioPin implements Windows.Devices.Gpio.IGpioPin, Windows.Foundation.IClosable {
+    Close(): void;
+    GetDriveMode(): number;
+    IsDriveModeSupported(driveMode: number): boolean;
+    Read(): number;
+    SetDriveMode(value: number): void;
+    Write(value: number): void;
+    DebounceTimeout: Windows.Foundation.TimeSpan;
+    readonly PinNumber: number;
+    readonly SharingMode: number;
+    ValueChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Gpio.GpioPin, Windows.Devices.Gpio.GpioPinValueChangedEventArgs> | null;
+  }
+
+  class GpioPinValueChangedEventArgs implements Windows.Devices.Gpio.IGpioPinValueChangedEventArgs {
+    readonly Edge: number;
+  }
+
+  enum GpioChangePolarity {
+    Falling = 0,
+    Rising = 1,
+    Both = 2,
+  }
+
+  enum GpioOpenStatus {
+    PinOpened = 0,
+    PinUnavailable = 1,
+    SharingViolation = 2,
+    MuxingConflict = 3,
+    UnknownError = 4,
+  }
+
+  enum GpioPinDriveMode {
+    Input = 0,
+    Output = 1,
+    InputPullUp = 2,
+    InputPullDown = 3,
+    OutputOpenDrain = 4,
+    OutputOpenDrainPullUp = 5,
+    OutputOpenSource = 6,
+    OutputOpenSourcePullDown = 7,
+  }
+
+  enum GpioPinEdge {
+    FallingEdge = 0,
+    RisingEdge = 1,
+  }
+
+  enum GpioPinValue {
+    Low = 0,
+    High = 1,
+  }
+
+  enum GpioSharingMode {
+    Exclusive = 0,
+    SharedReadOnly = 1,
+  }
+
+  interface GpioChangeCount {
+    Count: number | bigint;
+    RelativeTime: Windows.Foundation.TimeSpan;
+  }
+  var GpioChangeCount: {
+    new(count: number | bigint, relativeTime: Windows.Foundation.TimeSpan): GpioChangeCount;
+    new(fields: { Count?: number | bigint; RelativeTime?: Windows.Foundation.TimeSpan }): GpioChangeCount;
+  };
+
+  interface GpioChangeRecord {
+    RelativeTime: Windows.Foundation.TimeSpan;
+    Edge: number;
+  }
+  var GpioChangeRecord: {
+    new(relativeTime: Windows.Foundation.TimeSpan, edge: number): GpioChangeRecord;
+    new(fields: { RelativeTime?: Windows.Foundation.TimeSpan; Edge?: number }): GpioChangeRecord;
+  };
+
+  interface IGpioChangeCounter extends Windows.Foundation.IClosable {
+    Close(): void;
+    Read(): Windows.Devices.Gpio.GpioChangeCount;
+    Reset(): Windows.Devices.Gpio.GpioChangeCount;
+    Start(): void;
+    Stop(): void;
+    readonly IsStarted: boolean;
+    Polarity: number;
+  }
+  var IGpioChangeCounter: abstract new (...args: any[]) => IGpioChangeCounter;
+
+  interface IGpioChangeCounterFactory {
+    Create(pin: Windows.Devices.Gpio.GpioPin): Windows.Devices.Gpio.GpioChangeCounter;
+  }
+  var IGpioChangeCounterFactory: abstract new (...args: any[]) => IGpioChangeCounterFactory;
+
+  interface IGpioChangeReader extends Windows.Foundation.IClosable {
+    Clear(): void;
+    Close(): void;
+    GetAllItems(): Windows.Foundation.Collections.IVector<Windows.Devices.Gpio.GpioChangeRecord> | Windows.Devices.Gpio.GpioChangeRecord[];
+    GetNextItem(): Windows.Devices.Gpio.GpioChangeRecord;
+    PeekNextItem(): Windows.Devices.Gpio.GpioChangeRecord;
+    Start(): void;
+    Stop(): void;
+    WaitForItemsAsync(count: number): Windows.Foundation.IAsyncAction;
+    readonly Capacity: number;
+    readonly IsEmpty: boolean;
+    readonly IsOverflowed: boolean;
+    readonly IsStarted: boolean;
+    readonly Length: number;
+    Polarity: number;
+  }
+  var IGpioChangeReader: abstract new (...args: any[]) => IGpioChangeReader;
+
+  interface IGpioChangeReaderFactory {
+    Create(pin: Windows.Devices.Gpio.GpioPin): Windows.Devices.Gpio.GpioChangeReader;
+    CreateWithCapacity(pin: Windows.Devices.Gpio.GpioPin, minCapacity: number): Windows.Devices.Gpio.GpioChangeReader;
+  }
+  var IGpioChangeReaderFactory: abstract new (...args: any[]) => IGpioChangeReaderFactory;
+
+  interface IGpioController {
+    OpenPin(pinNumber: number): Windows.Devices.Gpio.GpioPin;
+    OpenPin(pinNumber: number, sharingMode: number): Windows.Devices.Gpio.GpioPin;
+    TryOpenPin(pinNumber: number, sharingMode: number, pin: Windows.Devices.Gpio.GpioPin, openStatus: number): boolean;
+    readonly PinCount: number;
+  }
+  var IGpioController: abstract new (...args: any[]) => IGpioController;
+
+  interface IGpioControllerStatics {
+    GetDefault(): Windows.Devices.Gpio.GpioController;
+  }
+  var IGpioControllerStatics: abstract new (...args: any[]) => IGpioControllerStatics;
+
+  interface IGpioControllerStatics2 {
+    GetControllersAsync(provider: Windows.Devices.Gpio.Provider.IGpioProvider): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Gpio.GpioController> | Windows.Devices.Gpio.GpioController[]>;
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Gpio.GpioController>;
+  }
+  var IGpioControllerStatics2: abstract new (...args: any[]) => IGpioControllerStatics2;
+
+  interface IGpioPin extends Windows.Foundation.IClosable {
+    Close(): void;
+    GetDriveMode(): number;
+    IsDriveModeSupported(driveMode: number): boolean;
+    Read(): number;
+    SetDriveMode(value: number): void;
+    Write(value: number): void;
+    DebounceTimeout: Windows.Foundation.TimeSpan;
+    readonly PinNumber: number;
+    readonly SharingMode: number;
+    ValueChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Gpio.GpioPin, Windows.Devices.Gpio.GpioPinValueChangedEventArgs> | null;
+  }
+  var IGpioPin: abstract new (...args: any[]) => IGpioPin;
+
+  interface IGpioPinValueChangedEventArgs {
+    readonly Edge: number;
+  }
+  var IGpioPinValueChangedEventArgs: abstract new (...args: any[]) => IGpioPinValueChangedEventArgs;
+
+}
+
+declare namespace Windows.Devices.Gpio.Provider {
+  class GpioPinProviderValueChangedEventArgs implements Windows.Devices.Gpio.Provider.IGpioPinProviderValueChangedEventArgs {
+    constructor(edge: number);
+    readonly Edge: number;
+  }
+
+  enum ProviderGpioPinDriveMode {
+    Input = 0,
+    Output = 1,
+    InputPullUp = 2,
+    InputPullDown = 3,
+    OutputOpenDrain = 4,
+    OutputOpenDrainPullUp = 5,
+    OutputOpenSource = 6,
+    OutputOpenSourcePullDown = 7,
+  }
+
+  enum ProviderGpioPinEdge {
+    FallingEdge = 0,
+    RisingEdge = 1,
+  }
+
+  enum ProviderGpioPinValue {
+    Low = 0,
+    High = 1,
+  }
+
+  enum ProviderGpioSharingMode {
+    Exclusive = 0,
+    SharedReadOnly = 1,
+  }
+
+  interface IGpioControllerProvider {
+    OpenPinProvider(pin: number, sharingMode: number): Windows.Devices.Gpio.Provider.IGpioPinProvider;
+    readonly PinCount: number;
+  }
+  var IGpioControllerProvider: abstract new (...args: any[]) => IGpioControllerProvider;
+
+  interface IGpioPinProvider {
+    GetDriveMode(): number;
+    IsDriveModeSupported(driveMode: number): boolean;
+    Read(): number;
+    SetDriveMode(value: number): void;
+    Write(value: number): void;
+    DebounceTimeout: Windows.Foundation.TimeSpan;
+    readonly PinNumber: number;
+    readonly SharingMode: number;
+    ValueChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Gpio.Provider.IGpioPinProvider, Windows.Devices.Gpio.Provider.GpioPinProviderValueChangedEventArgs> | null;
+  }
+  var IGpioPinProvider: abstract new (...args: any[]) => IGpioPinProvider;
+
+  interface IGpioPinProviderValueChangedEventArgs {
+    readonly Edge: number;
+  }
+  var IGpioPinProviderValueChangedEventArgs: abstract new (...args: any[]) => IGpioPinProviderValueChangedEventArgs;
+
+  interface IGpioPinProviderValueChangedEventArgsFactory {
+    Create(edge: number): Windows.Devices.Gpio.Provider.GpioPinProviderValueChangedEventArgs;
+  }
+  var IGpioPinProviderValueChangedEventArgsFactory: abstract new (...args: any[]) => IGpioPinProviderValueChangedEventArgsFactory;
+
+  interface IGpioProvider {
+    GetControllers(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Gpio.Provider.IGpioControllerProvider> | Windows.Devices.Gpio.Provider.IGpioControllerProvider[];
+  }
+  var IGpioProvider: abstract new (...args: any[]) => IGpioProvider;
+
+}
+
+declare namespace Windows.Devices.Haptics {
+  class KnownSimpleHapticsControllerWaveforms {
+    static readonly BrushContinuous: number;
+    static readonly BuzzContinuous: number;
+    static readonly ChiselMarkerContinuous: number;
+    static readonly Click: number;
+    static readonly EraserContinuous: number;
+    static readonly Error: number;
+    static readonly GalaxyPenContinuous: number;
+    static readonly Hover: number;
+    static readonly InkContinuous: number;
+    static readonly MarkerContinuous: number;
+    static readonly PencilContinuous: number;
+    static readonly Press: number;
+    static readonly Release: number;
+    static readonly RumbleContinuous: number;
+    static readonly Success: number;
+  }
+
+  class SimpleHapticsController implements Windows.Devices.Haptics.ISimpleHapticsController {
+    SendHapticFeedback(feedback: Windows.Devices.Haptics.SimpleHapticsControllerFeedback): void;
+    SendHapticFeedback(feedback: Windows.Devices.Haptics.SimpleHapticsControllerFeedback, intensity: number): void;
+    SendHapticFeedbackForDuration(feedback: Windows.Devices.Haptics.SimpleHapticsControllerFeedback, intensity: number, playDuration: Windows.Foundation.TimeSpan): void;
+    SendHapticFeedbackForPlayCount(feedback: Windows.Devices.Haptics.SimpleHapticsControllerFeedback, intensity: number, playCount: number, replayPauseInterval: Windows.Foundation.TimeSpan): void;
+    StopFeedback(): void;
+    readonly Id: string;
+    readonly IsIntensitySupported: boolean;
+    readonly IsPlayCountSupported: boolean;
+    readonly IsPlayDurationSupported: boolean;
+    readonly IsReplayPauseIntervalSupported: boolean;
+    readonly SupportedFeedback: Windows.Foundation.Collections.IVectorView<Windows.Devices.Haptics.SimpleHapticsControllerFeedback> | Windows.Devices.Haptics.SimpleHapticsControllerFeedback[];
+  }
+
+  class SimpleHapticsControllerFeedback implements Windows.Devices.Haptics.ISimpleHapticsControllerFeedback {
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly Waveform: number;
+  }
+
+  class VibrationDevice implements Windows.Devices.Haptics.IVibrationDevice {
+    static FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Haptics.VibrationDevice> | Windows.Devices.Haptics.VibrationDevice[]>;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Haptics.VibrationDevice>;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Haptics.VibrationDevice>;
+    static GetDeviceSelector(): string;
+    static RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly Id: string;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+
+  enum VibrationAccessStatus {
+    Allowed = 0,
+    DeniedByUser = 1,
+    DeniedBySystem = 2,
+    DeniedByEnergySaver = 3,
+  }
+
+  interface IKnownSimpleHapticsControllerWaveformsStatics {
+    readonly BuzzContinuous: number;
+    readonly Click: number;
+    readonly Press: number;
+    readonly Release: number;
+    readonly RumbleContinuous: number;
+  }
+  var IKnownSimpleHapticsControllerWaveformsStatics: abstract new (...args: any[]) => IKnownSimpleHapticsControllerWaveformsStatics;
+
+  interface IKnownSimpleHapticsControllerWaveformsStatics2 {
+    readonly BrushContinuous: number;
+    readonly ChiselMarkerContinuous: number;
+    readonly EraserContinuous: number;
+    readonly Error: number;
+    readonly GalaxyPenContinuous: number;
+    readonly Hover: number;
+    readonly InkContinuous: number;
+    readonly MarkerContinuous: number;
+    readonly PencilContinuous: number;
+    readonly Success: number;
+  }
+  var IKnownSimpleHapticsControllerWaveformsStatics2: abstract new (...args: any[]) => IKnownSimpleHapticsControllerWaveformsStatics2;
+
+  interface ISimpleHapticsController {
+    SendHapticFeedback(feedback: Windows.Devices.Haptics.SimpleHapticsControllerFeedback): void;
+    SendHapticFeedback(feedback: Windows.Devices.Haptics.SimpleHapticsControllerFeedback, intensity: number): void;
+    SendHapticFeedbackForDuration(feedback: Windows.Devices.Haptics.SimpleHapticsControllerFeedback, intensity: number, playDuration: Windows.Foundation.TimeSpan): void;
+    SendHapticFeedbackForPlayCount(feedback: Windows.Devices.Haptics.SimpleHapticsControllerFeedback, intensity: number, playCount: number, replayPauseInterval: Windows.Foundation.TimeSpan): void;
+    StopFeedback(): void;
+    readonly Id: string;
+    readonly IsIntensitySupported: boolean;
+    readonly IsPlayCountSupported: boolean;
+    readonly IsPlayDurationSupported: boolean;
+    readonly IsReplayPauseIntervalSupported: boolean;
+    readonly SupportedFeedback: Windows.Foundation.Collections.IVectorView<Windows.Devices.Haptics.SimpleHapticsControllerFeedback> | Windows.Devices.Haptics.SimpleHapticsControllerFeedback[];
+  }
+  var ISimpleHapticsController: abstract new (...args: any[]) => ISimpleHapticsController;
+
+  interface ISimpleHapticsControllerFeedback {
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly Waveform: number;
+  }
+  var ISimpleHapticsControllerFeedback: abstract new (...args: any[]) => ISimpleHapticsControllerFeedback;
+
+  interface IVibrationDevice {
+    readonly Id: string;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+  var IVibrationDevice: abstract new (...args: any[]) => IVibrationDevice;
+
+  interface IVibrationDeviceStatics {
+    FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Haptics.VibrationDevice> | Windows.Devices.Haptics.VibrationDevice[]>;
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Haptics.VibrationDevice>;
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Haptics.VibrationDevice>;
+    GetDeviceSelector(): string;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IVibrationDeviceStatics: abstract new (...args: any[]) => IVibrationDeviceStatics;
+
+}
+
+declare namespace Windows.Devices.HumanInterfaceDevice {
+  class HidBooleanControl implements Windows.Devices.HumanInterfaceDevice.IHidBooleanControl {
+    readonly ControlDescription: Windows.Devices.HumanInterfaceDevice.HidBooleanControlDescription;
+    readonly Id: number;
+    IsActive: boolean;
+    readonly UsageId: number;
+    readonly UsagePage: number;
+  }
+
+  class HidBooleanControlDescription implements Windows.Devices.HumanInterfaceDevice.IHidBooleanControlDescription, Windows.Devices.HumanInterfaceDevice.IHidBooleanControlDescription2 {
+    readonly Id: number;
+    readonly IsAbsolute: boolean;
+    readonly ParentCollections: Windows.Foundation.Collections.IVectorView<Windows.Devices.HumanInterfaceDevice.HidCollection> | Windows.Devices.HumanInterfaceDevice.HidCollection[];
+    readonly ReportId: number;
+    readonly ReportType: number;
+    readonly UsageId: number;
+    readonly UsagePage: number;
+  }
+
+  class HidCollection implements Windows.Devices.HumanInterfaceDevice.IHidCollection {
+    readonly Id: number;
+    readonly Type: number;
+    readonly UsageId: number;
+    readonly UsagePage: number;
+  }
+
+  class HidDevice implements Windows.Devices.HumanInterfaceDevice.IHidDevice, Windows.Foundation.IClosable {
+    Close(): void;
+    CreateFeatureReport(): Windows.Devices.HumanInterfaceDevice.HidFeatureReport;
+    CreateFeatureReport(reportId: number): Windows.Devices.HumanInterfaceDevice.HidFeatureReport;
+    CreateOutputReport(): Windows.Devices.HumanInterfaceDevice.HidOutputReport;
+    CreateOutputReport(reportId: number): Windows.Devices.HumanInterfaceDevice.HidOutputReport;
+    static FromIdAsync(deviceId: string, accessMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.HumanInterfaceDevice.HidDevice>;
+    GetBooleanControlDescriptions(reportType: number, usagePage: number, usageId: number): Windows.Foundation.Collections.IVectorView<Windows.Devices.HumanInterfaceDevice.HidBooleanControlDescription> | Windows.Devices.HumanInterfaceDevice.HidBooleanControlDescription[];
+    static GetDeviceSelector(usagePage: number, usageId: number): string;
+    static GetDeviceSelector(usagePage: number, usageId: number, vendorId: number, productId: number): string;
+    GetFeatureReportAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.HumanInterfaceDevice.HidFeatureReport>;
+    GetFeatureReportAsync(reportId: number): Windows.Foundation.IAsyncOperation<Windows.Devices.HumanInterfaceDevice.HidFeatureReport>;
+    GetInputReportAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.HumanInterfaceDevice.HidInputReport>;
+    GetInputReportAsync(reportId: number): Windows.Foundation.IAsyncOperation<Windows.Devices.HumanInterfaceDevice.HidInputReport>;
+    GetNumericControlDescriptions(reportType: number, usagePage: number, usageId: number): Windows.Foundation.Collections.IVectorView<Windows.Devices.HumanInterfaceDevice.HidNumericControlDescription> | Windows.Devices.HumanInterfaceDevice.HidNumericControlDescription[];
+    SendFeatureReportAsync(featureReport: Windows.Devices.HumanInterfaceDevice.HidFeatureReport): Windows.Foundation.IAsyncOperation<number>;
+    SendOutputReportAsync(outputReport: Windows.Devices.HumanInterfaceDevice.HidOutputReport): Windows.Foundation.IAsyncOperation<number>;
+    readonly ProductId: number;
+    readonly UsageId: number;
+    readonly UsagePage: number;
+    readonly VendorId: number;
+    readonly Version: number;
+    InputReportReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.HumanInterfaceDevice.HidDevice, Windows.Devices.HumanInterfaceDevice.HidInputReportReceivedEventArgs> | null;
+  }
+
+  class HidFeatureReport implements Windows.Devices.HumanInterfaceDevice.IHidFeatureReport {
+    GetBooleanControl(usagePage: number, usageId: number): Windows.Devices.HumanInterfaceDevice.HidBooleanControl;
+    GetBooleanControlByDescription(controlDescription: Windows.Devices.HumanInterfaceDevice.HidBooleanControlDescription): Windows.Devices.HumanInterfaceDevice.HidBooleanControl;
+    GetNumericControl(usagePage: number, usageId: number): Windows.Devices.HumanInterfaceDevice.HidNumericControl;
+    GetNumericControlByDescription(controlDescription: Windows.Devices.HumanInterfaceDevice.HidNumericControlDescription): Windows.Devices.HumanInterfaceDevice.HidNumericControl;
+    Data: Windows.Storage.Streams.IBuffer;
+    readonly Id: number;
+  }
+
+  class HidInputReport implements Windows.Devices.HumanInterfaceDevice.IHidInputReport {
+    GetBooleanControl(usagePage: number, usageId: number): Windows.Devices.HumanInterfaceDevice.HidBooleanControl;
+    GetBooleanControlByDescription(controlDescription: Windows.Devices.HumanInterfaceDevice.HidBooleanControlDescription): Windows.Devices.HumanInterfaceDevice.HidBooleanControl;
+    GetNumericControl(usagePage: number, usageId: number): Windows.Devices.HumanInterfaceDevice.HidNumericControl;
+    GetNumericControlByDescription(controlDescription: Windows.Devices.HumanInterfaceDevice.HidNumericControlDescription): Windows.Devices.HumanInterfaceDevice.HidNumericControl;
+    readonly ActivatedBooleanControls: Windows.Foundation.Collections.IVectorView<Windows.Devices.HumanInterfaceDevice.HidBooleanControl> | Windows.Devices.HumanInterfaceDevice.HidBooleanControl[];
+    readonly Data: Windows.Storage.Streams.IBuffer;
+    readonly Id: number;
+    readonly TransitionedBooleanControls: Windows.Foundation.Collections.IVectorView<Windows.Devices.HumanInterfaceDevice.HidBooleanControl> | Windows.Devices.HumanInterfaceDevice.HidBooleanControl[];
+  }
+
+  class HidInputReportReceivedEventArgs implements Windows.Devices.HumanInterfaceDevice.IHidInputReportReceivedEventArgs {
+    readonly Report: Windows.Devices.HumanInterfaceDevice.HidInputReport;
+  }
+
+  class HidNumericControl implements Windows.Devices.HumanInterfaceDevice.IHidNumericControl {
+    readonly ControlDescription: Windows.Devices.HumanInterfaceDevice.HidNumericControlDescription;
+    readonly Id: number;
+    readonly IsGrouped: boolean;
+    ScaledValue: number | bigint;
+    readonly UsageId: number;
+    readonly UsagePage: number;
+    Value: number | bigint;
+  }
+
+  class HidNumericControlDescription implements Windows.Devices.HumanInterfaceDevice.IHidNumericControlDescription {
+    readonly HasNull: boolean;
+    readonly Id: number;
+    readonly IsAbsolute: boolean;
+    readonly LogicalMaximum: number;
+    readonly LogicalMinimum: number;
+    readonly ParentCollections: Windows.Foundation.Collections.IVectorView<Windows.Devices.HumanInterfaceDevice.HidCollection> | Windows.Devices.HumanInterfaceDevice.HidCollection[];
+    readonly PhysicalMaximum: number;
+    readonly PhysicalMinimum: number;
+    readonly ReportCount: number;
+    readonly ReportId: number;
+    readonly ReportSize: number;
+    readonly ReportType: number;
+    readonly Unit: number;
+    readonly UnitExponent: number;
+    readonly UsageId: number;
+    readonly UsagePage: number;
+  }
+
+  class HidOutputReport implements Windows.Devices.HumanInterfaceDevice.IHidOutputReport {
+    GetBooleanControl(usagePage: number, usageId: number): Windows.Devices.HumanInterfaceDevice.HidBooleanControl;
+    GetBooleanControlByDescription(controlDescription: Windows.Devices.HumanInterfaceDevice.HidBooleanControlDescription): Windows.Devices.HumanInterfaceDevice.HidBooleanControl;
+    GetNumericControl(usagePage: number, usageId: number): Windows.Devices.HumanInterfaceDevice.HidNumericControl;
+    GetNumericControlByDescription(controlDescription: Windows.Devices.HumanInterfaceDevice.HidNumericControlDescription): Windows.Devices.HumanInterfaceDevice.HidNumericControl;
+    Data: Windows.Storage.Streams.IBuffer;
+    readonly Id: number;
+  }
+
+  enum HidCollectionType {
+    Physical = 0,
+    Application = 1,
+    Logical = 2,
+    Report = 3,
+    NamedArray = 4,
+    UsageSwitch = 5,
+    UsageModifier = 6,
+    Other = 7,
+  }
+
+  enum HidReportType {
+    Input = 0,
+    Output = 1,
+    Feature = 2,
+  }
+
+  interface IHidBooleanControl {
+    readonly ControlDescription: Windows.Devices.HumanInterfaceDevice.HidBooleanControlDescription;
+    readonly Id: number;
+    IsActive: boolean;
+    readonly UsageId: number;
+    readonly UsagePage: number;
+  }
+  var IHidBooleanControl: abstract new (...args: any[]) => IHidBooleanControl;
+
+  interface IHidBooleanControlDescription {
+    readonly Id: number;
+    readonly ParentCollections: Windows.Foundation.Collections.IVectorView<Windows.Devices.HumanInterfaceDevice.HidCollection> | Windows.Devices.HumanInterfaceDevice.HidCollection[];
+    readonly ReportId: number;
+    readonly ReportType: number;
+    readonly UsageId: number;
+    readonly UsagePage: number;
+  }
+  var IHidBooleanControlDescription: abstract new (...args: any[]) => IHidBooleanControlDescription;
+
+  interface IHidBooleanControlDescription2 {
+    readonly IsAbsolute: boolean;
+  }
+  var IHidBooleanControlDescription2: abstract new (...args: any[]) => IHidBooleanControlDescription2;
+
+  interface IHidCollection {
+    readonly Id: number;
+    readonly Type: number;
+    readonly UsageId: number;
+    readonly UsagePage: number;
+  }
+  var IHidCollection: abstract new (...args: any[]) => IHidCollection;
+
+  interface IHidDevice extends Windows.Foundation.IClosable {
+    Close(): void;
+    CreateFeatureReport(): Windows.Devices.HumanInterfaceDevice.HidFeatureReport;
+    CreateFeatureReport(reportId: number): Windows.Devices.HumanInterfaceDevice.HidFeatureReport;
+    CreateOutputReport(): Windows.Devices.HumanInterfaceDevice.HidOutputReport;
+    CreateOutputReport(reportId: number): Windows.Devices.HumanInterfaceDevice.HidOutputReport;
+    GetBooleanControlDescriptions(reportType: number, usagePage: number, usageId: number): Windows.Foundation.Collections.IVectorView<Windows.Devices.HumanInterfaceDevice.HidBooleanControlDescription> | Windows.Devices.HumanInterfaceDevice.HidBooleanControlDescription[];
+    GetFeatureReportAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.HumanInterfaceDevice.HidFeatureReport>;
+    GetFeatureReportAsync(reportId: number): Windows.Foundation.IAsyncOperation<Windows.Devices.HumanInterfaceDevice.HidFeatureReport>;
+    GetInputReportAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.HumanInterfaceDevice.HidInputReport>;
+    GetInputReportAsync(reportId: number): Windows.Foundation.IAsyncOperation<Windows.Devices.HumanInterfaceDevice.HidInputReport>;
+    GetNumericControlDescriptions(reportType: number, usagePage: number, usageId: number): Windows.Foundation.Collections.IVectorView<Windows.Devices.HumanInterfaceDevice.HidNumericControlDescription> | Windows.Devices.HumanInterfaceDevice.HidNumericControlDescription[];
+    SendFeatureReportAsync(featureReport: Windows.Devices.HumanInterfaceDevice.HidFeatureReport): Windows.Foundation.IAsyncOperation<number>;
+    SendOutputReportAsync(outputReport: Windows.Devices.HumanInterfaceDevice.HidOutputReport): Windows.Foundation.IAsyncOperation<number>;
+    readonly ProductId: number;
+    readonly UsageId: number;
+    readonly UsagePage: number;
+    readonly VendorId: number;
+    readonly Version: number;
+    InputReportReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.HumanInterfaceDevice.HidDevice, Windows.Devices.HumanInterfaceDevice.HidInputReportReceivedEventArgs> | null;
+  }
+  var IHidDevice: abstract new (...args: any[]) => IHidDevice;
+
+  interface IHidDeviceStatics {
+    FromIdAsync(deviceId: string, accessMode: number): Windows.Foundation.IAsyncOperation<Windows.Devices.HumanInterfaceDevice.HidDevice>;
+    GetDeviceSelector(usagePage: number, usageId: number): string;
+    GetDeviceSelector(usagePage: number, usageId: number, vendorId: number, productId: number): string;
+  }
+  var IHidDeviceStatics: abstract new (...args: any[]) => IHidDeviceStatics;
+
+  interface IHidFeatureReport {
+    GetBooleanControl(usagePage: number, usageId: number): Windows.Devices.HumanInterfaceDevice.HidBooleanControl;
+    GetBooleanControlByDescription(controlDescription: Windows.Devices.HumanInterfaceDevice.HidBooleanControlDescription): Windows.Devices.HumanInterfaceDevice.HidBooleanControl;
+    GetNumericControl(usagePage: number, usageId: number): Windows.Devices.HumanInterfaceDevice.HidNumericControl;
+    GetNumericControlByDescription(controlDescription: Windows.Devices.HumanInterfaceDevice.HidNumericControlDescription): Windows.Devices.HumanInterfaceDevice.HidNumericControl;
+    Data: Windows.Storage.Streams.IBuffer;
+    readonly Id: number;
+  }
+  var IHidFeatureReport: abstract new (...args: any[]) => IHidFeatureReport;
+
+  interface IHidInputReport {
+    GetBooleanControl(usagePage: number, usageId: number): Windows.Devices.HumanInterfaceDevice.HidBooleanControl;
+    GetBooleanControlByDescription(controlDescription: Windows.Devices.HumanInterfaceDevice.HidBooleanControlDescription): Windows.Devices.HumanInterfaceDevice.HidBooleanControl;
+    GetNumericControl(usagePage: number, usageId: number): Windows.Devices.HumanInterfaceDevice.HidNumericControl;
+    GetNumericControlByDescription(controlDescription: Windows.Devices.HumanInterfaceDevice.HidNumericControlDescription): Windows.Devices.HumanInterfaceDevice.HidNumericControl;
+    readonly ActivatedBooleanControls: Windows.Foundation.Collections.IVectorView<Windows.Devices.HumanInterfaceDevice.HidBooleanControl> | Windows.Devices.HumanInterfaceDevice.HidBooleanControl[];
+    readonly Data: Windows.Storage.Streams.IBuffer;
+    readonly Id: number;
+    readonly TransitionedBooleanControls: Windows.Foundation.Collections.IVectorView<Windows.Devices.HumanInterfaceDevice.HidBooleanControl> | Windows.Devices.HumanInterfaceDevice.HidBooleanControl[];
+  }
+  var IHidInputReport: abstract new (...args: any[]) => IHidInputReport;
+
+  interface IHidInputReportReceivedEventArgs {
+    readonly Report: Windows.Devices.HumanInterfaceDevice.HidInputReport;
+  }
+  var IHidInputReportReceivedEventArgs: abstract new (...args: any[]) => IHidInputReportReceivedEventArgs;
+
+  interface IHidNumericControl {
+    readonly ControlDescription: Windows.Devices.HumanInterfaceDevice.HidNumericControlDescription;
+    readonly Id: number;
+    readonly IsGrouped: boolean;
+    ScaledValue: number | bigint;
+    readonly UsageId: number;
+    readonly UsagePage: number;
+    Value: number | bigint;
+  }
+  var IHidNumericControl: abstract new (...args: any[]) => IHidNumericControl;
+
+  interface IHidNumericControlDescription {
+    readonly HasNull: boolean;
+    readonly Id: number;
+    readonly IsAbsolute: boolean;
+    readonly LogicalMaximum: number;
+    readonly LogicalMinimum: number;
+    readonly ParentCollections: Windows.Foundation.Collections.IVectorView<Windows.Devices.HumanInterfaceDevice.HidCollection> | Windows.Devices.HumanInterfaceDevice.HidCollection[];
+    readonly PhysicalMaximum: number;
+    readonly PhysicalMinimum: number;
+    readonly ReportCount: number;
+    readonly ReportId: number;
+    readonly ReportSize: number;
+    readonly ReportType: number;
+    readonly Unit: number;
+    readonly UnitExponent: number;
+    readonly UsageId: number;
+    readonly UsagePage: number;
+  }
+  var IHidNumericControlDescription: abstract new (...args: any[]) => IHidNumericControlDescription;
+
+  interface IHidOutputReport {
+    GetBooleanControl(usagePage: number, usageId: number): Windows.Devices.HumanInterfaceDevice.HidBooleanControl;
+    GetBooleanControlByDescription(controlDescription: Windows.Devices.HumanInterfaceDevice.HidBooleanControlDescription): Windows.Devices.HumanInterfaceDevice.HidBooleanControl;
+    GetNumericControl(usagePage: number, usageId: number): Windows.Devices.HumanInterfaceDevice.HidNumericControl;
+    GetNumericControlByDescription(controlDescription: Windows.Devices.HumanInterfaceDevice.HidNumericControlDescription): Windows.Devices.HumanInterfaceDevice.HidNumericControl;
+    Data: Windows.Storage.Streams.IBuffer;
+    readonly Id: number;
+  }
+  var IHidOutputReport: abstract new (...args: any[]) => IHidOutputReport;
+
+}
+
+declare namespace Windows.Devices.I2c {
+  class I2cConnectionSettings implements Windows.Devices.I2c.II2cConnectionSettings {
+    constructor(slaveAddress: number);
+    BusSpeed: number;
+    SharingMode: number;
+    SlaveAddress: number;
+  }
+
+  class I2cController implements Windows.Devices.I2c.II2cController {
+    static GetControllersAsync(provider: Windows.Devices.I2c.Provider.II2cProvider): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.I2c.I2cController> | Windows.Devices.I2c.I2cController[]>;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.I2c.I2cController>;
+    GetDevice(settings: Windows.Devices.I2c.I2cConnectionSettings): Windows.Devices.I2c.I2cDevice;
+  }
+
+  class I2cDevice implements Windows.Devices.I2c.II2cDevice, Windows.Foundation.IClosable {
+    Close(): void;
+    static FromIdAsync(deviceId: string, settings: Windows.Devices.I2c.I2cConnectionSettings): Windows.Foundation.IAsyncOperation<Windows.Devices.I2c.I2cDevice>;
+    static GetDeviceSelector(): string;
+    static GetDeviceSelector(friendlyName: string): string;
+    Read(buffer: number[]): void;
+    ReadPartial(buffer: number[]): Windows.Devices.I2c.I2cTransferResult;
+    Write(buffer: number[]): void;
+    WritePartial(buffer: number[]): Windows.Devices.I2c.I2cTransferResult;
+    WriteRead(writeBuffer: number[], readBuffer: number[]): void;
+    WriteReadPartial(writeBuffer: number[], readBuffer: number[]): Windows.Devices.I2c.I2cTransferResult;
+    readonly ConnectionSettings: Windows.Devices.I2c.I2cConnectionSettings;
+    readonly DeviceId: string;
+  }
+
+  enum I2cBusSpeed {
+    StandardMode = 0,
+    FastMode = 1,
+  }
+
+  enum I2cSharingMode {
+    Exclusive = 0,
+    Shared = 1,
+  }
+
+  enum I2cTransferStatus {
+    FullTransfer = 0,
+    PartialTransfer = 1,
+    SlaveAddressNotAcknowledged = 2,
+    ClockStretchTimeout = 3,
+    UnknownError = 4,
+  }
+
+  interface I2cTransferResult {
+    Status: number;
+    BytesTransferred: number;
+  }
+  var I2cTransferResult: {
+    new(status: number, bytesTransferred: number): I2cTransferResult;
+    new(fields: { Status?: number; BytesTransferred?: number }): I2cTransferResult;
+  };
+
+  interface II2cConnectionSettings {
+    BusSpeed: number;
+    SharingMode: number;
+    SlaveAddress: number;
+  }
+  var II2cConnectionSettings: abstract new (...args: any[]) => II2cConnectionSettings;
+
+  interface II2cConnectionSettingsFactory {
+    Create(slaveAddress: number): Windows.Devices.I2c.I2cConnectionSettings;
+  }
+  var II2cConnectionSettingsFactory: abstract new (...args: any[]) => II2cConnectionSettingsFactory;
+
+  interface II2cController {
+    GetDevice(settings: Windows.Devices.I2c.I2cConnectionSettings): Windows.Devices.I2c.I2cDevice;
+  }
+  var II2cController: abstract new (...args: any[]) => II2cController;
+
+  interface II2cControllerStatics {
+    GetControllersAsync(provider: Windows.Devices.I2c.Provider.II2cProvider): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.I2c.I2cController> | Windows.Devices.I2c.I2cController[]>;
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.I2c.I2cController>;
+  }
+  var II2cControllerStatics: abstract new (...args: any[]) => II2cControllerStatics;
+
+  interface II2cDevice extends Windows.Foundation.IClosable {
+    Close(): void;
+    Read(buffer: number[]): void;
+    ReadPartial(buffer: number[]): Windows.Devices.I2c.I2cTransferResult;
+    Write(buffer: number[]): void;
+    WritePartial(buffer: number[]): Windows.Devices.I2c.I2cTransferResult;
+    WriteRead(writeBuffer: number[], readBuffer: number[]): void;
+    WriteReadPartial(writeBuffer: number[], readBuffer: number[]): Windows.Devices.I2c.I2cTransferResult;
+    readonly ConnectionSettings: Windows.Devices.I2c.I2cConnectionSettings;
+    readonly DeviceId: string;
+  }
+  var II2cDevice: abstract new (...args: any[]) => II2cDevice;
+
+  interface II2cDeviceStatics {
+    FromIdAsync(deviceId: string, settings: Windows.Devices.I2c.I2cConnectionSettings): Windows.Foundation.IAsyncOperation<Windows.Devices.I2c.I2cDevice>;
+    GetDeviceSelector(): string;
+    GetDeviceSelector(friendlyName: string): string;
+  }
+  var II2cDeviceStatics: abstract new (...args: any[]) => II2cDeviceStatics;
+
+}
+
+declare namespace Windows.Devices.I2c.Provider {
+  class ProviderI2cConnectionSettings implements Windows.Devices.I2c.Provider.IProviderI2cConnectionSettings {
+    BusSpeed: number;
+    SharingMode: number;
+    SlaveAddress: number;
+  }
+
+  enum ProviderI2cBusSpeed {
+    StandardMode = 0,
+    FastMode = 1,
+  }
+
+  enum ProviderI2cSharingMode {
+    Exclusive = 0,
+    Shared = 1,
+  }
+
+  enum ProviderI2cTransferStatus {
+    FullTransfer = 0,
+    PartialTransfer = 1,
+    SlaveAddressNotAcknowledged = 2,
+  }
+
+  interface II2cControllerProvider {
+    GetDeviceProvider(settings: Windows.Devices.I2c.Provider.ProviderI2cConnectionSettings): Windows.Devices.I2c.Provider.II2cDeviceProvider;
+  }
+  var II2cControllerProvider: abstract new (...args: any[]) => II2cControllerProvider;
+
+  interface II2cDeviceProvider extends Windows.Foundation.IClosable {
+    Close(): void;
+    Read(buffer: number[]): void;
+    ReadPartial(buffer: number[]): Windows.Devices.I2c.Provider.ProviderI2cTransferResult;
+    Write(buffer: number[]): void;
+    WritePartial(buffer: number[]): Windows.Devices.I2c.Provider.ProviderI2cTransferResult;
+    WriteRead(writeBuffer: number[], readBuffer: number[]): void;
+    WriteReadPartial(writeBuffer: number[], readBuffer: number[]): Windows.Devices.I2c.Provider.ProviderI2cTransferResult;
+    readonly DeviceId: string;
+  }
+  var II2cDeviceProvider: abstract new (...args: any[]) => II2cDeviceProvider;
+
+  interface II2cProvider {
+    GetControllersAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.I2c.Provider.II2cControllerProvider> | Windows.Devices.I2c.Provider.II2cControllerProvider[]>;
+  }
+  var II2cProvider: abstract new (...args: any[]) => II2cProvider;
+
+  interface IProviderI2cConnectionSettings {
+    BusSpeed: number;
+    SharingMode: number;
+    SlaveAddress: number;
+  }
+  var IProviderI2cConnectionSettings: abstract new (...args: any[]) => IProviderI2cConnectionSettings;
+
+  interface ProviderI2cTransferResult {
+    Status: number;
+    BytesTransferred: number;
+  }
+  var ProviderI2cTransferResult: {
+    new(status: number, bytesTransferred: number): ProviderI2cTransferResult;
+    new(fields: { Status?: number; BytesTransferred?: number }): ProviderI2cTransferResult;
+  };
+
+}
+
+declare namespace Windows.Devices.Input {
+  class KeyboardCapabilities implements Windows.Devices.Input.IKeyboardCapabilities {
+    constructor();
+    readonly KeyboardPresent: number;
+  }
+
+  class MouseCapabilities implements Windows.Devices.Input.IMouseCapabilities {
+    constructor();
+    readonly HorizontalWheelPresent: number;
+    readonly MousePresent: number;
+    readonly NumberOfButtons: number;
+    readonly SwapButtons: number;
+    readonly VerticalWheelPresent: number;
+  }
+
+  class MouseDevice implements Windows.Devices.Input.IMouseDevice {
+    static GetForCurrentView(): Windows.Devices.Input.MouseDevice;
+    MouseMoved: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.MouseDevice, Windows.Devices.Input.MouseEventArgs> | null;
+  }
+
+  class MouseEventArgs implements Windows.Devices.Input.IMouseEventArgs {
+    readonly MouseDelta: Windows.Devices.Input.MouseDelta;
+  }
+
+  class PenButtonListener implements Windows.Devices.Input.IPenButtonListener {
+    static GetDefault(): Windows.Devices.Input.PenButtonListener;
+    IsSupported(): boolean;
+    IsSupportedChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.PenButtonListener, Object> | null;
+    TailButtonClicked: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.PenButtonListener, Windows.Devices.Input.PenTailButtonClickedEventArgs> | null;
+    TailButtonDoubleClicked: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.PenButtonListener, Windows.Devices.Input.PenTailButtonDoubleClickedEventArgs> | null;
+    TailButtonLongPressed: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.PenButtonListener, Windows.Devices.Input.PenTailButtonLongPressedEventArgs> | null;
+  }
+
+  class PenDevice implements Windows.Devices.Input.IPenDevice, Windows.Devices.Input.IPenDevice2 {
+    static GetFromPointerId(pointerId: number): Windows.Devices.Input.PenDevice;
+    readonly PenId: Guid;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+
+  class PenDockListener implements Windows.Devices.Input.IPenDockListener {
+    static GetDefault(): Windows.Devices.Input.PenDockListener;
+    IsSupported(): boolean;
+    Docked: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.PenDockListener, Windows.Devices.Input.PenDockedEventArgs> | null;
+    IsSupportedChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.PenDockListener, Object> | null;
+    Undocked: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.PenDockListener, Windows.Devices.Input.PenUndockedEventArgs> | null;
+  }
+
+  class PenDockedEventArgs implements Windows.Devices.Input.IPenDockedEventArgs {
+  }
+
+  class PenTailButtonClickedEventArgs implements Windows.Devices.Input.IPenTailButtonClickedEventArgs {
+  }
+
+  class PenTailButtonDoubleClickedEventArgs implements Windows.Devices.Input.IPenTailButtonDoubleClickedEventArgs {
+  }
+
+  class PenTailButtonLongPressedEventArgs implements Windows.Devices.Input.IPenTailButtonLongPressedEventArgs {
+  }
+
+  class PenUndockedEventArgs implements Windows.Devices.Input.IPenUndockedEventArgs {
+  }
+
+  class PointerDevice implements Windows.Devices.Input.IPointerDevice, Windows.Devices.Input.IPointerDevice2 {
+    static GetPointerDevice(pointerId: number): Windows.Devices.Input.PointerDevice;
+    static GetPointerDevices(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Input.PointerDevice> | Windows.Devices.Input.PointerDevice[];
+    readonly IsIntegrated: boolean;
+    readonly MaxContacts: number;
+    readonly MaxPointersWithZDistance: number;
+    readonly PhysicalDeviceRect: Windows.Foundation.Rect;
+    readonly PointerDeviceType: number;
+    readonly ScreenRect: Windows.Foundation.Rect;
+    readonly SupportedUsages: Windows.Foundation.Collections.IVectorView<Windows.Devices.Input.PointerDeviceUsage> | Windows.Devices.Input.PointerDeviceUsage[];
+  }
+
+  class TouchCapabilities implements Windows.Devices.Input.ITouchCapabilities {
+    constructor();
+    readonly Contacts: number;
+    readonly TouchPresent: number;
+  }
+
+  enum PointerDeviceType {
+    Touch = 0,
+    Pen = 1,
+    Mouse = 2,
+    Touchpad = 3,
+  }
+
+  interface IKeyboardCapabilities {
+    readonly KeyboardPresent: number;
+  }
+  var IKeyboardCapabilities: abstract new (...args: any[]) => IKeyboardCapabilities;
+
+  interface IMouseCapabilities {
+    readonly HorizontalWheelPresent: number;
+    readonly MousePresent: number;
+    readonly NumberOfButtons: number;
+    readonly SwapButtons: number;
+    readonly VerticalWheelPresent: number;
+  }
+  var IMouseCapabilities: abstract new (...args: any[]) => IMouseCapabilities;
+
+  interface IMouseDevice {
+    MouseMoved: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.MouseDevice, Windows.Devices.Input.MouseEventArgs> | null;
+  }
+  var IMouseDevice: abstract new (...args: any[]) => IMouseDevice;
+
+  interface IMouseDeviceStatics {
+    GetForCurrentView(): Windows.Devices.Input.MouseDevice;
+  }
+  var IMouseDeviceStatics: abstract new (...args: any[]) => IMouseDeviceStatics;
+
+  interface IMouseEventArgs {
+    readonly MouseDelta: Windows.Devices.Input.MouseDelta;
+  }
+  var IMouseEventArgs: abstract new (...args: any[]) => IMouseEventArgs;
+
+  interface IPenButtonListener {
+    IsSupported(): boolean;
+    IsSupportedChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.PenButtonListener, Object> | null;
+    TailButtonClicked: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.PenButtonListener, Windows.Devices.Input.PenTailButtonClickedEventArgs> | null;
+    TailButtonDoubleClicked: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.PenButtonListener, Windows.Devices.Input.PenTailButtonDoubleClickedEventArgs> | null;
+    TailButtonLongPressed: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.PenButtonListener, Windows.Devices.Input.PenTailButtonLongPressedEventArgs> | null;
+  }
+  var IPenButtonListener: abstract new (...args: any[]) => IPenButtonListener;
+
+  interface IPenButtonListenerStatics {
+    GetDefault(): Windows.Devices.Input.PenButtonListener;
+  }
+  var IPenButtonListenerStatics: abstract new (...args: any[]) => IPenButtonListenerStatics;
+
+  interface IPenDevice {
+    readonly PenId: Guid;
+  }
+  var IPenDevice: abstract new (...args: any[]) => IPenDevice;
+
+  interface IPenDevice2 {
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+  var IPenDevice2: abstract new (...args: any[]) => IPenDevice2;
+
+  interface IPenDeviceStatics {
+    GetFromPointerId(pointerId: number): Windows.Devices.Input.PenDevice;
+  }
+  var IPenDeviceStatics: abstract new (...args: any[]) => IPenDeviceStatics;
+
+  interface IPenDockListener {
+    IsSupported(): boolean;
+    Docked: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.PenDockListener, Windows.Devices.Input.PenDockedEventArgs> | null;
+    IsSupportedChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.PenDockListener, Object> | null;
+    Undocked: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.PenDockListener, Windows.Devices.Input.PenUndockedEventArgs> | null;
+  }
+  var IPenDockListener: abstract new (...args: any[]) => IPenDockListener;
+
+  interface IPenDockListenerStatics {
+    GetDefault(): Windows.Devices.Input.PenDockListener;
+  }
+  var IPenDockListenerStatics: abstract new (...args: any[]) => IPenDockListenerStatics;
+
+  interface IPenDockedEventArgs {
+  }
+  var IPenDockedEventArgs: abstract new (...args: any[]) => IPenDockedEventArgs;
+
+  interface IPenTailButtonClickedEventArgs {
+  }
+  var IPenTailButtonClickedEventArgs: abstract new (...args: any[]) => IPenTailButtonClickedEventArgs;
+
+  interface IPenTailButtonDoubleClickedEventArgs {
+  }
+  var IPenTailButtonDoubleClickedEventArgs: abstract new (...args: any[]) => IPenTailButtonDoubleClickedEventArgs;
+
+  interface IPenTailButtonLongPressedEventArgs {
+  }
+  var IPenTailButtonLongPressedEventArgs: abstract new (...args: any[]) => IPenTailButtonLongPressedEventArgs;
+
+  interface IPenUndockedEventArgs {
+  }
+  var IPenUndockedEventArgs: abstract new (...args: any[]) => IPenUndockedEventArgs;
+
+  interface IPointerDevice {
+    readonly IsIntegrated: boolean;
+    readonly MaxContacts: number;
+    readonly PhysicalDeviceRect: Windows.Foundation.Rect;
+    readonly PointerDeviceType: number;
+    readonly ScreenRect: Windows.Foundation.Rect;
+    readonly SupportedUsages: Windows.Foundation.Collections.IVectorView<Windows.Devices.Input.PointerDeviceUsage> | Windows.Devices.Input.PointerDeviceUsage[];
+  }
+  var IPointerDevice: abstract new (...args: any[]) => IPointerDevice;
+
+  interface IPointerDevice2 {
+    readonly MaxPointersWithZDistance: number;
+  }
+  var IPointerDevice2: abstract new (...args: any[]) => IPointerDevice2;
+
+  interface IPointerDeviceStatics {
+    GetPointerDevice(pointerId: number): Windows.Devices.Input.PointerDevice;
+    GetPointerDevices(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Input.PointerDevice> | Windows.Devices.Input.PointerDevice[];
+  }
+  var IPointerDeviceStatics: abstract new (...args: any[]) => IPointerDeviceStatics;
+
+  interface ITouchCapabilities {
+    readonly Contacts: number;
+    readonly TouchPresent: number;
+  }
+  var ITouchCapabilities: abstract new (...args: any[]) => ITouchCapabilities;
+
+  interface MouseDelta {
+    X: number;
+    Y: number;
+  }
+  var MouseDelta: {
+    new(x: number, y: number): MouseDelta;
+    new(fields: { X?: number; Y?: number }): MouseDelta;
+  };
+
+  interface PointerDeviceUsage {
+    UsagePage: number;
+    Usage: number;
+    MinLogical: number;
+    MaxLogical: number;
+    MinPhysical: number;
+    MaxPhysical: number;
+    Unit: number;
+    PhysicalMultiplier: number;
+  }
+  var PointerDeviceUsage: {
+    new(usagePage: number, usage: number, minLogical: number, maxLogical: number, minPhysical: number, maxPhysical: number, unit: number, physicalMultiplier: number): PointerDeviceUsage;
+    new(fields: { UsagePage?: number; Usage?: number; MinLogical?: number; MaxLogical?: number; MinPhysical?: number; MaxPhysical?: number; Unit?: number; PhysicalMultiplier?: number }): PointerDeviceUsage;
+  };
+
+}
+
+declare namespace Windows.Devices.Input.Preview {
+  class GazeDevicePreview implements Windows.Devices.Input.Preview.IGazeDevicePreview {
+    GetBooleanControlDescriptions(usagePage: number, usageId: number): Windows.Foundation.Collections.IVectorView<Windows.Devices.HumanInterfaceDevice.HidBooleanControlDescription> | Windows.Devices.HumanInterfaceDevice.HidBooleanControlDescription[];
+    GetNumericControlDescriptions(usagePage: number, usageId: number): Windows.Foundation.Collections.IVectorView<Windows.Devices.HumanInterfaceDevice.HidNumericControlDescription> | Windows.Devices.HumanInterfaceDevice.HidNumericControlDescription[];
+    RequestCalibrationAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly CanTrackEyes: boolean;
+    readonly CanTrackHead: boolean;
+    readonly ConfigurationState: number;
+    readonly Id: number;
+  }
+
+  class GazeDeviceWatcherAddedPreviewEventArgs implements Windows.Devices.Input.Preview.IGazeDeviceWatcherAddedPreviewEventArgs {
+    readonly Device: Windows.Devices.Input.Preview.GazeDevicePreview;
+  }
+
+  class GazeDeviceWatcherPreview implements Windows.Devices.Input.Preview.IGazeDeviceWatcherPreview {
+    Start(): void;
+    Stop(): void;
+    Added: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.Preview.GazeDeviceWatcherPreview, Windows.Devices.Input.Preview.GazeDeviceWatcherAddedPreviewEventArgs> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.Preview.GazeDeviceWatcherPreview, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.Preview.GazeDeviceWatcherPreview, Windows.Devices.Input.Preview.GazeDeviceWatcherRemovedPreviewEventArgs> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.Preview.GazeDeviceWatcherPreview, Windows.Devices.Input.Preview.GazeDeviceWatcherUpdatedPreviewEventArgs> | null;
+  }
+
+  class GazeDeviceWatcherRemovedPreviewEventArgs implements Windows.Devices.Input.Preview.IGazeDeviceWatcherRemovedPreviewEventArgs {
+    readonly Device: Windows.Devices.Input.Preview.GazeDevicePreview;
+  }
+
+  class GazeDeviceWatcherUpdatedPreviewEventArgs implements Windows.Devices.Input.Preview.IGazeDeviceWatcherUpdatedPreviewEventArgs {
+    readonly Device: Windows.Devices.Input.Preview.GazeDevicePreview;
+  }
+
+  class GazeEnteredPreviewEventArgs implements Windows.Devices.Input.Preview.IGazeEnteredPreviewEventArgs {
+    readonly CurrentPoint: Windows.Devices.Input.Preview.GazePointPreview;
+    Handled: boolean;
+  }
+
+  class GazeExitedPreviewEventArgs implements Windows.Devices.Input.Preview.IGazeExitedPreviewEventArgs {
+    readonly CurrentPoint: Windows.Devices.Input.Preview.GazePointPreview;
+    Handled: boolean;
+  }
+
+  class GazeInputSourcePreview implements Windows.Devices.Input.Preview.IGazeInputSourcePreview {
+    static CreateWatcher(): Windows.Devices.Input.Preview.GazeDeviceWatcherPreview;
+    static GetForCurrentView(): Windows.Devices.Input.Preview.GazeInputSourcePreview;
+    GazeEntered: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.Preview.GazeInputSourcePreview, Windows.Devices.Input.Preview.GazeEnteredPreviewEventArgs> | null;
+    GazeExited: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.Preview.GazeInputSourcePreview, Windows.Devices.Input.Preview.GazeExitedPreviewEventArgs> | null;
+    GazeMoved: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.Preview.GazeInputSourcePreview, Windows.Devices.Input.Preview.GazeMovedPreviewEventArgs> | null;
+  }
+
+  class GazeMovedPreviewEventArgs implements Windows.Devices.Input.Preview.IGazeMovedPreviewEventArgs {
+    GetIntermediatePoints(): Windows.Foundation.Collections.IVector<Windows.Devices.Input.Preview.GazePointPreview> | Windows.Devices.Input.Preview.GazePointPreview[];
+    readonly CurrentPoint: Windows.Devices.Input.Preview.GazePointPreview;
+    Handled: boolean;
+  }
+
+  class GazePointPreview implements Windows.Devices.Input.Preview.IGazePointPreview {
+    readonly EyeGazePosition: Windows.Foundation.Point | null;
+    readonly HeadGazePosition: Windows.Foundation.Point | null;
+    readonly HidInputReport: Windows.Devices.HumanInterfaceDevice.HidInputReport;
+    readonly SourceDevice: Windows.Devices.Input.Preview.GazeDevicePreview;
+    readonly Timestamp: number | bigint;
+  }
+
+  enum GazeDeviceConfigurationStatePreview {
+    Unknown = 0,
+    Ready = 1,
+    Configuring = 2,
+    ScreenSetupNeeded = 3,
+    UserCalibrationNeeded = 4,
+  }
+
+  interface IGazeDevicePreview {
+    GetBooleanControlDescriptions(usagePage: number, usageId: number): Windows.Foundation.Collections.IVectorView<Windows.Devices.HumanInterfaceDevice.HidBooleanControlDescription> | Windows.Devices.HumanInterfaceDevice.HidBooleanControlDescription[];
+    GetNumericControlDescriptions(usagePage: number, usageId: number): Windows.Foundation.Collections.IVectorView<Windows.Devices.HumanInterfaceDevice.HidNumericControlDescription> | Windows.Devices.HumanInterfaceDevice.HidNumericControlDescription[];
+    RequestCalibrationAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly CanTrackEyes: boolean;
+    readonly CanTrackHead: boolean;
+    readonly ConfigurationState: number;
+    readonly Id: number;
+  }
+  var IGazeDevicePreview: abstract new (...args: any[]) => IGazeDevicePreview;
+
+  interface IGazeDeviceWatcherAddedPreviewEventArgs {
+    readonly Device: Windows.Devices.Input.Preview.GazeDevicePreview;
+  }
+  var IGazeDeviceWatcherAddedPreviewEventArgs: abstract new (...args: any[]) => IGazeDeviceWatcherAddedPreviewEventArgs;
+
+  interface IGazeDeviceWatcherPreview {
+    Start(): void;
+    Stop(): void;
+    Added: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.Preview.GazeDeviceWatcherPreview, Windows.Devices.Input.Preview.GazeDeviceWatcherAddedPreviewEventArgs> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.Preview.GazeDeviceWatcherPreview, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.Preview.GazeDeviceWatcherPreview, Windows.Devices.Input.Preview.GazeDeviceWatcherRemovedPreviewEventArgs> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.Preview.GazeDeviceWatcherPreview, Windows.Devices.Input.Preview.GazeDeviceWatcherUpdatedPreviewEventArgs> | null;
+  }
+  var IGazeDeviceWatcherPreview: abstract new (...args: any[]) => IGazeDeviceWatcherPreview;
+
+  interface IGazeDeviceWatcherRemovedPreviewEventArgs {
+    readonly Device: Windows.Devices.Input.Preview.GazeDevicePreview;
+  }
+  var IGazeDeviceWatcherRemovedPreviewEventArgs: abstract new (...args: any[]) => IGazeDeviceWatcherRemovedPreviewEventArgs;
+
+  interface IGazeDeviceWatcherUpdatedPreviewEventArgs {
+    readonly Device: Windows.Devices.Input.Preview.GazeDevicePreview;
+  }
+  var IGazeDeviceWatcherUpdatedPreviewEventArgs: abstract new (...args: any[]) => IGazeDeviceWatcherUpdatedPreviewEventArgs;
+
+  interface IGazeEnteredPreviewEventArgs {
+    readonly CurrentPoint: Windows.Devices.Input.Preview.GazePointPreview;
+    Handled: boolean;
+  }
+  var IGazeEnteredPreviewEventArgs: abstract new (...args: any[]) => IGazeEnteredPreviewEventArgs;
+
+  interface IGazeExitedPreviewEventArgs {
+    readonly CurrentPoint: Windows.Devices.Input.Preview.GazePointPreview;
+    Handled: boolean;
+  }
+  var IGazeExitedPreviewEventArgs: abstract new (...args: any[]) => IGazeExitedPreviewEventArgs;
+
+  interface IGazeInputSourcePreview {
+    GazeEntered: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.Preview.GazeInputSourcePreview, Windows.Devices.Input.Preview.GazeEnteredPreviewEventArgs> | null;
+    GazeExited: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.Preview.GazeInputSourcePreview, Windows.Devices.Input.Preview.GazeExitedPreviewEventArgs> | null;
+    GazeMoved: Windows.Foundation.TypedEventHandler<Windows.Devices.Input.Preview.GazeInputSourcePreview, Windows.Devices.Input.Preview.GazeMovedPreviewEventArgs> | null;
+  }
+  var IGazeInputSourcePreview: abstract new (...args: any[]) => IGazeInputSourcePreview;
+
+  interface IGazeInputSourcePreviewStatics {
+    CreateWatcher(): Windows.Devices.Input.Preview.GazeDeviceWatcherPreview;
+    GetForCurrentView(): Windows.Devices.Input.Preview.GazeInputSourcePreview;
+  }
+  var IGazeInputSourcePreviewStatics: abstract new (...args: any[]) => IGazeInputSourcePreviewStatics;
+
+  interface IGazeMovedPreviewEventArgs {
+    GetIntermediatePoints(): Windows.Foundation.Collections.IVector<Windows.Devices.Input.Preview.GazePointPreview> | Windows.Devices.Input.Preview.GazePointPreview[];
+    readonly CurrentPoint: Windows.Devices.Input.Preview.GazePointPreview;
+    Handled: boolean;
+  }
+  var IGazeMovedPreviewEventArgs: abstract new (...args: any[]) => IGazeMovedPreviewEventArgs;
+
+  interface IGazePointPreview {
+    readonly EyeGazePosition: Windows.Foundation.Point | null;
+    readonly HeadGazePosition: Windows.Foundation.Point | null;
+    readonly HidInputReport: Windows.Devices.HumanInterfaceDevice.HidInputReport;
+    readonly SourceDevice: Windows.Devices.Input.Preview.GazeDevicePreview;
+    readonly Timestamp: number | bigint;
+  }
+  var IGazePointPreview: abstract new (...args: any[]) => IGazePointPreview;
+
+}
+
+declare namespace Windows.Devices.Lights {
+  class Lamp implements Windows.Devices.Lights.ILamp, Windows.Foundation.IClosable {
+    Close(): void;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Lights.Lamp>;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Lights.Lamp>;
+    static GetDeviceSelector(): string;
+    BrightnessLevel: number;
+    Color: Windows.UI.Color;
+    readonly DeviceId: string;
+    readonly IsColorSettable: boolean;
+    IsEnabled: boolean;
+    AvailabilityChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Lights.Lamp, Windows.Devices.Lights.LampAvailabilityChangedEventArgs> | null;
+  }
+
+  class LampArray implements Windows.Devices.Lights.ILampArray, Windows.Devices.Lights.ILampArray2 {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Lights.LampArray>;
+    static GetDeviceSelector(): string;
+    GetIndicesForKey(key: number): number[];
+    GetIndicesForPurposes(purposes: number): number[];
+    GetLampInfo(lampIndex: number): Windows.Devices.Lights.LampInfo;
+    RequestMessageAsync(messageId: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    SendMessageAsync(messageId: number, message: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncAction;
+    SetColor(desiredColor: Windows.UI.Color): void;
+    SetColorForIndex(lampIndex: number, desiredColor: Windows.UI.Color): void;
+    SetColorsForIndices(desiredColors: Windows.UI.Color[], lampIndexes: number[]): void;
+    SetColorsForKey(desiredColor: Windows.UI.Color, key: number): void;
+    SetColorsForKeys(desiredColors: Windows.UI.Color[], keys: number[]): void;
+    SetColorsForPurposes(desiredColor: Windows.UI.Color, purposes: number): void;
+    SetSingleColorForIndices(desiredColor: Windows.UI.Color, lampIndexes: number[]): void;
+    readonly BoundingBox: Windows.Foundation.Numerics.Vector3;
+    BrightnessLevel: number;
+    readonly DeviceId: string;
+    readonly HardwareProductId: number;
+    readonly HardwareVendorId: number;
+    readonly HardwareVersion: number;
+    readonly IsAvailable: boolean;
+    readonly IsConnected: boolean;
+    IsEnabled: boolean;
+    readonly LampArrayKind: number;
+    readonly LampCount: number;
+    readonly MinUpdateInterval: Windows.Foundation.TimeSpan;
+    readonly SupportsVirtualKeys: boolean;
+    AvailabilityChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Lights.LampArray, Object> | null;
+  }
+
+  class LampAvailabilityChangedEventArgs implements Windows.Devices.Lights.ILampAvailabilityChangedEventArgs {
+    readonly IsAvailable: boolean;
+  }
+
+  class LampInfo implements Windows.Devices.Lights.ILampInfo {
+    GetNearestSupportedColor(desiredColor: Windows.UI.Color): Windows.UI.Color;
+    readonly BlueLevelCount: number;
+    readonly FixedColor: Windows.UI.Color | null;
+    readonly GainLevelCount: number;
+    readonly GreenLevelCount: number;
+    readonly Index: number;
+    readonly Position: Windows.Foundation.Numerics.Vector3;
+    readonly Purposes: number;
+    readonly RedLevelCount: number;
+    readonly UpdateLatency: Windows.Foundation.TimeSpan;
+  }
+
+  enum LampArrayKind {
+    Undefined = 0,
+    Keyboard = 1,
+    Mouse = 2,
+    GameController = 3,
+    Peripheral = 4,
+    Scene = 5,
+    Notification = 6,
+    Chassis = 7,
+    Wearable = 8,
+    Furniture = 9,
+    Art = 10,
+    Headset = 11,
+    Microphone = 12,
+    Speaker = 13,
+  }
+
+  enum LampPurposes {
+    Undefined = 0,
+    Control = 1,
+    Accent = 2,
+    Branding = 4,
+    Status = 8,
+    Illumination = 16,
+    Presentation = 32,
+  }
+
+  interface ILamp extends Windows.Foundation.IClosable {
+    Close(): void;
+    BrightnessLevel: number;
+    Color: Windows.UI.Color;
+    readonly DeviceId: string;
+    readonly IsColorSettable: boolean;
+    IsEnabled: boolean;
+    AvailabilityChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Lights.Lamp, Windows.Devices.Lights.LampAvailabilityChangedEventArgs> | null;
+  }
+  var ILamp: abstract new (...args: any[]) => ILamp;
+
+  interface ILampArray {
+    GetIndicesForKey(key: number): number[];
+    GetIndicesForPurposes(purposes: number): number[];
+    GetLampInfo(lampIndex: number): Windows.Devices.Lights.LampInfo;
+    RequestMessageAsync(messageId: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    SendMessageAsync(messageId: number, message: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncAction;
+    SetColor(desiredColor: Windows.UI.Color): void;
+    SetColorForIndex(lampIndex: number, desiredColor: Windows.UI.Color): void;
+    SetColorsForIndices(desiredColors: Windows.UI.Color[], lampIndexes: number[]): void;
+    SetColorsForKey(desiredColor: Windows.UI.Color, key: number): void;
+    SetColorsForKeys(desiredColors: Windows.UI.Color[], keys: number[]): void;
+    SetColorsForPurposes(desiredColor: Windows.UI.Color, purposes: number): void;
+    SetSingleColorForIndices(desiredColor: Windows.UI.Color, lampIndexes: number[]): void;
+    readonly BoundingBox: Windows.Foundation.Numerics.Vector3;
+    BrightnessLevel: number;
+    readonly DeviceId: string;
+    readonly HardwareProductId: number;
+    readonly HardwareVendorId: number;
+    readonly HardwareVersion: number;
+    readonly IsConnected: boolean;
+    IsEnabled: boolean;
+    readonly LampArrayKind: number;
+    readonly LampCount: number;
+    readonly MinUpdateInterval: Windows.Foundation.TimeSpan;
+    readonly SupportsVirtualKeys: boolean;
+  }
+  var ILampArray: abstract new (...args: any[]) => ILampArray;
+
+  interface ILampArray2 {
+    readonly IsAvailable: boolean;
+    AvailabilityChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Lights.LampArray, Object> | null;
+  }
+  var ILampArray2: abstract new (...args: any[]) => ILampArray2;
+
+  interface ILampArrayStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Lights.LampArray>;
+    GetDeviceSelector(): string;
+  }
+  var ILampArrayStatics: abstract new (...args: any[]) => ILampArrayStatics;
+
+  interface ILampAvailabilityChangedEventArgs {
+    readonly IsAvailable: boolean;
+  }
+  var ILampAvailabilityChangedEventArgs: abstract new (...args: any[]) => ILampAvailabilityChangedEventArgs;
+
+  interface ILampInfo {
+    GetNearestSupportedColor(desiredColor: Windows.UI.Color): Windows.UI.Color;
+    readonly BlueLevelCount: number;
+    readonly FixedColor: Windows.UI.Color | null;
+    readonly GainLevelCount: number;
+    readonly GreenLevelCount: number;
+    readonly Index: number;
+    readonly Position: Windows.Foundation.Numerics.Vector3;
+    readonly Purposes: number;
+    readonly RedLevelCount: number;
+    readonly UpdateLatency: Windows.Foundation.TimeSpan;
+  }
+  var ILampInfo: abstract new (...args: any[]) => ILampInfo;
+
+  interface ILampStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Lights.Lamp>;
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Lights.Lamp>;
+    GetDeviceSelector(): string;
+  }
+  var ILampStatics: abstract new (...args: any[]) => ILampStatics;
+
+}
+
+declare namespace Windows.Devices.Lights.Effects {
+  class LampArrayBitmapEffect implements Windows.Devices.Lights.Effects.ILampArrayBitmapEffect, Windows.Devices.Lights.Effects.ILampArrayEffect {
+    constructor(lampArray: Windows.Devices.Lights.LampArray, lampIndexes: number[]);
+    Duration: Windows.Foundation.TimeSpan;
+    StartDelay: Windows.Foundation.TimeSpan;
+    readonly SuggestedBitmapSize: Windows.Foundation.Size;
+    UpdateInterval: Windows.Foundation.TimeSpan;
+    ZIndex: number;
+    BitmapRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Lights.Effects.LampArrayBitmapEffect, Windows.Devices.Lights.Effects.LampArrayBitmapRequestedEventArgs> | null;
+  }
+
+  class LampArrayBitmapRequestedEventArgs implements Windows.Devices.Lights.Effects.ILampArrayBitmapRequestedEventArgs {
+    UpdateBitmap(bitmap: Windows.Graphics.Imaging.SoftwareBitmap): void;
+    readonly SinceStarted: Windows.Foundation.TimeSpan;
+  }
+
+  class LampArrayBlinkEffect implements Windows.Devices.Lights.Effects.ILampArrayBlinkEffect, Windows.Devices.Lights.Effects.ILampArrayEffect {
+    constructor(lampArray: Windows.Devices.Lights.LampArray, lampIndexes: number[]);
+    AttackDuration: Windows.Foundation.TimeSpan;
+    Color: Windows.UI.Color;
+    DecayDuration: Windows.Foundation.TimeSpan;
+    Occurrences: number;
+    RepetitionDelay: Windows.Foundation.TimeSpan;
+    RepetitionMode: number;
+    StartDelay: Windows.Foundation.TimeSpan;
+    SustainDuration: Windows.Foundation.TimeSpan;
+    ZIndex: number;
+  }
+
+  class LampArrayColorRampEffect implements Windows.Devices.Lights.Effects.ILampArrayColorRampEffect, Windows.Devices.Lights.Effects.ILampArrayEffect {
+    constructor(lampArray: Windows.Devices.Lights.LampArray, lampIndexes: number[]);
+    Color: Windows.UI.Color;
+    CompletionBehavior: number;
+    RampDuration: Windows.Foundation.TimeSpan;
+    StartDelay: Windows.Foundation.TimeSpan;
+    ZIndex: number;
+  }
+
+  class LampArrayCustomEffect implements Windows.Devices.Lights.Effects.ILampArrayCustomEffect, Windows.Devices.Lights.Effects.ILampArrayEffect {
+    constructor(lampArray: Windows.Devices.Lights.LampArray, lampIndexes: number[]);
+    Duration: Windows.Foundation.TimeSpan;
+    UpdateInterval: Windows.Foundation.TimeSpan;
+    ZIndex: number;
+    UpdateRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Lights.Effects.LampArrayCustomEffect, Windows.Devices.Lights.Effects.LampArrayUpdateRequestedEventArgs> | null;
+  }
+
+  class LampArrayEffectPlaylist implements Windows.Devices.Lights.Effects.ILampArrayEffectPlaylist {
+    constructor();
+    Append(effect: Windows.Devices.Lights.Effects.ILampArrayEffect): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Devices.Lights.Effects.ILampArrayEffect>;
+    GetAt(index: number): Windows.Devices.Lights.Effects.ILampArrayEffect;
+    GetMany(startIndex: number, items: Windows.Devices.Lights.Effects.ILampArrayEffect[]): number;
+    IndexOf(value: Windows.Devices.Lights.Effects.ILampArrayEffect, index: number): boolean;
+    OverrideZIndex(zIndex: number): void;
+    Pause(): void;
+    static PauseAll(value: Windows.Foundation.Collections.IIterable<Windows.Devices.Lights.Effects.LampArrayEffectPlaylist> | Windows.Devices.Lights.Effects.LampArrayEffectPlaylist[]): void;
+    Start(): void;
+    static StartAll(value: Windows.Foundation.Collections.IIterable<Windows.Devices.Lights.Effects.LampArrayEffectPlaylist> | Windows.Devices.Lights.Effects.LampArrayEffectPlaylist[]): void;
+    Stop(): void;
+    static StopAll(value: Windows.Foundation.Collections.IIterable<Windows.Devices.Lights.Effects.LampArrayEffectPlaylist> | Windows.Devices.Lights.Effects.LampArrayEffectPlaylist[]): void;
+    EffectStartMode: number;
+    Occurrences: number;
+    RepetitionMode: number;
+    readonly Size: number;
+  }
+
+  class LampArraySolidEffect implements Windows.Devices.Lights.Effects.ILampArrayEffect, Windows.Devices.Lights.Effects.ILampArraySolidEffect {
+    constructor(lampArray: Windows.Devices.Lights.LampArray, lampIndexes: number[]);
+    Color: Windows.UI.Color;
+    CompletionBehavior: number;
+    Duration: Windows.Foundation.TimeSpan;
+    StartDelay: Windows.Foundation.TimeSpan;
+    ZIndex: number;
+  }
+
+  class LampArrayUpdateRequestedEventArgs implements Windows.Devices.Lights.Effects.ILampArrayUpdateRequestedEventArgs {
+    SetColor(desiredColor: Windows.UI.Color): void;
+    SetColorForIndex(lampIndex: number, desiredColor: Windows.UI.Color): void;
+    SetColorsForIndices(desiredColors: Windows.UI.Color[], lampIndexes: number[]): void;
+    SetSingleColorForIndices(desiredColor: Windows.UI.Color, lampIndexes: number[]): void;
+    readonly SinceStarted: Windows.Foundation.TimeSpan;
+  }
+
+  enum LampArrayEffectCompletionBehavior {
+    ClearState = 0,
+    KeepState = 1,
+  }
+
+  enum LampArrayEffectStartMode {
+    Sequential = 0,
+    Simultaneous = 1,
+  }
+
+  enum LampArrayRepetitionMode {
+    Occurrences = 0,
+    Forever = 1,
+  }
+
+  interface ILampArrayBitmapEffect {
+    Duration: Windows.Foundation.TimeSpan;
+    StartDelay: Windows.Foundation.TimeSpan;
+    readonly SuggestedBitmapSize: Windows.Foundation.Size;
+    UpdateInterval: Windows.Foundation.TimeSpan;
+    BitmapRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Lights.Effects.LampArrayBitmapEffect, Windows.Devices.Lights.Effects.LampArrayBitmapRequestedEventArgs> | null;
+  }
+  var ILampArrayBitmapEffect: abstract new (...args: any[]) => ILampArrayBitmapEffect;
+
+  interface ILampArrayBitmapEffectFactory {
+    CreateInstance(lampArray: Windows.Devices.Lights.LampArray, lampIndexes: number[]): Windows.Devices.Lights.Effects.LampArrayBitmapEffect;
+  }
+  var ILampArrayBitmapEffectFactory: abstract new (...args: any[]) => ILampArrayBitmapEffectFactory;
+
+  interface ILampArrayBitmapRequestedEventArgs {
+    UpdateBitmap(bitmap: Windows.Graphics.Imaging.SoftwareBitmap): void;
+    readonly SinceStarted: Windows.Foundation.TimeSpan;
+  }
+  var ILampArrayBitmapRequestedEventArgs: abstract new (...args: any[]) => ILampArrayBitmapRequestedEventArgs;
+
+  interface ILampArrayBlinkEffect {
+    AttackDuration: Windows.Foundation.TimeSpan;
+    Color: Windows.UI.Color;
+    DecayDuration: Windows.Foundation.TimeSpan;
+    Occurrences: number;
+    RepetitionDelay: Windows.Foundation.TimeSpan;
+    RepetitionMode: number;
+    StartDelay: Windows.Foundation.TimeSpan;
+    SustainDuration: Windows.Foundation.TimeSpan;
+  }
+  var ILampArrayBlinkEffect: abstract new (...args: any[]) => ILampArrayBlinkEffect;
+
+  interface ILampArrayBlinkEffectFactory {
+    CreateInstance(lampArray: Windows.Devices.Lights.LampArray, lampIndexes: number[]): Windows.Devices.Lights.Effects.LampArrayBlinkEffect;
+  }
+  var ILampArrayBlinkEffectFactory: abstract new (...args: any[]) => ILampArrayBlinkEffectFactory;
+
+  interface ILampArrayColorRampEffect {
+    Color: Windows.UI.Color;
+    CompletionBehavior: number;
+    RampDuration: Windows.Foundation.TimeSpan;
+    StartDelay: Windows.Foundation.TimeSpan;
+  }
+  var ILampArrayColorRampEffect: abstract new (...args: any[]) => ILampArrayColorRampEffect;
+
+  interface ILampArrayColorRampEffectFactory {
+    CreateInstance(lampArray: Windows.Devices.Lights.LampArray, lampIndexes: number[]): Windows.Devices.Lights.Effects.LampArrayColorRampEffect;
+  }
+  var ILampArrayColorRampEffectFactory: abstract new (...args: any[]) => ILampArrayColorRampEffectFactory;
+
+  interface ILampArrayCustomEffect {
+    Duration: Windows.Foundation.TimeSpan;
+    UpdateInterval: Windows.Foundation.TimeSpan;
+    UpdateRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Lights.Effects.LampArrayCustomEffect, Windows.Devices.Lights.Effects.LampArrayUpdateRequestedEventArgs> | null;
+  }
+  var ILampArrayCustomEffect: abstract new (...args: any[]) => ILampArrayCustomEffect;
+
+  interface ILampArrayCustomEffectFactory {
+    CreateInstance(lampArray: Windows.Devices.Lights.LampArray, lampIndexes: number[]): Windows.Devices.Lights.Effects.LampArrayCustomEffect;
+  }
+  var ILampArrayCustomEffectFactory: abstract new (...args: any[]) => ILampArrayCustomEffectFactory;
+
+  interface ILampArrayEffect {
+    ZIndex: number;
+  }
+  var ILampArrayEffect: abstract new (...args: any[]) => ILampArrayEffect;
+
+  interface ILampArrayEffectPlaylist {
+    Append(effect: Windows.Devices.Lights.Effects.ILampArrayEffect): void;
+    OverrideZIndex(zIndex: number): void;
+    Pause(): void;
+    Start(): void;
+    Stop(): void;
+    EffectStartMode: number;
+    Occurrences: number;
+    RepetitionMode: number;
+  }
+  var ILampArrayEffectPlaylist: abstract new (...args: any[]) => ILampArrayEffectPlaylist;
+
+  interface ILampArrayEffectPlaylistStatics {
+    PauseAll(value: Windows.Foundation.Collections.IIterable<Windows.Devices.Lights.Effects.LampArrayEffectPlaylist> | Windows.Devices.Lights.Effects.LampArrayEffectPlaylist[]): void;
+    StartAll(value: Windows.Foundation.Collections.IIterable<Windows.Devices.Lights.Effects.LampArrayEffectPlaylist> | Windows.Devices.Lights.Effects.LampArrayEffectPlaylist[]): void;
+    StopAll(value: Windows.Foundation.Collections.IIterable<Windows.Devices.Lights.Effects.LampArrayEffectPlaylist> | Windows.Devices.Lights.Effects.LampArrayEffectPlaylist[]): void;
+  }
+  var ILampArrayEffectPlaylistStatics: abstract new (...args: any[]) => ILampArrayEffectPlaylistStatics;
+
+  interface ILampArraySolidEffect {
+    Color: Windows.UI.Color;
+    CompletionBehavior: number;
+    Duration: Windows.Foundation.TimeSpan;
+    StartDelay: Windows.Foundation.TimeSpan;
+  }
+  var ILampArraySolidEffect: abstract new (...args: any[]) => ILampArraySolidEffect;
+
+  interface ILampArraySolidEffectFactory {
+    CreateInstance(lampArray: Windows.Devices.Lights.LampArray, lampIndexes: number[]): Windows.Devices.Lights.Effects.LampArraySolidEffect;
+  }
+  var ILampArraySolidEffectFactory: abstract new (...args: any[]) => ILampArraySolidEffectFactory;
+
+  interface ILampArrayUpdateRequestedEventArgs {
+    SetColor(desiredColor: Windows.UI.Color): void;
+    SetColorForIndex(lampIndex: number, desiredColor: Windows.UI.Color): void;
+    SetColorsForIndices(desiredColors: Windows.UI.Color[], lampIndexes: number[]): void;
+    SetSingleColorForIndices(desiredColor: Windows.UI.Color, lampIndexes: number[]): void;
+    readonly SinceStarted: Windows.Foundation.TimeSpan;
+  }
+  var ILampArrayUpdateRequestedEventArgs: abstract new (...args: any[]) => ILampArrayUpdateRequestedEventArgs;
+
+}
+
+declare namespace Windows.Devices.Midi {
+  class MidiActiveSensingMessage implements Windows.Devices.Midi.IMidiMessage {
+    constructor();
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+  }
+
+  class MidiChannelPressureMessage implements Windows.Devices.Midi.IMidiChannelPressureMessage, Windows.Devices.Midi.IMidiMessage {
+    constructor(channel: number, pressure: number);
+    readonly Channel: number;
+    readonly Pressure: number;
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+  }
+
+  class MidiContinueMessage implements Windows.Devices.Midi.IMidiMessage {
+    constructor();
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+  }
+
+  class MidiControlChangeMessage implements Windows.Devices.Midi.IMidiControlChangeMessage, Windows.Devices.Midi.IMidiMessage {
+    constructor(channel: number, controller: number, controlValue: number);
+    readonly Channel: number;
+    readonly ControlValue: number;
+    readonly Controller: number;
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+  }
+
+  class MidiInPort implements Windows.Devices.Midi.IMidiInPort, Windows.Foundation.IClosable {
+    Close(): void;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Midi.MidiInPort>;
+    static GetDeviceSelector(): string;
+    readonly DeviceId: string;
+    MessageReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.Midi.MidiInPort, Windows.Devices.Midi.MidiMessageReceivedEventArgs> | null;
+  }
+
+  class MidiMessageReceivedEventArgs implements Windows.Devices.Midi.IMidiMessageReceivedEventArgs {
+    readonly Message: Windows.Devices.Midi.IMidiMessage;
+  }
+
+  class MidiNoteOffMessage implements Windows.Devices.Midi.IMidiMessage, Windows.Devices.Midi.IMidiNoteOffMessage {
+    constructor(channel: number, note: number, velocity: number);
+    readonly Channel: number;
+    readonly Note: number;
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+    readonly Velocity: number;
+  }
+
+  class MidiNoteOnMessage implements Windows.Devices.Midi.IMidiMessage, Windows.Devices.Midi.IMidiNoteOnMessage {
+    constructor(channel: number, note: number, velocity: number);
+    readonly Channel: number;
+    readonly Note: number;
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+    readonly Velocity: number;
+  }
+
+  class MidiOutPort implements Windows.Devices.Midi.IMidiOutPort, Windows.Foundation.IClosable {
+    Close(): void;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Midi.IMidiOutPort>;
+    static GetDeviceSelector(): string;
+    SendBuffer(midiData: Windows.Storage.Streams.IBuffer): void;
+    SendMessage(midiMessage: Windows.Devices.Midi.IMidiMessage): void;
+    readonly DeviceId: string;
+  }
+
+  class MidiPitchBendChangeMessage implements Windows.Devices.Midi.IMidiMessage, Windows.Devices.Midi.IMidiPitchBendChangeMessage {
+    constructor(channel: number, bend: number);
+    readonly Bend: number;
+    readonly Channel: number;
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+  }
+
+  class MidiPolyphonicKeyPressureMessage implements Windows.Devices.Midi.IMidiMessage, Windows.Devices.Midi.IMidiPolyphonicKeyPressureMessage {
+    constructor(channel: number, note: number, pressure: number);
+    readonly Channel: number;
+    readonly Note: number;
+    readonly Pressure: number;
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+  }
+
+  class MidiProgramChangeMessage implements Windows.Devices.Midi.IMidiMessage, Windows.Devices.Midi.IMidiProgramChangeMessage {
+    constructor(channel: number, program: number);
+    readonly Channel: number;
+    readonly Program: number;
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+  }
+
+  class MidiSongPositionPointerMessage implements Windows.Devices.Midi.IMidiMessage, Windows.Devices.Midi.IMidiSongPositionPointerMessage {
+    constructor(beats: number);
+    readonly Beats: number;
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+  }
+
+  class MidiSongSelectMessage implements Windows.Devices.Midi.IMidiMessage, Windows.Devices.Midi.IMidiSongSelectMessage {
+    constructor(song: number);
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    readonly Song: number;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+  }
+
+  class MidiStartMessage implements Windows.Devices.Midi.IMidiMessage {
+    constructor();
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+  }
+
+  class MidiStopMessage implements Windows.Devices.Midi.IMidiMessage {
+    constructor();
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+  }
+
+  class MidiSynthesizer implements Windows.Devices.Midi.IMidiOutPort, Windows.Devices.Midi.IMidiSynthesizer, Windows.Foundation.IClosable {
+    Close(): void;
+    static CreateAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Midi.MidiSynthesizer>;
+    static CreateAsync(audioDevice: Windows.Devices.Enumeration.DeviceInformation): Windows.Foundation.IAsyncOperation<Windows.Devices.Midi.MidiSynthesizer>;
+    static IsSynthesizer(midiDevice: Windows.Devices.Enumeration.DeviceInformation): boolean;
+    SendBuffer(midiData: Windows.Storage.Streams.IBuffer): void;
+    SendMessage(midiMessage: Windows.Devices.Midi.IMidiMessage): void;
+    readonly AudioDevice: Windows.Devices.Enumeration.DeviceInformation;
+    readonly DeviceId: string;
+    Volume: number;
+  }
+
+  class MidiSystemExclusiveMessage implements Windows.Devices.Midi.IMidiMessage {
+    constructor(rawData: Windows.Storage.Streams.IBuffer);
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+  }
+
+  class MidiSystemResetMessage implements Windows.Devices.Midi.IMidiMessage {
+    constructor();
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+  }
+
+  class MidiTimeCodeMessage implements Windows.Devices.Midi.IMidiMessage, Windows.Devices.Midi.IMidiTimeCodeMessage {
+    constructor(frameType: number, values: number);
+    readonly FrameType: number;
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+    readonly Values: number;
+  }
+
+  class MidiTimingClockMessage implements Windows.Devices.Midi.IMidiMessage {
+    constructor();
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+  }
+
+  class MidiTuneRequestMessage implements Windows.Devices.Midi.IMidiMessage {
+    constructor();
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+  }
+
+  enum MidiMessageType {
+    None = 0,
+    NoteOff = 128,
+    NoteOn = 144,
+    PolyphonicKeyPressure = 160,
+    ControlChange = 176,
+    ProgramChange = 192,
+    ChannelPressure = 208,
+    PitchBendChange = 224,
+    SystemExclusive = 240,
+    MidiTimeCode = 241,
+    SongPositionPointer = 242,
+    SongSelect = 243,
+    TuneRequest = 246,
+    EndSystemExclusive = 247,
+    TimingClock = 248,
+    Start = 250,
+    Continue = 251,
+    Stop = 252,
+    ActiveSensing = 254,
+    SystemReset = 255,
+  }
+
+  interface IMidiChannelPressureMessage extends Windows.Devices.Midi.IMidiMessage {
+    readonly Channel: number;
+    readonly Pressure: number;
+  }
+  var IMidiChannelPressureMessage: abstract new (...args: any[]) => IMidiChannelPressureMessage;
+
+  interface IMidiChannelPressureMessageFactory {
+    CreateMidiChannelPressureMessage(channel: number, pressure: number): Windows.Devices.Midi.MidiChannelPressureMessage;
+  }
+  var IMidiChannelPressureMessageFactory: abstract new (...args: any[]) => IMidiChannelPressureMessageFactory;
+
+  interface IMidiControlChangeMessage extends Windows.Devices.Midi.IMidiMessage {
+    readonly Channel: number;
+    readonly ControlValue: number;
+    readonly Controller: number;
+  }
+  var IMidiControlChangeMessage: abstract new (...args: any[]) => IMidiControlChangeMessage;
+
+  interface IMidiControlChangeMessageFactory {
+    CreateMidiControlChangeMessage(channel: number, controller: number, controlValue: number): Windows.Devices.Midi.MidiControlChangeMessage;
+  }
+  var IMidiControlChangeMessageFactory: abstract new (...args: any[]) => IMidiControlChangeMessageFactory;
+
+  interface IMidiInPort extends Windows.Foundation.IClosable {
+    Close(): void;
+    readonly DeviceId: string;
+    MessageReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.Midi.MidiInPort, Windows.Devices.Midi.MidiMessageReceivedEventArgs> | null;
+  }
+  var IMidiInPort: abstract new (...args: any[]) => IMidiInPort;
+
+  interface IMidiInPortStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Midi.MidiInPort>;
+    GetDeviceSelector(): string;
+  }
+  var IMidiInPortStatics: abstract new (...args: any[]) => IMidiInPortStatics;
+
+  interface IMidiMessage {
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+  }
+  var IMidiMessage: abstract new (...args: any[]) => IMidiMessage;
+
+  interface IMidiMessageReceivedEventArgs {
+    readonly Message: Windows.Devices.Midi.IMidiMessage;
+  }
+  var IMidiMessageReceivedEventArgs: abstract new (...args: any[]) => IMidiMessageReceivedEventArgs;
+
+  interface IMidiNoteOffMessage extends Windows.Devices.Midi.IMidiMessage {
+    readonly Channel: number;
+    readonly Note: number;
+    readonly Velocity: number;
+  }
+  var IMidiNoteOffMessage: abstract new (...args: any[]) => IMidiNoteOffMessage;
+
+  interface IMidiNoteOffMessageFactory {
+    CreateMidiNoteOffMessage(channel: number, note: number, velocity: number): Windows.Devices.Midi.MidiNoteOffMessage;
+  }
+  var IMidiNoteOffMessageFactory: abstract new (...args: any[]) => IMidiNoteOffMessageFactory;
+
+  interface IMidiNoteOnMessage extends Windows.Devices.Midi.IMidiMessage {
+    readonly Channel: number;
+    readonly Note: number;
+    readonly Velocity: number;
+  }
+  var IMidiNoteOnMessage: abstract new (...args: any[]) => IMidiNoteOnMessage;
+
+  interface IMidiNoteOnMessageFactory {
+    CreateMidiNoteOnMessage(channel: number, note: number, velocity: number): Windows.Devices.Midi.MidiNoteOnMessage;
+  }
+  var IMidiNoteOnMessageFactory: abstract new (...args: any[]) => IMidiNoteOnMessageFactory;
+
+  interface IMidiOutPort extends Windows.Foundation.IClosable {
+    Close(): void;
+    SendBuffer(midiData: Windows.Storage.Streams.IBuffer): void;
+    SendMessage(midiMessage: Windows.Devices.Midi.IMidiMessage): void;
+    readonly DeviceId: string;
+  }
+  var IMidiOutPort: abstract new (...args: any[]) => IMidiOutPort;
+
+  interface IMidiOutPortStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Midi.IMidiOutPort>;
+    GetDeviceSelector(): string;
+  }
+  var IMidiOutPortStatics: abstract new (...args: any[]) => IMidiOutPortStatics;
+
+  interface IMidiPitchBendChangeMessage extends Windows.Devices.Midi.IMidiMessage {
+    readonly Bend: number;
+    readonly Channel: number;
+  }
+  var IMidiPitchBendChangeMessage: abstract new (...args: any[]) => IMidiPitchBendChangeMessage;
+
+  interface IMidiPitchBendChangeMessageFactory {
+    CreateMidiPitchBendChangeMessage(channel: number, bend: number): Windows.Devices.Midi.MidiPitchBendChangeMessage;
+  }
+  var IMidiPitchBendChangeMessageFactory: abstract new (...args: any[]) => IMidiPitchBendChangeMessageFactory;
+
+  interface IMidiPolyphonicKeyPressureMessage extends Windows.Devices.Midi.IMidiMessage {
+    readonly Channel: number;
+    readonly Note: number;
+    readonly Pressure: number;
+  }
+  var IMidiPolyphonicKeyPressureMessage: abstract new (...args: any[]) => IMidiPolyphonicKeyPressureMessage;
+
+  interface IMidiPolyphonicKeyPressureMessageFactory {
+    CreateMidiPolyphonicKeyPressureMessage(channel: number, note: number, pressure: number): Windows.Devices.Midi.MidiPolyphonicKeyPressureMessage;
+  }
+  var IMidiPolyphonicKeyPressureMessageFactory: abstract new (...args: any[]) => IMidiPolyphonicKeyPressureMessageFactory;
+
+  interface IMidiProgramChangeMessage extends Windows.Devices.Midi.IMidiMessage {
+    readonly Channel: number;
+    readonly Program: number;
+  }
+  var IMidiProgramChangeMessage: abstract new (...args: any[]) => IMidiProgramChangeMessage;
+
+  interface IMidiProgramChangeMessageFactory {
+    CreateMidiProgramChangeMessage(channel: number, program: number): Windows.Devices.Midi.MidiProgramChangeMessage;
+  }
+  var IMidiProgramChangeMessageFactory: abstract new (...args: any[]) => IMidiProgramChangeMessageFactory;
+
+  interface IMidiSongPositionPointerMessage extends Windows.Devices.Midi.IMidiMessage {
+    readonly Beats: number;
+  }
+  var IMidiSongPositionPointerMessage: abstract new (...args: any[]) => IMidiSongPositionPointerMessage;
+
+  interface IMidiSongPositionPointerMessageFactory {
+    CreateMidiSongPositionPointerMessage(beats: number): Windows.Devices.Midi.MidiSongPositionPointerMessage;
+  }
+  var IMidiSongPositionPointerMessageFactory: abstract new (...args: any[]) => IMidiSongPositionPointerMessageFactory;
+
+  interface IMidiSongSelectMessage extends Windows.Devices.Midi.IMidiMessage {
+    readonly Song: number;
+  }
+  var IMidiSongSelectMessage: abstract new (...args: any[]) => IMidiSongSelectMessage;
+
+  interface IMidiSongSelectMessageFactory {
+    CreateMidiSongSelectMessage(song: number): Windows.Devices.Midi.MidiSongSelectMessage;
+  }
+  var IMidiSongSelectMessageFactory: abstract new (...args: any[]) => IMidiSongSelectMessageFactory;
+
+  interface IMidiSynthesizer extends Windows.Devices.Midi.IMidiOutPort, Windows.Foundation.IClosable {
+    Close(): void;
+    SendBuffer(midiData: Windows.Storage.Streams.IBuffer): void;
+    SendMessage(midiMessage: Windows.Devices.Midi.IMidiMessage): void;
+    readonly AudioDevice: Windows.Devices.Enumeration.DeviceInformation;
+    Volume: number;
+  }
+  var IMidiSynthesizer: abstract new (...args: any[]) => IMidiSynthesizer;
+
+  interface IMidiSynthesizerStatics {
+    CreateAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Midi.MidiSynthesizer>;
+    CreateAsync(audioDevice: Windows.Devices.Enumeration.DeviceInformation): Windows.Foundation.IAsyncOperation<Windows.Devices.Midi.MidiSynthesizer>;
+    IsSynthesizer(midiDevice: Windows.Devices.Enumeration.DeviceInformation): boolean;
+  }
+  var IMidiSynthesizerStatics: abstract new (...args: any[]) => IMidiSynthesizerStatics;
+
+  interface IMidiSystemExclusiveMessageFactory {
+    CreateMidiSystemExclusiveMessage(rawData: Windows.Storage.Streams.IBuffer): Windows.Devices.Midi.MidiSystemExclusiveMessage;
+  }
+  var IMidiSystemExclusiveMessageFactory: abstract new (...args: any[]) => IMidiSystemExclusiveMessageFactory;
+
+  interface IMidiTimeCodeMessage extends Windows.Devices.Midi.IMidiMessage {
+    readonly FrameType: number;
+    readonly Values: number;
+  }
+  var IMidiTimeCodeMessage: abstract new (...args: any[]) => IMidiTimeCodeMessage;
+
+  interface IMidiTimeCodeMessageFactory {
+    CreateMidiTimeCodeMessage(frameType: number, values: number): Windows.Devices.Midi.MidiTimeCodeMessage;
+  }
+  var IMidiTimeCodeMessageFactory: abstract new (...args: any[]) => IMidiTimeCodeMessageFactory;
+
+}
+
+declare namespace Windows.Devices.Perception {
+  class KnownCameraIntrinsicsProperties {
+    static readonly FocalLength: string;
+    static readonly PrincipalPoint: string;
+    static readonly RadialDistortion: string;
+    static readonly TangentialDistortion: string;
+  }
+
+  class KnownPerceptionColorFrameSourceProperties {
+    static readonly AutoExposureEnabled: string;
+    static readonly Exposure: string;
+    static readonly ExposureCompensation: string;
+  }
+
+  class KnownPerceptionDepthFrameSourceProperties {
+    static readonly MaxDepth: string;
+    static readonly MinDepth: string;
+  }
+
+  class KnownPerceptionFrameSourceProperties {
+    static readonly DeviceId: string;
+    static readonly DeviceModelVersion: string;
+    static readonly EnclosureLocation: string;
+    static readonly FrameKind: string;
+    static readonly Id: string;
+    static readonly PhysicalDeviceIds: string;
+  }
+
+  class KnownPerceptionInfraredFrameSourceProperties {
+    static readonly ActiveIlluminationEnabled: string;
+    static readonly AmbientSubtractionEnabled: string;
+    static readonly AutoExposureEnabled: string;
+    static readonly Exposure: string;
+    static readonly ExposureCompensation: string;
+    static readonly InterleavedIlluminationEnabled: string;
+    static readonly StructureLightPatternEnabled: string;
+  }
+
+  class KnownPerceptionVideoFrameSourceProperties {
+    static readonly AvailableVideoProfiles: string;
+    static readonly CameraIntrinsics: string;
+    static readonly IsMirrored: string;
+    static readonly SupportedVideoProfiles: string;
+    static readonly VideoProfile: string;
+  }
+
+  class KnownPerceptionVideoProfileProperties {
+    static readonly BitmapAlphaMode: string;
+    static readonly BitmapPixelFormat: string;
+    static readonly FrameDuration: string;
+    static readonly Height: string;
+    static readonly Width: string;
+  }
+
+  class PerceptionColorFrame implements Windows.Devices.Perception.IPerceptionColorFrame, Windows.Foundation.IClosable {
+    Close(): void;
+    readonly VideoFrame: Windows.Media.VideoFrame;
+  }
+
+  class PerceptionColorFrameArrivedEventArgs implements Windows.Devices.Perception.IPerceptionColorFrameArrivedEventArgs {
+    TryOpenFrame(): Windows.Devices.Perception.PerceptionColorFrame;
+    readonly RelativeTime: Windows.Foundation.TimeSpan;
+  }
+
+  class PerceptionColorFrameReader implements Windows.Devices.Perception.IPerceptionColorFrameReader, Windows.Foundation.IClosable {
+    Close(): void;
+    TryReadLatestFrame(): Windows.Devices.Perception.PerceptionColorFrame;
+    IsPaused: boolean;
+    readonly Source: Windows.Devices.Perception.PerceptionColorFrameSource;
+    FrameArrived: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameReader, Windows.Devices.Perception.PerceptionColorFrameArrivedEventArgs> | null;
+  }
+
+  class PerceptionColorFrameSource implements Windows.Devices.Perception.IPerceptionColorFrameSource, Windows.Devices.Perception.IPerceptionColorFrameSource2 {
+    AcquireControlSession(): Windows.Devices.Perception.PerceptionControlSession;
+    CanControlIndependentlyFrom(targetId: string): boolean;
+    static CreateWatcher(): Windows.Devices.Perception.PerceptionColorFrameSourceWatcher;
+    static FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.PerceptionColorFrameSource> | Windows.Devices.Perception.PerceptionColorFrameSource[]>;
+    static FromIdAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionColorFrameSource>;
+    IsCorrelatedWith(targetId: string): boolean;
+    OpenReader(): Windows.Devices.Perception.PerceptionColorFrameReader;
+    static RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    TryGetDepthCorrelatedCameraIntrinsicsAsync(correlatedDepthFrameSource: Windows.Devices.Perception.PerceptionDepthFrameSource): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionDepthCorrelatedCameraIntrinsics>;
+    TryGetDepthCorrelatedCoordinateMapperAsync(targetSourceId: string, correlatedDepthFrameSource: Windows.Devices.Perception.PerceptionDepthFrameSource): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionDepthCorrelatedCoordinateMapper>;
+    TryGetTransformTo(targetId: string, result: Windows.Foundation.Numerics.Matrix4x4): boolean;
+    TrySetVideoProfileAsync(controlSession: Windows.Devices.Perception.PerceptionControlSession, profile: Windows.Devices.Perception.PerceptionVideoProfile): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionFrameSourcePropertyChangeResult>;
+    readonly Active: boolean;
+    readonly Available: boolean;
+    readonly AvailableVideoProfiles: Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.PerceptionVideoProfile> | Windows.Devices.Perception.PerceptionVideoProfile[];
+    readonly CameraIntrinsics: Windows.Media.Devices.Core.CameraIntrinsics;
+    readonly DeviceId: string;
+    readonly DeviceKind: string;
+    readonly DisplayName: string;
+    readonly Id: string;
+    readonly IsControlled: boolean;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly SupportedVideoProfiles: Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.PerceptionVideoProfile> | Windows.Devices.Perception.PerceptionVideoProfile[];
+    readonly VideoProfile: Windows.Devices.Perception.PerceptionVideoProfile;
+    ActiveChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameSource, Object> | null;
+    AvailableChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameSource, Object> | null;
+    CameraIntrinsicsChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameSource, Object> | null;
+    PropertiesChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameSource, Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs> | null;
+    VideoProfileChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameSource, Object> | null;
+  }
+
+  class PerceptionColorFrameSourceAddedEventArgs implements Windows.Devices.Perception.IPerceptionColorFrameSourceAddedEventArgs {
+    readonly FrameSource: Windows.Devices.Perception.PerceptionColorFrameSource;
+  }
+
+  class PerceptionColorFrameSourceRemovedEventArgs implements Windows.Devices.Perception.IPerceptionColorFrameSourceRemovedEventArgs {
+    readonly FrameSource: Windows.Devices.Perception.PerceptionColorFrameSource;
+  }
+
+  class PerceptionColorFrameSourceWatcher implements Windows.Devices.Perception.IPerceptionColorFrameSourceWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameSourceWatcher, Object> | null;
+    SourceAdded: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameSourceWatcher, Windows.Devices.Perception.PerceptionColorFrameSourceAddedEventArgs> | null;
+    SourceRemoved: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameSourceWatcher, Windows.Devices.Perception.PerceptionColorFrameSourceRemovedEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameSourceWatcher, Object> | null;
+  }
+
+  class PerceptionControlSession implements Windows.Devices.Perception.IPerceptionControlSession, Windows.Foundation.IClosable {
+    Close(): void;
+    TrySetPropertyAsync(name: string, value: Object): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionFrameSourcePropertyChangeResult>;
+    ControlLost: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionControlSession, Object> | null;
+  }
+
+  class PerceptionDepthCorrelatedCameraIntrinsics implements Windows.Devices.Perception.IPerceptionDepthCorrelatedCameraIntrinsics {
+    UnprojectAllPixelsAtCorrelatedDepthAsync(depthFrame: Windows.Devices.Perception.PerceptionDepthFrame, results: Windows.Foundation.Numerics.Vector3[]): Windows.Foundation.IAsyncAction;
+    UnprojectPixelAtCorrelatedDepth(pixelCoordinate: Windows.Foundation.Point, depthFrame: Windows.Devices.Perception.PerceptionDepthFrame): Windows.Foundation.Numerics.Vector3;
+    UnprojectPixelsAtCorrelatedDepth(sourceCoordinates: Windows.Foundation.Point[], depthFrame: Windows.Devices.Perception.PerceptionDepthFrame, results: Windows.Foundation.Numerics.Vector3[]): void;
+    UnprojectRegionPixelsAtCorrelatedDepthAsync(region: Windows.Foundation.Rect, depthFrame: Windows.Devices.Perception.PerceptionDepthFrame, results: Windows.Foundation.Numerics.Vector3[]): Windows.Foundation.IAsyncAction;
+  }
+
+  class PerceptionDepthCorrelatedCoordinateMapper implements Windows.Devices.Perception.IPerceptionDepthCorrelatedCoordinateMapper {
+    MapAllPixelsToTargetAsync(depthFrame: Windows.Devices.Perception.PerceptionDepthFrame, targetCoordinates: Windows.Foundation.Point[]): Windows.Foundation.IAsyncAction;
+    MapPixelToTarget(sourcePixelCoordinate: Windows.Foundation.Point, depthFrame: Windows.Devices.Perception.PerceptionDepthFrame): Windows.Foundation.Point;
+    MapPixelsToTarget(sourceCoordinates: Windows.Foundation.Point[], depthFrame: Windows.Devices.Perception.PerceptionDepthFrame, results: Windows.Foundation.Point[]): void;
+    MapRegionOfPixelsToTargetAsync(region: Windows.Foundation.Rect, depthFrame: Windows.Devices.Perception.PerceptionDepthFrame, targetCoordinates: Windows.Foundation.Point[]): Windows.Foundation.IAsyncAction;
+  }
+
+  class PerceptionDepthFrame implements Windows.Devices.Perception.IPerceptionDepthFrame, Windows.Foundation.IClosable {
+    Close(): void;
+    readonly VideoFrame: Windows.Media.VideoFrame;
+  }
+
+  class PerceptionDepthFrameArrivedEventArgs implements Windows.Devices.Perception.IPerceptionDepthFrameArrivedEventArgs {
+    TryOpenFrame(): Windows.Devices.Perception.PerceptionDepthFrame;
+    readonly RelativeTime: Windows.Foundation.TimeSpan;
+  }
+
+  class PerceptionDepthFrameReader implements Windows.Devices.Perception.IPerceptionDepthFrameReader, Windows.Foundation.IClosable {
+    Close(): void;
+    TryReadLatestFrame(): Windows.Devices.Perception.PerceptionDepthFrame;
+    IsPaused: boolean;
+    readonly Source: Windows.Devices.Perception.PerceptionDepthFrameSource;
+    FrameArrived: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameReader, Windows.Devices.Perception.PerceptionDepthFrameArrivedEventArgs> | null;
+  }
+
+  class PerceptionDepthFrameSource implements Windows.Devices.Perception.IPerceptionDepthFrameSource, Windows.Devices.Perception.IPerceptionDepthFrameSource2 {
+    AcquireControlSession(): Windows.Devices.Perception.PerceptionControlSession;
+    CanControlIndependentlyFrom(targetId: string): boolean;
+    static CreateWatcher(): Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher;
+    static FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.PerceptionDepthFrameSource> | Windows.Devices.Perception.PerceptionDepthFrameSource[]>;
+    static FromIdAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionDepthFrameSource>;
+    IsCorrelatedWith(targetId: string): boolean;
+    OpenReader(): Windows.Devices.Perception.PerceptionDepthFrameReader;
+    static RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    TryGetDepthCorrelatedCameraIntrinsicsAsync(target: Windows.Devices.Perception.PerceptionDepthFrameSource): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionDepthCorrelatedCameraIntrinsics>;
+    TryGetDepthCorrelatedCoordinateMapperAsync(targetId: string, depthFrameSourceToMapWith: Windows.Devices.Perception.PerceptionDepthFrameSource): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionDepthCorrelatedCoordinateMapper>;
+    TryGetTransformTo(targetId: string, result: Windows.Foundation.Numerics.Matrix4x4): boolean;
+    TrySetVideoProfileAsync(controlSession: Windows.Devices.Perception.PerceptionControlSession, profile: Windows.Devices.Perception.PerceptionVideoProfile): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionFrameSourcePropertyChangeResult>;
+    readonly Active: boolean;
+    readonly Available: boolean;
+    readonly AvailableVideoProfiles: Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.PerceptionVideoProfile> | Windows.Devices.Perception.PerceptionVideoProfile[];
+    readonly CameraIntrinsics: Windows.Media.Devices.Core.CameraIntrinsics;
+    readonly DeviceId: string;
+    readonly DeviceKind: string;
+    readonly DisplayName: string;
+    readonly Id: string;
+    readonly IsControlled: boolean;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly SupportedVideoProfiles: Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.PerceptionVideoProfile> | Windows.Devices.Perception.PerceptionVideoProfile[];
+    readonly VideoProfile: Windows.Devices.Perception.PerceptionVideoProfile;
+    ActiveChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameSource, Object> | null;
+    AvailableChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameSource, Object> | null;
+    CameraIntrinsicsChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameSource, Object> | null;
+    PropertiesChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameSource, Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs> | null;
+    VideoProfileChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameSource, Object> | null;
+  }
+
+  class PerceptionDepthFrameSourceAddedEventArgs implements Windows.Devices.Perception.IPerceptionDepthFrameSourceAddedEventArgs {
+    readonly FrameSource: Windows.Devices.Perception.PerceptionDepthFrameSource;
+  }
+
+  class PerceptionDepthFrameSourceRemovedEventArgs implements Windows.Devices.Perception.IPerceptionDepthFrameSourceRemovedEventArgs {
+    readonly FrameSource: Windows.Devices.Perception.PerceptionDepthFrameSource;
+  }
+
+  class PerceptionDepthFrameSourceWatcher implements Windows.Devices.Perception.IPerceptionDepthFrameSourceWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher, Object> | null;
+    SourceAdded: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher, Windows.Devices.Perception.PerceptionDepthFrameSourceAddedEventArgs> | null;
+    SourceRemoved: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher, Windows.Devices.Perception.PerceptionDepthFrameSourceRemovedEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher, Object> | null;
+  }
+
+  class PerceptionFrameSourcePropertiesChangedEventArgs implements Windows.Devices.Perception.IPerceptionFrameSourcePropertiesChangedEventArgs {
+    readonly CollectionChange: number;
+    readonly Key: string;
+  }
+
+  class PerceptionFrameSourcePropertyChangeResult implements Windows.Devices.Perception.IPerceptionFrameSourcePropertyChangeResult {
+    readonly NewValue: Object;
+    readonly Status: number;
+  }
+
+  class PerceptionInfraredFrame implements Windows.Devices.Perception.IPerceptionInfraredFrame, Windows.Foundation.IClosable {
+    Close(): void;
+    readonly VideoFrame: Windows.Media.VideoFrame;
+  }
+
+  class PerceptionInfraredFrameArrivedEventArgs implements Windows.Devices.Perception.IPerceptionInfraredFrameArrivedEventArgs {
+    TryOpenFrame(): Windows.Devices.Perception.PerceptionInfraredFrame;
+    readonly RelativeTime: Windows.Foundation.TimeSpan;
+  }
+
+  class PerceptionInfraredFrameReader implements Windows.Devices.Perception.IPerceptionInfraredFrameReader, Windows.Foundation.IClosable {
+    Close(): void;
+    TryReadLatestFrame(): Windows.Devices.Perception.PerceptionInfraredFrame;
+    IsPaused: boolean;
+    readonly Source: Windows.Devices.Perception.PerceptionInfraredFrameSource;
+    FrameArrived: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameReader, Windows.Devices.Perception.PerceptionInfraredFrameArrivedEventArgs> | null;
+  }
+
+  class PerceptionInfraredFrameSource implements Windows.Devices.Perception.IPerceptionInfraredFrameSource, Windows.Devices.Perception.IPerceptionInfraredFrameSource2 {
+    AcquireControlSession(): Windows.Devices.Perception.PerceptionControlSession;
+    CanControlIndependentlyFrom(targetId: string): boolean;
+    static CreateWatcher(): Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher;
+    static FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.PerceptionInfraredFrameSource> | Windows.Devices.Perception.PerceptionInfraredFrameSource[]>;
+    static FromIdAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionInfraredFrameSource>;
+    IsCorrelatedWith(targetId: string): boolean;
+    OpenReader(): Windows.Devices.Perception.PerceptionInfraredFrameReader;
+    static RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    TryGetDepthCorrelatedCameraIntrinsicsAsync(target: Windows.Devices.Perception.PerceptionDepthFrameSource): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionDepthCorrelatedCameraIntrinsics>;
+    TryGetDepthCorrelatedCoordinateMapperAsync(targetId: string, depthFrameSourceToMapWith: Windows.Devices.Perception.PerceptionDepthFrameSource): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionDepthCorrelatedCoordinateMapper>;
+    TryGetTransformTo(targetId: string, result: Windows.Foundation.Numerics.Matrix4x4): boolean;
+    TrySetVideoProfileAsync(controlSession: Windows.Devices.Perception.PerceptionControlSession, profile: Windows.Devices.Perception.PerceptionVideoProfile): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionFrameSourcePropertyChangeResult>;
+    readonly Active: boolean;
+    readonly Available: boolean;
+    readonly AvailableVideoProfiles: Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.PerceptionVideoProfile> | Windows.Devices.Perception.PerceptionVideoProfile[];
+    readonly CameraIntrinsics: Windows.Media.Devices.Core.CameraIntrinsics;
+    readonly DeviceId: string;
+    readonly DeviceKind: string;
+    readonly DisplayName: string;
+    readonly Id: string;
+    readonly IsControlled: boolean;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly SupportedVideoProfiles: Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.PerceptionVideoProfile> | Windows.Devices.Perception.PerceptionVideoProfile[];
+    readonly VideoProfile: Windows.Devices.Perception.PerceptionVideoProfile;
+    ActiveChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameSource, Object> | null;
+    AvailableChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameSource, Object> | null;
+    CameraIntrinsicsChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameSource, Object> | null;
+    PropertiesChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameSource, Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs> | null;
+    VideoProfileChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameSource, Object> | null;
+  }
+
+  class PerceptionInfraredFrameSourceAddedEventArgs implements Windows.Devices.Perception.IPerceptionInfraredFrameSourceAddedEventArgs {
+    readonly FrameSource: Windows.Devices.Perception.PerceptionInfraredFrameSource;
+  }
+
+  class PerceptionInfraredFrameSourceRemovedEventArgs implements Windows.Devices.Perception.IPerceptionInfraredFrameSourceRemovedEventArgs {
+    readonly FrameSource: Windows.Devices.Perception.PerceptionInfraredFrameSource;
+  }
+
+  class PerceptionInfraredFrameSourceWatcher implements Windows.Devices.Perception.IPerceptionInfraredFrameSourceWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher, Object> | null;
+    SourceAdded: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher, Windows.Devices.Perception.PerceptionInfraredFrameSourceAddedEventArgs> | null;
+    SourceRemoved: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher, Windows.Devices.Perception.PerceptionInfraredFrameSourceRemovedEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher, Object> | null;
+  }
+
+  class PerceptionVideoProfile implements Windows.Devices.Perception.IPerceptionVideoProfile {
+    IsEqual(other: Windows.Devices.Perception.PerceptionVideoProfile): boolean;
+    readonly BitmapAlphaMode: number;
+    readonly BitmapPixelFormat: number;
+    readonly FrameDuration: Windows.Foundation.TimeSpan;
+    readonly Height: number;
+    readonly Width: number;
+  }
+
+  enum PerceptionFrameSourceAccessStatus {
+    Unspecified = 0,
+    Allowed = 1,
+    DeniedByUser = 2,
+    DeniedBySystem = 3,
+  }
+
+  enum PerceptionFrameSourcePropertyChangeStatus {
+    Unknown = 0,
+    Accepted = 1,
+    LostControl = 2,
+    PropertyNotSupported = 3,
+    PropertyReadOnly = 4,
+    ValueOutOfRange = 5,
+  }
+
+  interface IKnownCameraIntrinsicsPropertiesStatics {
+    readonly FocalLength: string;
+    readonly PrincipalPoint: string;
+    readonly RadialDistortion: string;
+    readonly TangentialDistortion: string;
+  }
+  var IKnownCameraIntrinsicsPropertiesStatics: abstract new (...args: any[]) => IKnownCameraIntrinsicsPropertiesStatics;
+
+  interface IKnownPerceptionColorFrameSourcePropertiesStatics {
+    readonly AutoExposureEnabled: string;
+    readonly Exposure: string;
+    readonly ExposureCompensation: string;
+  }
+  var IKnownPerceptionColorFrameSourcePropertiesStatics: abstract new (...args: any[]) => IKnownPerceptionColorFrameSourcePropertiesStatics;
+
+  interface IKnownPerceptionDepthFrameSourcePropertiesStatics {
+    readonly MaxDepth: string;
+    readonly MinDepth: string;
+  }
+  var IKnownPerceptionDepthFrameSourcePropertiesStatics: abstract new (...args: any[]) => IKnownPerceptionDepthFrameSourcePropertiesStatics;
+
+  interface IKnownPerceptionFrameSourcePropertiesStatics {
+    readonly DeviceModelVersion: string;
+    readonly EnclosureLocation: string;
+    readonly FrameKind: string;
+    readonly Id: string;
+    readonly PhysicalDeviceIds: string;
+  }
+  var IKnownPerceptionFrameSourcePropertiesStatics: abstract new (...args: any[]) => IKnownPerceptionFrameSourcePropertiesStatics;
+
+  interface IKnownPerceptionFrameSourcePropertiesStatics2 {
+    readonly DeviceId: string;
+  }
+  var IKnownPerceptionFrameSourcePropertiesStatics2: abstract new (...args: any[]) => IKnownPerceptionFrameSourcePropertiesStatics2;
+
+  interface IKnownPerceptionInfraredFrameSourcePropertiesStatics {
+    readonly ActiveIlluminationEnabled: string;
+    readonly AmbientSubtractionEnabled: string;
+    readonly AutoExposureEnabled: string;
+    readonly Exposure: string;
+    readonly ExposureCompensation: string;
+    readonly InterleavedIlluminationEnabled: string;
+    readonly StructureLightPatternEnabled: string;
+  }
+  var IKnownPerceptionInfraredFrameSourcePropertiesStatics: abstract new (...args: any[]) => IKnownPerceptionInfraredFrameSourcePropertiesStatics;
+
+  interface IKnownPerceptionVideoFrameSourcePropertiesStatics {
+    readonly AvailableVideoProfiles: string;
+    readonly CameraIntrinsics: string;
+    readonly IsMirrored: string;
+    readonly SupportedVideoProfiles: string;
+    readonly VideoProfile: string;
+  }
+  var IKnownPerceptionVideoFrameSourcePropertiesStatics: abstract new (...args: any[]) => IKnownPerceptionVideoFrameSourcePropertiesStatics;
+
+  interface IKnownPerceptionVideoProfilePropertiesStatics {
+    readonly BitmapAlphaMode: string;
+    readonly BitmapPixelFormat: string;
+    readonly FrameDuration: string;
+    readonly Height: string;
+    readonly Width: string;
+  }
+  var IKnownPerceptionVideoProfilePropertiesStatics: abstract new (...args: any[]) => IKnownPerceptionVideoProfilePropertiesStatics;
+
+  interface IPerceptionColorFrame extends Windows.Foundation.IClosable {
+    Close(): void;
+    readonly VideoFrame: Windows.Media.VideoFrame;
+  }
+  var IPerceptionColorFrame: abstract new (...args: any[]) => IPerceptionColorFrame;
+
+  interface IPerceptionColorFrameArrivedEventArgs {
+    TryOpenFrame(): Windows.Devices.Perception.PerceptionColorFrame;
+    readonly RelativeTime: Windows.Foundation.TimeSpan;
+  }
+  var IPerceptionColorFrameArrivedEventArgs: abstract new (...args: any[]) => IPerceptionColorFrameArrivedEventArgs;
+
+  interface IPerceptionColorFrameReader extends Windows.Foundation.IClosable {
+    Close(): void;
+    TryReadLatestFrame(): Windows.Devices.Perception.PerceptionColorFrame;
+    IsPaused: boolean;
+    readonly Source: Windows.Devices.Perception.PerceptionColorFrameSource;
+    FrameArrived: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameReader, Windows.Devices.Perception.PerceptionColorFrameArrivedEventArgs> | null;
+  }
+  var IPerceptionColorFrameReader: abstract new (...args: any[]) => IPerceptionColorFrameReader;
+
+  interface IPerceptionColorFrameSource {
+    AcquireControlSession(): Windows.Devices.Perception.PerceptionControlSession;
+    CanControlIndependentlyFrom(targetId: string): boolean;
+    IsCorrelatedWith(targetId: string): boolean;
+    OpenReader(): Windows.Devices.Perception.PerceptionColorFrameReader;
+    TryGetDepthCorrelatedCameraIntrinsicsAsync(correlatedDepthFrameSource: Windows.Devices.Perception.PerceptionDepthFrameSource): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionDepthCorrelatedCameraIntrinsics>;
+    TryGetDepthCorrelatedCoordinateMapperAsync(targetSourceId: string, correlatedDepthFrameSource: Windows.Devices.Perception.PerceptionDepthFrameSource): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionDepthCorrelatedCoordinateMapper>;
+    TryGetTransformTo(targetId: string, result: Windows.Foundation.Numerics.Matrix4x4): boolean;
+    TrySetVideoProfileAsync(controlSession: Windows.Devices.Perception.PerceptionControlSession, profile: Windows.Devices.Perception.PerceptionVideoProfile): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionFrameSourcePropertyChangeResult>;
+    readonly Active: boolean;
+    readonly Available: boolean;
+    readonly AvailableVideoProfiles: Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.PerceptionVideoProfile> | Windows.Devices.Perception.PerceptionVideoProfile[];
+    readonly CameraIntrinsics: Windows.Media.Devices.Core.CameraIntrinsics;
+    readonly DeviceKind: string;
+    readonly DisplayName: string;
+    readonly Id: string;
+    readonly IsControlled: boolean;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly SupportedVideoProfiles: Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.PerceptionVideoProfile> | Windows.Devices.Perception.PerceptionVideoProfile[];
+    readonly VideoProfile: Windows.Devices.Perception.PerceptionVideoProfile;
+    ActiveChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameSource, Object> | null;
+    AvailableChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameSource, Object> | null;
+    CameraIntrinsicsChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameSource, Object> | null;
+    PropertiesChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameSource, Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs> | null;
+    VideoProfileChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameSource, Object> | null;
+  }
+  var IPerceptionColorFrameSource: abstract new (...args: any[]) => IPerceptionColorFrameSource;
+
+  interface IPerceptionColorFrameSource2 {
+    readonly DeviceId: string;
+  }
+  var IPerceptionColorFrameSource2: abstract new (...args: any[]) => IPerceptionColorFrameSource2;
+
+  interface IPerceptionColorFrameSourceAddedEventArgs {
+    readonly FrameSource: Windows.Devices.Perception.PerceptionColorFrameSource;
+  }
+  var IPerceptionColorFrameSourceAddedEventArgs: abstract new (...args: any[]) => IPerceptionColorFrameSourceAddedEventArgs;
+
+  interface IPerceptionColorFrameSourceRemovedEventArgs {
+    readonly FrameSource: Windows.Devices.Perception.PerceptionColorFrameSource;
+  }
+  var IPerceptionColorFrameSourceRemovedEventArgs: abstract new (...args: any[]) => IPerceptionColorFrameSourceRemovedEventArgs;
+
+  interface IPerceptionColorFrameSourceStatics {
+    CreateWatcher(): Windows.Devices.Perception.PerceptionColorFrameSourceWatcher;
+    FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.PerceptionColorFrameSource> | Windows.Devices.Perception.PerceptionColorFrameSource[]>;
+    FromIdAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionColorFrameSource>;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IPerceptionColorFrameSourceStatics: abstract new (...args: any[]) => IPerceptionColorFrameSourceStatics;
+
+  interface IPerceptionColorFrameSourceWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameSourceWatcher, Object> | null;
+    SourceAdded: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameSourceWatcher, Windows.Devices.Perception.PerceptionColorFrameSourceAddedEventArgs> | null;
+    SourceRemoved: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameSourceWatcher, Windows.Devices.Perception.PerceptionColorFrameSourceRemovedEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionColorFrameSourceWatcher, Object> | null;
+  }
+  var IPerceptionColorFrameSourceWatcher: abstract new (...args: any[]) => IPerceptionColorFrameSourceWatcher;
+
+  interface IPerceptionControlSession extends Windows.Foundation.IClosable {
+    Close(): void;
+    TrySetPropertyAsync(name: string, value: Object): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionFrameSourcePropertyChangeResult>;
+    ControlLost: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionControlSession, Object> | null;
+  }
+  var IPerceptionControlSession: abstract new (...args: any[]) => IPerceptionControlSession;
+
+  interface IPerceptionDepthCorrelatedCameraIntrinsics {
+    UnprojectAllPixelsAtCorrelatedDepthAsync(depthFrame: Windows.Devices.Perception.PerceptionDepthFrame, results: Windows.Foundation.Numerics.Vector3[]): Windows.Foundation.IAsyncAction;
+    UnprojectPixelAtCorrelatedDepth(pixelCoordinate: Windows.Foundation.Point, depthFrame: Windows.Devices.Perception.PerceptionDepthFrame): Windows.Foundation.Numerics.Vector3;
+    UnprojectPixelsAtCorrelatedDepth(sourceCoordinates: Windows.Foundation.Point[], depthFrame: Windows.Devices.Perception.PerceptionDepthFrame, results: Windows.Foundation.Numerics.Vector3[]): void;
+    UnprojectRegionPixelsAtCorrelatedDepthAsync(region: Windows.Foundation.Rect, depthFrame: Windows.Devices.Perception.PerceptionDepthFrame, results: Windows.Foundation.Numerics.Vector3[]): Windows.Foundation.IAsyncAction;
+  }
+  var IPerceptionDepthCorrelatedCameraIntrinsics: abstract new (...args: any[]) => IPerceptionDepthCorrelatedCameraIntrinsics;
+
+  interface IPerceptionDepthCorrelatedCoordinateMapper {
+    MapAllPixelsToTargetAsync(depthFrame: Windows.Devices.Perception.PerceptionDepthFrame, targetCoordinates: Windows.Foundation.Point[]): Windows.Foundation.IAsyncAction;
+    MapPixelToTarget(sourcePixelCoordinate: Windows.Foundation.Point, depthFrame: Windows.Devices.Perception.PerceptionDepthFrame): Windows.Foundation.Point;
+    MapPixelsToTarget(sourceCoordinates: Windows.Foundation.Point[], depthFrame: Windows.Devices.Perception.PerceptionDepthFrame, results: Windows.Foundation.Point[]): void;
+    MapRegionOfPixelsToTargetAsync(region: Windows.Foundation.Rect, depthFrame: Windows.Devices.Perception.PerceptionDepthFrame, targetCoordinates: Windows.Foundation.Point[]): Windows.Foundation.IAsyncAction;
+  }
+  var IPerceptionDepthCorrelatedCoordinateMapper: abstract new (...args: any[]) => IPerceptionDepthCorrelatedCoordinateMapper;
+
+  interface IPerceptionDepthFrame extends Windows.Foundation.IClosable {
+    Close(): void;
+    readonly VideoFrame: Windows.Media.VideoFrame;
+  }
+  var IPerceptionDepthFrame: abstract new (...args: any[]) => IPerceptionDepthFrame;
+
+  interface IPerceptionDepthFrameArrivedEventArgs {
+    TryOpenFrame(): Windows.Devices.Perception.PerceptionDepthFrame;
+    readonly RelativeTime: Windows.Foundation.TimeSpan;
+  }
+  var IPerceptionDepthFrameArrivedEventArgs: abstract new (...args: any[]) => IPerceptionDepthFrameArrivedEventArgs;
+
+  interface IPerceptionDepthFrameReader extends Windows.Foundation.IClosable {
+    Close(): void;
+    TryReadLatestFrame(): Windows.Devices.Perception.PerceptionDepthFrame;
+    IsPaused: boolean;
+    readonly Source: Windows.Devices.Perception.PerceptionDepthFrameSource;
+    FrameArrived: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameReader, Windows.Devices.Perception.PerceptionDepthFrameArrivedEventArgs> | null;
+  }
+  var IPerceptionDepthFrameReader: abstract new (...args: any[]) => IPerceptionDepthFrameReader;
+
+  interface IPerceptionDepthFrameSource {
+    AcquireControlSession(): Windows.Devices.Perception.PerceptionControlSession;
+    CanControlIndependentlyFrom(targetId: string): boolean;
+    IsCorrelatedWith(targetId: string): boolean;
+    OpenReader(): Windows.Devices.Perception.PerceptionDepthFrameReader;
+    TryGetDepthCorrelatedCameraIntrinsicsAsync(target: Windows.Devices.Perception.PerceptionDepthFrameSource): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionDepthCorrelatedCameraIntrinsics>;
+    TryGetDepthCorrelatedCoordinateMapperAsync(targetId: string, depthFrameSourceToMapWith: Windows.Devices.Perception.PerceptionDepthFrameSource): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionDepthCorrelatedCoordinateMapper>;
+    TryGetTransformTo(targetId: string, result: Windows.Foundation.Numerics.Matrix4x4): boolean;
+    TrySetVideoProfileAsync(controlSession: Windows.Devices.Perception.PerceptionControlSession, profile: Windows.Devices.Perception.PerceptionVideoProfile): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionFrameSourcePropertyChangeResult>;
+    readonly Active: boolean;
+    readonly Available: boolean;
+    readonly AvailableVideoProfiles: Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.PerceptionVideoProfile> | Windows.Devices.Perception.PerceptionVideoProfile[];
+    readonly CameraIntrinsics: Windows.Media.Devices.Core.CameraIntrinsics;
+    readonly DeviceKind: string;
+    readonly DisplayName: string;
+    readonly Id: string;
+    readonly IsControlled: boolean;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly SupportedVideoProfiles: Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.PerceptionVideoProfile> | Windows.Devices.Perception.PerceptionVideoProfile[];
+    readonly VideoProfile: Windows.Devices.Perception.PerceptionVideoProfile;
+    ActiveChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameSource, Object> | null;
+    AvailableChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameSource, Object> | null;
+    CameraIntrinsicsChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameSource, Object> | null;
+    PropertiesChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameSource, Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs> | null;
+    VideoProfileChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameSource, Object> | null;
+  }
+  var IPerceptionDepthFrameSource: abstract new (...args: any[]) => IPerceptionDepthFrameSource;
+
+  interface IPerceptionDepthFrameSource2 {
+    readonly DeviceId: string;
+  }
+  var IPerceptionDepthFrameSource2: abstract new (...args: any[]) => IPerceptionDepthFrameSource2;
+
+  interface IPerceptionDepthFrameSourceAddedEventArgs {
+    readonly FrameSource: Windows.Devices.Perception.PerceptionDepthFrameSource;
+  }
+  var IPerceptionDepthFrameSourceAddedEventArgs: abstract new (...args: any[]) => IPerceptionDepthFrameSourceAddedEventArgs;
+
+  interface IPerceptionDepthFrameSourceRemovedEventArgs {
+    readonly FrameSource: Windows.Devices.Perception.PerceptionDepthFrameSource;
+  }
+  var IPerceptionDepthFrameSourceRemovedEventArgs: abstract new (...args: any[]) => IPerceptionDepthFrameSourceRemovedEventArgs;
+
+  interface IPerceptionDepthFrameSourceStatics {
+    CreateWatcher(): Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher;
+    FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.PerceptionDepthFrameSource> | Windows.Devices.Perception.PerceptionDepthFrameSource[]>;
+    FromIdAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionDepthFrameSource>;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IPerceptionDepthFrameSourceStatics: abstract new (...args: any[]) => IPerceptionDepthFrameSourceStatics;
+
+  interface IPerceptionDepthFrameSourceWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher, Object> | null;
+    SourceAdded: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher, Windows.Devices.Perception.PerceptionDepthFrameSourceAddedEventArgs> | null;
+    SourceRemoved: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher, Windows.Devices.Perception.PerceptionDepthFrameSourceRemovedEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionDepthFrameSourceWatcher, Object> | null;
+  }
+  var IPerceptionDepthFrameSourceWatcher: abstract new (...args: any[]) => IPerceptionDepthFrameSourceWatcher;
+
+  interface IPerceptionFrameSourcePropertiesChangedEventArgs {
+    readonly CollectionChange: number;
+    readonly Key: string;
+  }
+  var IPerceptionFrameSourcePropertiesChangedEventArgs: abstract new (...args: any[]) => IPerceptionFrameSourcePropertiesChangedEventArgs;
+
+  interface IPerceptionFrameSourcePropertyChangeResult {
+    readonly NewValue: Object;
+    readonly Status: number;
+  }
+  var IPerceptionFrameSourcePropertyChangeResult: abstract new (...args: any[]) => IPerceptionFrameSourcePropertyChangeResult;
+
+  interface IPerceptionInfraredFrame extends Windows.Foundation.IClosable {
+    Close(): void;
+    readonly VideoFrame: Windows.Media.VideoFrame;
+  }
+  var IPerceptionInfraredFrame: abstract new (...args: any[]) => IPerceptionInfraredFrame;
+
+  interface IPerceptionInfraredFrameArrivedEventArgs {
+    TryOpenFrame(): Windows.Devices.Perception.PerceptionInfraredFrame;
+    readonly RelativeTime: Windows.Foundation.TimeSpan;
+  }
+  var IPerceptionInfraredFrameArrivedEventArgs: abstract new (...args: any[]) => IPerceptionInfraredFrameArrivedEventArgs;
+
+  interface IPerceptionInfraredFrameReader extends Windows.Foundation.IClosable {
+    Close(): void;
+    TryReadLatestFrame(): Windows.Devices.Perception.PerceptionInfraredFrame;
+    IsPaused: boolean;
+    readonly Source: Windows.Devices.Perception.PerceptionInfraredFrameSource;
+    FrameArrived: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameReader, Windows.Devices.Perception.PerceptionInfraredFrameArrivedEventArgs> | null;
+  }
+  var IPerceptionInfraredFrameReader: abstract new (...args: any[]) => IPerceptionInfraredFrameReader;
+
+  interface IPerceptionInfraredFrameSource {
+    AcquireControlSession(): Windows.Devices.Perception.PerceptionControlSession;
+    CanControlIndependentlyFrom(targetId: string): boolean;
+    IsCorrelatedWith(targetId: string): boolean;
+    OpenReader(): Windows.Devices.Perception.PerceptionInfraredFrameReader;
+    TryGetDepthCorrelatedCameraIntrinsicsAsync(target: Windows.Devices.Perception.PerceptionDepthFrameSource): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionDepthCorrelatedCameraIntrinsics>;
+    TryGetDepthCorrelatedCoordinateMapperAsync(targetId: string, depthFrameSourceToMapWith: Windows.Devices.Perception.PerceptionDepthFrameSource): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionDepthCorrelatedCoordinateMapper>;
+    TryGetTransformTo(targetId: string, result: Windows.Foundation.Numerics.Matrix4x4): boolean;
+    TrySetVideoProfileAsync(controlSession: Windows.Devices.Perception.PerceptionControlSession, profile: Windows.Devices.Perception.PerceptionVideoProfile): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionFrameSourcePropertyChangeResult>;
+    readonly Active: boolean;
+    readonly Available: boolean;
+    readonly AvailableVideoProfiles: Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.PerceptionVideoProfile> | Windows.Devices.Perception.PerceptionVideoProfile[];
+    readonly CameraIntrinsics: Windows.Media.Devices.Core.CameraIntrinsics;
+    readonly DeviceKind: string;
+    readonly DisplayName: string;
+    readonly Id: string;
+    readonly IsControlled: boolean;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly SupportedVideoProfiles: Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.PerceptionVideoProfile> | Windows.Devices.Perception.PerceptionVideoProfile[];
+    readonly VideoProfile: Windows.Devices.Perception.PerceptionVideoProfile;
+    ActiveChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameSource, Object> | null;
+    AvailableChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameSource, Object> | null;
+    CameraIntrinsicsChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameSource, Object> | null;
+    PropertiesChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameSource, Windows.Devices.Perception.PerceptionFrameSourcePropertiesChangedEventArgs> | null;
+    VideoProfileChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameSource, Object> | null;
+  }
+  var IPerceptionInfraredFrameSource: abstract new (...args: any[]) => IPerceptionInfraredFrameSource;
+
+  interface IPerceptionInfraredFrameSource2 {
+    readonly DeviceId: string;
+  }
+  var IPerceptionInfraredFrameSource2: abstract new (...args: any[]) => IPerceptionInfraredFrameSource2;
+
+  interface IPerceptionInfraredFrameSourceAddedEventArgs {
+    readonly FrameSource: Windows.Devices.Perception.PerceptionInfraredFrameSource;
+  }
+  var IPerceptionInfraredFrameSourceAddedEventArgs: abstract new (...args: any[]) => IPerceptionInfraredFrameSourceAddedEventArgs;
+
+  interface IPerceptionInfraredFrameSourceRemovedEventArgs {
+    readonly FrameSource: Windows.Devices.Perception.PerceptionInfraredFrameSource;
+  }
+  var IPerceptionInfraredFrameSourceRemovedEventArgs: abstract new (...args: any[]) => IPerceptionInfraredFrameSourceRemovedEventArgs;
+
+  interface IPerceptionInfraredFrameSourceStatics {
+    CreateWatcher(): Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher;
+    FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.PerceptionInfraredFrameSource> | Windows.Devices.Perception.PerceptionInfraredFrameSource[]>;
+    FromIdAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Perception.PerceptionInfraredFrameSource>;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IPerceptionInfraredFrameSourceStatics: abstract new (...args: any[]) => IPerceptionInfraredFrameSourceStatics;
+
+  interface IPerceptionInfraredFrameSourceWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher, Object> | null;
+    SourceAdded: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher, Windows.Devices.Perception.PerceptionInfraredFrameSourceAddedEventArgs> | null;
+    SourceRemoved: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher, Windows.Devices.Perception.PerceptionInfraredFrameSourceRemovedEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Devices.Perception.PerceptionInfraredFrameSourceWatcher, Object> | null;
+  }
+  var IPerceptionInfraredFrameSourceWatcher: abstract new (...args: any[]) => IPerceptionInfraredFrameSourceWatcher;
+
+  interface IPerceptionVideoProfile {
+    IsEqual(other: Windows.Devices.Perception.PerceptionVideoProfile): boolean;
+    readonly BitmapAlphaMode: number;
+    readonly BitmapPixelFormat: number;
+    readonly FrameDuration: Windows.Foundation.TimeSpan;
+    readonly Height: number;
+    readonly Width: number;
+  }
+  var IPerceptionVideoProfile: abstract new (...args: any[]) => IPerceptionVideoProfile;
+
+}
+
+declare namespace Windows.Devices.Perception.Provider {
+  class KnownPerceptionFrameKind {
+    static readonly Color: string;
+    static readonly Depth: string;
+    static readonly Infrared: string;
+  }
+
+  class PerceptionControlGroup implements Windows.Devices.Perception.Provider.IPerceptionControlGroup {
+    constructor(ids: Windows.Foundation.Collections.IIterable<string> | string[]);
+    readonly FrameProviderIds: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+
+  class PerceptionCorrelation implements Windows.Devices.Perception.Provider.IPerceptionCorrelation {
+    constructor(targetId: string, position: Windows.Foundation.Numerics.Vector3, orientation: Windows.Foundation.Numerics.Quaternion);
+    readonly Orientation: Windows.Foundation.Numerics.Quaternion;
+    readonly Position: Windows.Foundation.Numerics.Vector3;
+    readonly TargetId: string;
+  }
+
+  class PerceptionCorrelationGroup implements Windows.Devices.Perception.Provider.IPerceptionCorrelationGroup {
+    constructor(relativeLocations: Windows.Foundation.Collections.IIterable<Windows.Devices.Perception.Provider.PerceptionCorrelation> | Windows.Devices.Perception.Provider.PerceptionCorrelation[]);
+    readonly RelativeLocations: Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.Provider.PerceptionCorrelation> | Windows.Devices.Perception.Provider.PerceptionCorrelation[];
+  }
+
+  class PerceptionFaceAuthenticationGroup implements Windows.Devices.Perception.Provider.IPerceptionFaceAuthenticationGroup {
+    constructor(ids: Windows.Foundation.Collections.IIterable<string> | string[], startHandler: Windows.Devices.Perception.Provider.PerceptionStartFaceAuthenticationHandler, stopHandler: Windows.Devices.Perception.Provider.PerceptionStopFaceAuthenticationHandler);
+    readonly FrameProviderIds: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+
+  class PerceptionFrame implements Windows.Devices.Perception.Provider.IPerceptionFrame {
+    readonly FrameData: Windows.Foundation.IMemoryBuffer;
+    readonly Properties: Windows.Foundation.Collections.ValueSet;
+    RelativeTime: Windows.Foundation.TimeSpan;
+  }
+
+  class PerceptionFrameProviderInfo implements Windows.Devices.Perception.Provider.IPerceptionFrameProviderInfo {
+    constructor();
+    DeviceKind: string;
+    DisplayName: string;
+    FrameKind: string;
+    Hidden: boolean;
+    Id: string;
+  }
+
+  class PerceptionFrameProviderManagerService {
+    static PublishFrameForProvider(provider: Windows.Devices.Perception.Provider.IPerceptionFrameProvider, frame: Windows.Devices.Perception.Provider.PerceptionFrame): void;
+    static RegisterControlGroup(manager: Windows.Devices.Perception.Provider.IPerceptionFrameProviderManager, controlGroup: Windows.Devices.Perception.Provider.PerceptionControlGroup): void;
+    static RegisterCorrelationGroup(manager: Windows.Devices.Perception.Provider.IPerceptionFrameProviderManager, correlationGroup: Windows.Devices.Perception.Provider.PerceptionCorrelationGroup): void;
+    static RegisterFaceAuthenticationGroup(manager: Windows.Devices.Perception.Provider.IPerceptionFrameProviderManager, faceAuthenticationGroup: Windows.Devices.Perception.Provider.PerceptionFaceAuthenticationGroup): void;
+    static RegisterFrameProviderInfo(manager: Windows.Devices.Perception.Provider.IPerceptionFrameProviderManager, frameProviderInfo: Windows.Devices.Perception.Provider.PerceptionFrameProviderInfo): void;
+    static UnregisterControlGroup(manager: Windows.Devices.Perception.Provider.IPerceptionFrameProviderManager, controlGroup: Windows.Devices.Perception.Provider.PerceptionControlGroup): void;
+    static UnregisterCorrelationGroup(manager: Windows.Devices.Perception.Provider.IPerceptionFrameProviderManager, correlationGroup: Windows.Devices.Perception.Provider.PerceptionCorrelationGroup): void;
+    static UnregisterFaceAuthenticationGroup(manager: Windows.Devices.Perception.Provider.IPerceptionFrameProviderManager, faceAuthenticationGroup: Windows.Devices.Perception.Provider.PerceptionFaceAuthenticationGroup): void;
+    static UnregisterFrameProviderInfo(manager: Windows.Devices.Perception.Provider.IPerceptionFrameProviderManager, frameProviderInfo: Windows.Devices.Perception.Provider.PerceptionFrameProviderInfo): void;
+    static UpdateAvailabilityForProvider(provider: Windows.Devices.Perception.Provider.IPerceptionFrameProvider, available: boolean): void;
+  }
+
+  class PerceptionPropertyChangeRequest implements Windows.Devices.Perception.Provider.IPerceptionPropertyChangeRequest {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Name: string;
+    Status: number;
+    readonly Value: Object;
+  }
+
+  class PerceptionVideoFrameAllocator implements Windows.Devices.Perception.Provider.IPerceptionVideoFrameAllocator, Windows.Foundation.IClosable {
+    constructor(maxOutstandingFrameCountForWrite: number, format: number, resolution: Windows.Foundation.Size, alpha: number);
+    AllocateFrame(): Windows.Devices.Perception.Provider.PerceptionFrame;
+    Close(): void;
+    CopyFromVideoFrame(frame: Windows.Media.VideoFrame): Windows.Devices.Perception.Provider.PerceptionFrame;
+  }
+
+  interface IKnownPerceptionFrameKindStatics {
+    readonly Color: string;
+    readonly Depth: string;
+    readonly Infrared: string;
+  }
+  var IKnownPerceptionFrameKindStatics: abstract new (...args: any[]) => IKnownPerceptionFrameKindStatics;
+
+  interface IPerceptionControlGroup {
+    readonly FrameProviderIds: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var IPerceptionControlGroup: abstract new (...args: any[]) => IPerceptionControlGroup;
+
+  interface IPerceptionControlGroupFactory {
+    Create(ids: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Devices.Perception.Provider.PerceptionControlGroup;
+  }
+  var IPerceptionControlGroupFactory: abstract new (...args: any[]) => IPerceptionControlGroupFactory;
+
+  interface IPerceptionCorrelation {
+    readonly Orientation: Windows.Foundation.Numerics.Quaternion;
+    readonly Position: Windows.Foundation.Numerics.Vector3;
+    readonly TargetId: string;
+  }
+  var IPerceptionCorrelation: abstract new (...args: any[]) => IPerceptionCorrelation;
+
+  interface IPerceptionCorrelationFactory {
+    Create(targetId: string, position: Windows.Foundation.Numerics.Vector3, orientation: Windows.Foundation.Numerics.Quaternion): Windows.Devices.Perception.Provider.PerceptionCorrelation;
+  }
+  var IPerceptionCorrelationFactory: abstract new (...args: any[]) => IPerceptionCorrelationFactory;
+
+  interface IPerceptionCorrelationGroup {
+    readonly RelativeLocations: Windows.Foundation.Collections.IVectorView<Windows.Devices.Perception.Provider.PerceptionCorrelation> | Windows.Devices.Perception.Provider.PerceptionCorrelation[];
+  }
+  var IPerceptionCorrelationGroup: abstract new (...args: any[]) => IPerceptionCorrelationGroup;
+
+  interface IPerceptionCorrelationGroupFactory {
+    Create(relativeLocations: Windows.Foundation.Collections.IIterable<Windows.Devices.Perception.Provider.PerceptionCorrelation> | Windows.Devices.Perception.Provider.PerceptionCorrelation[]): Windows.Devices.Perception.Provider.PerceptionCorrelationGroup;
+  }
+  var IPerceptionCorrelationGroupFactory: abstract new (...args: any[]) => IPerceptionCorrelationGroupFactory;
+
+  interface IPerceptionFaceAuthenticationGroup {
+    readonly FrameProviderIds: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var IPerceptionFaceAuthenticationGroup: abstract new (...args: any[]) => IPerceptionFaceAuthenticationGroup;
+
+  interface IPerceptionFaceAuthenticationGroupFactory {
+    Create(ids: Windows.Foundation.Collections.IIterable<string> | string[], startHandler: Windows.Devices.Perception.Provider.PerceptionStartFaceAuthenticationHandler, stopHandler: Windows.Devices.Perception.Provider.PerceptionStopFaceAuthenticationHandler): Windows.Devices.Perception.Provider.PerceptionFaceAuthenticationGroup;
+  }
+  var IPerceptionFaceAuthenticationGroupFactory: abstract new (...args: any[]) => IPerceptionFaceAuthenticationGroupFactory;
+
+  interface IPerceptionFrame {
+    readonly FrameData: Windows.Foundation.IMemoryBuffer;
+    readonly Properties: Windows.Foundation.Collections.ValueSet;
+    RelativeTime: Windows.Foundation.TimeSpan;
+  }
+  var IPerceptionFrame: abstract new (...args: any[]) => IPerceptionFrame;
+
+  interface IPerceptionFrameProvider extends Windows.Foundation.IClosable {
+    Close(): void;
+    SetProperty(value: Windows.Devices.Perception.Provider.PerceptionPropertyChangeRequest): void;
+    Start(): void;
+    Stop(): void;
+    readonly Available: boolean;
+    readonly FrameProviderInfo: Windows.Devices.Perception.Provider.PerceptionFrameProviderInfo;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+  }
+  var IPerceptionFrameProvider: abstract new (...args: any[]) => IPerceptionFrameProvider;
+
+  interface IPerceptionFrameProviderInfo {
+    DeviceKind: string;
+    DisplayName: string;
+    FrameKind: string;
+    Hidden: boolean;
+    Id: string;
+  }
+  var IPerceptionFrameProviderInfo: abstract new (...args: any[]) => IPerceptionFrameProviderInfo;
+
+  interface IPerceptionFrameProviderManager extends Windows.Foundation.IClosable {
+    Close(): void;
+    GetFrameProvider(frameProviderInfo: Windows.Devices.Perception.Provider.PerceptionFrameProviderInfo): Windows.Devices.Perception.Provider.IPerceptionFrameProvider;
+  }
+  var IPerceptionFrameProviderManager: abstract new (...args: any[]) => IPerceptionFrameProviderManager;
+
+  interface IPerceptionFrameProviderManagerServiceStatics {
+    PublishFrameForProvider(provider: Windows.Devices.Perception.Provider.IPerceptionFrameProvider, frame: Windows.Devices.Perception.Provider.PerceptionFrame): void;
+    RegisterControlGroup(manager: Windows.Devices.Perception.Provider.IPerceptionFrameProviderManager, controlGroup: Windows.Devices.Perception.Provider.PerceptionControlGroup): void;
+    RegisterCorrelationGroup(manager: Windows.Devices.Perception.Provider.IPerceptionFrameProviderManager, correlationGroup: Windows.Devices.Perception.Provider.PerceptionCorrelationGroup): void;
+    RegisterFaceAuthenticationGroup(manager: Windows.Devices.Perception.Provider.IPerceptionFrameProviderManager, faceAuthenticationGroup: Windows.Devices.Perception.Provider.PerceptionFaceAuthenticationGroup): void;
+    RegisterFrameProviderInfo(manager: Windows.Devices.Perception.Provider.IPerceptionFrameProviderManager, frameProviderInfo: Windows.Devices.Perception.Provider.PerceptionFrameProviderInfo): void;
+    UnregisterControlGroup(manager: Windows.Devices.Perception.Provider.IPerceptionFrameProviderManager, controlGroup: Windows.Devices.Perception.Provider.PerceptionControlGroup): void;
+    UnregisterCorrelationGroup(manager: Windows.Devices.Perception.Provider.IPerceptionFrameProviderManager, correlationGroup: Windows.Devices.Perception.Provider.PerceptionCorrelationGroup): void;
+    UnregisterFaceAuthenticationGroup(manager: Windows.Devices.Perception.Provider.IPerceptionFrameProviderManager, faceAuthenticationGroup: Windows.Devices.Perception.Provider.PerceptionFaceAuthenticationGroup): void;
+    UnregisterFrameProviderInfo(manager: Windows.Devices.Perception.Provider.IPerceptionFrameProviderManager, frameProviderInfo: Windows.Devices.Perception.Provider.PerceptionFrameProviderInfo): void;
+    UpdateAvailabilityForProvider(provider: Windows.Devices.Perception.Provider.IPerceptionFrameProvider, available: boolean): void;
+  }
+  var IPerceptionFrameProviderManagerServiceStatics: abstract new (...args: any[]) => IPerceptionFrameProviderManagerServiceStatics;
+
+  interface IPerceptionPropertyChangeRequest {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Name: string;
+    Status: number;
+    readonly Value: Object;
+  }
+  var IPerceptionPropertyChangeRequest: abstract new (...args: any[]) => IPerceptionPropertyChangeRequest;
+
+  interface IPerceptionVideoFrameAllocator extends Windows.Foundation.IClosable {
+    AllocateFrame(): Windows.Devices.Perception.Provider.PerceptionFrame;
+    Close(): void;
+    CopyFromVideoFrame(frame: Windows.Media.VideoFrame): Windows.Devices.Perception.Provider.PerceptionFrame;
+  }
+  var IPerceptionVideoFrameAllocator: abstract new (...args: any[]) => IPerceptionVideoFrameAllocator;
+
+  interface IPerceptionVideoFrameAllocatorFactory {
+    Create(maxOutstandingFrameCountForWrite: number, format: number, resolution: Windows.Foundation.Size, alpha: number): Windows.Devices.Perception.Provider.PerceptionVideoFrameAllocator;
+  }
+  var IPerceptionVideoFrameAllocatorFactory: abstract new (...args: any[]) => IPerceptionVideoFrameAllocatorFactory;
+
+  interface PerceptionStartFaceAuthenticationHandler {
+    (sender: Windows.Devices.Perception.Provider.PerceptionFaceAuthenticationGroup): boolean;
+  }
+  var PerceptionStartFaceAuthenticationHandler: {
+    new(callback: (sender: Windows.Devices.Perception.Provider.PerceptionFaceAuthenticationGroup) => boolean): PerceptionStartFaceAuthenticationHandler;
+  };
+
+  interface PerceptionStopFaceAuthenticationHandler {
+    (sender: Windows.Devices.Perception.Provider.PerceptionFaceAuthenticationGroup): void;
+  }
+  var PerceptionStopFaceAuthenticationHandler: {
+    new(callback: (sender: Windows.Devices.Perception.Provider.PerceptionFaceAuthenticationGroup) => void): PerceptionStopFaceAuthenticationHandler;
+  };
+
+}
+
+declare namespace Windows.Devices.PointOfService {
+  class BarcodeScanner implements Windows.Devices.PointOfService.IBarcodeScanner, Windows.Devices.PointOfService.IBarcodeScanner2, Windows.Foundation.IClosable {
+    CheckHealthAsync(level: number): Windows.Foundation.IAsyncOperation<string>;
+    ClaimScannerAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.ClaimedBarcodeScanner>;
+    Close(): void;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.BarcodeScanner>;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.BarcodeScanner>;
+    static GetDeviceSelector(connectionTypes: number): string;
+    static GetDeviceSelector(): string;
+    GetSupportedProfiles(): Windows.Foundation.Collections.IVectorView<string> | string[];
+    GetSupportedSymbologiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<number> | number[]>;
+    IsProfileSupported(profile: string): boolean;
+    IsSymbologySupportedAsync(barcodeSymbology: number): Windows.Foundation.IAsyncOperation<boolean>;
+    RetrieveStatisticsAsync(statisticsCategories: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    readonly Capabilities: Windows.Devices.PointOfService.BarcodeScannerCapabilities;
+    readonly DeviceId: string;
+    readonly VideoDeviceId: string;
+    StatusUpdated: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.BarcodeScanner, Windows.Devices.PointOfService.BarcodeScannerStatusUpdatedEventArgs> | null;
+  }
+
+  class BarcodeScannerCapabilities implements Windows.Devices.PointOfService.IBarcodeScannerCapabilities, Windows.Devices.PointOfService.IBarcodeScannerCapabilities1, Windows.Devices.PointOfService.IBarcodeScannerCapabilities2 {
+    readonly IsImagePreviewSupported: boolean;
+    readonly IsSoftwareTriggerSupported: boolean;
+    readonly IsStatisticsReportingSupported: boolean;
+    readonly IsStatisticsUpdatingSupported: boolean;
+    readonly IsVideoPreviewSupported: boolean;
+    readonly PowerReportingType: number;
+  }
+
+  class BarcodeScannerDataReceivedEventArgs implements Windows.Devices.PointOfService.IBarcodeScannerDataReceivedEventArgs {
+    readonly Report: Windows.Devices.PointOfService.BarcodeScannerReport;
+  }
+
+  class BarcodeScannerErrorOccurredEventArgs implements Windows.Devices.PointOfService.IBarcodeScannerErrorOccurredEventArgs {
+    readonly ErrorData: Windows.Devices.PointOfService.UnifiedPosErrorData;
+    readonly IsRetriable: boolean;
+    readonly PartialInputData: Windows.Devices.PointOfService.BarcodeScannerReport;
+  }
+
+  class BarcodeScannerImagePreviewReceivedEventArgs implements Windows.Devices.PointOfService.IBarcodeScannerImagePreviewReceivedEventArgs {
+    readonly Preview: Windows.Storage.Streams.IRandomAccessStreamWithContentType;
+  }
+
+  class BarcodeScannerReport implements Windows.Devices.PointOfService.IBarcodeScannerReport {
+    constructor(scanDataType: number, scanData: Windows.Storage.Streams.IBuffer, scanDataLabel: Windows.Storage.Streams.IBuffer);
+    readonly ScanData: Windows.Storage.Streams.IBuffer;
+    readonly ScanDataLabel: Windows.Storage.Streams.IBuffer;
+    readonly ScanDataType: number;
+  }
+
+  class BarcodeScannerStatusUpdatedEventArgs implements Windows.Devices.PointOfService.IBarcodeScannerStatusUpdatedEventArgs {
+    readonly ExtendedStatus: number;
+    readonly Status: number;
+  }
+
+  class BarcodeSymbologies {
+    static GetName(scanDataType: number): string;
+    static readonly AusPost: number;
+    static readonly Aztec: number;
+    static readonly CanPost: number;
+    static readonly Ccab: number;
+    static readonly Ccc: number;
+    static readonly ChinaPost: number;
+    static readonly Codabar: number;
+    static readonly Codablock128: number;
+    static readonly CodablockA: number;
+    static readonly CodablockF: number;
+    static readonly Code11: number;
+    static readonly Code128: number;
+    static readonly Code16k: number;
+    static readonly Code32: number;
+    static readonly Code39: number;
+    static readonly Code39Ex: number;
+    static readonly Code49: number;
+    static readonly Code93: number;
+    static readonly Code93Ex: number;
+    static readonly DataCode: number;
+    static readonly DataMatrix: number;
+    static readonly DutchKix: number;
+    static readonly Ean13: number;
+    static readonly Ean13Add2: number;
+    static readonly Ean13Add5: number;
+    static readonly Ean8: number;
+    static readonly Ean8Add2: number;
+    static readonly Ean8Add5: number;
+    static readonly Ean99: number;
+    static readonly Ean99Add2: number;
+    static readonly Ean99Add5: number;
+    static readonly Eanv: number;
+    static readonly EanvAdd2: number;
+    static readonly EanvAdd5: number;
+    static readonly ExtendedBase: number;
+    static readonly Gs1128: number;
+    static readonly Gs1128Coupon: number;
+    static readonly Gs1DWCode: number;
+    static readonly Gs1DatabarType1: number;
+    static readonly Gs1DatabarType2: number;
+    static readonly Gs1DatabarType3: number;
+    static readonly HanXin: number;
+    static readonly InfoMail: number;
+    static readonly Isbn: number;
+    static readonly IsbnAdd5: number;
+    static readonly Isbt: number;
+    static readonly Ismn: number;
+    static readonly IsmnAdd2: number;
+    static readonly IsmnAdd5: number;
+    static readonly Issn: number;
+    static readonly IssnAdd2: number;
+    static readonly IssnAdd5: number;
+    static readonly ItalianPost25: number;
+    static readonly ItalianPost39: number;
+    static readonly JapanPost: number;
+    static readonly KoreanPost: number;
+    static readonly Maxicode: number;
+    static readonly Micr: number;
+    static readonly MicroPdf417: number;
+    static readonly MicroQr: number;
+    static readonly MsTag: number;
+    static readonly Msi: number;
+    static readonly OcrA: number;
+    static readonly OcrB: number;
+    static readonly Pdf417: number;
+    static readonly Plessey: number;
+    static readonly Pzn: number;
+    static readonly Qr: number;
+    static readonly Sisac: number;
+    static readonly SwedenPost: number;
+    static readonly Telepen: number;
+    static readonly TfDis: number;
+    static readonly TfIata: number;
+    static readonly TfInd: number;
+    static readonly TfInt: number;
+    static readonly TfMat: number;
+    static readonly TfStd: number;
+    static readonly Tlc39: number;
+    static readonly Trioptic39: number;
+    static readonly UccEan128: number;
+    static readonly UkPost: number;
+    static readonly Unknown: number;
+    static readonly UpcCoupon: number;
+    static readonly Upca: number;
+    static readonly UpcaAdd2: number;
+    static readonly UpcaAdd5: number;
+    static readonly Upce: number;
+    static readonly UpceAdd2: number;
+    static readonly UpceAdd5: number;
+    static readonly Us4StateFics: number;
+    static readonly UsIntelligent: number;
+    static readonly UsIntelligentPkg: number;
+    static readonly UsPlanet: number;
+    static readonly UsPostNet: number;
+  }
+
+  class BarcodeSymbologyAttributes implements Windows.Devices.PointOfService.IBarcodeSymbologyAttributes {
+    DecodeLength1: number;
+    DecodeLength2: number;
+    DecodeLengthKind: number;
+    IsCheckDigitTransmissionEnabled: boolean;
+    readonly IsCheckDigitTransmissionSupported: boolean;
+    IsCheckDigitValidationEnabled: boolean;
+    readonly IsCheckDigitValidationSupported: boolean;
+    readonly IsDecodeLengthSupported: boolean;
+  }
+
+  class CashDrawer implements Windows.Devices.PointOfService.ICashDrawer, Windows.Foundation.IClosable {
+    CheckHealthAsync(level: number): Windows.Foundation.IAsyncOperation<string>;
+    ClaimDrawerAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.ClaimedCashDrawer>;
+    Close(): void;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.CashDrawer>;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.CashDrawer>;
+    static GetDeviceSelector(connectionTypes: number): string;
+    static GetDeviceSelector(): string;
+    GetStatisticsAsync(statisticsCategories: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<string>;
+    readonly Capabilities: Windows.Devices.PointOfService.CashDrawerCapabilities;
+    readonly DeviceId: string;
+    readonly DrawerEventSource: Windows.Devices.PointOfService.CashDrawerEventSource;
+    readonly IsDrawerOpen: boolean;
+    readonly Status: Windows.Devices.PointOfService.CashDrawerStatus;
+    StatusUpdated: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.CashDrawer, Windows.Devices.PointOfService.CashDrawerStatusUpdatedEventArgs> | null;
+  }
+
+  class CashDrawerCapabilities implements Windows.Devices.PointOfService.ICashDrawerCapabilities {
+    readonly IsDrawerOpenSensorAvailable: boolean;
+    readonly IsStatisticsReportingSupported: boolean;
+    readonly IsStatisticsUpdatingSupported: boolean;
+    readonly IsStatusMultiDrawerDetectSupported: boolean;
+    readonly IsStatusReportingSupported: boolean;
+    readonly PowerReportingType: number;
+  }
+
+  class CashDrawerCloseAlarm implements Windows.Devices.PointOfService.ICashDrawerCloseAlarm {
+    StartAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    AlarmTimeout: Windows.Foundation.TimeSpan;
+    BeepDelay: Windows.Foundation.TimeSpan;
+    BeepDuration: Windows.Foundation.TimeSpan;
+    BeepFrequency: number;
+    AlarmTimeoutExpired: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.CashDrawerCloseAlarm, Object> | null;
+  }
+
+  class CashDrawerClosedEventArgs implements Windows.Devices.PointOfService.ICashDrawerEventSourceEventArgs {
+    readonly CashDrawer: Windows.Devices.PointOfService.CashDrawer;
+  }
+
+  class CashDrawerEventSource implements Windows.Devices.PointOfService.ICashDrawerEventSource {
+    DrawerClosed: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.CashDrawerEventSource, Windows.Devices.PointOfService.CashDrawerClosedEventArgs> | null;
+    DrawerOpened: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.CashDrawerEventSource, Windows.Devices.PointOfService.CashDrawerOpenedEventArgs> | null;
+  }
+
+  class CashDrawerOpenedEventArgs implements Windows.Devices.PointOfService.ICashDrawerEventSourceEventArgs {
+    readonly CashDrawer: Windows.Devices.PointOfService.CashDrawer;
+  }
+
+  class CashDrawerStatus implements Windows.Devices.PointOfService.ICashDrawerStatus {
+    readonly ExtendedStatus: number;
+    readonly StatusKind: number;
+  }
+
+  class CashDrawerStatusUpdatedEventArgs implements Windows.Devices.PointOfService.ICashDrawerStatusUpdatedEventArgs {
+    readonly Status: Windows.Devices.PointOfService.CashDrawerStatus;
+  }
+
+  class ClaimedBarcodeScanner implements Windows.Devices.PointOfService.IClaimedBarcodeScanner, Windows.Devices.PointOfService.IClaimedBarcodeScanner1, Windows.Devices.PointOfService.IClaimedBarcodeScanner2, Windows.Devices.PointOfService.IClaimedBarcodeScanner3, Windows.Devices.PointOfService.IClaimedBarcodeScanner4, Windows.Foundation.IClosable {
+    Close(): void;
+    DisableAsync(): Windows.Foundation.IAsyncAction;
+    EnableAsync(): Windows.Foundation.IAsyncAction;
+    GetSymbologyAttributesAsync(barcodeSymbology: number): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.BarcodeSymbologyAttributes>;
+    HideVideoPreview(): void;
+    ResetStatisticsAsync(statisticsCategories: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    RetainDevice(): void;
+    SetActiveProfileAsync(profile: string): Windows.Foundation.IAsyncAction;
+    SetActiveSymbologiesAsync(symbologies: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.Foundation.IAsyncAction;
+    SetSymbologyAttributesAsync(barcodeSymbology: number, attributes: Windows.Devices.PointOfService.BarcodeSymbologyAttributes): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowVideoPreviewAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    StartSoftwareTriggerAsync(): Windows.Foundation.IAsyncAction;
+    StopSoftwareTriggerAsync(): Windows.Foundation.IAsyncAction;
+    UpdateStatisticsAsync(statistics: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, string>> | Windows.Foundation.Collections.IKeyValuePair<string, string>[]): Windows.Foundation.IAsyncAction;
+    readonly DeviceId: string;
+    IsDecodeDataEnabled: boolean;
+    IsDisabledOnDataReceived: boolean;
+    readonly IsEnabled: boolean;
+    IsVideoPreviewShownOnEnable: boolean;
+    DataReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedBarcodeScanner, Windows.Devices.PointOfService.BarcodeScannerDataReceivedEventArgs> | null;
+    ErrorOccurred: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedBarcodeScanner, Windows.Devices.PointOfService.BarcodeScannerErrorOccurredEventArgs> | null;
+    ImagePreviewReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedBarcodeScanner, Windows.Devices.PointOfService.BarcodeScannerImagePreviewReceivedEventArgs> | null;
+    ReleaseDeviceRequested: Windows.Foundation.EventHandler<Windows.Devices.PointOfService.ClaimedBarcodeScanner> | null;
+    TriggerPressed: Windows.Foundation.EventHandler<Windows.Devices.PointOfService.ClaimedBarcodeScanner> | null;
+    TriggerReleased: Windows.Foundation.EventHandler<Windows.Devices.PointOfService.ClaimedBarcodeScanner> | null;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedBarcodeScanner, Windows.Devices.PointOfService.ClaimedBarcodeScannerClosedEventArgs> | null;
+  }
+
+  class ClaimedBarcodeScannerClosedEventArgs implements Windows.Devices.PointOfService.IClaimedBarcodeScannerClosedEventArgs {
+  }
+
+  class ClaimedCashDrawer implements Windows.Devices.PointOfService.IClaimedCashDrawer, Windows.Devices.PointOfService.IClaimedCashDrawer2, Windows.Foundation.IClosable {
+    Close(): void;
+    DisableAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    EnableAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    OpenDrawerAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    ResetStatisticsAsync(statisticsCategories: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<boolean>;
+    RetainDeviceAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    UpdateStatisticsAsync(statistics: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, string>> | Windows.Foundation.Collections.IKeyValuePair<string, string>[]): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly CloseAlarm: Windows.Devices.PointOfService.CashDrawerCloseAlarm;
+    readonly DeviceId: string;
+    readonly IsDrawerOpen: boolean;
+    readonly IsEnabled: boolean;
+    ReleaseDeviceRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedCashDrawer, Object> | null;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedCashDrawer, Windows.Devices.PointOfService.ClaimedCashDrawerClosedEventArgs> | null;
+  }
+
+  class ClaimedCashDrawerClosedEventArgs implements Windows.Devices.PointOfService.IClaimedCashDrawerClosedEventArgs {
+  }
+
+  class ClaimedJournalPrinter implements Windows.Devices.PointOfService.IClaimedJournalPrinter, Windows.Devices.PointOfService.ICommonClaimedPosPrinterStation {
+    CreateJob(): Windows.Devices.PointOfService.JournalPrintJob;
+    ValidateData(data: string): boolean;
+    CharactersPerLine: number;
+    ColorCartridge: number;
+    readonly IsCartridgeEmpty: boolean;
+    readonly IsCartridgeRemoved: boolean;
+    readonly IsCoverOpen: boolean;
+    readonly IsHeadCleaning: boolean;
+    IsLetterQuality: boolean;
+    readonly IsPaperEmpty: boolean;
+    readonly IsPaperNearEnd: boolean;
+    readonly IsReadyToPrint: boolean;
+    LineHeight: number;
+    LineSpacing: number;
+    readonly LineWidth: number;
+  }
+
+  class ClaimedLineDisplay implements Windows.Devices.PointOfService.IClaimedLineDisplay, Windows.Devices.PointOfService.IClaimedLineDisplay2, Windows.Devices.PointOfService.IClaimedLineDisplay3, Windows.Foundation.IClosable {
+    CheckHealthAsync(level: number): Windows.Foundation.IAsyncOperation<string>;
+    CheckPowerStatusAsync(): Windows.Foundation.IAsyncOperation<number>;
+    Close(): void;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.ClaimedLineDisplay>;
+    GetAttributes(): Windows.Devices.PointOfService.LineDisplayAttributes;
+    static GetDeviceSelector(): string;
+    static GetDeviceSelector(connectionTypes: number): string;
+    GetStatisticsAsync(statisticsCategories: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<string>;
+    RetainDevice(): void;
+    TryClearDescriptorsAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryCreateWindowAsync(viewport: Windows.Foundation.Rect, windowSize: Windows.Foundation.Size): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.LineDisplayWindow>;
+    TrySetDescriptorAsync(descriptor: number, descriptorState: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryStoreStorageFileBitmapAsync(bitmap: Windows.Storage.StorageFile): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.LineDisplayStoredBitmap>;
+    TryStoreStorageFileBitmapAsync(bitmap: Windows.Storage.StorageFile, horizontalAlignment: number, verticalAlignment: number): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.LineDisplayStoredBitmap>;
+    TryStoreStorageFileBitmapAsync(bitmap: Windows.Storage.StorageFile, horizontalAlignment: number, verticalAlignment: number, widthInPixels: number): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.LineDisplayStoredBitmap>;
+    TryUpdateAttributesAsync(attributes: Windows.Devices.PointOfService.LineDisplayAttributes): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Capabilities: Windows.Devices.PointOfService.LineDisplayCapabilities;
+    readonly CustomGlyphs: Windows.Devices.PointOfService.LineDisplayCustomGlyphs;
+    readonly DefaultWindow: Windows.Devices.PointOfService.LineDisplayWindow;
+    readonly DeviceControlDescription: string;
+    readonly DeviceControlVersion: string;
+    readonly DeviceId: string;
+    readonly DeviceServiceVersion: string;
+    readonly MaxBitmapSizeInPixels: Windows.Foundation.Size;
+    readonly PhysicalDeviceDescription: string;
+    readonly PhysicalDeviceName: string;
+    readonly SupportedCharacterSets: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedScreenSizesInCharacters: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Size> | Windows.Foundation.Size[];
+    ReleaseDeviceRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedLineDisplay, Object> | null;
+    StatusUpdated: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedLineDisplay, Windows.Devices.PointOfService.LineDisplayStatusUpdatedEventArgs> | null;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedLineDisplay, Windows.Devices.PointOfService.ClaimedLineDisplayClosedEventArgs> | null;
+  }
+
+  class ClaimedLineDisplayClosedEventArgs implements Windows.Devices.PointOfService.IClaimedLineDisplayClosedEventArgs {
+  }
+
+  class ClaimedMagneticStripeReader implements Windows.Devices.PointOfService.IClaimedMagneticStripeReader, Windows.Devices.PointOfService.IClaimedMagneticStripeReader2, Windows.Foundation.IClosable {
+    AuthenticateDeviceAsync(responseToken: number[]): Windows.Foundation.IAsyncAction;
+    Close(): void;
+    DeAuthenticateDeviceAsync(responseToken: number[]): Windows.Foundation.IAsyncAction;
+    DisableAsync(): Windows.Foundation.IAsyncAction;
+    EnableAsync(): Windows.Foundation.IAsyncAction;
+    ResetStatisticsAsync(statisticsCategories: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    RetainDevice(): void;
+    RetrieveDeviceAuthenticationDataAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    SetErrorReportingType(value: number): void;
+    UpdateKeyAsync(key: string, keyName: string): Windows.Foundation.IAsyncAction;
+    UpdateStatisticsAsync(statistics: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, string>> | Windows.Foundation.Collections.IKeyValuePair<string, string>[]): Windows.Foundation.IAsyncAction;
+    DataEncryptionAlgorithm: number;
+    readonly DeviceId: string;
+    IsDecodeDataEnabled: boolean;
+    readonly IsDeviceAuthenticated: boolean;
+    IsDisabledOnDataReceived: boolean;
+    readonly IsEnabled: boolean;
+    IsTransmitSentinelsEnabled: boolean;
+    TracksToRead: number;
+    AamvaCardDataReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedMagneticStripeReader, Windows.Devices.PointOfService.MagneticStripeReaderAamvaCardDataReceivedEventArgs> | null;
+    BankCardDataReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedMagneticStripeReader, Windows.Devices.PointOfService.MagneticStripeReaderBankCardDataReceivedEventArgs> | null;
+    ErrorOccurred: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedMagneticStripeReader, Windows.Devices.PointOfService.MagneticStripeReaderErrorOccurredEventArgs> | null;
+    ReleaseDeviceRequested: Windows.Foundation.EventHandler<Windows.Devices.PointOfService.ClaimedMagneticStripeReader> | null;
+    VendorSpecificDataReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedMagneticStripeReader, Windows.Devices.PointOfService.MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs> | null;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedMagneticStripeReader, Windows.Devices.PointOfService.ClaimedMagneticStripeReaderClosedEventArgs> | null;
+  }
+
+  class ClaimedMagneticStripeReaderClosedEventArgs implements Windows.Devices.PointOfService.IClaimedMagneticStripeReaderClosedEventArgs {
+  }
+
+  class ClaimedPosPrinter implements Windows.Devices.PointOfService.IClaimedPosPrinter, Windows.Devices.PointOfService.IClaimedPosPrinter2, Windows.Foundation.IClosable {
+    Close(): void;
+    DisableAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    EnableAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    ResetStatisticsAsync(statisticsCategories: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<boolean>;
+    RetainDeviceAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    UpdateStatisticsAsync(statistics: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, string>> | Windows.Foundation.Collections.IKeyValuePair<string, string>[]): Windows.Foundation.IAsyncOperation<boolean>;
+    CharacterSet: number;
+    readonly DeviceId: string;
+    IsCharacterSetMappingEnabled: boolean;
+    readonly IsCoverOpen: boolean;
+    readonly IsEnabled: boolean;
+    readonly Journal: Windows.Devices.PointOfService.ClaimedJournalPrinter;
+    MapMode: number;
+    readonly Receipt: Windows.Devices.PointOfService.ClaimedReceiptPrinter;
+    readonly Slip: Windows.Devices.PointOfService.ClaimedSlipPrinter;
+    ReleaseDeviceRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedPosPrinter, Windows.Devices.PointOfService.PosPrinterReleaseDeviceRequestedEventArgs> | null;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedPosPrinter, Windows.Devices.PointOfService.ClaimedPosPrinterClosedEventArgs> | null;
+  }
+
+  class ClaimedPosPrinterClosedEventArgs implements Windows.Devices.PointOfService.IClaimedPosPrinterClosedEventArgs {
+  }
+
+  class ClaimedReceiptPrinter implements Windows.Devices.PointOfService.IClaimedReceiptPrinter, Windows.Devices.PointOfService.ICommonClaimedPosPrinterStation {
+    CreateJob(): Windows.Devices.PointOfService.ReceiptPrintJob;
+    ValidateData(data: string): boolean;
+    CharactersPerLine: number;
+    ColorCartridge: number;
+    readonly IsCartridgeEmpty: boolean;
+    readonly IsCartridgeRemoved: boolean;
+    readonly IsCoverOpen: boolean;
+    readonly IsHeadCleaning: boolean;
+    IsLetterQuality: boolean;
+    readonly IsPaperEmpty: boolean;
+    readonly IsPaperNearEnd: boolean;
+    readonly IsReadyToPrint: boolean;
+    LineHeight: number;
+    LineSpacing: number;
+    readonly LineWidth: number;
+    readonly LinesToPaperCut: number;
+    readonly PageSize: Windows.Foundation.Size;
+    readonly PrintArea: Windows.Foundation.Rect;
+    readonly SidewaysMaxChars: number;
+    readonly SidewaysMaxLines: number;
+  }
+
+  class ClaimedSlipPrinter implements Windows.Devices.PointOfService.IClaimedSlipPrinter, Windows.Devices.PointOfService.ICommonClaimedPosPrinterStation {
+    ChangePrintSide(printSide: number): void;
+    CloseJaws(): void;
+    CreateJob(): Windows.Devices.PointOfService.SlipPrintJob;
+    InsertSlipAsync(timeout: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<boolean>;
+    OpenJaws(): void;
+    RemoveSlipAsync(timeout: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<boolean>;
+    ValidateData(data: string): boolean;
+    CharactersPerLine: number;
+    ColorCartridge: number;
+    readonly IsCartridgeEmpty: boolean;
+    readonly IsCartridgeRemoved: boolean;
+    readonly IsCoverOpen: boolean;
+    readonly IsHeadCleaning: boolean;
+    IsLetterQuality: boolean;
+    readonly IsPaperEmpty: boolean;
+    readonly IsPaperNearEnd: boolean;
+    readonly IsReadyToPrint: boolean;
+    LineHeight: number;
+    LineSpacing: number;
+    readonly LineWidth: number;
+    readonly LinesNearEndToEnd: number;
+    readonly MaxLines: number;
+    readonly PageSize: Windows.Foundation.Size;
+    readonly PrintArea: Windows.Foundation.Rect;
+    readonly PrintSide: number;
+    readonly SidewaysMaxChars: number;
+    readonly SidewaysMaxLines: number;
+  }
+
+  class JournalPrintJob implements Windows.Devices.PointOfService.IJournalPrintJob, Windows.Devices.PointOfService.IPosPrinterJob {
+    ExecuteAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    FeedPaperByLine(lineCount: number): void;
+    FeedPaperByMapModeUnit(distance: number): void;
+    Print(data: string, printOptions: Windows.Devices.PointOfService.PosPrinterPrintOptions): void;
+    Print(data: string): void;
+    PrintLine(data: string): void;
+    PrintLine(): void;
+  }
+
+  class JournalPrinterCapabilities implements Windows.Devices.PointOfService.ICommonPosPrintStationCapabilities, Windows.Devices.PointOfService.IJournalPrinterCapabilities, Windows.Devices.PointOfService.IJournalPrinterCapabilities2 {
+    readonly CartridgeSensors: number;
+    readonly ColorCartridgeCapabilities: number;
+    readonly IsBoldSupported: boolean;
+    readonly IsDoubleHighDoubleWidePrintSupported: boolean;
+    readonly IsDoubleHighPrintSupported: boolean;
+    readonly IsDoubleWidePrintSupported: boolean;
+    readonly IsDualColorSupported: boolean;
+    readonly IsItalicSupported: boolean;
+    readonly IsPaperEmptySensorSupported: boolean;
+    readonly IsPaperNearEndSensorSupported: boolean;
+    readonly IsPrinterPresent: boolean;
+    readonly IsReversePaperFeedByLineSupported: boolean;
+    readonly IsReversePaperFeedByMapModeUnitSupported: boolean;
+    readonly IsReverseVideoSupported: boolean;
+    readonly IsStrikethroughSupported: boolean;
+    readonly IsSubscriptSupported: boolean;
+    readonly IsSuperscriptSupported: boolean;
+    readonly IsUnderlineSupported: boolean;
+    readonly SupportedCharactersPerLine: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class LineDisplay implements Windows.Devices.PointOfService.ILineDisplay, Windows.Devices.PointOfService.ILineDisplay2, Windows.Foundation.IClosable {
+    CheckPowerStatusAsync(): Windows.Foundation.IAsyncOperation<number>;
+    ClaimAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.ClaimedLineDisplay>;
+    Close(): void;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.LineDisplay>;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.LineDisplay>;
+    static GetDeviceSelector(): string;
+    static GetDeviceSelector(connectionTypes: number): string;
+    readonly Capabilities: Windows.Devices.PointOfService.LineDisplayCapabilities;
+    readonly DeviceControlDescription: string;
+    readonly DeviceControlVersion: string;
+    readonly DeviceId: string;
+    readonly DeviceServiceVersion: string;
+    readonly PhysicalDeviceDescription: string;
+    readonly PhysicalDeviceName: string;
+    static readonly StatisticsCategorySelector: Windows.Devices.PointOfService.LineDisplayStatisticsCategorySelector;
+  }
+
+  class LineDisplayAttributes implements Windows.Devices.PointOfService.ILineDisplayAttributes {
+    BlinkRate: Windows.Foundation.TimeSpan;
+    Brightness: number;
+    CharacterSet: number;
+    CurrentWindow: Windows.Devices.PointOfService.LineDisplayWindow;
+    IsCharacterSetMappingEnabled: boolean;
+    IsPowerNotifyEnabled: boolean;
+    ScreenSizeInCharacters: Windows.Foundation.Size;
+  }
+
+  class LineDisplayCapabilities implements Windows.Devices.PointOfService.ILineDisplayCapabilities {
+    readonly CanBlink: number;
+    readonly CanChangeBlinkRate: boolean;
+    readonly CanChangeScreenSize: boolean;
+    readonly CanDisplayBitmaps: boolean;
+    readonly CanDisplayCustomGlyphs: boolean;
+    readonly CanMapCharacterSets: boolean;
+    readonly CanReadCharacterAtCursor: boolean;
+    readonly CanReverse: number;
+    readonly IsBrightnessSupported: boolean;
+    readonly IsCursorSupported: boolean;
+    readonly IsHorizontalMarqueeSupported: boolean;
+    readonly IsInterCharacterWaitSupported: boolean;
+    readonly IsStatisticsReportingSupported: boolean;
+    readonly IsStatisticsUpdatingSupported: boolean;
+    readonly IsVerticalMarqueeSupported: boolean;
+    readonly PowerReportingType: number;
+    readonly SupportedDescriptors: number;
+    readonly SupportedWindows: number;
+  }
+
+  class LineDisplayCursor implements Windows.Devices.PointOfService.ILineDisplayCursor {
+    GetAttributes(): Windows.Devices.PointOfService.LineDisplayCursorAttributes;
+    TryUpdateAttributesAsync(attributes: Windows.Devices.PointOfService.LineDisplayCursorAttributes): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly CanCustomize: boolean;
+    readonly IsBlinkSupported: boolean;
+    readonly IsBlockSupported: boolean;
+    readonly IsHalfBlockSupported: boolean;
+    readonly IsOtherSupported: boolean;
+    readonly IsReverseSupported: boolean;
+    readonly IsUnderlineSupported: boolean;
+  }
+
+  class LineDisplayCursorAttributes implements Windows.Devices.PointOfService.ILineDisplayCursorAttributes {
+    CursorType: number;
+    IsAutoAdvanceEnabled: boolean;
+    IsBlinkEnabled: boolean;
+    Position: Windows.Foundation.Point;
+  }
+
+  class LineDisplayCustomGlyphs implements Windows.Devices.PointOfService.ILineDisplayCustomGlyphs {
+    TryRedefineAsync(glyphCode: number, glyphData: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly SizeInPixels: Windows.Foundation.Size;
+    readonly SupportedGlyphCodes: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class LineDisplayMarquee implements Windows.Devices.PointOfService.ILineDisplayMarquee {
+    TryStartScrollingAsync(direction: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryStopScrollingAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    Format: number;
+    RepeatWaitInterval: Windows.Foundation.TimeSpan;
+    ScrollWaitInterval: Windows.Foundation.TimeSpan;
+  }
+
+  class LineDisplayStatisticsCategorySelector implements Windows.Devices.PointOfService.ILineDisplayStatisticsCategorySelector {
+    readonly AllStatistics: string;
+    readonly ManufacturerStatistics: string;
+    readonly UnifiedPosStatistics: string;
+  }
+
+  class LineDisplayStatusUpdatedEventArgs implements Windows.Devices.PointOfService.ILineDisplayStatusUpdatedEventArgs {
+    readonly Status: number;
+  }
+
+  class LineDisplayStoredBitmap implements Windows.Devices.PointOfService.ILineDisplayStoredBitmap {
+    TryDeleteAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly EscapeSequence: string;
+  }
+
+  class LineDisplayWindow implements Windows.Devices.PointOfService.ILineDisplayWindow, Windows.Devices.PointOfService.ILineDisplayWindow2, Windows.Foundation.IClosable {
+    Close(): void;
+    ReadCharacterAtCursorAsync(): Windows.Foundation.IAsyncOperation<number>;
+    TryClearTextAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDisplayStorageFileBitmapAtCursorAsync(bitmap: Windows.Storage.StorageFile): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDisplayStorageFileBitmapAtCursorAsync(bitmap: Windows.Storage.StorageFile, horizontalAlignment: number, verticalAlignment: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDisplayStorageFileBitmapAtCursorAsync(bitmap: Windows.Storage.StorageFile, horizontalAlignment: number, verticalAlignment: number, widthInPixels: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDisplayStorageFileBitmapAtPointAsync(bitmap: Windows.Storage.StorageFile, offsetInPixels: Windows.Foundation.Point): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDisplayStorageFileBitmapAtPointAsync(bitmap: Windows.Storage.StorageFile, offsetInPixels: Windows.Foundation.Point, widthInPixels: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDisplayStoredBitmapAtCursorAsync(bitmap: Windows.Devices.PointOfService.LineDisplayStoredBitmap): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDisplayTextAsync(text: string, displayAttribute: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDisplayTextAsync(text: string, displayAttribute: number, startPosition: Windows.Foundation.Point): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDisplayTextAsync(text: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryRefreshAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryScrollTextAsync(direction: number, numberOfColumnsOrRows: number): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Cursor: Windows.Devices.PointOfService.LineDisplayCursor;
+    InterCharacterWaitInterval: Windows.Foundation.TimeSpan;
+    readonly Marquee: Windows.Devices.PointOfService.LineDisplayMarquee;
+    readonly SizeInCharacters: Windows.Foundation.Size;
+  }
+
+  class MagneticStripeReader implements Windows.Devices.PointOfService.IMagneticStripeReader, Windows.Foundation.IClosable {
+    CheckHealthAsync(level: number): Windows.Foundation.IAsyncOperation<string>;
+    ClaimReaderAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.ClaimedMagneticStripeReader>;
+    Close(): void;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.MagneticStripeReader>;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.MagneticStripeReader>;
+    static GetDeviceSelector(connectionTypes: number): string;
+    static GetDeviceSelector(): string;
+    GetErrorReportingType(): number;
+    RetrieveStatisticsAsync(statisticsCategories: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    readonly Capabilities: Windows.Devices.PointOfService.MagneticStripeReaderCapabilities;
+    readonly DeviceAuthenticationProtocol: number;
+    readonly DeviceId: string;
+    readonly SupportedCardTypes: number[];
+    StatusUpdated: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.MagneticStripeReader, Windows.Devices.PointOfService.MagneticStripeReaderStatusUpdatedEventArgs> | null;
+  }
+
+  class MagneticStripeReaderAamvaCardDataReceivedEventArgs implements Windows.Devices.PointOfService.IMagneticStripeReaderAamvaCardDataReceivedEventArgs {
+    readonly Address: string;
+    readonly BirthDate: string;
+    readonly City: string;
+    readonly Class: string;
+    readonly Endorsements: string;
+    readonly ExpirationDate: string;
+    readonly EyeColor: string;
+    readonly FirstName: string;
+    readonly Gender: string;
+    readonly HairColor: string;
+    readonly Height: string;
+    readonly LicenseNumber: string;
+    readonly PostalCode: string;
+    readonly Report: Windows.Devices.PointOfService.MagneticStripeReaderReport;
+    readonly Restrictions: string;
+    readonly State: string;
+    readonly Suffix: string;
+    readonly Surname: string;
+    readonly Weight: string;
+  }
+
+  class MagneticStripeReaderBankCardDataReceivedEventArgs implements Windows.Devices.PointOfService.IMagneticStripeReaderBankCardDataReceivedEventArgs {
+    readonly AccountNumber: string;
+    readonly ExpirationDate: string;
+    readonly FirstName: string;
+    readonly MiddleInitial: string;
+    readonly Report: Windows.Devices.PointOfService.MagneticStripeReaderReport;
+    readonly ServiceCode: string;
+    readonly Suffix: string;
+    readonly Surname: string;
+    readonly Title: string;
+  }
+
+  class MagneticStripeReaderCapabilities implements Windows.Devices.PointOfService.IMagneticStripeReaderCapabilities {
+    readonly AuthenticationLevel: number;
+    readonly CardAuthentication: string;
+    readonly IsIsoSupported: boolean;
+    readonly IsJisOneSupported: boolean;
+    readonly IsJisTwoSupported: boolean;
+    readonly IsStatisticsReportingSupported: boolean;
+    readonly IsStatisticsUpdatingSupported: boolean;
+    readonly IsTrackDataMaskingSupported: boolean;
+    readonly IsTransmitSentinelsSupported: boolean;
+    readonly PowerReportingType: number;
+    readonly SupportedEncryptionAlgorithms: number;
+  }
+
+  class MagneticStripeReaderCardTypes {
+    static readonly Aamva: number;
+    static readonly Bank: number;
+    static readonly ExtendedBase: number;
+    static readonly Unknown: number;
+  }
+
+  class MagneticStripeReaderEncryptionAlgorithms {
+    static readonly ExtendedBase: number;
+    static readonly None: number;
+    static readonly TripleDesDukpt: number;
+  }
+
+  class MagneticStripeReaderErrorOccurredEventArgs implements Windows.Devices.PointOfService.IMagneticStripeReaderErrorOccurredEventArgs {
+    readonly ErrorData: Windows.Devices.PointOfService.UnifiedPosErrorData;
+    readonly PartialInputData: Windows.Devices.PointOfService.MagneticStripeReaderReport;
+    readonly Track1Status: number;
+    readonly Track2Status: number;
+    readonly Track3Status: number;
+    readonly Track4Status: number;
+  }
+
+  class MagneticStripeReaderReport implements Windows.Devices.PointOfService.IMagneticStripeReaderReport {
+    readonly AdditionalSecurityInformation: Windows.Storage.Streams.IBuffer;
+    readonly CardAuthenticationData: Windows.Storage.Streams.IBuffer;
+    readonly CardAuthenticationDataLength: number;
+    readonly CardType: number;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, string>;
+    readonly Track1: Windows.Devices.PointOfService.MagneticStripeReaderTrackData;
+    readonly Track2: Windows.Devices.PointOfService.MagneticStripeReaderTrackData;
+    readonly Track3: Windows.Devices.PointOfService.MagneticStripeReaderTrackData;
+    readonly Track4: Windows.Devices.PointOfService.MagneticStripeReaderTrackData;
+  }
+
+  class MagneticStripeReaderStatusUpdatedEventArgs implements Windows.Devices.PointOfService.IMagneticStripeReaderStatusUpdatedEventArgs {
+    readonly ExtendedStatus: number;
+    readonly Status: number;
+  }
+
+  class MagneticStripeReaderTrackData implements Windows.Devices.PointOfService.IMagneticStripeReaderTrackData {
+    readonly Data: Windows.Storage.Streams.IBuffer;
+    readonly DiscretionaryData: Windows.Storage.Streams.IBuffer;
+    readonly EncryptedData: Windows.Storage.Streams.IBuffer;
+  }
+
+  class MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs implements Windows.Devices.PointOfService.IMagneticStripeReaderVendorSpecificCardDataReceivedEventArgs {
+    readonly Report: Windows.Devices.PointOfService.MagneticStripeReaderReport;
+  }
+
+  class PosPrinter implements Windows.Devices.PointOfService.IPosPrinter, Windows.Devices.PointOfService.IPosPrinter2, Windows.Foundation.IClosable {
+    CheckHealthAsync(level: number): Windows.Foundation.IAsyncOperation<string>;
+    ClaimPrinterAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.ClaimedPosPrinter>;
+    Close(): void;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.PosPrinter>;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.PosPrinter>;
+    static GetDeviceSelector(connectionTypes: number): string;
+    static GetDeviceSelector(): string;
+    GetFontProperty(typeface: string): Windows.Devices.PointOfService.PosPrinterFontProperty;
+    GetStatisticsAsync(statisticsCategories: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<string>;
+    readonly Capabilities: Windows.Devices.PointOfService.PosPrinterCapabilities;
+    readonly DeviceId: string;
+    readonly Status: Windows.Devices.PointOfService.PosPrinterStatus;
+    readonly SupportedBarcodeSymbologies: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedCharacterSets: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedTypeFaces: Windows.Foundation.Collections.IVectorView<string> | string[];
+    StatusUpdated: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.PosPrinter, Windows.Devices.PointOfService.PosPrinterStatusUpdatedEventArgs> | null;
+  }
+
+  class PosPrinterCapabilities implements Windows.Devices.PointOfService.IPosPrinterCapabilities {
+    readonly CanMapCharacterSet: boolean;
+    readonly DefaultCharacterSet: number;
+    readonly HasCoverSensor: boolean;
+    readonly IsStatisticsReportingSupported: boolean;
+    readonly IsStatisticsUpdatingSupported: boolean;
+    readonly IsTransactionSupported: boolean;
+    readonly Journal: Windows.Devices.PointOfService.JournalPrinterCapabilities;
+    readonly PowerReportingType: number;
+    readonly Receipt: Windows.Devices.PointOfService.ReceiptPrinterCapabilities;
+    readonly Slip: Windows.Devices.PointOfService.SlipPrinterCapabilities;
+  }
+
+  class PosPrinterCharacterSetIds {
+    static readonly Ansi: number;
+    static readonly Ascii: number;
+    static readonly Utf16LE: number;
+  }
+
+  class PosPrinterFontProperty implements Windows.Devices.PointOfService.IPosPrinterFontProperty {
+    readonly CharacterSizes: Windows.Foundation.Collections.IVectorView<Windows.Devices.PointOfService.SizeUInt32> | Windows.Devices.PointOfService.SizeUInt32[];
+    readonly IsScalableToAnySize: boolean;
+    readonly TypeFace: string;
+  }
+
+  class PosPrinterPrintOptions implements Windows.Devices.PointOfService.IPosPrinterPrintOptions {
+    constructor();
+    Alignment: number;
+    Bold: boolean;
+    CharacterHeight: number;
+    CharacterSet: number;
+    DoubleHigh: boolean;
+    DoubleWide: boolean;
+    Italic: boolean;
+    ReverseVideo: boolean;
+    Strikethrough: boolean;
+    Subscript: boolean;
+    Superscript: boolean;
+    TypeFace: string;
+    Underline: boolean;
+  }
+
+  class PosPrinterReleaseDeviceRequestedEventArgs implements Windows.Devices.PointOfService.IPosPrinterReleaseDeviceRequestedEventArgs {
+  }
+
+  class PosPrinterStatus implements Windows.Devices.PointOfService.IPosPrinterStatus {
+    readonly ExtendedStatus: number;
+    readonly StatusKind: number;
+  }
+
+  class PosPrinterStatusUpdatedEventArgs implements Windows.Devices.PointOfService.IPosPrinterStatusUpdatedEventArgs {
+    readonly Status: Windows.Devices.PointOfService.PosPrinterStatus;
+  }
+
+  class ReceiptPrintJob implements Windows.Devices.PointOfService.IPosPrinterJob, Windows.Devices.PointOfService.IReceiptOrSlipJob, Windows.Devices.PointOfService.IReceiptPrintJob, Windows.Devices.PointOfService.IReceiptPrintJob2 {
+    CutPaper(percentage: number): void;
+    CutPaper(): void;
+    DrawRuledLine(positionList: string, lineDirection: number, lineWidth: number, lineStyle: number, lineColor: number): void;
+    ExecuteAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    FeedPaperByLine(lineCount: number): void;
+    FeedPaperByMapModeUnit(distance: number): void;
+    MarkFeed(kind: number): void;
+    Print(data: string, printOptions: Windows.Devices.PointOfService.PosPrinterPrintOptions): void;
+    Print(data: string): void;
+    PrintBarcode(data: string, symbology: number, height: number, width: number, textPosition: number, alignment: number): void;
+    PrintBarcodeCustomAlign(data: string, symbology: number, height: number, width: number, textPosition: number, alignmentDistance: number): void;
+    PrintBitmap(bitmap: Windows.Graphics.Imaging.BitmapFrame, alignment: number): void;
+    PrintBitmap(bitmap: Windows.Graphics.Imaging.BitmapFrame, alignment: number, width: number): void;
+    PrintCustomAlignedBitmap(bitmap: Windows.Graphics.Imaging.BitmapFrame, alignmentDistance: number): void;
+    PrintCustomAlignedBitmap(bitmap: Windows.Graphics.Imaging.BitmapFrame, alignmentDistance: number, width: number): void;
+    PrintLine(data: string): void;
+    PrintLine(): void;
+    PrintSavedBitmap(bitmapNumber: number): void;
+    SetBarcodeRotation(value: number): void;
+    SetBitmap(bitmapNumber: number, bitmap: Windows.Graphics.Imaging.BitmapFrame, alignment: number): void;
+    SetBitmap(bitmapNumber: number, bitmap: Windows.Graphics.Imaging.BitmapFrame, alignment: number, width: number): void;
+    SetCustomAlignedBitmap(bitmapNumber: number, bitmap: Windows.Graphics.Imaging.BitmapFrame, alignmentDistance: number): void;
+    SetCustomAlignedBitmap(bitmapNumber: number, bitmap: Windows.Graphics.Imaging.BitmapFrame, alignmentDistance: number, width: number): void;
+    SetPrintArea(value: Windows.Foundation.Rect): void;
+    SetPrintRotation(value: number, includeBitmaps: boolean): void;
+    StampPaper(): void;
+  }
+
+  class ReceiptPrinterCapabilities implements Windows.Devices.PointOfService.ICommonPosPrintStationCapabilities, Windows.Devices.PointOfService.ICommonReceiptSlipCapabilities, Windows.Devices.PointOfService.IReceiptPrinterCapabilities, Windows.Devices.PointOfService.IReceiptPrinterCapabilities2 {
+    readonly CanCutPaper: boolean;
+    readonly CartridgeSensors: number;
+    readonly ColorCartridgeCapabilities: number;
+    readonly Is180RotationSupported: boolean;
+    readonly IsBarcodeSupported: boolean;
+    readonly IsBitmapSupported: boolean;
+    readonly IsBoldSupported: boolean;
+    readonly IsDoubleHighDoubleWidePrintSupported: boolean;
+    readonly IsDoubleHighPrintSupported: boolean;
+    readonly IsDoubleWidePrintSupported: boolean;
+    readonly IsDualColorSupported: boolean;
+    readonly IsItalicSupported: boolean;
+    readonly IsLeft90RotationSupported: boolean;
+    readonly IsPaperEmptySensorSupported: boolean;
+    readonly IsPaperNearEndSensorSupported: boolean;
+    readonly IsPrintAreaSupported: boolean;
+    readonly IsPrinterPresent: boolean;
+    readonly IsReversePaperFeedByLineSupported: boolean;
+    readonly IsReversePaperFeedByMapModeUnitSupported: boolean;
+    readonly IsReverseVideoSupported: boolean;
+    readonly IsRight90RotationSupported: boolean;
+    readonly IsStampSupported: boolean;
+    readonly IsStrikethroughSupported: boolean;
+    readonly IsSubscriptSupported: boolean;
+    readonly IsSuperscriptSupported: boolean;
+    readonly IsUnderlineSupported: boolean;
+    readonly MarkFeedCapabilities: number;
+    readonly RuledLineCapabilities: number;
+    readonly SupportedBarcodeRotations: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedBitmapRotations: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedCharactersPerLine: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class SlipPrintJob implements Windows.Devices.PointOfService.IPosPrinterJob, Windows.Devices.PointOfService.IReceiptOrSlipJob, Windows.Devices.PointOfService.ISlipPrintJob {
+    DrawRuledLine(positionList: string, lineDirection: number, lineWidth: number, lineStyle: number, lineColor: number): void;
+    ExecuteAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    FeedPaperByLine(lineCount: number): void;
+    FeedPaperByMapModeUnit(distance: number): void;
+    Print(data: string, printOptions: Windows.Devices.PointOfService.PosPrinterPrintOptions): void;
+    Print(data: string): void;
+    PrintBarcode(data: string, symbology: number, height: number, width: number, textPosition: number, alignment: number): void;
+    PrintBarcodeCustomAlign(data: string, symbology: number, height: number, width: number, textPosition: number, alignmentDistance: number): void;
+    PrintBitmap(bitmap: Windows.Graphics.Imaging.BitmapFrame, alignment: number): void;
+    PrintBitmap(bitmap: Windows.Graphics.Imaging.BitmapFrame, alignment: number, width: number): void;
+    PrintCustomAlignedBitmap(bitmap: Windows.Graphics.Imaging.BitmapFrame, alignmentDistance: number): void;
+    PrintCustomAlignedBitmap(bitmap: Windows.Graphics.Imaging.BitmapFrame, alignmentDistance: number, width: number): void;
+    PrintLine(data: string): void;
+    PrintLine(): void;
+    PrintSavedBitmap(bitmapNumber: number): void;
+    SetBarcodeRotation(value: number): void;
+    SetBitmap(bitmapNumber: number, bitmap: Windows.Graphics.Imaging.BitmapFrame, alignment: number): void;
+    SetBitmap(bitmapNumber: number, bitmap: Windows.Graphics.Imaging.BitmapFrame, alignment: number, width: number): void;
+    SetCustomAlignedBitmap(bitmapNumber: number, bitmap: Windows.Graphics.Imaging.BitmapFrame, alignmentDistance: number): void;
+    SetCustomAlignedBitmap(bitmapNumber: number, bitmap: Windows.Graphics.Imaging.BitmapFrame, alignmentDistance: number, width: number): void;
+    SetPrintArea(value: Windows.Foundation.Rect): void;
+    SetPrintRotation(value: number, includeBitmaps: boolean): void;
+  }
+
+  class SlipPrinterCapabilities implements Windows.Devices.PointOfService.ICommonPosPrintStationCapabilities, Windows.Devices.PointOfService.ICommonReceiptSlipCapabilities, Windows.Devices.PointOfService.ISlipPrinterCapabilities, Windows.Devices.PointOfService.ISlipPrinterCapabilities2 {
+    readonly CartridgeSensors: number;
+    readonly ColorCartridgeCapabilities: number;
+    readonly Is180RotationSupported: boolean;
+    readonly IsBarcodeSupported: boolean;
+    readonly IsBitmapSupported: boolean;
+    readonly IsBoldSupported: boolean;
+    readonly IsBothSidesPrintingSupported: boolean;
+    readonly IsDoubleHighDoubleWidePrintSupported: boolean;
+    readonly IsDoubleHighPrintSupported: boolean;
+    readonly IsDoubleWidePrintSupported: boolean;
+    readonly IsDualColorSupported: boolean;
+    readonly IsFullLengthSupported: boolean;
+    readonly IsItalicSupported: boolean;
+    readonly IsLeft90RotationSupported: boolean;
+    readonly IsPaperEmptySensorSupported: boolean;
+    readonly IsPaperNearEndSensorSupported: boolean;
+    readonly IsPrintAreaSupported: boolean;
+    readonly IsPrinterPresent: boolean;
+    readonly IsReversePaperFeedByLineSupported: boolean;
+    readonly IsReversePaperFeedByMapModeUnitSupported: boolean;
+    readonly IsReverseVideoSupported: boolean;
+    readonly IsRight90RotationSupported: boolean;
+    readonly IsStrikethroughSupported: boolean;
+    readonly IsSubscriptSupported: boolean;
+    readonly IsSuperscriptSupported: boolean;
+    readonly IsUnderlineSupported: boolean;
+    readonly RuledLineCapabilities: number;
+    readonly SupportedBarcodeRotations: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedBitmapRotations: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedCharactersPerLine: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class UnifiedPosErrorData implements Windows.Devices.PointOfService.IUnifiedPosErrorData {
+    constructor(message: string, severity: number, reason: number, extendedReason: number);
+    readonly ExtendedReason: number;
+    readonly Message: string;
+    readonly Reason: number;
+    readonly Severity: number;
+  }
+
+  enum BarcodeScannerStatus {
+    Online = 0,
+    Off = 1,
+    Offline = 2,
+    OffOrOffline = 3,
+    Extended = 4,
+  }
+
+  enum BarcodeSymbologyDecodeLengthKind {
+    AnyLength = 0,
+    Discrete = 1,
+    Range = 2,
+  }
+
+  enum CashDrawerStatusKind {
+    Online = 0,
+    Off = 1,
+    Offline = 2,
+    OffOrOffline = 3,
+    Extended = 4,
+  }
+
+  enum LineDisplayCursorType {
+    None = 0,
+    Block = 1,
+    HalfBlock = 2,
+    Underline = 3,
+    Reverse = 4,
+    Other = 5,
+  }
+
+  enum LineDisplayDescriptorState {
+    Off = 0,
+    On = 1,
+    Blink = 2,
+  }
+
+  enum LineDisplayHorizontalAlignment {
+    Left = 0,
+    Center = 1,
+    Right = 2,
+  }
+
+  enum LineDisplayMarqueeFormat {
+    None = 0,
+    Walk = 1,
+    Place = 2,
+  }
+
+  enum LineDisplayPowerStatus {
+    Unknown = 0,
+    Online = 1,
+    Off = 2,
+    Offline = 3,
+    OffOrOffline = 4,
+  }
+
+  enum LineDisplayScrollDirection {
+    Up = 0,
+    Down = 1,
+    Left = 2,
+    Right = 3,
+  }
+
+  enum LineDisplayTextAttribute {
+    Normal = 0,
+    Blink = 1,
+    Reverse = 2,
+    ReverseBlink = 3,
+  }
+
+  enum LineDisplayTextAttributeGranularity {
+    NotSupported = 0,
+    EntireDisplay = 1,
+    PerCharacter = 2,
+  }
+
+  enum LineDisplayVerticalAlignment {
+    Top = 0,
+    Center = 1,
+    Bottom = 2,
+  }
+
+  enum MagneticStripeReaderAuthenticationLevel {
+    NotSupported = 0,
+    Optional = 1,
+    Required = 2,
+  }
+
+  enum MagneticStripeReaderAuthenticationProtocol {
+    None = 0,
+    ChallengeResponse = 1,
+  }
+
+  enum MagneticStripeReaderErrorReportingType {
+    CardLevel = 0,
+    TrackLevel = 1,
+  }
+
+  enum MagneticStripeReaderStatus {
+    Unauthenticated = 0,
+    Authenticated = 1,
+    Extended = 2,
+  }
+
+  enum MagneticStripeReaderTrackErrorType {
+    None = 0,
+    StartSentinelError = 1,
+    EndSentinelError = 2,
+    ParityError = 3,
+    LrcError = 4,
+    Unknown = -1,
+  }
+
+  enum MagneticStripeReaderTrackIds {
+    None = 0,
+    Track1 = 1,
+    Track2 = 2,
+    Track3 = 4,
+    Track4 = 8,
+  }
+
+  enum PosConnectionTypes {
+    Local = 1,
+    IP = 2,
+    Bluetooth = 4,
+    All = 4294967295,
+  }
+
+  enum PosPrinterAlignment {
+    Left = 0,
+    Center = 1,
+    Right = 2,
+  }
+
+  enum PosPrinterBarcodeTextPosition {
+    None = 0,
+    Above = 1,
+    Below = 2,
+  }
+
+  enum PosPrinterCartridgeSensors {
+    None = 0,
+    Removed = 1,
+    Empty = 2,
+    HeadCleaning = 4,
+    NearEnd = 8,
+  }
+
+  enum PosPrinterColorCapabilities {
+    None = 0,
+    Primary = 1,
+    Custom1 = 2,
+    Custom2 = 4,
+    Custom3 = 8,
+    Custom4 = 16,
+    Custom5 = 32,
+    Custom6 = 64,
+    Cyan = 128,
+    Magenta = 256,
+    Yellow = 512,
+    Full = 1024,
+  }
+
+  enum PosPrinterColorCartridge {
+    Unknown = 0,
+    Primary = 1,
+    Custom1 = 2,
+    Custom2 = 3,
+    Custom3 = 4,
+    Custom4 = 5,
+    Custom5 = 6,
+    Custom6 = 7,
+    Cyan = 8,
+    Magenta = 9,
+    Yellow = 10,
+  }
+
+  enum PosPrinterLineDirection {
+    Horizontal = 0,
+    Vertical = 1,
+  }
+
+  enum PosPrinterLineStyle {
+    SingleSolid = 0,
+    DoubleSolid = 1,
+    Broken = 2,
+    Chain = 3,
+  }
+
+  enum PosPrinterMapMode {
+    Dots = 0,
+    Twips = 1,
+    English = 2,
+    Metric = 3,
+  }
+
+  enum PosPrinterMarkFeedCapabilities {
+    None = 0,
+    ToTakeUp = 1,
+    ToCutter = 2,
+    ToCurrentTopOfForm = 4,
+    ToNextTopOfForm = 8,
+  }
+
+  enum PosPrinterMarkFeedKind {
+    ToTakeUp = 0,
+    ToCutter = 1,
+    ToCurrentTopOfForm = 2,
+    ToNextTopOfForm = 3,
+  }
+
+  enum PosPrinterPrintSide {
+    Unknown = 0,
+    Side1 = 1,
+    Side2 = 2,
+  }
+
+  enum PosPrinterRotation {
+    Normal = 0,
+    Right90 = 1,
+    Left90 = 2,
+    Rotate180 = 3,
+  }
+
+  enum PosPrinterRuledLineCapabilities {
+    None = 0,
+    Horizontal = 1,
+    Vertical = 2,
+  }
+
+  enum PosPrinterStatusKind {
+    Online = 0,
+    Off = 1,
+    Offline = 2,
+    OffOrOffline = 3,
+    Extended = 4,
+  }
+
+  enum UnifiedPosErrorReason {
+    UnknownErrorReason = 0,
+    NoService = 1,
+    Disabled = 2,
+    Illegal = 3,
+    NoHardware = 4,
+    Closed = 5,
+    Offline = 6,
+    Failure = 7,
+    Timeout = 8,
+    Busy = 9,
+    Extended = 10,
+  }
+
+  enum UnifiedPosErrorSeverity {
+    UnknownErrorSeverity = 0,
+    Warning = 1,
+    Recoverable = 2,
+    Unrecoverable = 3,
+    AssistanceRequired = 4,
+    Fatal = 5,
+  }
+
+  enum UnifiedPosHealthCheckLevel {
+    UnknownHealthCheckLevel = 0,
+    POSInternal = 1,
+    External = 2,
+    Interactive = 3,
+  }
+
+  enum UnifiedPosPowerReportingType {
+    UnknownPowerReportingType = 0,
+    Standard = 1,
+    Advanced = 2,
+  }
+
+  interface IBarcodeScanner {
+    CheckHealthAsync(level: number): Windows.Foundation.IAsyncOperation<string>;
+    ClaimScannerAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.ClaimedBarcodeScanner>;
+    GetSupportedProfiles(): Windows.Foundation.Collections.IVectorView<string> | string[];
+    GetSupportedSymbologiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<number> | number[]>;
+    IsProfileSupported(profile: string): boolean;
+    IsSymbologySupportedAsync(barcodeSymbology: number): Windows.Foundation.IAsyncOperation<boolean>;
+    RetrieveStatisticsAsync(statisticsCategories: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    readonly Capabilities: Windows.Devices.PointOfService.BarcodeScannerCapabilities;
+    readonly DeviceId: string;
+    StatusUpdated: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.BarcodeScanner, Windows.Devices.PointOfService.BarcodeScannerStatusUpdatedEventArgs> | null;
+  }
+  var IBarcodeScanner: abstract new (...args: any[]) => IBarcodeScanner;
+
+  interface IBarcodeScanner2 {
+    readonly VideoDeviceId: string;
+  }
+  var IBarcodeScanner2: abstract new (...args: any[]) => IBarcodeScanner2;
+
+  interface IBarcodeScannerCapabilities {
+    readonly IsImagePreviewSupported: boolean;
+    readonly IsStatisticsReportingSupported: boolean;
+    readonly IsStatisticsUpdatingSupported: boolean;
+    readonly PowerReportingType: number;
+  }
+  var IBarcodeScannerCapabilities: abstract new (...args: any[]) => IBarcodeScannerCapabilities;
+
+  interface IBarcodeScannerCapabilities1 {
+    readonly IsSoftwareTriggerSupported: boolean;
+  }
+  var IBarcodeScannerCapabilities1: abstract new (...args: any[]) => IBarcodeScannerCapabilities1;
+
+  interface IBarcodeScannerCapabilities2 {
+    readonly IsVideoPreviewSupported: boolean;
+  }
+  var IBarcodeScannerCapabilities2: abstract new (...args: any[]) => IBarcodeScannerCapabilities2;
+
+  interface IBarcodeScannerDataReceivedEventArgs {
+    readonly Report: Windows.Devices.PointOfService.BarcodeScannerReport;
+  }
+  var IBarcodeScannerDataReceivedEventArgs: abstract new (...args: any[]) => IBarcodeScannerDataReceivedEventArgs;
+
+  interface IBarcodeScannerErrorOccurredEventArgs {
+    readonly ErrorData: Windows.Devices.PointOfService.UnifiedPosErrorData;
+    readonly IsRetriable: boolean;
+    readonly PartialInputData: Windows.Devices.PointOfService.BarcodeScannerReport;
+  }
+  var IBarcodeScannerErrorOccurredEventArgs: abstract new (...args: any[]) => IBarcodeScannerErrorOccurredEventArgs;
+
+  interface IBarcodeScannerImagePreviewReceivedEventArgs {
+    readonly Preview: Windows.Storage.Streams.IRandomAccessStreamWithContentType;
+  }
+  var IBarcodeScannerImagePreviewReceivedEventArgs: abstract new (...args: any[]) => IBarcodeScannerImagePreviewReceivedEventArgs;
+
+  interface IBarcodeScannerReport {
+    readonly ScanData: Windows.Storage.Streams.IBuffer;
+    readonly ScanDataLabel: Windows.Storage.Streams.IBuffer;
+    readonly ScanDataType: number;
+  }
+  var IBarcodeScannerReport: abstract new (...args: any[]) => IBarcodeScannerReport;
+
+  interface IBarcodeScannerReportFactory {
+    CreateInstance(scanDataType: number, scanData: Windows.Storage.Streams.IBuffer, scanDataLabel: Windows.Storage.Streams.IBuffer): Windows.Devices.PointOfService.BarcodeScannerReport;
+  }
+  var IBarcodeScannerReportFactory: abstract new (...args: any[]) => IBarcodeScannerReportFactory;
+
+  interface IBarcodeScannerStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.BarcodeScanner>;
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.BarcodeScanner>;
+    GetDeviceSelector(): string;
+  }
+  var IBarcodeScannerStatics: abstract new (...args: any[]) => IBarcodeScannerStatics;
+
+  interface IBarcodeScannerStatics2 {
+    GetDeviceSelector(connectionTypes: number): string;
+  }
+  var IBarcodeScannerStatics2: abstract new (...args: any[]) => IBarcodeScannerStatics2;
+
+  interface IBarcodeScannerStatusUpdatedEventArgs {
+    readonly ExtendedStatus: number;
+    readonly Status: number;
+  }
+  var IBarcodeScannerStatusUpdatedEventArgs: abstract new (...args: any[]) => IBarcodeScannerStatusUpdatedEventArgs;
+
+  interface IBarcodeSymbologiesStatics {
+    GetName(scanDataType: number): string;
+    readonly AusPost: number;
+    readonly Aztec: number;
+    readonly CanPost: number;
+    readonly Ccab: number;
+    readonly Ccc: number;
+    readonly ChinaPost: number;
+    readonly Codabar: number;
+    readonly Codablock128: number;
+    readonly CodablockA: number;
+    readonly CodablockF: number;
+    readonly Code11: number;
+    readonly Code128: number;
+    readonly Code16k: number;
+    readonly Code32: number;
+    readonly Code39: number;
+    readonly Code39Ex: number;
+    readonly Code49: number;
+    readonly Code93: number;
+    readonly Code93Ex: number;
+    readonly DataCode: number;
+    readonly DataMatrix: number;
+    readonly DutchKix: number;
+    readonly Ean13: number;
+    readonly Ean13Add2: number;
+    readonly Ean13Add5: number;
+    readonly Ean8: number;
+    readonly Ean8Add2: number;
+    readonly Ean8Add5: number;
+    readonly Ean99: number;
+    readonly Ean99Add2: number;
+    readonly Ean99Add5: number;
+    readonly Eanv: number;
+    readonly EanvAdd2: number;
+    readonly EanvAdd5: number;
+    readonly ExtendedBase: number;
+    readonly Gs1128: number;
+    readonly Gs1128Coupon: number;
+    readonly Gs1DatabarType1: number;
+    readonly Gs1DatabarType2: number;
+    readonly Gs1DatabarType3: number;
+    readonly HanXin: number;
+    readonly InfoMail: number;
+    readonly Isbn: number;
+    readonly IsbnAdd5: number;
+    readonly Isbt: number;
+    readonly Ismn: number;
+    readonly IsmnAdd2: number;
+    readonly IsmnAdd5: number;
+    readonly Issn: number;
+    readonly IssnAdd2: number;
+    readonly IssnAdd5: number;
+    readonly ItalianPost25: number;
+    readonly ItalianPost39: number;
+    readonly JapanPost: number;
+    readonly KoreanPost: number;
+    readonly Maxicode: number;
+    readonly Micr: number;
+    readonly MicroPdf417: number;
+    readonly MicroQr: number;
+    readonly MsTag: number;
+    readonly Msi: number;
+    readonly OcrA: number;
+    readonly OcrB: number;
+    readonly Pdf417: number;
+    readonly Plessey: number;
+    readonly Pzn: number;
+    readonly Qr: number;
+    readonly Sisac: number;
+    readonly SwedenPost: number;
+    readonly Telepen: number;
+    readonly TfDis: number;
+    readonly TfIata: number;
+    readonly TfInd: number;
+    readonly TfInt: number;
+    readonly TfMat: number;
+    readonly TfStd: number;
+    readonly Tlc39: number;
+    readonly Trioptic39: number;
+    readonly UccEan128: number;
+    readonly UkPost: number;
+    readonly Unknown: number;
+    readonly UpcCoupon: number;
+    readonly Upca: number;
+    readonly UpcaAdd2: number;
+    readonly UpcaAdd5: number;
+    readonly Upce: number;
+    readonly UpceAdd2: number;
+    readonly UpceAdd5: number;
+    readonly Us4StateFics: number;
+    readonly UsIntelligent: number;
+    readonly UsIntelligentPkg: number;
+    readonly UsPlanet: number;
+    readonly UsPostNet: number;
+  }
+  var IBarcodeSymbologiesStatics: abstract new (...args: any[]) => IBarcodeSymbologiesStatics;
+
+  interface IBarcodeSymbologiesStatics2 {
+    readonly Gs1DWCode: number;
+  }
+  var IBarcodeSymbologiesStatics2: abstract new (...args: any[]) => IBarcodeSymbologiesStatics2;
+
+  interface IBarcodeSymbologyAttributes {
+    DecodeLength1: number;
+    DecodeLength2: number;
+    DecodeLengthKind: number;
+    IsCheckDigitTransmissionEnabled: boolean;
+    readonly IsCheckDigitTransmissionSupported: boolean;
+    IsCheckDigitValidationEnabled: boolean;
+    readonly IsCheckDigitValidationSupported: boolean;
+    readonly IsDecodeLengthSupported: boolean;
+  }
+  var IBarcodeSymbologyAttributes: abstract new (...args: any[]) => IBarcodeSymbologyAttributes;
+
+  interface ICashDrawer {
+    CheckHealthAsync(level: number): Windows.Foundation.IAsyncOperation<string>;
+    ClaimDrawerAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.ClaimedCashDrawer>;
+    GetStatisticsAsync(statisticsCategories: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<string>;
+    readonly Capabilities: Windows.Devices.PointOfService.CashDrawerCapabilities;
+    readonly DeviceId: string;
+    readonly DrawerEventSource: Windows.Devices.PointOfService.CashDrawerEventSource;
+    readonly IsDrawerOpen: boolean;
+    readonly Status: Windows.Devices.PointOfService.CashDrawerStatus;
+    StatusUpdated: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.CashDrawer, Windows.Devices.PointOfService.CashDrawerStatusUpdatedEventArgs> | null;
+  }
+  var ICashDrawer: abstract new (...args: any[]) => ICashDrawer;
+
+  interface ICashDrawerCapabilities {
+    readonly IsDrawerOpenSensorAvailable: boolean;
+    readonly IsStatisticsReportingSupported: boolean;
+    readonly IsStatisticsUpdatingSupported: boolean;
+    readonly IsStatusMultiDrawerDetectSupported: boolean;
+    readonly IsStatusReportingSupported: boolean;
+    readonly PowerReportingType: number;
+  }
+  var ICashDrawerCapabilities: abstract new (...args: any[]) => ICashDrawerCapabilities;
+
+  interface ICashDrawerCloseAlarm {
+    StartAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    AlarmTimeout: Windows.Foundation.TimeSpan;
+    BeepDelay: Windows.Foundation.TimeSpan;
+    BeepDuration: Windows.Foundation.TimeSpan;
+    BeepFrequency: number;
+    AlarmTimeoutExpired: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.CashDrawerCloseAlarm, Object> | null;
+  }
+  var ICashDrawerCloseAlarm: abstract new (...args: any[]) => ICashDrawerCloseAlarm;
+
+  interface ICashDrawerEventSource {
+    DrawerClosed: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.CashDrawerEventSource, Windows.Devices.PointOfService.CashDrawerClosedEventArgs> | null;
+    DrawerOpened: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.CashDrawerEventSource, Windows.Devices.PointOfService.CashDrawerOpenedEventArgs> | null;
+  }
+  var ICashDrawerEventSource: abstract new (...args: any[]) => ICashDrawerEventSource;
+
+  interface ICashDrawerEventSourceEventArgs {
+    readonly CashDrawer: Windows.Devices.PointOfService.CashDrawer;
+  }
+  var ICashDrawerEventSourceEventArgs: abstract new (...args: any[]) => ICashDrawerEventSourceEventArgs;
+
+  interface ICashDrawerStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.CashDrawer>;
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.CashDrawer>;
+    GetDeviceSelector(): string;
+  }
+  var ICashDrawerStatics: abstract new (...args: any[]) => ICashDrawerStatics;
+
+  interface ICashDrawerStatics2 {
+    GetDeviceSelector(connectionTypes: number): string;
+  }
+  var ICashDrawerStatics2: abstract new (...args: any[]) => ICashDrawerStatics2;
+
+  interface ICashDrawerStatus {
+    readonly ExtendedStatus: number;
+    readonly StatusKind: number;
+  }
+  var ICashDrawerStatus: abstract new (...args: any[]) => ICashDrawerStatus;
+
+  interface ICashDrawerStatusUpdatedEventArgs {
+    readonly Status: Windows.Devices.PointOfService.CashDrawerStatus;
+  }
+  var ICashDrawerStatusUpdatedEventArgs: abstract new (...args: any[]) => ICashDrawerStatusUpdatedEventArgs;
+
+  interface IClaimedBarcodeScanner {
+    DisableAsync(): Windows.Foundation.IAsyncAction;
+    EnableAsync(): Windows.Foundation.IAsyncAction;
+    ResetStatisticsAsync(statisticsCategories: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    RetainDevice(): void;
+    SetActiveProfileAsync(profile: string): Windows.Foundation.IAsyncAction;
+    SetActiveSymbologiesAsync(symbologies: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.Foundation.IAsyncAction;
+    UpdateStatisticsAsync(statistics: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, string>> | Windows.Foundation.Collections.IKeyValuePair<string, string>[]): Windows.Foundation.IAsyncAction;
+    readonly DeviceId: string;
+    IsDecodeDataEnabled: boolean;
+    IsDisabledOnDataReceived: boolean;
+    readonly IsEnabled: boolean;
+    DataReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedBarcodeScanner, Windows.Devices.PointOfService.BarcodeScannerDataReceivedEventArgs> | null;
+    ErrorOccurred: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedBarcodeScanner, Windows.Devices.PointOfService.BarcodeScannerErrorOccurredEventArgs> | null;
+    ImagePreviewReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedBarcodeScanner, Windows.Devices.PointOfService.BarcodeScannerImagePreviewReceivedEventArgs> | null;
+    ReleaseDeviceRequested: Windows.Foundation.EventHandler<Windows.Devices.PointOfService.ClaimedBarcodeScanner> | null;
+    TriggerPressed: Windows.Foundation.EventHandler<Windows.Devices.PointOfService.ClaimedBarcodeScanner> | null;
+    TriggerReleased: Windows.Foundation.EventHandler<Windows.Devices.PointOfService.ClaimedBarcodeScanner> | null;
+  }
+  var IClaimedBarcodeScanner: abstract new (...args: any[]) => IClaimedBarcodeScanner;
+
+  interface IClaimedBarcodeScanner1 {
+    StartSoftwareTriggerAsync(): Windows.Foundation.IAsyncAction;
+    StopSoftwareTriggerAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var IClaimedBarcodeScanner1: abstract new (...args: any[]) => IClaimedBarcodeScanner1;
+
+  interface IClaimedBarcodeScanner2 {
+    GetSymbologyAttributesAsync(barcodeSymbology: number): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.BarcodeSymbologyAttributes>;
+    SetSymbologyAttributesAsync(barcodeSymbology: number, attributes: Windows.Devices.PointOfService.BarcodeSymbologyAttributes): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IClaimedBarcodeScanner2: abstract new (...args: any[]) => IClaimedBarcodeScanner2;
+
+  interface IClaimedBarcodeScanner3 {
+    HideVideoPreview(): void;
+    ShowVideoPreviewAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    IsVideoPreviewShownOnEnable: boolean;
+  }
+  var IClaimedBarcodeScanner3: abstract new (...args: any[]) => IClaimedBarcodeScanner3;
+
+  interface IClaimedBarcodeScanner4 {
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedBarcodeScanner, Windows.Devices.PointOfService.ClaimedBarcodeScannerClosedEventArgs> | null;
+  }
+  var IClaimedBarcodeScanner4: abstract new (...args: any[]) => IClaimedBarcodeScanner4;
+
+  interface IClaimedBarcodeScannerClosedEventArgs {
+  }
+  var IClaimedBarcodeScannerClosedEventArgs: abstract new (...args: any[]) => IClaimedBarcodeScannerClosedEventArgs;
+
+  interface IClaimedCashDrawer {
+    DisableAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    EnableAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    OpenDrawerAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    ResetStatisticsAsync(statisticsCategories: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<boolean>;
+    RetainDeviceAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    UpdateStatisticsAsync(statistics: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, string>> | Windows.Foundation.Collections.IKeyValuePair<string, string>[]): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly CloseAlarm: Windows.Devices.PointOfService.CashDrawerCloseAlarm;
+    readonly DeviceId: string;
+    readonly IsDrawerOpen: boolean;
+    readonly IsEnabled: boolean;
+    ReleaseDeviceRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedCashDrawer, Object> | null;
+  }
+  var IClaimedCashDrawer: abstract new (...args: any[]) => IClaimedCashDrawer;
+
+  interface IClaimedCashDrawer2 {
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedCashDrawer, Windows.Devices.PointOfService.ClaimedCashDrawerClosedEventArgs> | null;
+  }
+  var IClaimedCashDrawer2: abstract new (...args: any[]) => IClaimedCashDrawer2;
+
+  interface IClaimedCashDrawerClosedEventArgs {
+  }
+  var IClaimedCashDrawerClosedEventArgs: abstract new (...args: any[]) => IClaimedCashDrawerClosedEventArgs;
+
+  interface IClaimedJournalPrinter {
+    CreateJob(): Windows.Devices.PointOfService.JournalPrintJob;
+  }
+  var IClaimedJournalPrinter: abstract new (...args: any[]) => IClaimedJournalPrinter;
+
+  interface IClaimedLineDisplay {
+    RetainDevice(): void;
+    readonly Capabilities: Windows.Devices.PointOfService.LineDisplayCapabilities;
+    readonly DefaultWindow: Windows.Devices.PointOfService.LineDisplayWindow;
+    readonly DeviceControlDescription: string;
+    readonly DeviceControlVersion: string;
+    readonly DeviceId: string;
+    readonly DeviceServiceVersion: string;
+    readonly PhysicalDeviceDescription: string;
+    readonly PhysicalDeviceName: string;
+    ReleaseDeviceRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedLineDisplay, Object> | null;
+  }
+  var IClaimedLineDisplay: abstract new (...args: any[]) => IClaimedLineDisplay;
+
+  interface IClaimedLineDisplay2 {
+    CheckHealthAsync(level: number): Windows.Foundation.IAsyncOperation<string>;
+    CheckPowerStatusAsync(): Windows.Foundation.IAsyncOperation<number>;
+    GetAttributes(): Windows.Devices.PointOfService.LineDisplayAttributes;
+    GetStatisticsAsync(statisticsCategories: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<string>;
+    TryClearDescriptorsAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryCreateWindowAsync(viewport: Windows.Foundation.Rect, windowSize: Windows.Foundation.Size): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.LineDisplayWindow>;
+    TrySetDescriptorAsync(descriptor: number, descriptorState: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryStoreStorageFileBitmapAsync(bitmap: Windows.Storage.StorageFile): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.LineDisplayStoredBitmap>;
+    TryStoreStorageFileBitmapAsync(bitmap: Windows.Storage.StorageFile, horizontalAlignment: number, verticalAlignment: number): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.LineDisplayStoredBitmap>;
+    TryStoreStorageFileBitmapAsync(bitmap: Windows.Storage.StorageFile, horizontalAlignment: number, verticalAlignment: number, widthInPixels: number): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.LineDisplayStoredBitmap>;
+    TryUpdateAttributesAsync(attributes: Windows.Devices.PointOfService.LineDisplayAttributes): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly CustomGlyphs: Windows.Devices.PointOfService.LineDisplayCustomGlyphs;
+    readonly MaxBitmapSizeInPixels: Windows.Foundation.Size;
+    readonly SupportedCharacterSets: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedScreenSizesInCharacters: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Size> | Windows.Foundation.Size[];
+    StatusUpdated: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedLineDisplay, Windows.Devices.PointOfService.LineDisplayStatusUpdatedEventArgs> | null;
+  }
+  var IClaimedLineDisplay2: abstract new (...args: any[]) => IClaimedLineDisplay2;
+
+  interface IClaimedLineDisplay3 {
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedLineDisplay, Windows.Devices.PointOfService.ClaimedLineDisplayClosedEventArgs> | null;
+  }
+  var IClaimedLineDisplay3: abstract new (...args: any[]) => IClaimedLineDisplay3;
+
+  interface IClaimedLineDisplayClosedEventArgs {
+  }
+  var IClaimedLineDisplayClosedEventArgs: abstract new (...args: any[]) => IClaimedLineDisplayClosedEventArgs;
+
+  interface IClaimedLineDisplayStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.ClaimedLineDisplay>;
+    GetDeviceSelector(): string;
+    GetDeviceSelector(connectionTypes: number): string;
+  }
+  var IClaimedLineDisplayStatics: abstract new (...args: any[]) => IClaimedLineDisplayStatics;
+
+  interface IClaimedMagneticStripeReader {
+    AuthenticateDeviceAsync(responseToken: number[]): Windows.Foundation.IAsyncAction;
+    DeAuthenticateDeviceAsync(responseToken: number[]): Windows.Foundation.IAsyncAction;
+    DisableAsync(): Windows.Foundation.IAsyncAction;
+    EnableAsync(): Windows.Foundation.IAsyncAction;
+    ResetStatisticsAsync(statisticsCategories: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    RetainDevice(): void;
+    RetrieveDeviceAuthenticationDataAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    SetErrorReportingType(value: number): void;
+    UpdateKeyAsync(key: string, keyName: string): Windows.Foundation.IAsyncAction;
+    UpdateStatisticsAsync(statistics: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, string>> | Windows.Foundation.Collections.IKeyValuePair<string, string>[]): Windows.Foundation.IAsyncAction;
+    DataEncryptionAlgorithm: number;
+    readonly DeviceId: string;
+    IsDecodeDataEnabled: boolean;
+    readonly IsDeviceAuthenticated: boolean;
+    IsDisabledOnDataReceived: boolean;
+    readonly IsEnabled: boolean;
+    IsTransmitSentinelsEnabled: boolean;
+    TracksToRead: number;
+    AamvaCardDataReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedMagneticStripeReader, Windows.Devices.PointOfService.MagneticStripeReaderAamvaCardDataReceivedEventArgs> | null;
+    BankCardDataReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedMagneticStripeReader, Windows.Devices.PointOfService.MagneticStripeReaderBankCardDataReceivedEventArgs> | null;
+    ErrorOccurred: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedMagneticStripeReader, Windows.Devices.PointOfService.MagneticStripeReaderErrorOccurredEventArgs> | null;
+    ReleaseDeviceRequested: Windows.Foundation.EventHandler<Windows.Devices.PointOfService.ClaimedMagneticStripeReader> | null;
+    VendorSpecificDataReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedMagneticStripeReader, Windows.Devices.PointOfService.MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs> | null;
+  }
+  var IClaimedMagneticStripeReader: abstract new (...args: any[]) => IClaimedMagneticStripeReader;
+
+  interface IClaimedMagneticStripeReader2 {
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedMagneticStripeReader, Windows.Devices.PointOfService.ClaimedMagneticStripeReaderClosedEventArgs> | null;
+  }
+  var IClaimedMagneticStripeReader2: abstract new (...args: any[]) => IClaimedMagneticStripeReader2;
+
+  interface IClaimedMagneticStripeReaderClosedEventArgs {
+  }
+  var IClaimedMagneticStripeReaderClosedEventArgs: abstract new (...args: any[]) => IClaimedMagneticStripeReaderClosedEventArgs;
+
+  interface IClaimedPosPrinter {
+    DisableAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    EnableAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    ResetStatisticsAsync(statisticsCategories: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<boolean>;
+    RetainDeviceAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    UpdateStatisticsAsync(statistics: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, string>> | Windows.Foundation.Collections.IKeyValuePair<string, string>[]): Windows.Foundation.IAsyncOperation<boolean>;
+    CharacterSet: number;
+    readonly DeviceId: string;
+    IsCharacterSetMappingEnabled: boolean;
+    readonly IsCoverOpen: boolean;
+    readonly IsEnabled: boolean;
+    readonly Journal: Windows.Devices.PointOfService.ClaimedJournalPrinter;
+    MapMode: number;
+    readonly Receipt: Windows.Devices.PointOfService.ClaimedReceiptPrinter;
+    readonly Slip: Windows.Devices.PointOfService.ClaimedSlipPrinter;
+    ReleaseDeviceRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedPosPrinter, Windows.Devices.PointOfService.PosPrinterReleaseDeviceRequestedEventArgs> | null;
+  }
+  var IClaimedPosPrinter: abstract new (...args: any[]) => IClaimedPosPrinter;
+
+  interface IClaimedPosPrinter2 {
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.ClaimedPosPrinter, Windows.Devices.PointOfService.ClaimedPosPrinterClosedEventArgs> | null;
+  }
+  var IClaimedPosPrinter2: abstract new (...args: any[]) => IClaimedPosPrinter2;
+
+  interface IClaimedPosPrinterClosedEventArgs {
+  }
+  var IClaimedPosPrinterClosedEventArgs: abstract new (...args: any[]) => IClaimedPosPrinterClosedEventArgs;
+
+  interface IClaimedReceiptPrinter {
+    CreateJob(): Windows.Devices.PointOfService.ReceiptPrintJob;
+    readonly LinesToPaperCut: number;
+    readonly PageSize: Windows.Foundation.Size;
+    readonly PrintArea: Windows.Foundation.Rect;
+    readonly SidewaysMaxChars: number;
+    readonly SidewaysMaxLines: number;
+  }
+  var IClaimedReceiptPrinter: abstract new (...args: any[]) => IClaimedReceiptPrinter;
+
+  interface IClaimedSlipPrinter {
+    ChangePrintSide(printSide: number): void;
+    CloseJaws(): void;
+    CreateJob(): Windows.Devices.PointOfService.SlipPrintJob;
+    InsertSlipAsync(timeout: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<boolean>;
+    OpenJaws(): void;
+    RemoveSlipAsync(timeout: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly LinesNearEndToEnd: number;
+    readonly MaxLines: number;
+    readonly PageSize: Windows.Foundation.Size;
+    readonly PrintArea: Windows.Foundation.Rect;
+    readonly PrintSide: number;
+    readonly SidewaysMaxChars: number;
+    readonly SidewaysMaxLines: number;
+  }
+  var IClaimedSlipPrinter: abstract new (...args: any[]) => IClaimedSlipPrinter;
+
+  interface ICommonClaimedPosPrinterStation {
+    ValidateData(data: string): boolean;
+    CharactersPerLine: number;
+    ColorCartridge: number;
+    readonly IsCartridgeEmpty: boolean;
+    readonly IsCartridgeRemoved: boolean;
+    readonly IsCoverOpen: boolean;
+    readonly IsHeadCleaning: boolean;
+    IsLetterQuality: boolean;
+    readonly IsPaperEmpty: boolean;
+    readonly IsPaperNearEnd: boolean;
+    readonly IsReadyToPrint: boolean;
+    LineHeight: number;
+    LineSpacing: number;
+    readonly LineWidth: number;
+  }
+  var ICommonClaimedPosPrinterStation: abstract new (...args: any[]) => ICommonClaimedPosPrinterStation;
+
+  interface ICommonPosPrintStationCapabilities {
+    readonly CartridgeSensors: number;
+    readonly ColorCartridgeCapabilities: number;
+    readonly IsBoldSupported: boolean;
+    readonly IsDoubleHighDoubleWidePrintSupported: boolean;
+    readonly IsDoubleHighPrintSupported: boolean;
+    readonly IsDoubleWidePrintSupported: boolean;
+    readonly IsDualColorSupported: boolean;
+    readonly IsItalicSupported: boolean;
+    readonly IsPaperEmptySensorSupported: boolean;
+    readonly IsPaperNearEndSensorSupported: boolean;
+    readonly IsPrinterPresent: boolean;
+    readonly IsUnderlineSupported: boolean;
+    readonly SupportedCharactersPerLine: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var ICommonPosPrintStationCapabilities: abstract new (...args: any[]) => ICommonPosPrintStationCapabilities;
+
+  interface ICommonReceiptSlipCapabilities extends Windows.Devices.PointOfService.ICommonPosPrintStationCapabilities {
+    readonly Is180RotationSupported: boolean;
+    readonly IsBarcodeSupported: boolean;
+    readonly IsBitmapSupported: boolean;
+    readonly IsLeft90RotationSupported: boolean;
+    readonly IsPrintAreaSupported: boolean;
+    readonly IsRight90RotationSupported: boolean;
+    readonly RuledLineCapabilities: number;
+    readonly SupportedBarcodeRotations: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedBitmapRotations: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var ICommonReceiptSlipCapabilities: abstract new (...args: any[]) => ICommonReceiptSlipCapabilities;
+
+  interface IJournalPrintJob {
+    FeedPaperByLine(lineCount: number): void;
+    FeedPaperByMapModeUnit(distance: number): void;
+    Print(data: string, printOptions: Windows.Devices.PointOfService.PosPrinterPrintOptions): void;
+  }
+  var IJournalPrintJob: abstract new (...args: any[]) => IJournalPrintJob;
+
+  interface IJournalPrinterCapabilities {
+  }
+  var IJournalPrinterCapabilities: abstract new (...args: any[]) => IJournalPrinterCapabilities;
+
+  interface IJournalPrinterCapabilities2 {
+    readonly IsReversePaperFeedByLineSupported: boolean;
+    readonly IsReversePaperFeedByMapModeUnitSupported: boolean;
+    readonly IsReverseVideoSupported: boolean;
+    readonly IsStrikethroughSupported: boolean;
+    readonly IsSubscriptSupported: boolean;
+    readonly IsSuperscriptSupported: boolean;
+  }
+  var IJournalPrinterCapabilities2: abstract new (...args: any[]) => IJournalPrinterCapabilities2;
+
+  interface ILineDisplay {
+    ClaimAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.ClaimedLineDisplay>;
+    readonly Capabilities: Windows.Devices.PointOfService.LineDisplayCapabilities;
+    readonly DeviceControlDescription: string;
+    readonly DeviceControlVersion: string;
+    readonly DeviceId: string;
+    readonly DeviceServiceVersion: string;
+    readonly PhysicalDeviceDescription: string;
+    readonly PhysicalDeviceName: string;
+  }
+  var ILineDisplay: abstract new (...args: any[]) => ILineDisplay;
+
+  interface ILineDisplay2 {
+    CheckPowerStatusAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var ILineDisplay2: abstract new (...args: any[]) => ILineDisplay2;
+
+  interface ILineDisplayAttributes {
+    BlinkRate: Windows.Foundation.TimeSpan;
+    Brightness: number;
+    CharacterSet: number;
+    CurrentWindow: Windows.Devices.PointOfService.LineDisplayWindow;
+    IsCharacterSetMappingEnabled: boolean;
+    IsPowerNotifyEnabled: boolean;
+    ScreenSizeInCharacters: Windows.Foundation.Size;
+  }
+  var ILineDisplayAttributes: abstract new (...args: any[]) => ILineDisplayAttributes;
+
+  interface ILineDisplayCapabilities {
+    readonly CanBlink: number;
+    readonly CanChangeBlinkRate: boolean;
+    readonly CanChangeScreenSize: boolean;
+    readonly CanDisplayBitmaps: boolean;
+    readonly CanDisplayCustomGlyphs: boolean;
+    readonly CanMapCharacterSets: boolean;
+    readonly CanReadCharacterAtCursor: boolean;
+    readonly CanReverse: number;
+    readonly IsBrightnessSupported: boolean;
+    readonly IsCursorSupported: boolean;
+    readonly IsHorizontalMarqueeSupported: boolean;
+    readonly IsInterCharacterWaitSupported: boolean;
+    readonly IsStatisticsReportingSupported: boolean;
+    readonly IsStatisticsUpdatingSupported: boolean;
+    readonly IsVerticalMarqueeSupported: boolean;
+    readonly PowerReportingType: number;
+    readonly SupportedDescriptors: number;
+    readonly SupportedWindows: number;
+  }
+  var ILineDisplayCapabilities: abstract new (...args: any[]) => ILineDisplayCapabilities;
+
+  interface ILineDisplayCursor {
+    GetAttributes(): Windows.Devices.PointOfService.LineDisplayCursorAttributes;
+    TryUpdateAttributesAsync(attributes: Windows.Devices.PointOfService.LineDisplayCursorAttributes): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly CanCustomize: boolean;
+    readonly IsBlinkSupported: boolean;
+    readonly IsBlockSupported: boolean;
+    readonly IsHalfBlockSupported: boolean;
+    readonly IsOtherSupported: boolean;
+    readonly IsReverseSupported: boolean;
+    readonly IsUnderlineSupported: boolean;
+  }
+  var ILineDisplayCursor: abstract new (...args: any[]) => ILineDisplayCursor;
+
+  interface ILineDisplayCursorAttributes {
+    CursorType: number;
+    IsAutoAdvanceEnabled: boolean;
+    IsBlinkEnabled: boolean;
+    Position: Windows.Foundation.Point;
+  }
+  var ILineDisplayCursorAttributes: abstract new (...args: any[]) => ILineDisplayCursorAttributes;
+
+  interface ILineDisplayCustomGlyphs {
+    TryRedefineAsync(glyphCode: number, glyphData: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly SizeInPixels: Windows.Foundation.Size;
+    readonly SupportedGlyphCodes: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var ILineDisplayCustomGlyphs: abstract new (...args: any[]) => ILineDisplayCustomGlyphs;
+
+  interface ILineDisplayMarquee {
+    TryStartScrollingAsync(direction: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryStopScrollingAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    Format: number;
+    RepeatWaitInterval: Windows.Foundation.TimeSpan;
+    ScrollWaitInterval: Windows.Foundation.TimeSpan;
+  }
+  var ILineDisplayMarquee: abstract new (...args: any[]) => ILineDisplayMarquee;
+
+  interface ILineDisplayStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.LineDisplay>;
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.LineDisplay>;
+    GetDeviceSelector(): string;
+    GetDeviceSelector(connectionTypes: number): string;
+  }
+  var ILineDisplayStatics: abstract new (...args: any[]) => ILineDisplayStatics;
+
+  interface ILineDisplayStatics2 {
+    readonly StatisticsCategorySelector: Windows.Devices.PointOfService.LineDisplayStatisticsCategorySelector;
+  }
+  var ILineDisplayStatics2: abstract new (...args: any[]) => ILineDisplayStatics2;
+
+  interface ILineDisplayStatisticsCategorySelector {
+    readonly AllStatistics: string;
+    readonly ManufacturerStatistics: string;
+    readonly UnifiedPosStatistics: string;
+  }
+  var ILineDisplayStatisticsCategorySelector: abstract new (...args: any[]) => ILineDisplayStatisticsCategorySelector;
+
+  interface ILineDisplayStatusUpdatedEventArgs {
+    readonly Status: number;
+  }
+  var ILineDisplayStatusUpdatedEventArgs: abstract new (...args: any[]) => ILineDisplayStatusUpdatedEventArgs;
+
+  interface ILineDisplayStoredBitmap {
+    TryDeleteAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly EscapeSequence: string;
+  }
+  var ILineDisplayStoredBitmap: abstract new (...args: any[]) => ILineDisplayStoredBitmap;
+
+  interface ILineDisplayWindow {
+    TryClearTextAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDisplayTextAsync(text: string, displayAttribute: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDisplayTextAsync(text: string, displayAttribute: number, startPosition: Windows.Foundation.Point): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDisplayTextAsync(text: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryRefreshAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryScrollTextAsync(direction: number, numberOfColumnsOrRows: number): Windows.Foundation.IAsyncOperation<boolean>;
+    InterCharacterWaitInterval: Windows.Foundation.TimeSpan;
+    readonly SizeInCharacters: Windows.Foundation.Size;
+  }
+  var ILineDisplayWindow: abstract new (...args: any[]) => ILineDisplayWindow;
+
+  interface ILineDisplayWindow2 {
+    ReadCharacterAtCursorAsync(): Windows.Foundation.IAsyncOperation<number>;
+    TryDisplayStorageFileBitmapAtCursorAsync(bitmap: Windows.Storage.StorageFile): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDisplayStorageFileBitmapAtCursorAsync(bitmap: Windows.Storage.StorageFile, horizontalAlignment: number, verticalAlignment: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDisplayStorageFileBitmapAtCursorAsync(bitmap: Windows.Storage.StorageFile, horizontalAlignment: number, verticalAlignment: number, widthInPixels: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDisplayStorageFileBitmapAtPointAsync(bitmap: Windows.Storage.StorageFile, offsetInPixels: Windows.Foundation.Point): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDisplayStorageFileBitmapAtPointAsync(bitmap: Windows.Storage.StorageFile, offsetInPixels: Windows.Foundation.Point, widthInPixels: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryDisplayStoredBitmapAtCursorAsync(bitmap: Windows.Devices.PointOfService.LineDisplayStoredBitmap): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Cursor: Windows.Devices.PointOfService.LineDisplayCursor;
+    readonly Marquee: Windows.Devices.PointOfService.LineDisplayMarquee;
+  }
+  var ILineDisplayWindow2: abstract new (...args: any[]) => ILineDisplayWindow2;
+
+  interface IMagneticStripeReader {
+    CheckHealthAsync(level: number): Windows.Foundation.IAsyncOperation<string>;
+    ClaimReaderAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.ClaimedMagneticStripeReader>;
+    GetErrorReportingType(): number;
+    RetrieveStatisticsAsync(statisticsCategories: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    readonly Capabilities: Windows.Devices.PointOfService.MagneticStripeReaderCapabilities;
+    readonly DeviceAuthenticationProtocol: number;
+    readonly DeviceId: string;
+    readonly SupportedCardTypes: number[];
+    StatusUpdated: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.MagneticStripeReader, Windows.Devices.PointOfService.MagneticStripeReaderStatusUpdatedEventArgs> | null;
+  }
+  var IMagneticStripeReader: abstract new (...args: any[]) => IMagneticStripeReader;
+
+  interface IMagneticStripeReaderAamvaCardDataReceivedEventArgs {
+    readonly Address: string;
+    readonly BirthDate: string;
+    readonly City: string;
+    readonly Class: string;
+    readonly Endorsements: string;
+    readonly ExpirationDate: string;
+    readonly EyeColor: string;
+    readonly FirstName: string;
+    readonly Gender: string;
+    readonly HairColor: string;
+    readonly Height: string;
+    readonly LicenseNumber: string;
+    readonly PostalCode: string;
+    readonly Report: Windows.Devices.PointOfService.MagneticStripeReaderReport;
+    readonly Restrictions: string;
+    readonly State: string;
+    readonly Suffix: string;
+    readonly Surname: string;
+    readonly Weight: string;
+  }
+  var IMagneticStripeReaderAamvaCardDataReceivedEventArgs: abstract new (...args: any[]) => IMagneticStripeReaderAamvaCardDataReceivedEventArgs;
+
+  interface IMagneticStripeReaderBankCardDataReceivedEventArgs {
+    readonly AccountNumber: string;
+    readonly ExpirationDate: string;
+    readonly FirstName: string;
+    readonly MiddleInitial: string;
+    readonly Report: Windows.Devices.PointOfService.MagneticStripeReaderReport;
+    readonly ServiceCode: string;
+    readonly Suffix: string;
+    readonly Surname: string;
+    readonly Title: string;
+  }
+  var IMagneticStripeReaderBankCardDataReceivedEventArgs: abstract new (...args: any[]) => IMagneticStripeReaderBankCardDataReceivedEventArgs;
+
+  interface IMagneticStripeReaderCapabilities {
+    readonly AuthenticationLevel: number;
+    readonly CardAuthentication: string;
+    readonly IsIsoSupported: boolean;
+    readonly IsJisOneSupported: boolean;
+    readonly IsJisTwoSupported: boolean;
+    readonly IsStatisticsReportingSupported: boolean;
+    readonly IsStatisticsUpdatingSupported: boolean;
+    readonly IsTrackDataMaskingSupported: boolean;
+    readonly IsTransmitSentinelsSupported: boolean;
+    readonly PowerReportingType: number;
+    readonly SupportedEncryptionAlgorithms: number;
+  }
+  var IMagneticStripeReaderCapabilities: abstract new (...args: any[]) => IMagneticStripeReaderCapabilities;
+
+  interface IMagneticStripeReaderCardTypesStatics {
+    readonly Aamva: number;
+    readonly Bank: number;
+    readonly ExtendedBase: number;
+    readonly Unknown: number;
+  }
+  var IMagneticStripeReaderCardTypesStatics: abstract new (...args: any[]) => IMagneticStripeReaderCardTypesStatics;
+
+  interface IMagneticStripeReaderEncryptionAlgorithmsStatics {
+    readonly ExtendedBase: number;
+    readonly None: number;
+    readonly TripleDesDukpt: number;
+  }
+  var IMagneticStripeReaderEncryptionAlgorithmsStatics: abstract new (...args: any[]) => IMagneticStripeReaderEncryptionAlgorithmsStatics;
+
+  interface IMagneticStripeReaderErrorOccurredEventArgs {
+    readonly ErrorData: Windows.Devices.PointOfService.UnifiedPosErrorData;
+    readonly PartialInputData: Windows.Devices.PointOfService.MagneticStripeReaderReport;
+    readonly Track1Status: number;
+    readonly Track2Status: number;
+    readonly Track3Status: number;
+    readonly Track4Status: number;
+  }
+  var IMagneticStripeReaderErrorOccurredEventArgs: abstract new (...args: any[]) => IMagneticStripeReaderErrorOccurredEventArgs;
+
+  interface IMagneticStripeReaderReport {
+    readonly AdditionalSecurityInformation: Windows.Storage.Streams.IBuffer;
+    readonly CardAuthenticationData: Windows.Storage.Streams.IBuffer;
+    readonly CardAuthenticationDataLength: number;
+    readonly CardType: number;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, string>;
+    readonly Track1: Windows.Devices.PointOfService.MagneticStripeReaderTrackData;
+    readonly Track2: Windows.Devices.PointOfService.MagneticStripeReaderTrackData;
+    readonly Track3: Windows.Devices.PointOfService.MagneticStripeReaderTrackData;
+    readonly Track4: Windows.Devices.PointOfService.MagneticStripeReaderTrackData;
+  }
+  var IMagneticStripeReaderReport: abstract new (...args: any[]) => IMagneticStripeReaderReport;
+
+  interface IMagneticStripeReaderStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.MagneticStripeReader>;
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.MagneticStripeReader>;
+    GetDeviceSelector(): string;
+  }
+  var IMagneticStripeReaderStatics: abstract new (...args: any[]) => IMagneticStripeReaderStatics;
+
+  interface IMagneticStripeReaderStatics2 {
+    GetDeviceSelector(connectionTypes: number): string;
+  }
+  var IMagneticStripeReaderStatics2: abstract new (...args: any[]) => IMagneticStripeReaderStatics2;
+
+  interface IMagneticStripeReaderStatusUpdatedEventArgs {
+    readonly ExtendedStatus: number;
+    readonly Status: number;
+  }
+  var IMagneticStripeReaderStatusUpdatedEventArgs: abstract new (...args: any[]) => IMagneticStripeReaderStatusUpdatedEventArgs;
+
+  interface IMagneticStripeReaderTrackData {
+    readonly Data: Windows.Storage.Streams.IBuffer;
+    readonly DiscretionaryData: Windows.Storage.Streams.IBuffer;
+    readonly EncryptedData: Windows.Storage.Streams.IBuffer;
+  }
+  var IMagneticStripeReaderTrackData: abstract new (...args: any[]) => IMagneticStripeReaderTrackData;
+
+  interface IMagneticStripeReaderVendorSpecificCardDataReceivedEventArgs {
+    readonly Report: Windows.Devices.PointOfService.MagneticStripeReaderReport;
+  }
+  var IMagneticStripeReaderVendorSpecificCardDataReceivedEventArgs: abstract new (...args: any[]) => IMagneticStripeReaderVendorSpecificCardDataReceivedEventArgs;
+
+  interface IPosPrinter {
+    CheckHealthAsync(level: number): Windows.Foundation.IAsyncOperation<string>;
+    ClaimPrinterAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.ClaimedPosPrinter>;
+    GetStatisticsAsync(statisticsCategories: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<string>;
+    readonly Capabilities: Windows.Devices.PointOfService.PosPrinterCapabilities;
+    readonly DeviceId: string;
+    readonly Status: Windows.Devices.PointOfService.PosPrinterStatus;
+    readonly SupportedCharacterSets: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedTypeFaces: Windows.Foundation.Collections.IVectorView<string> | string[];
+    StatusUpdated: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.PosPrinter, Windows.Devices.PointOfService.PosPrinterStatusUpdatedEventArgs> | null;
+  }
+  var IPosPrinter: abstract new (...args: any[]) => IPosPrinter;
+
+  interface IPosPrinter2 {
+    GetFontProperty(typeface: string): Windows.Devices.PointOfService.PosPrinterFontProperty;
+    readonly SupportedBarcodeSymbologies: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IPosPrinter2: abstract new (...args: any[]) => IPosPrinter2;
+
+  interface IPosPrinterCapabilities {
+    readonly CanMapCharacterSet: boolean;
+    readonly DefaultCharacterSet: number;
+    readonly HasCoverSensor: boolean;
+    readonly IsStatisticsReportingSupported: boolean;
+    readonly IsStatisticsUpdatingSupported: boolean;
+    readonly IsTransactionSupported: boolean;
+    readonly Journal: Windows.Devices.PointOfService.JournalPrinterCapabilities;
+    readonly PowerReportingType: number;
+    readonly Receipt: Windows.Devices.PointOfService.ReceiptPrinterCapabilities;
+    readonly Slip: Windows.Devices.PointOfService.SlipPrinterCapabilities;
+  }
+  var IPosPrinterCapabilities: abstract new (...args: any[]) => IPosPrinterCapabilities;
+
+  interface IPosPrinterCharacterSetIdsStatics {
+    readonly Ansi: number;
+    readonly Ascii: number;
+    readonly Utf16LE: number;
+  }
+  var IPosPrinterCharacterSetIdsStatics: abstract new (...args: any[]) => IPosPrinterCharacterSetIdsStatics;
+
+  interface IPosPrinterFontProperty {
+    readonly CharacterSizes: Windows.Foundation.Collections.IVectorView<Windows.Devices.PointOfService.SizeUInt32> | Windows.Devices.PointOfService.SizeUInt32[];
+    readonly IsScalableToAnySize: boolean;
+    readonly TypeFace: string;
+  }
+  var IPosPrinterFontProperty: abstract new (...args: any[]) => IPosPrinterFontProperty;
+
+  interface IPosPrinterJob {
+    ExecuteAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    Print(data: string): void;
+    PrintLine(data: string): void;
+    PrintLine(): void;
+  }
+  var IPosPrinterJob: abstract new (...args: any[]) => IPosPrinterJob;
+
+  interface IPosPrinterPrintOptions {
+    Alignment: number;
+    Bold: boolean;
+    CharacterHeight: number;
+    CharacterSet: number;
+    DoubleHigh: boolean;
+    DoubleWide: boolean;
+    Italic: boolean;
+    ReverseVideo: boolean;
+    Strikethrough: boolean;
+    Subscript: boolean;
+    Superscript: boolean;
+    TypeFace: string;
+    Underline: boolean;
+  }
+  var IPosPrinterPrintOptions: abstract new (...args: any[]) => IPosPrinterPrintOptions;
+
+  interface IPosPrinterReleaseDeviceRequestedEventArgs {
+  }
+  var IPosPrinterReleaseDeviceRequestedEventArgs: abstract new (...args: any[]) => IPosPrinterReleaseDeviceRequestedEventArgs;
+
+  interface IPosPrinterStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.PosPrinter>;
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.PosPrinter>;
+    GetDeviceSelector(): string;
+  }
+  var IPosPrinterStatics: abstract new (...args: any[]) => IPosPrinterStatics;
+
+  interface IPosPrinterStatics2 {
+    GetDeviceSelector(connectionTypes: number): string;
+  }
+  var IPosPrinterStatics2: abstract new (...args: any[]) => IPosPrinterStatics2;
+
+  interface IPosPrinterStatus {
+    readonly ExtendedStatus: number;
+    readonly StatusKind: number;
+  }
+  var IPosPrinterStatus: abstract new (...args: any[]) => IPosPrinterStatus;
+
+  interface IPosPrinterStatusUpdatedEventArgs {
+    readonly Status: Windows.Devices.PointOfService.PosPrinterStatus;
+  }
+  var IPosPrinterStatusUpdatedEventArgs: abstract new (...args: any[]) => IPosPrinterStatusUpdatedEventArgs;
+
+  interface IReceiptOrSlipJob extends Windows.Devices.PointOfService.IPosPrinterJob {
+    DrawRuledLine(positionList: string, lineDirection: number, lineWidth: number, lineStyle: number, lineColor: number): void;
+    ExecuteAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    Print(data: string): void;
+    PrintBarcode(data: string, symbology: number, height: number, width: number, textPosition: number, alignment: number): void;
+    PrintBarcodeCustomAlign(data: string, symbology: number, height: number, width: number, textPosition: number, alignmentDistance: number): void;
+    PrintBitmap(bitmap: Windows.Graphics.Imaging.BitmapFrame, alignment: number): void;
+    PrintBitmap(bitmap: Windows.Graphics.Imaging.BitmapFrame, alignment: number, width: number): void;
+    PrintCustomAlignedBitmap(bitmap: Windows.Graphics.Imaging.BitmapFrame, alignmentDistance: number): void;
+    PrintCustomAlignedBitmap(bitmap: Windows.Graphics.Imaging.BitmapFrame, alignmentDistance: number, width: number): void;
+    PrintLine(data: string): void;
+    PrintLine(): void;
+    PrintSavedBitmap(bitmapNumber: number): void;
+    SetBarcodeRotation(value: number): void;
+    SetBitmap(bitmapNumber: number, bitmap: Windows.Graphics.Imaging.BitmapFrame, alignment: number): void;
+    SetBitmap(bitmapNumber: number, bitmap: Windows.Graphics.Imaging.BitmapFrame, alignment: number, width: number): void;
+    SetCustomAlignedBitmap(bitmapNumber: number, bitmap: Windows.Graphics.Imaging.BitmapFrame, alignmentDistance: number): void;
+    SetCustomAlignedBitmap(bitmapNumber: number, bitmap: Windows.Graphics.Imaging.BitmapFrame, alignmentDistance: number, width: number): void;
+    SetPrintArea(value: Windows.Foundation.Rect): void;
+    SetPrintRotation(value: number, includeBitmaps: boolean): void;
+  }
+  var IReceiptOrSlipJob: abstract new (...args: any[]) => IReceiptOrSlipJob;
+
+  interface IReceiptPrintJob {
+    CutPaper(percentage: number): void;
+    CutPaper(): void;
+    MarkFeed(kind: number): void;
+  }
+  var IReceiptPrintJob: abstract new (...args: any[]) => IReceiptPrintJob;
+
+  interface IReceiptPrintJob2 {
+    FeedPaperByLine(lineCount: number): void;
+    FeedPaperByMapModeUnit(distance: number): void;
+    Print(data: string, printOptions: Windows.Devices.PointOfService.PosPrinterPrintOptions): void;
+    StampPaper(): void;
+  }
+  var IReceiptPrintJob2: abstract new (...args: any[]) => IReceiptPrintJob2;
+
+  interface IReceiptPrinterCapabilities {
+    readonly CanCutPaper: boolean;
+    readonly IsStampSupported: boolean;
+    readonly MarkFeedCapabilities: number;
+  }
+  var IReceiptPrinterCapabilities: abstract new (...args: any[]) => IReceiptPrinterCapabilities;
+
+  interface IReceiptPrinterCapabilities2 {
+    readonly IsReversePaperFeedByLineSupported: boolean;
+    readonly IsReversePaperFeedByMapModeUnitSupported: boolean;
+    readonly IsReverseVideoSupported: boolean;
+    readonly IsStrikethroughSupported: boolean;
+    readonly IsSubscriptSupported: boolean;
+    readonly IsSuperscriptSupported: boolean;
+  }
+  var IReceiptPrinterCapabilities2: abstract new (...args: any[]) => IReceiptPrinterCapabilities2;
+
+  interface ISlipPrintJob {
+    FeedPaperByLine(lineCount: number): void;
+    FeedPaperByMapModeUnit(distance: number): void;
+    Print(data: string, printOptions: Windows.Devices.PointOfService.PosPrinterPrintOptions): void;
+  }
+  var ISlipPrintJob: abstract new (...args: any[]) => ISlipPrintJob;
+
+  interface ISlipPrinterCapabilities {
+    readonly IsBothSidesPrintingSupported: boolean;
+    readonly IsFullLengthSupported: boolean;
+  }
+  var ISlipPrinterCapabilities: abstract new (...args: any[]) => ISlipPrinterCapabilities;
+
+  interface ISlipPrinterCapabilities2 {
+    readonly IsReversePaperFeedByLineSupported: boolean;
+    readonly IsReversePaperFeedByMapModeUnitSupported: boolean;
+    readonly IsReverseVideoSupported: boolean;
+    readonly IsStrikethroughSupported: boolean;
+    readonly IsSubscriptSupported: boolean;
+    readonly IsSuperscriptSupported: boolean;
+  }
+  var ISlipPrinterCapabilities2: abstract new (...args: any[]) => ISlipPrinterCapabilities2;
+
+  interface IUnifiedPosErrorData {
+    readonly ExtendedReason: number;
+    readonly Message: string;
+    readonly Reason: number;
+    readonly Severity: number;
+  }
+  var IUnifiedPosErrorData: abstract new (...args: any[]) => IUnifiedPosErrorData;
+
+  interface IUnifiedPosErrorDataFactory {
+    CreateInstance(message: string, severity: number, reason: number, extendedReason: number): Windows.Devices.PointOfService.UnifiedPosErrorData;
+  }
+  var IUnifiedPosErrorDataFactory: abstract new (...args: any[]) => IUnifiedPosErrorDataFactory;
+
+  interface SizeUInt32 {
+    Width: number;
+    Height: number;
+  }
+  var SizeUInt32: {
+    new(width: number, height: number): SizeUInt32;
+    new(fields: { Width?: number; Height?: number }): SizeUInt32;
+  };
+
+}
+
+declare namespace Windows.Devices.PointOfService.Provider {
+  class BarcodeScannerDisableScannerRequest implements Windows.Devices.PointOfService.Provider.IBarcodeScannerDisableScannerRequest, Windows.Devices.PointOfService.Provider.IBarcodeScannerDisableScannerRequest2 {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number, failedReasonDescription: string): Windows.Foundation.IAsyncAction;
+  }
+
+  class BarcodeScannerDisableScannerRequestEventArgs implements Windows.Devices.PointOfService.Provider.IBarcodeScannerDisableScannerRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequest;
+  }
+
+  class BarcodeScannerEnableScannerRequest implements Windows.Devices.PointOfService.Provider.IBarcodeScannerEnableScannerRequest, Windows.Devices.PointOfService.Provider.IBarcodeScannerEnableScannerRequest2 {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number, failedReasonDescription: string): Windows.Foundation.IAsyncAction;
+  }
+
+  class BarcodeScannerEnableScannerRequestEventArgs implements Windows.Devices.PointOfService.Provider.IBarcodeScannerEnableScannerRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequest;
+  }
+
+  class BarcodeScannerFrameReader implements Windows.Devices.PointOfService.Provider.IBarcodeScannerFrameReader, Windows.Foundation.IClosable {
+    Close(): void;
+    StartAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    StopAsync(): Windows.Foundation.IAsyncAction;
+    TryAcquireLatestFrameAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.Provider.BarcodeScannerVideoFrame>;
+    readonly Connection: Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection;
+    FrameArrived: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader, Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReaderFrameArrivedEventArgs> | null;
+  }
+
+  class BarcodeScannerFrameReaderFrameArrivedEventArgs implements Windows.Devices.PointOfService.Provider.IBarcodeScannerFrameReaderFrameArrivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+
+  class BarcodeScannerGetSymbologyAttributesRequest implements Windows.Devices.PointOfService.Provider.IBarcodeScannerGetSymbologyAttributesRequest, Windows.Devices.PointOfService.Provider.IBarcodeScannerGetSymbologyAttributesRequest2 {
+    ReportCompletedAsync(attributes: Windows.Devices.PointOfService.BarcodeSymbologyAttributes): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number, failedReasonDescription: string): Windows.Foundation.IAsyncAction;
+    readonly Symbology: number;
+  }
+
+  class BarcodeScannerGetSymbologyAttributesRequestEventArgs implements Windows.Devices.PointOfService.Provider.IBarcodeScannerGetSymbologyAttributesRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequest;
+  }
+
+  class BarcodeScannerHideVideoPreviewRequest implements Windows.Devices.PointOfService.Provider.IBarcodeScannerHideVideoPreviewRequest, Windows.Devices.PointOfService.Provider.IBarcodeScannerHideVideoPreviewRequest2 {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number, failedReasonDescription: string): Windows.Foundation.IAsyncAction;
+  }
+
+  class BarcodeScannerHideVideoPreviewRequestEventArgs implements Windows.Devices.PointOfService.Provider.IBarcodeScannerHideVideoPreviewRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequest;
+  }
+
+  class BarcodeScannerProviderConnection implements Windows.Devices.PointOfService.Provider.IBarcodeScannerProviderConnection, Windows.Devices.PointOfService.Provider.IBarcodeScannerProviderConnection2, Windows.Foundation.IClosable {
+    Close(): void;
+    CreateFrameReaderAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader>;
+    CreateFrameReaderAsync(preferredFormat: number): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader>;
+    CreateFrameReaderAsync(preferredFormat: number, preferredSize: Windows.Graphics.Imaging.BitmapSize): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader>;
+    ReportErrorAsync(errorData: Windows.Devices.PointOfService.UnifiedPosErrorData): Windows.Foundation.IAsyncAction;
+    ReportErrorAsync(errorData: Windows.Devices.PointOfService.UnifiedPosErrorData, isRetriable: boolean, scanReport: Windows.Devices.PointOfService.BarcodeScannerReport): Windows.Foundation.IAsyncAction;
+    ReportScannedDataAsync(report: Windows.Devices.PointOfService.BarcodeScannerReport): Windows.Foundation.IAsyncAction;
+    ReportTriggerStateAsync(state: number): Windows.Foundation.IAsyncAction;
+    Start(): void;
+    CompanyName: string;
+    readonly Id: string;
+    Name: string;
+    readonly SupportedSymbologies: Windows.Foundation.Collections.IVector<number> | number[];
+    Version: string;
+    readonly VideoDeviceId: string;
+    DisableScannerRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection, Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequestEventArgs> | null;
+    EnableScannerRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection, Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequestEventArgs> | null;
+    GetBarcodeSymbologyAttributesRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection, Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs> | null;
+    HideVideoPreviewRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection, Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequestEventArgs> | null;
+    SetActiveSymbologiesRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection, Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs> | null;
+    SetBarcodeSymbologyAttributesRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection, Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs> | null;
+    StartSoftwareTriggerRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection, Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs> | null;
+    StopSoftwareTriggerRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection, Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs> | null;
+  }
+
+  class BarcodeScannerProviderTriggerDetails implements Windows.Devices.PointOfService.Provider.IBarcodeScannerProviderTriggerDetails {
+    readonly Connection: Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection;
+  }
+
+  class BarcodeScannerSetActiveSymbologiesRequest implements Windows.Devices.PointOfService.Provider.IBarcodeScannerSetActiveSymbologiesRequest, Windows.Devices.PointOfService.Provider.IBarcodeScannerSetActiveSymbologiesRequest2 {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number, failedReasonDescription: string): Windows.Foundation.IAsyncAction;
+    readonly Symbologies: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class BarcodeScannerSetActiveSymbologiesRequestEventArgs implements Windows.Devices.PointOfService.Provider.IBarcodeScannerSetActiveSymbologiesRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequest;
+  }
+
+  class BarcodeScannerSetSymbologyAttributesRequest implements Windows.Devices.PointOfService.Provider.IBarcodeScannerSetSymbologyAttributesRequest, Windows.Devices.PointOfService.Provider.IBarcodeScannerSetSymbologyAttributesRequest2 {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number, failedReasonDescription: string): Windows.Foundation.IAsyncAction;
+    readonly Attributes: Windows.Devices.PointOfService.BarcodeSymbologyAttributes;
+    readonly Symbology: number;
+  }
+
+  class BarcodeScannerSetSymbologyAttributesRequestEventArgs implements Windows.Devices.PointOfService.Provider.IBarcodeScannerSetSymbologyAttributesRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequest;
+  }
+
+  class BarcodeScannerStartSoftwareTriggerRequest implements Windows.Devices.PointOfService.Provider.IBarcodeScannerStartSoftwareTriggerRequest, Windows.Devices.PointOfService.Provider.IBarcodeScannerStartSoftwareTriggerRequest2 {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number, failedReasonDescription: string): Windows.Foundation.IAsyncAction;
+  }
+
+  class BarcodeScannerStartSoftwareTriggerRequestEventArgs implements Windows.Devices.PointOfService.Provider.IBarcodeScannerStartSoftwareTriggerRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequest;
+  }
+
+  class BarcodeScannerStopSoftwareTriggerRequest implements Windows.Devices.PointOfService.Provider.IBarcodeScannerStopSoftwareTriggerRequest, Windows.Devices.PointOfService.Provider.IBarcodeScannerStopSoftwareTriggerRequest2 {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number, failedReasonDescription: string): Windows.Foundation.IAsyncAction;
+  }
+
+  class BarcodeScannerStopSoftwareTriggerRequestEventArgs implements Windows.Devices.PointOfService.Provider.IBarcodeScannerStopSoftwareTriggerRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequest;
+  }
+
+  class BarcodeScannerVideoFrame implements Windows.Devices.PointOfService.Provider.IBarcodeScannerVideoFrame, Windows.Foundation.IClosable {
+    Close(): void;
+    readonly Format: number;
+    readonly Height: number;
+    readonly PixelData: Windows.Storage.Streams.IBuffer;
+    readonly Width: number;
+  }
+
+  class BarcodeSymbologyAttributesBuilder implements Windows.Devices.PointOfService.Provider.IBarcodeSymbologyAttributesBuilder {
+    constructor();
+    CreateAttributes(): Windows.Devices.PointOfService.BarcodeSymbologyAttributes;
+    IsCheckDigitTransmissionSupported: boolean;
+    IsCheckDigitValidationSupported: boolean;
+    IsDecodeLengthSupported: boolean;
+  }
+
+  enum BarcodeScannerTriggerState {
+    Released = 0,
+    Pressed = 1,
+  }
+
+  interface IBarcodeScannerDisableScannerRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var IBarcodeScannerDisableScannerRequest: abstract new (...args: any[]) => IBarcodeScannerDisableScannerRequest;
+
+  interface IBarcodeScannerDisableScannerRequest2 {
+    ReportFailedAsync(reason: number): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number, failedReasonDescription: string): Windows.Foundation.IAsyncAction;
+  }
+  var IBarcodeScannerDisableScannerRequest2: abstract new (...args: any[]) => IBarcodeScannerDisableScannerRequest2;
+
+  interface IBarcodeScannerDisableScannerRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequest;
+  }
+  var IBarcodeScannerDisableScannerRequestEventArgs: abstract new (...args: any[]) => IBarcodeScannerDisableScannerRequestEventArgs;
+
+  interface IBarcodeScannerEnableScannerRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var IBarcodeScannerEnableScannerRequest: abstract new (...args: any[]) => IBarcodeScannerEnableScannerRequest;
+
+  interface IBarcodeScannerEnableScannerRequest2 {
+    ReportFailedAsync(reason: number): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number, failedReasonDescription: string): Windows.Foundation.IAsyncAction;
+  }
+  var IBarcodeScannerEnableScannerRequest2: abstract new (...args: any[]) => IBarcodeScannerEnableScannerRequest2;
+
+  interface IBarcodeScannerEnableScannerRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequest;
+  }
+  var IBarcodeScannerEnableScannerRequestEventArgs: abstract new (...args: any[]) => IBarcodeScannerEnableScannerRequestEventArgs;
+
+  interface IBarcodeScannerFrameReader {
+    StartAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    StopAsync(): Windows.Foundation.IAsyncAction;
+    TryAcquireLatestFrameAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.Provider.BarcodeScannerVideoFrame>;
+    readonly Connection: Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection;
+    FrameArrived: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader, Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReaderFrameArrivedEventArgs> | null;
+  }
+  var IBarcodeScannerFrameReader: abstract new (...args: any[]) => IBarcodeScannerFrameReader;
+
+  interface IBarcodeScannerFrameReaderFrameArrivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+  var IBarcodeScannerFrameReaderFrameArrivedEventArgs: abstract new (...args: any[]) => IBarcodeScannerFrameReaderFrameArrivedEventArgs;
+
+  interface IBarcodeScannerGetSymbologyAttributesRequest {
+    ReportCompletedAsync(attributes: Windows.Devices.PointOfService.BarcodeSymbologyAttributes): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly Symbology: number;
+  }
+  var IBarcodeScannerGetSymbologyAttributesRequest: abstract new (...args: any[]) => IBarcodeScannerGetSymbologyAttributesRequest;
+
+  interface IBarcodeScannerGetSymbologyAttributesRequest2 {
+    ReportFailedAsync(reason: number): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number, failedReasonDescription: string): Windows.Foundation.IAsyncAction;
+  }
+  var IBarcodeScannerGetSymbologyAttributesRequest2: abstract new (...args: any[]) => IBarcodeScannerGetSymbologyAttributesRequest2;
+
+  interface IBarcodeScannerGetSymbologyAttributesRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequest;
+  }
+  var IBarcodeScannerGetSymbologyAttributesRequestEventArgs: abstract new (...args: any[]) => IBarcodeScannerGetSymbologyAttributesRequestEventArgs;
+
+  interface IBarcodeScannerHideVideoPreviewRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var IBarcodeScannerHideVideoPreviewRequest: abstract new (...args: any[]) => IBarcodeScannerHideVideoPreviewRequest;
+
+  interface IBarcodeScannerHideVideoPreviewRequest2 {
+    ReportFailedAsync(reason: number): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number, failedReasonDescription: string): Windows.Foundation.IAsyncAction;
+  }
+  var IBarcodeScannerHideVideoPreviewRequest2: abstract new (...args: any[]) => IBarcodeScannerHideVideoPreviewRequest2;
+
+  interface IBarcodeScannerHideVideoPreviewRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequest;
+  }
+  var IBarcodeScannerHideVideoPreviewRequestEventArgs: abstract new (...args: any[]) => IBarcodeScannerHideVideoPreviewRequestEventArgs;
+
+  interface IBarcodeScannerProviderConnection {
+    ReportErrorAsync(errorData: Windows.Devices.PointOfService.UnifiedPosErrorData): Windows.Foundation.IAsyncAction;
+    ReportErrorAsync(errorData: Windows.Devices.PointOfService.UnifiedPosErrorData, isRetriable: boolean, scanReport: Windows.Devices.PointOfService.BarcodeScannerReport): Windows.Foundation.IAsyncAction;
+    ReportScannedDataAsync(report: Windows.Devices.PointOfService.BarcodeScannerReport): Windows.Foundation.IAsyncAction;
+    ReportTriggerStateAsync(state: number): Windows.Foundation.IAsyncAction;
+    Start(): void;
+    CompanyName: string;
+    readonly Id: string;
+    Name: string;
+    readonly SupportedSymbologies: Windows.Foundation.Collections.IVector<number> | number[];
+    Version: string;
+    readonly VideoDeviceId: string;
+    DisableScannerRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection, Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequestEventArgs> | null;
+    EnableScannerRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection, Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequestEventArgs> | null;
+    GetBarcodeSymbologyAttributesRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection, Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs> | null;
+    HideVideoPreviewRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection, Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequestEventArgs> | null;
+    SetActiveSymbologiesRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection, Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs> | null;
+    SetBarcodeSymbologyAttributesRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection, Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs> | null;
+    StartSoftwareTriggerRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection, Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs> | null;
+    StopSoftwareTriggerRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection, Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs> | null;
+  }
+  var IBarcodeScannerProviderConnection: abstract new (...args: any[]) => IBarcodeScannerProviderConnection;
+
+  interface IBarcodeScannerProviderConnection2 {
+    CreateFrameReaderAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader>;
+    CreateFrameReaderAsync(preferredFormat: number): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader>;
+    CreateFrameReaderAsync(preferredFormat: number, preferredSize: Windows.Graphics.Imaging.BitmapSize): Windows.Foundation.IAsyncOperation<Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader>;
+  }
+  var IBarcodeScannerProviderConnection2: abstract new (...args: any[]) => IBarcodeScannerProviderConnection2;
+
+  interface IBarcodeScannerProviderTriggerDetails {
+    readonly Connection: Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection;
+  }
+  var IBarcodeScannerProviderTriggerDetails: abstract new (...args: any[]) => IBarcodeScannerProviderTriggerDetails;
+
+  interface IBarcodeScannerSetActiveSymbologiesRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly Symbologies: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IBarcodeScannerSetActiveSymbologiesRequest: abstract new (...args: any[]) => IBarcodeScannerSetActiveSymbologiesRequest;
+
+  interface IBarcodeScannerSetActiveSymbologiesRequest2 {
+    ReportFailedAsync(reason: number): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number, failedReasonDescription: string): Windows.Foundation.IAsyncAction;
+  }
+  var IBarcodeScannerSetActiveSymbologiesRequest2: abstract new (...args: any[]) => IBarcodeScannerSetActiveSymbologiesRequest2;
+
+  interface IBarcodeScannerSetActiveSymbologiesRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequest;
+  }
+  var IBarcodeScannerSetActiveSymbologiesRequestEventArgs: abstract new (...args: any[]) => IBarcodeScannerSetActiveSymbologiesRequestEventArgs;
+
+  interface IBarcodeScannerSetSymbologyAttributesRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+    readonly Attributes: Windows.Devices.PointOfService.BarcodeSymbologyAttributes;
+    readonly Symbology: number;
+  }
+  var IBarcodeScannerSetSymbologyAttributesRequest: abstract new (...args: any[]) => IBarcodeScannerSetSymbologyAttributesRequest;
+
+  interface IBarcodeScannerSetSymbologyAttributesRequest2 {
+    ReportFailedAsync(reason: number): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number, failedReasonDescription: string): Windows.Foundation.IAsyncAction;
+  }
+  var IBarcodeScannerSetSymbologyAttributesRequest2: abstract new (...args: any[]) => IBarcodeScannerSetSymbologyAttributesRequest2;
+
+  interface IBarcodeScannerSetSymbologyAttributesRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequest;
+  }
+  var IBarcodeScannerSetSymbologyAttributesRequestEventArgs: abstract new (...args: any[]) => IBarcodeScannerSetSymbologyAttributesRequestEventArgs;
+
+  interface IBarcodeScannerStartSoftwareTriggerRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var IBarcodeScannerStartSoftwareTriggerRequest: abstract new (...args: any[]) => IBarcodeScannerStartSoftwareTriggerRequest;
+
+  interface IBarcodeScannerStartSoftwareTriggerRequest2 {
+    ReportFailedAsync(reason: number): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number, failedReasonDescription: string): Windows.Foundation.IAsyncAction;
+  }
+  var IBarcodeScannerStartSoftwareTriggerRequest2: abstract new (...args: any[]) => IBarcodeScannerStartSoftwareTriggerRequest2;
+
+  interface IBarcodeScannerStartSoftwareTriggerRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequest;
+  }
+  var IBarcodeScannerStartSoftwareTriggerRequestEventArgs: abstract new (...args: any[]) => IBarcodeScannerStartSoftwareTriggerRequestEventArgs;
+
+  interface IBarcodeScannerStopSoftwareTriggerRequest {
+    ReportCompletedAsync(): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var IBarcodeScannerStopSoftwareTriggerRequest: abstract new (...args: any[]) => IBarcodeScannerStopSoftwareTriggerRequest;
+
+  interface IBarcodeScannerStopSoftwareTriggerRequest2 {
+    ReportFailedAsync(reason: number): Windows.Foundation.IAsyncAction;
+    ReportFailedAsync(reason: number, failedReasonDescription: string): Windows.Foundation.IAsyncAction;
+  }
+  var IBarcodeScannerStopSoftwareTriggerRequest2: abstract new (...args: any[]) => IBarcodeScannerStopSoftwareTriggerRequest2;
+
+  interface IBarcodeScannerStopSoftwareTriggerRequestEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequest;
+  }
+  var IBarcodeScannerStopSoftwareTriggerRequestEventArgs: abstract new (...args: any[]) => IBarcodeScannerStopSoftwareTriggerRequestEventArgs;
+
+  interface IBarcodeScannerVideoFrame {
+    readonly Format: number;
+    readonly Height: number;
+    readonly PixelData: Windows.Storage.Streams.IBuffer;
+    readonly Width: number;
+  }
+  var IBarcodeScannerVideoFrame: abstract new (...args: any[]) => IBarcodeScannerVideoFrame;
+
+  interface IBarcodeSymbologyAttributesBuilder {
+    CreateAttributes(): Windows.Devices.PointOfService.BarcodeSymbologyAttributes;
+    IsCheckDigitTransmissionSupported: boolean;
+    IsCheckDigitValidationSupported: boolean;
+    IsDecodeLengthSupported: boolean;
+  }
+  var IBarcodeSymbologyAttributesBuilder: abstract new (...args: any[]) => IBarcodeSymbologyAttributesBuilder;
+
+}
+
+declare namespace Windows.Devices.Portable {
+  class ServiceDevice {
+    static GetDeviceSelector(serviceType: number): string;
+    static GetDeviceSelectorFromServiceId(serviceId: Guid): string;
+  }
+
+  class StorageDevice {
+    static FromId(deviceId: string): Windows.Storage.StorageFolder;
+    static GetDeviceSelector(): string;
+  }
+
+  enum ServiceDeviceType {
+    CalendarService = 0,
+    ContactsService = 1,
+    DeviceStatusService = 2,
+    NotesService = 3,
+    RingtonesService = 4,
+    SmsService = 5,
+    TasksService = 6,
+  }
+
+  interface IServiceDeviceStatics {
+    GetDeviceSelector(serviceType: number): string;
+    GetDeviceSelectorFromServiceId(serviceId: Guid): string;
+  }
+  var IServiceDeviceStatics: abstract new (...args: any[]) => IServiceDeviceStatics;
+
+  interface IStorageDeviceStatics {
+    FromId(deviceId: string): Windows.Storage.StorageFolder;
+    GetDeviceSelector(): string;
+  }
+  var IStorageDeviceStatics: abstract new (...args: any[]) => IStorageDeviceStatics;
+
+  interface PortableDeviceContract {
+  }
+  var PortableDeviceContract: {
+    new(fields: {  }): PortableDeviceContract;
+  };
+
+}
+
+declare namespace Windows.Devices.Power {
+  class Battery implements Windows.Devices.Power.IBattery {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Power.Battery>;
+    static GetDeviceSelector(): string;
+    GetReport(): Windows.Devices.Power.BatteryReport;
+    static readonly AggregateBattery: Windows.Devices.Power.Battery;
+    readonly DeviceId: string;
+    ReportUpdated: Windows.Foundation.TypedEventHandler<Windows.Devices.Power.Battery, Object> | null;
+  }
+
+  class BatteryReport implements Windows.Devices.Power.IBatteryReport {
+    readonly ChargeRateInMilliwatts: number | null;
+    readonly DesignCapacityInMilliwattHours: number | null;
+    readonly FullChargeCapacityInMilliwattHours: number | null;
+    readonly RemainingCapacityInMilliwattHours: number | null;
+    readonly Status: number;
+  }
+
+  class PowerGridData implements Windows.Devices.Power.IPowerGridData {
+    readonly IsLowUserExperienceImpact: boolean;
+    readonly Severity: number;
+  }
+
+  class PowerGridForecast implements Windows.Devices.Power.IPowerGridForecast {
+    static GetForecast(): Windows.Devices.Power.PowerGridForecast;
+    readonly BlockDuration: Windows.Foundation.TimeSpan;
+    readonly Forecast: Windows.Foundation.Collections.IVectorView<Windows.Devices.Power.PowerGridData> | Windows.Devices.Power.PowerGridData[];
+    readonly StartTime: Windows.Foundation.DateTime;
+    static ForecastUpdated: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  interface IBattery {
+    GetReport(): Windows.Devices.Power.BatteryReport;
+    readonly DeviceId: string;
+    ReportUpdated: Windows.Foundation.TypedEventHandler<Windows.Devices.Power.Battery, Object> | null;
+  }
+  var IBattery: abstract new (...args: any[]) => IBattery;
+
+  interface IBatteryReport {
+    readonly ChargeRateInMilliwatts: number | null;
+    readonly DesignCapacityInMilliwattHours: number | null;
+    readonly FullChargeCapacityInMilliwattHours: number | null;
+    readonly RemainingCapacityInMilliwattHours: number | null;
+    readonly Status: number;
+  }
+  var IBatteryReport: abstract new (...args: any[]) => IBatteryReport;
+
+  interface IBatteryStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Power.Battery>;
+    GetDeviceSelector(): string;
+    readonly AggregateBattery: Windows.Devices.Power.Battery;
+  }
+  var IBatteryStatics: abstract new (...args: any[]) => IBatteryStatics;
+
+  interface IPowerGridData {
+    readonly IsLowUserExperienceImpact: boolean;
+    readonly Severity: number;
+  }
+  var IPowerGridData: abstract new (...args: any[]) => IPowerGridData;
+
+  interface IPowerGridForecast {
+    readonly BlockDuration: Windows.Foundation.TimeSpan;
+    readonly Forecast: Windows.Foundation.Collections.IVectorView<Windows.Devices.Power.PowerGridData> | Windows.Devices.Power.PowerGridData[];
+    readonly StartTime: Windows.Foundation.DateTime;
+  }
+  var IPowerGridForecast: abstract new (...args: any[]) => IPowerGridForecast;
+
+  interface IPowerGridForecastStatics {
+    GetForecast(): Windows.Devices.Power.PowerGridForecast;
+    ForecastUpdated: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IPowerGridForecastStatics: abstract new (...args: any[]) => IPowerGridForecastStatics;
+
+  interface PowerGridApiContract {
+  }
+  var PowerGridApiContract: {
+    new(fields: {  }): PowerGridApiContract;
+  };
+
+}
+
+declare namespace Windows.Devices.Printers {
+  class IppAttributeError implements Windows.Devices.Printers.IIppAttributeError {
+    GetUnsupportedValues(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Printers.IppAttributeValue> | Windows.Devices.Printers.IppAttributeValue[];
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Reason: number;
+  }
+
+  class IppAttributeValue implements Windows.Devices.Printers.IIppAttributeValue {
+    static CreateBoolean(value: boolean): Windows.Devices.Printers.IppAttributeValue;
+    static CreateBooleanArray(values: Windows.Foundation.Collections.IIterable<boolean> | boolean[]): Windows.Devices.Printers.IppAttributeValue;
+    static CreateCharset(value: string): Windows.Devices.Printers.IppAttributeValue;
+    static CreateCharsetArray(values: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Devices.Printers.IppAttributeValue;
+    static CreateCollection(memberAttributes: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>[]): Windows.Devices.Printers.IppAttributeValue;
+    static CreateCollectionArray(memberAttributesArray: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>[][]): Windows.Devices.Printers.IppAttributeValue;
+    static CreateDateTime(value: Windows.Foundation.DateTime): Windows.Devices.Printers.IppAttributeValue;
+    static CreateDateTimeArray(values: Windows.Foundation.Collections.IIterable<Windows.Foundation.DateTime> | Windows.Foundation.DateTime[]): Windows.Devices.Printers.IppAttributeValue;
+    static CreateEnum(value: number): Windows.Devices.Printers.IppAttributeValue;
+    static CreateEnumArray(values: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.Devices.Printers.IppAttributeValue;
+    static CreateInteger(value: number): Windows.Devices.Printers.IppAttributeValue;
+    static CreateIntegerArray(values: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.Devices.Printers.IppAttributeValue;
+    static CreateKeyword(value: string): Windows.Devices.Printers.IppAttributeValue;
+    static CreateKeywordArray(values: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Devices.Printers.IppAttributeValue;
+    static CreateMimeMedia(value: string): Windows.Devices.Printers.IppAttributeValue;
+    static CreateMimeMediaArray(values: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Devices.Printers.IppAttributeValue;
+    static CreateNameWithLanguage(value: Windows.Devices.Printers.IppTextWithLanguage): Windows.Devices.Printers.IppAttributeValue;
+    static CreateNameWithLanguageArray(values: Windows.Foundation.Collections.IIterable<Windows.Devices.Printers.IppTextWithLanguage> | Windows.Devices.Printers.IppTextWithLanguage[]): Windows.Devices.Printers.IppAttributeValue;
+    static CreateNameWithoutLanguage(value: string): Windows.Devices.Printers.IppAttributeValue;
+    static CreateNameWithoutLanguageArray(values: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Devices.Printers.IppAttributeValue;
+    static CreateNaturalLanguage(value: string): Windows.Devices.Printers.IppAttributeValue;
+    static CreateNaturalLanguageArray(values: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Devices.Printers.IppAttributeValue;
+    static CreateNoValue(): Windows.Devices.Printers.IppAttributeValue;
+    static CreateOctetString(value: Windows.Storage.Streams.IBuffer): Windows.Devices.Printers.IppAttributeValue;
+    static CreateOctetStringArray(values: Windows.Foundation.Collections.IIterable<Windows.Storage.Streams.IBuffer> | Windows.Storage.Streams.IBuffer[]): Windows.Devices.Printers.IppAttributeValue;
+    static CreateRangeOfInteger(value: Windows.Devices.Printers.IppIntegerRange): Windows.Devices.Printers.IppAttributeValue;
+    static CreateRangeOfIntegerArray(values: Windows.Foundation.Collections.IIterable<Windows.Devices.Printers.IppIntegerRange> | Windows.Devices.Printers.IppIntegerRange[]): Windows.Devices.Printers.IppAttributeValue;
+    static CreateResolution(value: Windows.Devices.Printers.IppResolution): Windows.Devices.Printers.IppAttributeValue;
+    static CreateResolutionArray(values: Windows.Foundation.Collections.IIterable<Windows.Devices.Printers.IppResolution> | Windows.Devices.Printers.IppResolution[]): Windows.Devices.Printers.IppAttributeValue;
+    static CreateTextWithLanguage(value: Windows.Devices.Printers.IppTextWithLanguage): Windows.Devices.Printers.IppAttributeValue;
+    static CreateTextWithLanguageArray(values: Windows.Foundation.Collections.IIterable<Windows.Devices.Printers.IppTextWithLanguage> | Windows.Devices.Printers.IppTextWithLanguage[]): Windows.Devices.Printers.IppAttributeValue;
+    static CreateTextWithoutLanguage(value: string): Windows.Devices.Printers.IppAttributeValue;
+    static CreateTextWithoutLanguageArray(values: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Devices.Printers.IppAttributeValue;
+    static CreateUnknown(): Windows.Devices.Printers.IppAttributeValue;
+    static CreateUnsupported(): Windows.Devices.Printers.IppAttributeValue;
+    static CreateUri(value: Windows.Foundation.Uri): Windows.Devices.Printers.IppAttributeValue;
+    static CreateUriArray(values: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[]): Windows.Devices.Printers.IppAttributeValue;
+    static CreateUriSchema(value: string): Windows.Devices.Printers.IppAttributeValue;
+    static CreateUriSchemaArray(values: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Devices.Printers.IppAttributeValue;
+    GetBooleanArray(): Windows.Foundation.Collections.IVector<boolean> | boolean[];
+    GetCharsetArray(): Windows.Foundation.Collections.IVector<string> | string[];
+    GetCollectionArray(): Windows.Foundation.Collections.IVector<Windows.Foundation.Collections.IMapView<string, Windows.Devices.Printers.IppAttributeValue>> | Windows.Foundation.Collections.IMapView<string, Windows.Devices.Printers.IppAttributeValue>[];
+    GetDateTimeArray(): Windows.Foundation.Collections.IVector<Windows.Foundation.DateTime> | Windows.Foundation.DateTime[];
+    GetEnumArray(): Windows.Foundation.Collections.IVector<number> | number[];
+    GetIntegerArray(): Windows.Foundation.Collections.IVector<number> | number[];
+    GetKeywordArray(): Windows.Foundation.Collections.IVector<string> | string[];
+    GetMimeMediaTypeArray(): Windows.Foundation.Collections.IVector<string> | string[];
+    GetNameWithLanguageArray(): Windows.Foundation.Collections.IVector<Windows.Devices.Printers.IppTextWithLanguage> | Windows.Devices.Printers.IppTextWithLanguage[];
+    GetNameWithoutLanguageArray(): Windows.Foundation.Collections.IVector<string> | string[];
+    GetNaturalLanguageArray(): Windows.Foundation.Collections.IVector<string> | string[];
+    GetOctetStringArray(): Windows.Foundation.Collections.IVector<Windows.Storage.Streams.IBuffer> | Windows.Storage.Streams.IBuffer[];
+    GetRangeOfIntegerArray(): Windows.Foundation.Collections.IVector<Windows.Devices.Printers.IppIntegerRange> | Windows.Devices.Printers.IppIntegerRange[];
+    GetResolutionArray(): Windows.Foundation.Collections.IVector<Windows.Devices.Printers.IppResolution> | Windows.Devices.Printers.IppResolution[];
+    GetTextWithLanguageArray(): Windows.Foundation.Collections.IVector<Windows.Devices.Printers.IppTextWithLanguage> | Windows.Devices.Printers.IppTextWithLanguage[];
+    GetTextWithoutLanguageArray(): Windows.Foundation.Collections.IVector<string> | string[];
+    GetUriArray(): Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    GetUriSchemaArray(): Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Kind: number;
+  }
+
+  class IppIntegerRange implements Windows.Devices.Printers.IIppIntegerRange {
+    constructor(start: number, end: number);
+    readonly End: number;
+    readonly Start: number;
+  }
+
+  class IppPrintDevice implements Windows.Devices.Printers.IIppPrintDevice, Windows.Devices.Printers.IIppPrintDevice2, Windows.Devices.Printers.IIppPrintDevice3, Windows.Devices.Printers.IIppPrintDevice4 {
+    static FromId(deviceId: string): Windows.Devices.Printers.IppPrintDevice;
+    static FromPrinterName(printerName: string): Windows.Devices.Printers.IppPrintDevice;
+    static GetDeviceSelector(): string;
+    GetMaxSupportedPdfSize(): number | bigint;
+    GetMaxSupportedPdfVersion(): string;
+    GetMaxSupportedPdlVersion(pdlContentType: string): string;
+    GetPdlPassthroughProvider(): Windows.Devices.Printers.PdlPassthroughProvider;
+    GetPrinterAttributes(attributeNames: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.Collections.IMap<string, Windows.Devices.Printers.IppAttributeValue> | Record<string, Windows.Devices.Printers.IppAttributeValue>;
+    GetPrinterAttributesAsBuffer(attributeNames: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Storage.Streams.IBuffer;
+    static IsIppPrinter(printerName: string): boolean;
+    IsPdlPassthroughSupported(pdlContentType: string): boolean;
+    RefreshPrintDeviceCapabilities(): void;
+    SetPrinterAttributes(printerAttributes: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>[]): Windows.Devices.Printers.IppSetAttributesResult;
+    SetPrinterAttributesFromBuffer(printerAttributesBuffer: Windows.Storage.Streams.IBuffer): Windows.Devices.Printers.IppSetAttributesResult;
+    readonly CanModifyUserDefaultPrintTicket: boolean;
+    readonly DeviceKind: number;
+    readonly IsIppFaxOutPrinter: boolean;
+    readonly PrinterName: string;
+    readonly PrinterUri: Windows.Foundation.Uri;
+    UserDefaultPrintTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket;
+  }
+
+  class IppResolution implements Windows.Devices.Printers.IIppResolution {
+    constructor(width: number, height: number, unit: number);
+    readonly Height: number;
+    readonly Unit: number;
+    readonly Width: number;
+  }
+
+  class IppSetAttributesResult implements Windows.Devices.Printers.IIppSetAttributesResult {
+    readonly AttributeErrors: Windows.Foundation.Collections.IMapView<string, Windows.Devices.Printers.IppAttributeError>;
+    readonly Succeeded: boolean;
+  }
+
+  class IppTextWithLanguage implements Windows.Devices.Printers.IIppTextWithLanguage {
+    constructor(language: string, text: string);
+    readonly Language: string;
+    readonly Value: string;
+  }
+
+  class PageConfigurationSettings implements Windows.Devices.Printers.IPageConfigurationSettings {
+    constructor();
+    OrientationSource: number;
+    SizeSource: number;
+  }
+
+  class PdlPassthroughProvider implements Windows.Devices.Printers.IPdlPassthroughProvider {
+    StartPrintJobWithPrintTicket(jobName: string, pdlContentType: string, printTicket: Windows.Storage.Streams.IInputStream, pageConfigurationSettings: Windows.Devices.Printers.PageConfigurationSettings): Windows.Devices.Printers.PdlPassthroughTarget;
+    StartPrintJobWithTaskOptions(jobName: string, pdlContentType: string, taskOptions: Windows.Graphics.Printing.PrintTaskOptions, pageConfigurationSettings: Windows.Devices.Printers.PageConfigurationSettings): Windows.Devices.Printers.PdlPassthroughTarget;
+    readonly SupportedPdlContentTypes: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+
+  class PdlPassthroughTarget implements Windows.Devices.Printers.IPdlPassthroughTarget, Windows.Foundation.IClosable {
+    Close(): void;
+    GetOutputStream(): Windows.Storage.Streams.IOutputStream;
+    Submit(): void;
+    readonly PrintJobId: number;
+  }
+
+  class Print3DDevice implements Windows.Devices.Printers.IPrint3DDevice {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Printers.Print3DDevice>;
+    static GetDeviceSelector(): string;
+    readonly PrintSchema: Windows.Devices.Printers.PrintSchema;
+  }
+
+  class PrintSchema implements Windows.Devices.Printers.IPrintSchema {
+    GetCapabilitiesAsync(constrainTicket: Windows.Storage.Streams.IRandomAccessStreamWithContentType): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamWithContentType>;
+    GetDefaultPrintTicketAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamWithContentType>;
+    MergeAndValidateWithDefaultPrintTicketAsync(deltaTicket: Windows.Storage.Streams.IRandomAccessStreamWithContentType): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamWithContentType>;
+  }
+
+  class VirtualPrinterInstallationParameters implements Windows.Devices.Printers.IVirtualPrinterInstallationParameters {
+    constructor();
+    EntryPoint: string;
+    readonly OutputFileExtensions: Windows.Foundation.Collections.IVector<string> | string[];
+    PreferredInputFormat: number;
+    PrintDeviceCapabilitiesPackageRelativeFilePath: string;
+    PrintDeviceResourcesPackageRelativeFilePath: string;
+    PrinterName: string;
+    PrinterUri: Windows.Foundation.Uri;
+    readonly SupportedInputFormats: Windows.Foundation.Collections.IVector<Windows.Devices.Printers.VirtualPrinterSupportedFormat> | Windows.Devices.Printers.VirtualPrinterSupportedFormat[];
+  }
+
+  class VirtualPrinterInstallationResult implements Windows.Devices.Printers.IVirtualPrinterInstallationResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+
+  class VirtualPrinterManager {
+    static FindAllVirtualPrinters(): Windows.Foundation.Collections.IVectorView<string> | string[];
+    static FindAllVirtualPrinters(appPackageFamilyName: string): Windows.Foundation.Collections.IVectorView<string> | string[];
+    static InstallVirtualPrinterAsync(parameters: Windows.Devices.Printers.VirtualPrinterInstallationParameters): Windows.Foundation.IAsyncOperation<Windows.Devices.Printers.VirtualPrinterInstallationResult>;
+    static InstallVirtualPrinterAsync(parameters: Windows.Devices.Printers.VirtualPrinterInstallationParameters, appPackageFamilyName: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Printers.VirtualPrinterInstallationResult>;
+    static InstallVirtualPrinterForAllUsersAsync(parameters: Windows.Devices.Printers.VirtualPrinterInstallationParameters): Windows.Foundation.IAsyncOperation<Windows.Devices.Printers.VirtualPrinterInstallationResult>;
+    static InstallVirtualPrinterForAllUsersAsync(parameters: Windows.Devices.Printers.VirtualPrinterInstallationParameters, appPackageFamilyName: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Printers.VirtualPrinterInstallationResult>;
+    static RemoveVirtualPrinterAsync(printerName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    static RemoveVirtualPrinterForAllUsersAsync(printerName: string): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+
+  class VirtualPrinterSupportedFormat implements Windows.Devices.Printers.IVirtualPrinterSupportedFormat {
+    constructor(contentType: string, maxSupportedVersion: string);
+    ContentType: string;
+    MaxSupportedVersion: string;
+  }
+
+  enum IppAttributeErrorReason {
+    RequestEntityTooLarge = 0,
+    AttributeNotSupported = 1,
+    AttributeValuesNotSupported = 2,
+    AttributeNotSettable = 3,
+    ConflictingAttributes = 4,
+  }
+
+  enum IppAttributeValueKind {
+    Unsupported = 0,
+    Unknown = 1,
+    NoValue = 2,
+    Integer = 3,
+    Boolean = 4,
+    Enum = 5,
+    OctetString = 6,
+    DateTime = 7,
+    Resolution = 8,
+    RangeOfInteger = 9,
+    Collection = 10,
+    TextWithLanguage = 11,
+    NameWithLanguage = 12,
+    TextWithoutLanguage = 13,
+    NameWithoutLanguage = 14,
+    Keyword = 15,
+    Uri = 16,
+    UriSchema = 17,
+    Charset = 18,
+    NaturalLanguage = 19,
+    MimeMediaType = 20,
+  }
+
+  enum IppPrintDeviceKind {
+    Printer = 0,
+    FaxOut = 1,
+    VirtualPrinter = 2,
+  }
+
+  enum IppResolutionUnit {
+    DotsPerInch = 0,
+    DotsPerCentimeter = 1,
+  }
+
+  enum PageConfigurationSource {
+    PrintJobConfiguration = 0,
+    PdlContent = 1,
+  }
+
+  enum VirtualPrinterInstallationStatus {
+    InstallationSucceeded = 0,
+    PrinterAlreadyInstalled = 1,
+    PrinterInstallationAccessDenied = 2,
+    PrinterInstallationFailed = 3,
+  }
+
+  enum VirtualPrinterPreferredInputFormat {
+    OpenXps = 0,
+    PostScript = 1,
+  }
+
+  interface IIppAttributeError {
+    GetUnsupportedValues(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Printers.IppAttributeValue> | Windows.Devices.Printers.IppAttributeValue[];
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Reason: number;
+  }
+  var IIppAttributeError: abstract new (...args: any[]) => IIppAttributeError;
+
+  interface IIppAttributeValue {
+    GetBooleanArray(): Windows.Foundation.Collections.IVector<boolean> | boolean[];
+    GetCharsetArray(): Windows.Foundation.Collections.IVector<string> | string[];
+    GetCollectionArray(): Windows.Foundation.Collections.IVector<Windows.Foundation.Collections.IMapView<string, Windows.Devices.Printers.IppAttributeValue>> | Windows.Foundation.Collections.IMapView<string, Windows.Devices.Printers.IppAttributeValue>[];
+    GetDateTimeArray(): Windows.Foundation.Collections.IVector<Windows.Foundation.DateTime> | Windows.Foundation.DateTime[];
+    GetEnumArray(): Windows.Foundation.Collections.IVector<number> | number[];
+    GetIntegerArray(): Windows.Foundation.Collections.IVector<number> | number[];
+    GetKeywordArray(): Windows.Foundation.Collections.IVector<string> | string[];
+    GetMimeMediaTypeArray(): Windows.Foundation.Collections.IVector<string> | string[];
+    GetNameWithLanguageArray(): Windows.Foundation.Collections.IVector<Windows.Devices.Printers.IppTextWithLanguage> | Windows.Devices.Printers.IppTextWithLanguage[];
+    GetNameWithoutLanguageArray(): Windows.Foundation.Collections.IVector<string> | string[];
+    GetNaturalLanguageArray(): Windows.Foundation.Collections.IVector<string> | string[];
+    GetOctetStringArray(): Windows.Foundation.Collections.IVector<Windows.Storage.Streams.IBuffer> | Windows.Storage.Streams.IBuffer[];
+    GetRangeOfIntegerArray(): Windows.Foundation.Collections.IVector<Windows.Devices.Printers.IppIntegerRange> | Windows.Devices.Printers.IppIntegerRange[];
+    GetResolutionArray(): Windows.Foundation.Collections.IVector<Windows.Devices.Printers.IppResolution> | Windows.Devices.Printers.IppResolution[];
+    GetTextWithLanguageArray(): Windows.Foundation.Collections.IVector<Windows.Devices.Printers.IppTextWithLanguage> | Windows.Devices.Printers.IppTextWithLanguage[];
+    GetTextWithoutLanguageArray(): Windows.Foundation.Collections.IVector<string> | string[];
+    GetUriArray(): Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    GetUriSchemaArray(): Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Kind: number;
+  }
+  var IIppAttributeValue: abstract new (...args: any[]) => IIppAttributeValue;
+
+  interface IIppAttributeValueStatics {
+    CreateBoolean(value: boolean): Windows.Devices.Printers.IppAttributeValue;
+    CreateBooleanArray(values: Windows.Foundation.Collections.IIterable<boolean> | boolean[]): Windows.Devices.Printers.IppAttributeValue;
+    CreateCharset(value: string): Windows.Devices.Printers.IppAttributeValue;
+    CreateCharsetArray(values: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Devices.Printers.IppAttributeValue;
+    CreateCollection(memberAttributes: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>[]): Windows.Devices.Printers.IppAttributeValue;
+    CreateCollectionArray(memberAttributesArray: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>[][]): Windows.Devices.Printers.IppAttributeValue;
+    CreateDateTime(value: Windows.Foundation.DateTime): Windows.Devices.Printers.IppAttributeValue;
+    CreateDateTimeArray(values: Windows.Foundation.Collections.IIterable<Windows.Foundation.DateTime> | Windows.Foundation.DateTime[]): Windows.Devices.Printers.IppAttributeValue;
+    CreateEnum(value: number): Windows.Devices.Printers.IppAttributeValue;
+    CreateEnumArray(values: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.Devices.Printers.IppAttributeValue;
+    CreateInteger(value: number): Windows.Devices.Printers.IppAttributeValue;
+    CreateIntegerArray(values: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.Devices.Printers.IppAttributeValue;
+    CreateKeyword(value: string): Windows.Devices.Printers.IppAttributeValue;
+    CreateKeywordArray(values: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Devices.Printers.IppAttributeValue;
+    CreateMimeMedia(value: string): Windows.Devices.Printers.IppAttributeValue;
+    CreateMimeMediaArray(values: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Devices.Printers.IppAttributeValue;
+    CreateNameWithLanguage(value: Windows.Devices.Printers.IppTextWithLanguage): Windows.Devices.Printers.IppAttributeValue;
+    CreateNameWithLanguageArray(values: Windows.Foundation.Collections.IIterable<Windows.Devices.Printers.IppTextWithLanguage> | Windows.Devices.Printers.IppTextWithLanguage[]): Windows.Devices.Printers.IppAttributeValue;
+    CreateNameWithoutLanguage(value: string): Windows.Devices.Printers.IppAttributeValue;
+    CreateNameWithoutLanguageArray(values: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Devices.Printers.IppAttributeValue;
+    CreateNaturalLanguage(value: string): Windows.Devices.Printers.IppAttributeValue;
+    CreateNaturalLanguageArray(values: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Devices.Printers.IppAttributeValue;
+    CreateNoValue(): Windows.Devices.Printers.IppAttributeValue;
+    CreateOctetString(value: Windows.Storage.Streams.IBuffer): Windows.Devices.Printers.IppAttributeValue;
+    CreateOctetStringArray(values: Windows.Foundation.Collections.IIterable<Windows.Storage.Streams.IBuffer> | Windows.Storage.Streams.IBuffer[]): Windows.Devices.Printers.IppAttributeValue;
+    CreateRangeOfInteger(value: Windows.Devices.Printers.IppIntegerRange): Windows.Devices.Printers.IppAttributeValue;
+    CreateRangeOfIntegerArray(values: Windows.Foundation.Collections.IIterable<Windows.Devices.Printers.IppIntegerRange> | Windows.Devices.Printers.IppIntegerRange[]): Windows.Devices.Printers.IppAttributeValue;
+    CreateResolution(value: Windows.Devices.Printers.IppResolution): Windows.Devices.Printers.IppAttributeValue;
+    CreateResolutionArray(values: Windows.Foundation.Collections.IIterable<Windows.Devices.Printers.IppResolution> | Windows.Devices.Printers.IppResolution[]): Windows.Devices.Printers.IppAttributeValue;
+    CreateTextWithLanguage(value: Windows.Devices.Printers.IppTextWithLanguage): Windows.Devices.Printers.IppAttributeValue;
+    CreateTextWithLanguageArray(values: Windows.Foundation.Collections.IIterable<Windows.Devices.Printers.IppTextWithLanguage> | Windows.Devices.Printers.IppTextWithLanguage[]): Windows.Devices.Printers.IppAttributeValue;
+    CreateTextWithoutLanguage(value: string): Windows.Devices.Printers.IppAttributeValue;
+    CreateTextWithoutLanguageArray(values: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Devices.Printers.IppAttributeValue;
+    CreateUnknown(): Windows.Devices.Printers.IppAttributeValue;
+    CreateUnsupported(): Windows.Devices.Printers.IppAttributeValue;
+    CreateUri(value: Windows.Foundation.Uri): Windows.Devices.Printers.IppAttributeValue;
+    CreateUriArray(values: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[]): Windows.Devices.Printers.IppAttributeValue;
+    CreateUriSchema(value: string): Windows.Devices.Printers.IppAttributeValue;
+    CreateUriSchemaArray(values: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Devices.Printers.IppAttributeValue;
+  }
+  var IIppAttributeValueStatics: abstract new (...args: any[]) => IIppAttributeValueStatics;
+
+  interface IIppIntegerRange {
+    readonly End: number;
+    readonly Start: number;
+  }
+  var IIppIntegerRange: abstract new (...args: any[]) => IIppIntegerRange;
+
+  interface IIppIntegerRangeFactory {
+    CreateInstance(start: number, end: number): Windows.Devices.Printers.IppIntegerRange;
+  }
+  var IIppIntegerRangeFactory: abstract new (...args: any[]) => IIppIntegerRangeFactory;
+
+  interface IIppPrintDevice {
+    GetPrinterAttributes(attributeNames: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.Collections.IMap<string, Windows.Devices.Printers.IppAttributeValue> | Record<string, Windows.Devices.Printers.IppAttributeValue>;
+    GetPrinterAttributesAsBuffer(attributeNames: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Storage.Streams.IBuffer;
+    SetPrinterAttributes(printerAttributes: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>[]): Windows.Devices.Printers.IppSetAttributesResult;
+    SetPrinterAttributesFromBuffer(printerAttributesBuffer: Windows.Storage.Streams.IBuffer): Windows.Devices.Printers.IppSetAttributesResult;
+    readonly PrinterName: string;
+    readonly PrinterUri: Windows.Foundation.Uri;
+  }
+  var IIppPrintDevice: abstract new (...args: any[]) => IIppPrintDevice;
+
+  interface IIppPrintDevice2 {
+    GetMaxSupportedPdfSize(): number | bigint;
+    GetMaxSupportedPdfVersion(): string;
+    GetPdlPassthroughProvider(): Windows.Devices.Printers.PdlPassthroughProvider;
+    IsPdlPassthroughSupported(pdlContentType: string): boolean;
+  }
+  var IIppPrintDevice2: abstract new (...args: any[]) => IIppPrintDevice2;
+
+  interface IIppPrintDevice3 {
+    readonly IsIppFaxOutPrinter: boolean;
+  }
+  var IIppPrintDevice3: abstract new (...args: any[]) => IIppPrintDevice3;
+
+  interface IIppPrintDevice4 {
+    GetMaxSupportedPdlVersion(pdlContentType: string): string;
+    RefreshPrintDeviceCapabilities(): void;
+    readonly CanModifyUserDefaultPrintTicket: boolean;
+    readonly DeviceKind: number;
+    UserDefaultPrintTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket;
+  }
+  var IIppPrintDevice4: abstract new (...args: any[]) => IIppPrintDevice4;
+
+  interface IIppPrintDeviceStatics {
+    FromId(deviceId: string): Windows.Devices.Printers.IppPrintDevice;
+    FromPrinterName(printerName: string): Windows.Devices.Printers.IppPrintDevice;
+    GetDeviceSelector(): string;
+    IsIppPrinter(printerName: string): boolean;
+  }
+  var IIppPrintDeviceStatics: abstract new (...args: any[]) => IIppPrintDeviceStatics;
+
+  interface IIppResolution {
+    readonly Height: number;
+    readonly Unit: number;
+    readonly Width: number;
+  }
+  var IIppResolution: abstract new (...args: any[]) => IIppResolution;
+
+  interface IIppResolutionFactory {
+    CreateInstance(width: number, height: number, unit: number): Windows.Devices.Printers.IppResolution;
+  }
+  var IIppResolutionFactory: abstract new (...args: any[]) => IIppResolutionFactory;
+
+  interface IIppSetAttributesResult {
+    readonly AttributeErrors: Windows.Foundation.Collections.IMapView<string, Windows.Devices.Printers.IppAttributeError>;
+    readonly Succeeded: boolean;
+  }
+  var IIppSetAttributesResult: abstract new (...args: any[]) => IIppSetAttributesResult;
+
+  interface IIppTextWithLanguage {
+    readonly Language: string;
+    readonly Value: string;
+  }
+  var IIppTextWithLanguage: abstract new (...args: any[]) => IIppTextWithLanguage;
+
+  interface IIppTextWithLanguageFactory {
+    CreateInstance(language: string, text: string): Windows.Devices.Printers.IppTextWithLanguage;
+  }
+  var IIppTextWithLanguageFactory: abstract new (...args: any[]) => IIppTextWithLanguageFactory;
+
+  interface IPageConfigurationSettings {
+    OrientationSource: number;
+    SizeSource: number;
+  }
+  var IPageConfigurationSettings: abstract new (...args: any[]) => IPageConfigurationSettings;
+
+  interface IPdlPassthroughProvider {
+    StartPrintJobWithPrintTicket(jobName: string, pdlContentType: string, printTicket: Windows.Storage.Streams.IInputStream, pageConfigurationSettings: Windows.Devices.Printers.PageConfigurationSettings): Windows.Devices.Printers.PdlPassthroughTarget;
+    StartPrintJobWithTaskOptions(jobName: string, pdlContentType: string, taskOptions: Windows.Graphics.Printing.PrintTaskOptions, pageConfigurationSettings: Windows.Devices.Printers.PageConfigurationSettings): Windows.Devices.Printers.PdlPassthroughTarget;
+    readonly SupportedPdlContentTypes: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var IPdlPassthroughProvider: abstract new (...args: any[]) => IPdlPassthroughProvider;
+
+  interface IPdlPassthroughTarget {
+    GetOutputStream(): Windows.Storage.Streams.IOutputStream;
+    Submit(): void;
+    readonly PrintJobId: number;
+  }
+  var IPdlPassthroughTarget: abstract new (...args: any[]) => IPdlPassthroughTarget;
+
+  interface IPrint3DDevice {
+    readonly PrintSchema: Windows.Devices.Printers.PrintSchema;
+  }
+  var IPrint3DDevice: abstract new (...args: any[]) => IPrint3DDevice;
+
+  interface IPrint3DDeviceStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Printers.Print3DDevice>;
+    GetDeviceSelector(): string;
+  }
+  var IPrint3DDeviceStatics: abstract new (...args: any[]) => IPrint3DDeviceStatics;
+
+  interface IPrintSchema {
+    GetCapabilitiesAsync(constrainTicket: Windows.Storage.Streams.IRandomAccessStreamWithContentType): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamWithContentType>;
+    GetDefaultPrintTicketAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamWithContentType>;
+    MergeAndValidateWithDefaultPrintTicketAsync(deltaTicket: Windows.Storage.Streams.IRandomAccessStreamWithContentType): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamWithContentType>;
+  }
+  var IPrintSchema: abstract new (...args: any[]) => IPrintSchema;
+
+  interface IVirtualPrinterInstallationParameters {
+    EntryPoint: string;
+    readonly OutputFileExtensions: Windows.Foundation.Collections.IVector<string> | string[];
+    PreferredInputFormat: number;
+    PrintDeviceCapabilitiesPackageRelativeFilePath: string;
+    PrintDeviceResourcesPackageRelativeFilePath: string;
+    PrinterName: string;
+    PrinterUri: Windows.Foundation.Uri;
+    readonly SupportedInputFormats: Windows.Foundation.Collections.IVector<Windows.Devices.Printers.VirtualPrinterSupportedFormat> | Windows.Devices.Printers.VirtualPrinterSupportedFormat[];
+  }
+  var IVirtualPrinterInstallationParameters: abstract new (...args: any[]) => IVirtualPrinterInstallationParameters;
+
+  interface IVirtualPrinterInstallationResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+  var IVirtualPrinterInstallationResult: abstract new (...args: any[]) => IVirtualPrinterInstallationResult;
+
+  interface IVirtualPrinterManagerStatics {
+    FindAllVirtualPrinters(): Windows.Foundation.Collections.IVectorView<string> | string[];
+    FindAllVirtualPrinters(appPackageFamilyName: string): Windows.Foundation.Collections.IVectorView<string> | string[];
+    InstallVirtualPrinterAsync(parameters: Windows.Devices.Printers.VirtualPrinterInstallationParameters): Windows.Foundation.IAsyncOperation<Windows.Devices.Printers.VirtualPrinterInstallationResult>;
+    InstallVirtualPrinterAsync(parameters: Windows.Devices.Printers.VirtualPrinterInstallationParameters, appPackageFamilyName: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Printers.VirtualPrinterInstallationResult>;
+    InstallVirtualPrinterForAllUsersAsync(parameters: Windows.Devices.Printers.VirtualPrinterInstallationParameters): Windows.Foundation.IAsyncOperation<Windows.Devices.Printers.VirtualPrinterInstallationResult>;
+    InstallVirtualPrinterForAllUsersAsync(parameters: Windows.Devices.Printers.VirtualPrinterInstallationParameters, appPackageFamilyName: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Printers.VirtualPrinterInstallationResult>;
+    RemoveVirtualPrinterAsync(printerName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    RemoveVirtualPrinterForAllUsersAsync(printerName: string): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IVirtualPrinterManagerStatics: abstract new (...args: any[]) => IVirtualPrinterManagerStatics;
+
+  interface IVirtualPrinterSupportedFormat {
+    ContentType: string;
+    MaxSupportedVersion: string;
+  }
+  var IVirtualPrinterSupportedFormat: abstract new (...args: any[]) => IVirtualPrinterSupportedFormat;
+
+  interface IVirtualPrinterSupportedFormatFactory {
+    CreateInstance(contentType: string, maxSupportedVersion: string): Windows.Devices.Printers.VirtualPrinterSupportedFormat;
+  }
+  var IVirtualPrinterSupportedFormatFactory: abstract new (...args: any[]) => IVirtualPrinterSupportedFormatFactory;
+
+  interface PrintersContract {
+  }
+  var PrintersContract: {
+    new(fields: {  }): PrintersContract;
+  };
+
+}
+
+declare namespace Windows.Devices.Printers.Extensions {
+  class Print3DWorkflow implements Windows.Devices.Printers.Extensions.IPrint3DWorkflow, Windows.Devices.Printers.Extensions.IPrint3DWorkflow2 {
+    GetPrintModelPackage(): Object;
+    readonly DeviceID: string;
+    IsPrintReady: boolean;
+    PrintRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Printers.Extensions.Print3DWorkflow, Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs> | null;
+    PrinterChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Printers.Extensions.Print3DWorkflow, Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs> | null;
+  }
+
+  class Print3DWorkflowPrintRequestedEventArgs implements Windows.Devices.Printers.Extensions.IPrint3DWorkflowPrintRequestedEventArgs {
+    SetExtendedStatus(value: number): void;
+    SetSource(source: Object): void;
+    SetSourceChanged(value: boolean): void;
+    readonly Status: number;
+  }
+
+  class Print3DWorkflowPrinterChangedEventArgs implements Windows.Devices.Printers.Extensions.IPrint3DWorkflowPrinterChangedEventArgs {
+    readonly NewDeviceId: string;
+  }
+
+  class PrintExtensionContext {
+    static FromDeviceId(deviceId: string): Object;
+  }
+
+  class PrintNotificationEventDetails implements Windows.Devices.Printers.Extensions.IPrintNotificationEventDetails {
+    EventData: string;
+    readonly PrinterName: string;
+  }
+
+  class PrintTaskConfiguration implements Windows.Devices.Printers.Extensions.IPrintTaskConfiguration {
+    readonly PrinterExtensionContext: Object;
+    SaveRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Printers.Extensions.PrintTaskConfiguration, Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequestedEventArgs> | null;
+  }
+
+  class PrintTaskConfigurationSaveRequest implements Windows.Devices.Printers.Extensions.IPrintTaskConfigurationSaveRequest {
+    Cancel(): void;
+    GetDeferral(): Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequestedDeferral;
+    Save(printerExtensionContext: Object): void;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+
+  class PrintTaskConfigurationSaveRequestedDeferral implements Windows.Devices.Printers.Extensions.IPrintTaskConfigurationSaveRequestedDeferral {
+    Complete(): void;
+  }
+
+  class PrintTaskConfigurationSaveRequestedEventArgs implements Windows.Devices.Printers.Extensions.IPrintTaskConfigurationSaveRequestedEventArgs {
+    readonly Request: Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequest;
+  }
+
+  enum Print3DWorkflowDetail {
+    Unknown = 0,
+    ModelExceedsPrintBed = 1,
+    UploadFailed = 2,
+    InvalidMaterialSelection = 3,
+    InvalidModel = 4,
+    ModelNotManifold = 5,
+    InvalidPrintTicket = 6,
+  }
+
+  enum Print3DWorkflowStatus {
+    Abandoned = 0,
+    Canceled = 1,
+    Failed = 2,
+    Slicing = 3,
+    Submitted = 4,
+  }
+
+  interface ExtensionsContract {
+  }
+  var ExtensionsContract: {
+    new(fields: {  }): ExtensionsContract;
+  };
+
+  interface IPrint3DWorkflow {
+    GetPrintModelPackage(): Object;
+    readonly DeviceID: string;
+    IsPrintReady: boolean;
+    PrintRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Printers.Extensions.Print3DWorkflow, Windows.Devices.Printers.Extensions.Print3DWorkflowPrintRequestedEventArgs> | null;
+  }
+  var IPrint3DWorkflow: abstract new (...args: any[]) => IPrint3DWorkflow;
+
+  interface IPrint3DWorkflow2 {
+    PrinterChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Printers.Extensions.Print3DWorkflow, Windows.Devices.Printers.Extensions.Print3DWorkflowPrinterChangedEventArgs> | null;
+  }
+  var IPrint3DWorkflow2: abstract new (...args: any[]) => IPrint3DWorkflow2;
+
+  interface IPrint3DWorkflowPrintRequestedEventArgs {
+    SetExtendedStatus(value: number): void;
+    SetSource(source: Object): void;
+    SetSourceChanged(value: boolean): void;
+    readonly Status: number;
+  }
+  var IPrint3DWorkflowPrintRequestedEventArgs: abstract new (...args: any[]) => IPrint3DWorkflowPrintRequestedEventArgs;
+
+  interface IPrint3DWorkflowPrinterChangedEventArgs {
+    readonly NewDeviceId: string;
+  }
+  var IPrint3DWorkflowPrinterChangedEventArgs: abstract new (...args: any[]) => IPrint3DWorkflowPrinterChangedEventArgs;
+
+  interface IPrintExtensionContextStatic {
+    FromDeviceId(deviceId: string): Object;
+  }
+  var IPrintExtensionContextStatic: abstract new (...args: any[]) => IPrintExtensionContextStatic;
+
+  interface IPrintNotificationEventDetails {
+    EventData: string;
+    readonly PrinterName: string;
+  }
+  var IPrintNotificationEventDetails: abstract new (...args: any[]) => IPrintNotificationEventDetails;
+
+  interface IPrintTaskConfiguration {
+    readonly PrinterExtensionContext: Object;
+    SaveRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.Printers.Extensions.PrintTaskConfiguration, Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequestedEventArgs> | null;
+  }
+  var IPrintTaskConfiguration: abstract new (...args: any[]) => IPrintTaskConfiguration;
+
+  interface IPrintTaskConfigurationSaveRequest {
+    Cancel(): void;
+    GetDeferral(): Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequestedDeferral;
+    Save(printerExtensionContext: Object): void;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+  var IPrintTaskConfigurationSaveRequest: abstract new (...args: any[]) => IPrintTaskConfigurationSaveRequest;
+
+  interface IPrintTaskConfigurationSaveRequestedDeferral {
+    Complete(): void;
+  }
+  var IPrintTaskConfigurationSaveRequestedDeferral: abstract new (...args: any[]) => IPrintTaskConfigurationSaveRequestedDeferral;
+
+  interface IPrintTaskConfigurationSaveRequestedEventArgs {
+    readonly Request: Windows.Devices.Printers.Extensions.PrintTaskConfigurationSaveRequest;
+  }
+  var IPrintTaskConfigurationSaveRequestedEventArgs: abstract new (...args: any[]) => IPrintTaskConfigurationSaveRequestedEventArgs;
+
+}
+
+declare namespace Windows.Devices.Pwm {
+  class PwmController implements Windows.Devices.Pwm.IPwmController {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Pwm.PwmController>;
+    static GetControllersAsync(provider: Windows.Devices.Pwm.Provider.IPwmProvider): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Pwm.PwmController> | Windows.Devices.Pwm.PwmController[]>;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Pwm.PwmController>;
+    static GetDeviceSelector(): string;
+    static GetDeviceSelector(friendlyName: string): string;
+    OpenPin(pinNumber: number): Windows.Devices.Pwm.PwmPin;
+    SetDesiredFrequency(desiredFrequency: number): number;
+    readonly ActualFrequency: number;
+    readonly MaxFrequency: number;
+    readonly MinFrequency: number;
+    readonly PinCount: number;
+  }
+
+  class PwmPin implements Windows.Devices.Pwm.IPwmPin, Windows.Foundation.IClosable {
+    Close(): void;
+    GetActiveDutyCyclePercentage(): number;
+    SetActiveDutyCyclePercentage(dutyCyclePercentage: number): void;
+    Start(): void;
+    Stop(): void;
+    readonly Controller: Windows.Devices.Pwm.PwmController;
+    readonly IsStarted: boolean;
+    Polarity: number;
+  }
+
+  enum PwmPulsePolarity {
+    ActiveHigh = 0,
+    ActiveLow = 1,
+  }
+
+  interface IPwmController {
+    OpenPin(pinNumber: number): Windows.Devices.Pwm.PwmPin;
+    SetDesiredFrequency(desiredFrequency: number): number;
+    readonly ActualFrequency: number;
+    readonly MaxFrequency: number;
+    readonly MinFrequency: number;
+    readonly PinCount: number;
+  }
+  var IPwmController: abstract new (...args: any[]) => IPwmController;
+
+  interface IPwmControllerStatics {
+    GetControllersAsync(provider: Windows.Devices.Pwm.Provider.IPwmProvider): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Pwm.PwmController> | Windows.Devices.Pwm.PwmController[]>;
+  }
+  var IPwmControllerStatics: abstract new (...args: any[]) => IPwmControllerStatics;
+
+  interface IPwmControllerStatics2 {
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Pwm.PwmController>;
+  }
+  var IPwmControllerStatics2: abstract new (...args: any[]) => IPwmControllerStatics2;
+
+  interface IPwmControllerStatics3 {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Pwm.PwmController>;
+    GetDeviceSelector(): string;
+    GetDeviceSelector(friendlyName: string): string;
+  }
+  var IPwmControllerStatics3: abstract new (...args: any[]) => IPwmControllerStatics3;
+
+  interface IPwmPin extends Windows.Foundation.IClosable {
+    Close(): void;
+    GetActiveDutyCyclePercentage(): number;
+    SetActiveDutyCyclePercentage(dutyCyclePercentage: number): void;
+    Start(): void;
+    Stop(): void;
+    readonly Controller: Windows.Devices.Pwm.PwmController;
+    readonly IsStarted: boolean;
+    Polarity: number;
+  }
+  var IPwmPin: abstract new (...args: any[]) => IPwmPin;
+
+}
+
+declare namespace Windows.Devices.Pwm.Provider {
+  interface IPwmControllerProvider {
+    AcquirePin(pin: number): void;
+    DisablePin(pin: number): void;
+    EnablePin(pin: number): void;
+    ReleasePin(pin: number): void;
+    SetDesiredFrequency(frequency: number): number;
+    SetPulseParameters(pin: number, dutyCycle: number, invertPolarity: boolean): void;
+    readonly ActualFrequency: number;
+    readonly MaxFrequency: number;
+    readonly MinFrequency: number;
+    readonly PinCount: number;
+  }
+  var IPwmControllerProvider: abstract new (...args: any[]) => IPwmControllerProvider;
+
+  interface IPwmProvider {
+    GetControllers(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Pwm.Provider.IPwmControllerProvider> | Windows.Devices.Pwm.Provider.IPwmControllerProvider[];
+  }
+  var IPwmProvider: abstract new (...args: any[]) => IPwmProvider;
+
+}
+
+declare namespace Windows.Devices.Radios {
+  class Radio implements Windows.Devices.Radios.IRadio {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Radios.Radio>;
+    static GetDeviceSelector(): string;
+    static GetRadiosAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Radios.Radio> | Windows.Devices.Radios.Radio[]>;
+    static RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    SetStateAsync(value: number): Windows.Foundation.IAsyncOperation<number>;
+    readonly Kind: number;
+    readonly Name: string;
+    readonly State: number;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Radios.Radio, Object> | null;
+  }
+
+  enum RadioAccessStatus {
+    Unspecified = 0,
+    Allowed = 1,
+    DeniedByUser = 2,
+    DeniedBySystem = 3,
+  }
+
+  enum RadioKind {
+    Other = 0,
+    WiFi = 1,
+    MobileBroadband = 2,
+    Bluetooth = 3,
+    FM = 4,
+  }
+
+  enum RadioState {
+    Unknown = 0,
+    On = 1,
+    Off = 2,
+    Disabled = 3,
+  }
+
+  interface IRadio {
+    SetStateAsync(value: number): Windows.Foundation.IAsyncOperation<number>;
+    readonly Kind: number;
+    readonly Name: string;
+    readonly State: number;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Radios.Radio, Object> | null;
+  }
+  var IRadio: abstract new (...args: any[]) => IRadio;
+
+  interface IRadioStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Radios.Radio>;
+    GetDeviceSelector(): string;
+    GetRadiosAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Radios.Radio> | Windows.Devices.Radios.Radio[]>;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IRadioStatics: abstract new (...args: any[]) => IRadioStatics;
+
+}
+
+declare namespace Windows.Devices.Scanners {
+  class ImageScanner implements Windows.Devices.Scanners.IImageScanner {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Scanners.ImageScanner>;
+    static GetDeviceSelector(): string;
+    IsPreviewSupported(scanSource: number): boolean;
+    IsScanSourceSupported(value: number): boolean;
+    ScanFilesToFolderAsync(scanSource: number, storageFolder: Windows.Storage.StorageFolder): Windows.Foundation.IAsyncOperationWithProgress<Windows.Devices.Scanners.ImageScannerScanResult, number>;
+    ScanPreviewToStreamAsync(scanSource: number, targetStream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<Windows.Devices.Scanners.ImageScannerPreviewResult>;
+    readonly AutoConfiguration: Windows.Devices.Scanners.ImageScannerAutoConfiguration;
+    readonly DefaultScanSource: number;
+    readonly DeviceId: string;
+    readonly FeederConfiguration: Windows.Devices.Scanners.ImageScannerFeederConfiguration;
+    readonly FlatbedConfiguration: Windows.Devices.Scanners.ImageScannerFlatbedConfiguration;
+  }
+
+  class ImageScannerAutoConfiguration implements Windows.Devices.Scanners.IImageScannerFormatConfiguration {
+    IsFormatSupported(value: number): boolean;
+    readonly DefaultFormat: number;
+    Format: number;
+  }
+
+  class ImageScannerFeederConfiguration implements Windows.Devices.Scanners.IImageScannerFeederConfiguration, Windows.Devices.Scanners.IImageScannerFormatConfiguration, Windows.Devices.Scanners.IImageScannerSourceConfiguration {
+    IsAutoCroppingModeSupported(value: number): boolean;
+    IsColorModeSupported(value: number): boolean;
+    IsFormatSupported(value: number): boolean;
+    IsPageSizeSupported(pageSize: number, pageOrientation: number): boolean;
+    readonly ActualResolution: Windows.Devices.Scanners.ImageScannerResolution;
+    AutoCroppingMode: number;
+    AutoDetectPageSize: boolean;
+    Brightness: number;
+    readonly BrightnessStep: number;
+    readonly CanAutoDetectPageSize: boolean;
+    readonly CanScanAhead: boolean;
+    readonly CanScanDuplex: boolean;
+    ColorMode: number;
+    Contrast: number;
+    readonly ContrastStep: number;
+    readonly DefaultBrightness: number;
+    readonly DefaultColorMode: number;
+    readonly DefaultContrast: number;
+    readonly DefaultFormat: number;
+    DesiredResolution: Windows.Devices.Scanners.ImageScannerResolution;
+    Duplex: boolean;
+    Format: number;
+    readonly MaxBrightness: number;
+    readonly MaxContrast: number;
+    MaxNumberOfPages: number;
+    readonly MaxResolution: Windows.Devices.Scanners.ImageScannerResolution;
+    readonly MaxScanArea: Windows.Foundation.Size;
+    readonly MinBrightness: number;
+    readonly MinContrast: number;
+    readonly MinResolution: Windows.Devices.Scanners.ImageScannerResolution;
+    readonly MinScanArea: Windows.Foundation.Size;
+    readonly OpticalResolution: Windows.Devices.Scanners.ImageScannerResolution;
+    PageOrientation: number;
+    PageSize: number;
+    readonly PageSizeDimensions: Windows.Foundation.Size;
+    ScanAhead: boolean;
+    SelectedScanRegion: Windows.Foundation.Rect;
+  }
+
+  class ImageScannerFlatbedConfiguration implements Windows.Devices.Scanners.IImageScannerFormatConfiguration, Windows.Devices.Scanners.IImageScannerSourceConfiguration {
+    IsAutoCroppingModeSupported(value: number): boolean;
+    IsColorModeSupported(value: number): boolean;
+    IsFormatSupported(value: number): boolean;
+    readonly ActualResolution: Windows.Devices.Scanners.ImageScannerResolution;
+    AutoCroppingMode: number;
+    Brightness: number;
+    readonly BrightnessStep: number;
+    ColorMode: number;
+    Contrast: number;
+    readonly ContrastStep: number;
+    readonly DefaultBrightness: number;
+    readonly DefaultColorMode: number;
+    readonly DefaultContrast: number;
+    readonly DefaultFormat: number;
+    DesiredResolution: Windows.Devices.Scanners.ImageScannerResolution;
+    Format: number;
+    readonly MaxBrightness: number;
+    readonly MaxContrast: number;
+    readonly MaxResolution: Windows.Devices.Scanners.ImageScannerResolution;
+    readonly MaxScanArea: Windows.Foundation.Size;
+    readonly MinBrightness: number;
+    readonly MinContrast: number;
+    readonly MinResolution: Windows.Devices.Scanners.ImageScannerResolution;
+    readonly MinScanArea: Windows.Foundation.Size;
+    readonly OpticalResolution: Windows.Devices.Scanners.ImageScannerResolution;
+    SelectedScanRegion: Windows.Foundation.Rect;
+  }
+
+  class ImageScannerPreviewResult implements Windows.Devices.Scanners.IImageScannerPreviewResult {
+    readonly Format: number;
+    readonly Succeeded: boolean;
+  }
+
+  class ImageScannerScanResult implements Windows.Devices.Scanners.IImageScannerScanResult {
+    readonly ScannedFiles: Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[];
+  }
+
+  enum ImageScannerAutoCroppingMode {
+    Disabled = 0,
+    SingleRegion = 1,
+    MultipleRegion = 2,
+  }
+
+  enum ImageScannerColorMode {
+    Color = 0,
+    Grayscale = 1,
+    Monochrome = 2,
+    AutoColor = 3,
+  }
+
+  enum ImageScannerFormat {
+    Jpeg = 0,
+    Png = 1,
+    DeviceIndependentBitmap = 2,
+    Tiff = 3,
+    Xps = 4,
+    OpenXps = 5,
+    Pdf = 6,
+  }
+
+  enum ImageScannerScanSource {
+    Default = 0,
+    Flatbed = 1,
+    Feeder = 2,
+    AutoConfigured = 3,
+  }
+
+  interface IImageScanner {
+    IsPreviewSupported(scanSource: number): boolean;
+    IsScanSourceSupported(value: number): boolean;
+    ScanFilesToFolderAsync(scanSource: number, storageFolder: Windows.Storage.StorageFolder): Windows.Foundation.IAsyncOperationWithProgress<Windows.Devices.Scanners.ImageScannerScanResult, number>;
+    ScanPreviewToStreamAsync(scanSource: number, targetStream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<Windows.Devices.Scanners.ImageScannerPreviewResult>;
+    readonly AutoConfiguration: Windows.Devices.Scanners.ImageScannerAutoConfiguration;
+    readonly DefaultScanSource: number;
+    readonly DeviceId: string;
+    readonly FeederConfiguration: Windows.Devices.Scanners.ImageScannerFeederConfiguration;
+    readonly FlatbedConfiguration: Windows.Devices.Scanners.ImageScannerFlatbedConfiguration;
+  }
+  var IImageScanner: abstract new (...args: any[]) => IImageScanner;
+
+  interface IImageScannerFeederConfiguration extends Windows.Devices.Scanners.IImageScannerFormatConfiguration, Windows.Devices.Scanners.IImageScannerSourceConfiguration {
+    IsAutoCroppingModeSupported(value: number): boolean;
+    IsColorModeSupported(value: number): boolean;
+    IsFormatSupported(value: number): boolean;
+    IsPageSizeSupported(pageSize: number, pageOrientation: number): boolean;
+    AutoDetectPageSize: boolean;
+    readonly CanAutoDetectPageSize: boolean;
+    readonly CanScanAhead: boolean;
+    readonly CanScanDuplex: boolean;
+    Duplex: boolean;
+    MaxNumberOfPages: number;
+    PageOrientation: number;
+    PageSize: number;
+    readonly PageSizeDimensions: Windows.Foundation.Size;
+    ScanAhead: boolean;
+  }
+  var IImageScannerFeederConfiguration: abstract new (...args: any[]) => IImageScannerFeederConfiguration;
+
+  interface IImageScannerFormatConfiguration {
+    IsFormatSupported(value: number): boolean;
+    readonly DefaultFormat: number;
+    Format: number;
+  }
+  var IImageScannerFormatConfiguration: abstract new (...args: any[]) => IImageScannerFormatConfiguration;
+
+  interface IImageScannerPreviewResult {
+    readonly Format: number;
+    readonly Succeeded: boolean;
+  }
+  var IImageScannerPreviewResult: abstract new (...args: any[]) => IImageScannerPreviewResult;
+
+  interface IImageScannerScanResult {
+    readonly ScannedFiles: Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[];
+  }
+  var IImageScannerScanResult: abstract new (...args: any[]) => IImageScannerScanResult;
+
+  interface IImageScannerSourceConfiguration extends Windows.Devices.Scanners.IImageScannerFormatConfiguration {
+    IsAutoCroppingModeSupported(value: number): boolean;
+    IsColorModeSupported(value: number): boolean;
+    IsFormatSupported(value: number): boolean;
+    readonly ActualResolution: Windows.Devices.Scanners.ImageScannerResolution;
+    AutoCroppingMode: number;
+    Brightness: number;
+    readonly BrightnessStep: number;
+    ColorMode: number;
+    Contrast: number;
+    readonly ContrastStep: number;
+    readonly DefaultBrightness: number;
+    readonly DefaultColorMode: number;
+    readonly DefaultContrast: number;
+    DesiredResolution: Windows.Devices.Scanners.ImageScannerResolution;
+    readonly MaxBrightness: number;
+    readonly MaxContrast: number;
+    readonly MaxResolution: Windows.Devices.Scanners.ImageScannerResolution;
+    readonly MaxScanArea: Windows.Foundation.Size;
+    readonly MinBrightness: number;
+    readonly MinContrast: number;
+    readonly MinResolution: Windows.Devices.Scanners.ImageScannerResolution;
+    readonly MinScanArea: Windows.Foundation.Size;
+    readonly OpticalResolution: Windows.Devices.Scanners.ImageScannerResolution;
+    SelectedScanRegion: Windows.Foundation.Rect;
+  }
+  var IImageScannerSourceConfiguration: abstract new (...args: any[]) => IImageScannerSourceConfiguration;
+
+  interface IImageScannerStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Scanners.ImageScanner>;
+    GetDeviceSelector(): string;
+  }
+  var IImageScannerStatics: abstract new (...args: any[]) => IImageScannerStatics;
+
+  interface ImageScannerResolution {
+    DpiX: number;
+    DpiY: number;
+  }
+  var ImageScannerResolution: {
+    new(dpiX: number, dpiY: number): ImageScannerResolution;
+    new(fields: { DpiX?: number; DpiY?: number }): ImageScannerResolution;
+  };
+
+  interface ScannerDeviceContract {
+  }
+  var ScannerDeviceContract: {
+    new(fields: {  }): ScannerDeviceContract;
+  };
+
+}
+
+declare namespace Windows.Devices.Sensors {
+  class Accelerometer implements Windows.Devices.Sensors.IAccelerometer, Windows.Devices.Sensors.IAccelerometer2, Windows.Devices.Sensors.IAccelerometer3, Windows.Devices.Sensors.IAccelerometer4, Windows.Devices.Sensors.IAccelerometer5, Windows.Devices.Sensors.IAccelerometerDeviceId {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.Accelerometer>;
+    GetCurrentReading(): Windows.Devices.Sensors.AccelerometerReading;
+    static GetDefault(readingType: number): Windows.Devices.Sensors.Accelerometer;
+    static GetDefault(): Windows.Devices.Sensors.Accelerometer;
+    static GetDeviceSelector(readingType: number): string;
+    readonly DeviceId: string;
+    readonly MaxBatchSize: number;
+    readonly MinimumReportInterval: number;
+    ReadingTransform: number;
+    readonly ReadingType: number;
+    ReportInterval: number;
+    ReportLatency: number;
+    readonly ReportThreshold: Windows.Devices.Sensors.AccelerometerDataThreshold;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Accelerometer, Windows.Devices.Sensors.AccelerometerReadingChangedEventArgs> | null;
+    Shaken: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Accelerometer, Windows.Devices.Sensors.AccelerometerShakenEventArgs> | null;
+  }
+
+  class AccelerometerDataThreshold implements Windows.Devices.Sensors.IAccelerometerDataThreshold {
+    XAxisInGForce: number;
+    YAxisInGForce: number;
+    ZAxisInGForce: number;
+  }
+
+  class AccelerometerReading implements Windows.Devices.Sensors.IAccelerometerReading, Windows.Devices.Sensors.IAccelerometerReading2 {
+    readonly AccelerationX: number;
+    readonly AccelerationY: number;
+    readonly AccelerationZ: number;
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class AccelerometerReadingChangedEventArgs implements Windows.Devices.Sensors.IAccelerometerReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.AccelerometerReading;
+  }
+
+  class AccelerometerShakenEventArgs implements Windows.Devices.Sensors.IAccelerometerShakenEventArgs {
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class ActivitySensor implements Windows.Devices.Sensors.IActivitySensor {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.ActivitySensor>;
+    GetCurrentReadingAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.ActivitySensorReading>;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.ActivitySensor>;
+    static GetDeviceSelector(): string;
+    static GetSystemHistoryAsync(fromTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Sensors.ActivitySensorReading> | Windows.Devices.Sensors.ActivitySensorReading[]>;
+    static GetSystemHistoryAsync(fromTime: Windows.Foundation.DateTime, duration: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Sensors.ActivitySensorReading> | Windows.Devices.Sensors.ActivitySensorReading[]>;
+    readonly DeviceId: string;
+    readonly MinimumReportInterval: number;
+    readonly PowerInMilliwatts: number;
+    readonly SubscribedActivities: Windows.Foundation.Collections.IVector<number> | number[];
+    readonly SupportedActivities: Windows.Foundation.Collections.IVectorView<number> | number[];
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.ActivitySensor, Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs> | null;
+  }
+
+  class ActivitySensorReading implements Windows.Devices.Sensors.IActivitySensorReading {
+    readonly Activity: number;
+    readonly Confidence: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class ActivitySensorReadingChangeReport implements Windows.Devices.Sensors.IActivitySensorReadingChangeReport {
+    readonly Reading: Windows.Devices.Sensors.ActivitySensorReading;
+  }
+
+  class ActivitySensorReadingChangedEventArgs implements Windows.Devices.Sensors.IActivitySensorReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.ActivitySensorReading;
+  }
+
+  class ActivitySensorTriggerDetails implements Windows.Devices.Sensors.IActivitySensorTriggerDetails {
+    ReadReports(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Sensors.ActivitySensorReadingChangeReport> | Windows.Devices.Sensors.ActivitySensorReadingChangeReport[];
+  }
+
+  class AdaptiveDimmingOptions implements Windows.Devices.Sensors.IAdaptiveDimmingOptions {
+    AllowWhenExternalDisplayConnected: boolean;
+  }
+
+  class Altimeter implements Windows.Devices.Sensors.IAltimeter, Windows.Devices.Sensors.IAltimeter2 {
+    GetCurrentReading(): Windows.Devices.Sensors.AltimeterReading;
+    static GetDefault(): Windows.Devices.Sensors.Altimeter;
+    readonly DeviceId: string;
+    readonly MaxBatchSize: number;
+    readonly MinimumReportInterval: number;
+    ReportInterval: number;
+    ReportLatency: number;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Altimeter, Windows.Devices.Sensors.AltimeterReadingChangedEventArgs> | null;
+  }
+
+  class AltimeterReading implements Windows.Devices.Sensors.IAltimeterReading, Windows.Devices.Sensors.IAltimeterReading2 {
+    readonly AltitudeChangeInMeters: number;
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class AltimeterReadingChangedEventArgs implements Windows.Devices.Sensors.IAltimeterReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.AltimeterReading;
+  }
+
+  class Barometer implements Windows.Devices.Sensors.IBarometer, Windows.Devices.Sensors.IBarometer2, Windows.Devices.Sensors.IBarometer3 {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.Barometer>;
+    GetCurrentReading(): Windows.Devices.Sensors.BarometerReading;
+    static GetDefault(): Windows.Devices.Sensors.Barometer;
+    static GetDeviceSelector(): string;
+    readonly DeviceId: string;
+    readonly MaxBatchSize: number;
+    readonly MinimumReportInterval: number;
+    ReportInterval: number;
+    ReportLatency: number;
+    readonly ReportThreshold: Windows.Devices.Sensors.BarometerDataThreshold;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Barometer, Windows.Devices.Sensors.BarometerReadingChangedEventArgs> | null;
+  }
+
+  class BarometerDataThreshold implements Windows.Devices.Sensors.IBarometerDataThreshold {
+    Hectopascals: number;
+  }
+
+  class BarometerReading implements Windows.Devices.Sensors.IBarometerReading, Windows.Devices.Sensors.IBarometerReading2 {
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly StationPressureInHectopascals: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class BarometerReadingChangedEventArgs implements Windows.Devices.Sensors.IBarometerReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.BarometerReading;
+  }
+
+  class Compass implements Windows.Devices.Sensors.ICompass, Windows.Devices.Sensors.ICompass2, Windows.Devices.Sensors.ICompass3, Windows.Devices.Sensors.ICompass4, Windows.Devices.Sensors.ICompassDeviceId {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.Compass>;
+    GetCurrentReading(): Windows.Devices.Sensors.CompassReading;
+    static GetDefault(): Windows.Devices.Sensors.Compass;
+    static GetDeviceSelector(): string;
+    readonly DeviceId: string;
+    readonly MaxBatchSize: number;
+    readonly MinimumReportInterval: number;
+    ReadingTransform: number;
+    ReportInterval: number;
+    ReportLatency: number;
+    readonly ReportThreshold: Windows.Devices.Sensors.CompassDataThreshold;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Compass, Windows.Devices.Sensors.CompassReadingChangedEventArgs> | null;
+  }
+
+  class CompassDataThreshold implements Windows.Devices.Sensors.ICompassDataThreshold {
+    Degrees: number;
+  }
+
+  class CompassReading implements Windows.Devices.Sensors.ICompassReading, Windows.Devices.Sensors.ICompassReading2, Windows.Devices.Sensors.ICompassReadingHeadingAccuracy {
+    readonly HeadingAccuracy: number;
+    readonly HeadingMagneticNorth: number;
+    readonly HeadingTrueNorth: number | null;
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class CompassReadingChangedEventArgs implements Windows.Devices.Sensors.ICompassReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.CompassReading;
+  }
+
+  class DetectedPerson implements Windows.Devices.Sensors.IDetectedPerson {
+    readonly DistanceInMillimeters: number | null;
+    readonly Engagement: number;
+    readonly HeadOrientation: Windows.Devices.Sensors.HeadOrientation;
+    readonly HeadPosition: Windows.Devices.Sensors.HeadPosition;
+    readonly PersonId: number | null;
+  }
+
+  class Gyrometer implements Windows.Devices.Sensors.IGyrometer, Windows.Devices.Sensors.IGyrometer2, Windows.Devices.Sensors.IGyrometer3, Windows.Devices.Sensors.IGyrometer4, Windows.Devices.Sensors.IGyrometerDeviceId {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.Gyrometer>;
+    GetCurrentReading(): Windows.Devices.Sensors.GyrometerReading;
+    static GetDefault(): Windows.Devices.Sensors.Gyrometer;
+    static GetDeviceSelector(): string;
+    readonly DeviceId: string;
+    readonly MaxBatchSize: number;
+    readonly MinimumReportInterval: number;
+    ReadingTransform: number;
+    ReportInterval: number;
+    ReportLatency: number;
+    readonly ReportThreshold: Windows.Devices.Sensors.GyrometerDataThreshold;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Gyrometer, Windows.Devices.Sensors.GyrometerReadingChangedEventArgs> | null;
+  }
+
+  class GyrometerDataThreshold implements Windows.Devices.Sensors.IGyrometerDataThreshold {
+    XAxisInDegreesPerSecond: number;
+    YAxisInDegreesPerSecond: number;
+    ZAxisInDegreesPerSecond: number;
+  }
+
+  class GyrometerReading implements Windows.Devices.Sensors.IGyrometerReading, Windows.Devices.Sensors.IGyrometerReading2 {
+    readonly AngularVelocityX: number;
+    readonly AngularVelocityY: number;
+    readonly AngularVelocityZ: number;
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class GyrometerReadingChangedEventArgs implements Windows.Devices.Sensors.IGyrometerReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.GyrometerReading;
+  }
+
+  class HeadOrientation implements Windows.Devices.Sensors.IHeadOrientation {
+    readonly PitchInDegrees: number | null;
+    readonly RollInDegrees: number | null;
+    readonly YawInDegrees: number | null;
+  }
+
+  class HeadPosition implements Windows.Devices.Sensors.IHeadPosition {
+    readonly AltitudeInDegrees: number | null;
+    readonly AzimuthInDegrees: number | null;
+  }
+
+  class HingeAngleReading implements Windows.Devices.Sensors.IHingeAngleReading {
+    readonly AngleInDegrees: number;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class HingeAngleSensor implements Windows.Devices.Sensors.IHingeAngleSensor {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.HingeAngleSensor>;
+    GetCurrentReadingAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.HingeAngleReading>;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.HingeAngleSensor>;
+    static GetDeviceSelector(): string;
+    static GetRelatedToAdjacentPanelsAsync(firstPanelId: string, secondPanelId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.HingeAngleSensor>;
+    readonly DeviceId: string;
+    readonly MinReportThresholdInDegrees: number;
+    ReportThresholdInDegrees: number;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.HingeAngleSensor, Windows.Devices.Sensors.HingeAngleSensorReadingChangedEventArgs> | null;
+  }
+
+  class HingeAngleSensorReadingChangedEventArgs implements Windows.Devices.Sensors.IHingeAngleSensorReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.HingeAngleReading;
+  }
+
+  class HumanPresenceFeatures implements Windows.Devices.Sensors.IHumanPresenceFeatures, Windows.Devices.Sensors.IHumanPresenceFeatures2, Windows.Devices.Sensors.IHumanPresenceFeatures3 {
+    readonly IsAdaptiveDimmingSupported: boolean;
+    readonly IsAttentionAwareDimmingSupported: boolean;
+    readonly IsLockOnLeaveSupported: boolean;
+    readonly IsOnlookerDetectionSupported: boolean;
+    readonly IsWakeOnApproachSupported: boolean;
+    readonly SensorId: string;
+    readonly SupportedWakeOrLockDistancesInMillimeters: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class HumanPresenceSensor implements Windows.Devices.Sensors.IHumanPresenceSensor, Windows.Devices.Sensors.IHumanPresenceSensor2, Windows.Devices.Sensors.IHumanPresenceSensor3 {
+    static FromId(sensorId: string): Windows.Devices.Sensors.HumanPresenceSensor;
+    static FromIdAsync(sensorId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.HumanPresenceSensor>;
+    GetCurrentReading(): Windows.Devices.Sensors.HumanPresenceSensorReading;
+    static GetDefault(): Windows.Devices.Sensors.HumanPresenceSensor;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.HumanPresenceSensor>;
+    static GetDeviceSelector(): string;
+    readonly DeviceId: string;
+    readonly IsEngagementSupported: boolean;
+    readonly IsPresenceSupported: boolean;
+    readonly MaxDetectableAltitudeInDegrees: number | null;
+    readonly MaxDetectableAzimuthInDegrees: number | null;
+    readonly MaxDetectableDistanceInMillimeters: number | null;
+    readonly MaxDetectablePersons: number;
+    readonly MinDetectableAltitudeInDegrees: number | null;
+    readonly MinDetectableAzimuthInDegrees: number | null;
+    readonly MinDetectableDistanceInMillimeters: number | null;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.HumanPresenceSensor, Windows.Devices.Sensors.HumanPresenceSensorReadingChangedEventArgs> | null;
+  }
+
+  class HumanPresenceSensorReading implements Windows.Devices.Sensors.IHumanPresenceSensorReading, Windows.Devices.Sensors.IHumanPresenceSensorReading2, Windows.Devices.Sensors.IHumanPresenceSensorReading3 {
+    readonly DetectedPersons: Windows.Foundation.Collections.IVectorView<Windows.Devices.Sensors.DetectedPerson> | Windows.Devices.Sensors.DetectedPerson[];
+    readonly DistanceInMillimeters: number | null;
+    readonly Engagement: number;
+    readonly OnlookerPresence: number;
+    readonly Presence: number;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class HumanPresenceSensorReadingChangedEventArgs implements Windows.Devices.Sensors.IHumanPresenceSensorReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.HumanPresenceSensorReading;
+  }
+
+  class HumanPresenceSensorReadingUpdate implements Windows.Devices.Sensors.IHumanPresenceSensorReadingUpdate, Windows.Devices.Sensors.IHumanPresenceSensorReadingUpdate2 {
+    constructor();
+    DistanceInMillimeters: number | null;
+    Engagement: number | null;
+    OnlookerPresence: number | null;
+    Presence: number | null;
+    Timestamp: Windows.Foundation.DateTime | null;
+  }
+
+  class HumanPresenceSettings implements Windows.Devices.Sensors.IHumanPresenceSettings, Windows.Devices.Sensors.IHumanPresenceSettings2, Windows.Devices.Sensors.IHumanPresenceSettings3 {
+    static GetCurrentSettings(): Windows.Devices.Sensors.HumanPresenceSettings;
+    static GetCurrentSettingsAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.HumanPresenceSettings>;
+    static GetSupportedFeaturesForSensorId(sensorId: string): Windows.Devices.Sensors.HumanPresenceFeatures;
+    static GetSupportedFeaturesForSensorIdAsync(sensorId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.HumanPresenceFeatures>;
+    static GetSupportedLockOnLeaveTimeouts(): Windows.Foundation.Collections.IVectorView<Windows.Foundation.TimeSpan> | Windows.Foundation.TimeSpan[];
+    static UpdateSettings(settings: Windows.Devices.Sensors.HumanPresenceSettings): void;
+    static UpdateSettingsAsync(settings: Windows.Devices.Sensors.HumanPresenceSettings): Windows.Foundation.IAsyncAction;
+    readonly DimmingOptions: Windows.Devices.Sensors.AdaptiveDimmingOptions;
+    IsAdaptiveDimmingEnabled: boolean;
+    IsAttentionAwareDimmingEnabled: boolean;
+    IsLockOnLeaveEnabled: boolean;
+    IsOnlookerDetectionEnabled: boolean;
+    IsWakeOnApproachEnabled: boolean;
+    LockOnLeaveDistanceInMillimeters: number | null;
+    LockOnLeaveTimeout: Windows.Foundation.TimeSpan;
+    readonly LockOptions: Windows.Devices.Sensors.LockOnLeaveOptions;
+    readonly OnlookerDetectionOptions: Windows.Devices.Sensors.OnlookerDetectionOptions;
+    SensorId: string;
+    WakeOnApproachDistanceInMillimeters: number | null;
+    readonly WakeOptions: Windows.Devices.Sensors.WakeOnApproachOptions;
+    static SettingsChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class Inclinometer implements Windows.Devices.Sensors.IInclinometer, Windows.Devices.Sensors.IInclinometer2, Windows.Devices.Sensors.IInclinometer3, Windows.Devices.Sensors.IInclinometer4, Windows.Devices.Sensors.IInclinometerDeviceId {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.Inclinometer>;
+    GetCurrentReading(): Windows.Devices.Sensors.InclinometerReading;
+    static GetDefault(sensorReadingtype: number): Windows.Devices.Sensors.Inclinometer;
+    static GetDefault(): Windows.Devices.Sensors.Inclinometer;
+    static GetDefaultForRelativeReadings(): Windows.Devices.Sensors.Inclinometer;
+    static GetDeviceSelector(readingType: number): string;
+    readonly DeviceId: string;
+    readonly MaxBatchSize: number;
+    readonly MinimumReportInterval: number;
+    ReadingTransform: number;
+    readonly ReadingType: number;
+    ReportInterval: number;
+    ReportLatency: number;
+    readonly ReportThreshold: Windows.Devices.Sensors.InclinometerDataThreshold;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Inclinometer, Windows.Devices.Sensors.InclinometerReadingChangedEventArgs> | null;
+  }
+
+  class InclinometerDataThreshold implements Windows.Devices.Sensors.IInclinometerDataThreshold {
+    PitchInDegrees: number;
+    RollInDegrees: number;
+    YawInDegrees: number;
+  }
+
+  class InclinometerReading implements Windows.Devices.Sensors.IInclinometerReading, Windows.Devices.Sensors.IInclinometerReading2, Windows.Devices.Sensors.IInclinometerReadingYawAccuracy {
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+    readonly PitchDegrees: number;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly RollDegrees: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+    readonly YawAccuracy: number;
+    readonly YawDegrees: number;
+  }
+
+  class InclinometerReadingChangedEventArgs implements Windows.Devices.Sensors.IInclinometerReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.InclinometerReading;
+  }
+
+  class LightSensor implements Windows.Devices.Sensors.ILightSensor, Windows.Devices.Sensors.ILightSensor2, Windows.Devices.Sensors.ILightSensor3, Windows.Devices.Sensors.ILightSensor4, Windows.Devices.Sensors.ILightSensorDeviceId {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.LightSensor>;
+    GetCurrentReading(): Windows.Devices.Sensors.LightSensorReading;
+    static GetDefault(): Windows.Devices.Sensors.LightSensor;
+    static GetDeviceSelector(): string;
+    IsChromaticitySupported(): boolean;
+    readonly DeviceId: string;
+    readonly MaxBatchSize: number;
+    readonly MinimumReportInterval: number;
+    ReportInterval: number;
+    ReportLatency: number;
+    readonly ReportThreshold: Windows.Devices.Sensors.LightSensorDataThreshold;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.LightSensor, Windows.Devices.Sensors.LightSensorReadingChangedEventArgs> | null;
+  }
+
+  class LightSensorDataThreshold implements Windows.Devices.Sensors.ILightSensorDataThreshold, Windows.Devices.Sensors.ILightSensorDataThreshold2 {
+    AbsoluteLux: number;
+    Chromaticity: Windows.Devices.Sensors.LightSensorChromaticity;
+    LuxPercentage: number;
+  }
+
+  class LightSensorReading implements Windows.Devices.Sensors.ILightSensorReading, Windows.Devices.Sensors.ILightSensorReading2, Windows.Devices.Sensors.ILightSensorReading3 {
+    readonly Chromaticity: Windows.Devices.Sensors.LightSensorChromaticity;
+    readonly IlluminanceInLux: number;
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class LightSensorReadingChangedEventArgs implements Windows.Devices.Sensors.ILightSensorReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.LightSensorReading;
+  }
+
+  class LockOnLeaveOptions implements Windows.Devices.Sensors.ILockOnLeaveOptions {
+    AllowWhenExternalDisplayConnected: boolean;
+  }
+
+  class Magnetometer implements Windows.Devices.Sensors.IMagnetometer, Windows.Devices.Sensors.IMagnetometer2, Windows.Devices.Sensors.IMagnetometer3, Windows.Devices.Sensors.IMagnetometer4, Windows.Devices.Sensors.IMagnetometerDeviceId {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.Magnetometer>;
+    GetCurrentReading(): Windows.Devices.Sensors.MagnetometerReading;
+    static GetDefault(): Windows.Devices.Sensors.Magnetometer;
+    static GetDeviceSelector(): string;
+    readonly DeviceId: string;
+    readonly MaxBatchSize: number;
+    readonly MinimumReportInterval: number;
+    ReadingTransform: number;
+    ReportInterval: number;
+    ReportLatency: number;
+    readonly ReportThreshold: Windows.Devices.Sensors.MagnetometerDataThreshold;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Magnetometer, Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs> | null;
+  }
+
+  class MagnetometerDataThreshold implements Windows.Devices.Sensors.IMagnetometerDataThreshold {
+    XAxisMicroteslas: number;
+    YAxisMicroteslas: number;
+    ZAxisMicroteslas: number;
+  }
+
+  class MagnetometerReading implements Windows.Devices.Sensors.IMagnetometerReading, Windows.Devices.Sensors.IMagnetometerReading2 {
+    readonly DirectionalAccuracy: number;
+    readonly MagneticFieldX: number;
+    readonly MagneticFieldY: number;
+    readonly MagneticFieldZ: number;
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class MagnetometerReadingChangedEventArgs implements Windows.Devices.Sensors.IMagnetometerReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.MagnetometerReading;
+  }
+
+  class OnlookerDetectionOptions implements Windows.Devices.Sensors.IOnlookerDetectionOptions {
+    Action: number;
+    BackOnMode: number;
+  }
+
+  class OrientationSensor implements Windows.Devices.Sensors.IOrientationSensor, Windows.Devices.Sensors.IOrientationSensor2, Windows.Devices.Sensors.IOrientationSensor3, Windows.Devices.Sensors.IOrientationSensorDeviceId {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.OrientationSensor>;
+    GetCurrentReading(): Windows.Devices.Sensors.OrientationSensorReading;
+    static GetDefault(sensorReadingtype: number): Windows.Devices.Sensors.OrientationSensor;
+    static GetDefault(sensorReadingType: number, optimizationGoal: number): Windows.Devices.Sensors.OrientationSensor;
+    static GetDefault(): Windows.Devices.Sensors.OrientationSensor;
+    static GetDefaultForRelativeReadings(): Windows.Devices.Sensors.OrientationSensor;
+    static GetDeviceSelector(readingType: number): string;
+    static GetDeviceSelector(readingType: number, optimizationGoal: number): string;
+    readonly DeviceId: string;
+    readonly MaxBatchSize: number;
+    readonly MinimumReportInterval: number;
+    ReadingTransform: number;
+    readonly ReadingType: number;
+    ReportInterval: number;
+    ReportLatency: number;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.OrientationSensor, Windows.Devices.Sensors.OrientationSensorReadingChangedEventArgs> | null;
+  }
+
+  class OrientationSensorReading implements Windows.Devices.Sensors.IOrientationSensorReading, Windows.Devices.Sensors.IOrientationSensorReading2, Windows.Devices.Sensors.IOrientationSensorReadingYawAccuracy {
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Quaternion: Windows.Devices.Sensors.SensorQuaternion;
+    readonly RotationMatrix: Windows.Devices.Sensors.SensorRotationMatrix;
+    readonly Timestamp: Windows.Foundation.DateTime;
+    readonly YawAccuracy: number;
+  }
+
+  class OrientationSensorReadingChangedEventArgs implements Windows.Devices.Sensors.IOrientationSensorReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.OrientationSensorReading;
+  }
+
+  class Pedometer implements Windows.Devices.Sensors.IPedometer, Windows.Devices.Sensors.IPedometer2 {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.Pedometer>;
+    GetCurrentReadings(): Windows.Foundation.Collections.IMapView<number, Windows.Devices.Sensors.PedometerReading>;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.Pedometer>;
+    static GetDeviceSelector(): string;
+    static GetReadingsFromTriggerDetails(triggerDetails: Windows.Devices.Sensors.SensorDataThresholdTriggerDetails): Windows.Foundation.Collections.IVectorView<Windows.Devices.Sensors.PedometerReading> | Windows.Devices.Sensors.PedometerReading[];
+    static GetSystemHistoryAsync(fromTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Sensors.PedometerReading> | Windows.Devices.Sensors.PedometerReading[]>;
+    static GetSystemHistoryAsync(fromTime: Windows.Foundation.DateTime, duration: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Sensors.PedometerReading> | Windows.Devices.Sensors.PedometerReading[]>;
+    readonly DeviceId: string;
+    readonly MinimumReportInterval: number;
+    readonly PowerInMilliwatts: number;
+    ReportInterval: number;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Pedometer, Windows.Devices.Sensors.PedometerReadingChangedEventArgs> | null;
+  }
+
+  class PedometerDataThreshold implements Windows.Devices.Sensors.ISensorDataThreshold {
+    constructor(sensor: Windows.Devices.Sensors.Pedometer, stepGoal: number);
+  }
+
+  class PedometerReading implements Windows.Devices.Sensors.IPedometerReading {
+    readonly CumulativeSteps: number;
+    readonly CumulativeStepsDuration: Windows.Foundation.TimeSpan;
+    readonly StepKind: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class PedometerReadingChangedEventArgs implements Windows.Devices.Sensors.IPedometerReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.PedometerReading;
+  }
+
+  class ProximitySensor implements Windows.Devices.Sensors.IProximitySensor {
+    CreateDisplayOnOffController(): Windows.Devices.Sensors.ProximitySensorDisplayOnOffController;
+    static FromId(sensorId: string): Windows.Devices.Sensors.ProximitySensor;
+    GetCurrentReading(): Windows.Devices.Sensors.ProximitySensorReading;
+    static GetDeviceSelector(): string;
+    static GetReadingsFromTriggerDetails(triggerDetails: Windows.Devices.Sensors.SensorDataThresholdTriggerDetails): Windows.Foundation.Collections.IVectorView<Windows.Devices.Sensors.ProximitySensorReading> | Windows.Devices.Sensors.ProximitySensorReading[];
+    readonly DeviceId: string;
+    readonly MaxDistanceInMillimeters: number | null;
+    readonly MinDistanceInMillimeters: number | null;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.ProximitySensor, Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs> | null;
+  }
+
+  class ProximitySensorDataThreshold implements Windows.Devices.Sensors.ISensorDataThreshold {
+    constructor(sensor: Windows.Devices.Sensors.ProximitySensor);
+  }
+
+  class ProximitySensorDisplayOnOffController implements Windows.Foundation.IClosable {
+    Close(): void;
+  }
+
+  class ProximitySensorReading implements Windows.Devices.Sensors.IProximitySensorReading {
+    readonly DistanceInMillimeters: number | null;
+    readonly IsDetected: boolean;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class ProximitySensorReadingChangedEventArgs implements Windows.Devices.Sensors.IProximitySensorReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.ProximitySensorReading;
+  }
+
+  class SensorDataThresholdTriggerDetails implements Windows.Devices.Sensors.ISensorDataThresholdTriggerDetails {
+    readonly DeviceId: string;
+    readonly SensorType: number;
+  }
+
+  class SensorQuaternion implements Windows.Devices.Sensors.ISensorQuaternion {
+    readonly W: number;
+    readonly X: number;
+    readonly Y: number;
+    readonly Z: number;
+  }
+
+  class SensorRotationMatrix implements Windows.Devices.Sensors.ISensorRotationMatrix {
+    readonly M11: number;
+    readonly M12: number;
+    readonly M13: number;
+    readonly M21: number;
+    readonly M22: number;
+    readonly M23: number;
+    readonly M31: number;
+    readonly M32: number;
+    readonly M33: number;
+  }
+
+  class SimpleOrientationSensor implements Windows.Devices.Sensors.ISimpleOrientationSensor, Windows.Devices.Sensors.ISimpleOrientationSensor2, Windows.Devices.Sensors.ISimpleOrientationSensorDeviceId {
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.SimpleOrientationSensor>;
+    GetCurrentOrientation(): number;
+    static GetDefault(): Windows.Devices.Sensors.SimpleOrientationSensor;
+    static GetDeviceSelector(): string;
+    readonly DeviceId: string;
+    ReadingTransform: number;
+    OrientationChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.SimpleOrientationSensor, Windows.Devices.Sensors.SimpleOrientationSensorOrientationChangedEventArgs> | null;
+  }
+
+  class SimpleOrientationSensorOrientationChangedEventArgs implements Windows.Devices.Sensors.ISimpleOrientationSensorOrientationChangedEventArgs {
+    readonly Orientation: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class WakeOnApproachOptions implements Windows.Devices.Sensors.IWakeOnApproachOptions {
+    AllowWhenExternalDisplayConnected: boolean;
+    DisableWhenBatterySaverOn: boolean;
+  }
+
+  enum AccelerometerReadingType {
+    Standard = 0,
+    Linear = 1,
+    Gravity = 2,
+  }
+
+  enum ActivitySensorReadingConfidence {
+    High = 0,
+    Low = 1,
+  }
+
+  enum ActivityType {
+    Unknown = 0,
+    Idle = 1,
+    Stationary = 2,
+    Fidgeting = 3,
+    Walking = 4,
+    Running = 5,
+    InVehicle = 6,
+    Biking = 7,
+  }
+
+  enum HumanEngagement {
+    Unknown = 0,
+    Engaged = 1,
+    Unengaged = 2,
+  }
+
+  enum HumanPresence {
+    Unknown = 0,
+    Present = 1,
+    NotPresent = 2,
+  }
+
+  enum MagnetometerAccuracy {
+    Unknown = 0,
+    Unreliable = 1,
+    Approximate = 2,
+    High = 3,
+  }
+
+  enum OnlookerDetectionAction {
+    Dim = 0,
+    Notify = 1,
+    DimAndNotify = 2,
+  }
+
+  enum OnlookerDetectionBackOnMode {
+    Manually = 0,
+    OneHour = 1,
+    FourHours = 2,
+    OneDay = 3,
+  }
+
+  enum PedometerStepKind {
+    Unknown = 0,
+    Walking = 1,
+    Running = 2,
+  }
+
+  enum SensorOptimizationGoal {
+    Precision = 0,
+    PowerEfficiency = 1,
+  }
+
+  enum SensorReadingType {
+    Absolute = 0,
+    Relative = 1,
+  }
+
+  enum 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,
+  }
+
+  enum SimpleOrientation {
+    NotRotated = 0,
+    Rotated90DegreesCounterclockwise = 1,
+    Rotated180DegreesCounterclockwise = 2,
+    Rotated270DegreesCounterclockwise = 3,
+    Faceup = 4,
+    Facedown = 5,
+  }
+
+  interface IAccelerometer {
+    GetCurrentReading(): Windows.Devices.Sensors.AccelerometerReading;
+    readonly MinimumReportInterval: number;
+    ReportInterval: number;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Accelerometer, Windows.Devices.Sensors.AccelerometerReadingChangedEventArgs> | null;
+    Shaken: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Accelerometer, Windows.Devices.Sensors.AccelerometerShakenEventArgs> | null;
+  }
+  var IAccelerometer: abstract new (...args: any[]) => IAccelerometer;
+
+  interface IAccelerometer2 {
+    ReadingTransform: number;
+  }
+  var IAccelerometer2: abstract new (...args: any[]) => IAccelerometer2;
+
+  interface IAccelerometer3 {
+    readonly MaxBatchSize: number;
+    ReportLatency: number;
+  }
+  var IAccelerometer3: abstract new (...args: any[]) => IAccelerometer3;
+
+  interface IAccelerometer4 {
+    readonly ReadingType: number;
+  }
+  var IAccelerometer4: abstract new (...args: any[]) => IAccelerometer4;
+
+  interface IAccelerometer5 {
+    readonly ReportThreshold: Windows.Devices.Sensors.AccelerometerDataThreshold;
+  }
+  var IAccelerometer5: abstract new (...args: any[]) => IAccelerometer5;
+
+  interface IAccelerometerDataThreshold {
+    XAxisInGForce: number;
+    YAxisInGForce: number;
+    ZAxisInGForce: number;
+  }
+  var IAccelerometerDataThreshold: abstract new (...args: any[]) => IAccelerometerDataThreshold;
+
+  interface IAccelerometerDeviceId {
+    readonly DeviceId: string;
+  }
+  var IAccelerometerDeviceId: abstract new (...args: any[]) => IAccelerometerDeviceId;
+
+  interface IAccelerometerReading {
+    readonly AccelerationX: number;
+    readonly AccelerationY: number;
+    readonly AccelerationZ: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IAccelerometerReading: abstract new (...args: any[]) => IAccelerometerReading;
+
+  interface IAccelerometerReading2 {
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+  var IAccelerometerReading2: abstract new (...args: any[]) => IAccelerometerReading2;
+
+  interface IAccelerometerReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.AccelerometerReading;
+  }
+  var IAccelerometerReadingChangedEventArgs: abstract new (...args: any[]) => IAccelerometerReadingChangedEventArgs;
+
+  interface IAccelerometerShakenEventArgs {
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IAccelerometerShakenEventArgs: abstract new (...args: any[]) => IAccelerometerShakenEventArgs;
+
+  interface IAccelerometerStatics {
+    GetDefault(): Windows.Devices.Sensors.Accelerometer;
+  }
+  var IAccelerometerStatics: abstract new (...args: any[]) => IAccelerometerStatics;
+
+  interface IAccelerometerStatics2 {
+    GetDefault(readingType: number): Windows.Devices.Sensors.Accelerometer;
+  }
+  var IAccelerometerStatics2: abstract new (...args: any[]) => IAccelerometerStatics2;
+
+  interface IAccelerometerStatics3 {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.Accelerometer>;
+    GetDeviceSelector(readingType: number): string;
+  }
+  var IAccelerometerStatics3: abstract new (...args: any[]) => IAccelerometerStatics3;
+
+  interface IActivitySensor {
+    GetCurrentReadingAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.ActivitySensorReading>;
+    readonly DeviceId: string;
+    readonly MinimumReportInterval: number;
+    readonly PowerInMilliwatts: number;
+    readonly SubscribedActivities: Windows.Foundation.Collections.IVector<number> | number[];
+    readonly SupportedActivities: Windows.Foundation.Collections.IVectorView<number> | number[];
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.ActivitySensor, Windows.Devices.Sensors.ActivitySensorReadingChangedEventArgs> | null;
+  }
+  var IActivitySensor: abstract new (...args: any[]) => IActivitySensor;
+
+  interface IActivitySensorReading {
+    readonly Activity: number;
+    readonly Confidence: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IActivitySensorReading: abstract new (...args: any[]) => IActivitySensorReading;
+
+  interface IActivitySensorReadingChangeReport {
+    readonly Reading: Windows.Devices.Sensors.ActivitySensorReading;
+  }
+  var IActivitySensorReadingChangeReport: abstract new (...args: any[]) => IActivitySensorReadingChangeReport;
+
+  interface IActivitySensorReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.ActivitySensorReading;
+  }
+  var IActivitySensorReadingChangedEventArgs: abstract new (...args: any[]) => IActivitySensorReadingChangedEventArgs;
+
+  interface IActivitySensorStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.ActivitySensor>;
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.ActivitySensor>;
+    GetDeviceSelector(): string;
+    GetSystemHistoryAsync(fromTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Sensors.ActivitySensorReading> | Windows.Devices.Sensors.ActivitySensorReading[]>;
+    GetSystemHistoryAsync(fromTime: Windows.Foundation.DateTime, duration: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Sensors.ActivitySensorReading> | Windows.Devices.Sensors.ActivitySensorReading[]>;
+  }
+  var IActivitySensorStatics: abstract new (...args: any[]) => IActivitySensorStatics;
+
+  interface IActivitySensorTriggerDetails {
+    ReadReports(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Sensors.ActivitySensorReadingChangeReport> | Windows.Devices.Sensors.ActivitySensorReadingChangeReport[];
+  }
+  var IActivitySensorTriggerDetails: abstract new (...args: any[]) => IActivitySensorTriggerDetails;
+
+  interface IAdaptiveDimmingOptions {
+    AllowWhenExternalDisplayConnected: boolean;
+  }
+  var IAdaptiveDimmingOptions: abstract new (...args: any[]) => IAdaptiveDimmingOptions;
+
+  interface IAltimeter {
+    GetCurrentReading(): Windows.Devices.Sensors.AltimeterReading;
+    readonly DeviceId: string;
+    readonly MinimumReportInterval: number;
+    ReportInterval: number;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Altimeter, Windows.Devices.Sensors.AltimeterReadingChangedEventArgs> | null;
+  }
+  var IAltimeter: abstract new (...args: any[]) => IAltimeter;
+
+  interface IAltimeter2 {
+    readonly MaxBatchSize: number;
+    ReportLatency: number;
+  }
+  var IAltimeter2: abstract new (...args: any[]) => IAltimeter2;
+
+  interface IAltimeterReading {
+    readonly AltitudeChangeInMeters: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IAltimeterReading: abstract new (...args: any[]) => IAltimeterReading;
+
+  interface IAltimeterReading2 {
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+  var IAltimeterReading2: abstract new (...args: any[]) => IAltimeterReading2;
+
+  interface IAltimeterReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.AltimeterReading;
+  }
+  var IAltimeterReadingChangedEventArgs: abstract new (...args: any[]) => IAltimeterReadingChangedEventArgs;
+
+  interface IAltimeterStatics {
+    GetDefault(): Windows.Devices.Sensors.Altimeter;
+  }
+  var IAltimeterStatics: abstract new (...args: any[]) => IAltimeterStatics;
+
+  interface IBarometer {
+    GetCurrentReading(): Windows.Devices.Sensors.BarometerReading;
+    readonly DeviceId: string;
+    readonly MinimumReportInterval: number;
+    ReportInterval: number;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Barometer, Windows.Devices.Sensors.BarometerReadingChangedEventArgs> | null;
+  }
+  var IBarometer: abstract new (...args: any[]) => IBarometer;
+
+  interface IBarometer2 {
+    readonly MaxBatchSize: number;
+    ReportLatency: number;
+  }
+  var IBarometer2: abstract new (...args: any[]) => IBarometer2;
+
+  interface IBarometer3 {
+    readonly ReportThreshold: Windows.Devices.Sensors.BarometerDataThreshold;
+  }
+  var IBarometer3: abstract new (...args: any[]) => IBarometer3;
+
+  interface IBarometerDataThreshold {
+    Hectopascals: number;
+  }
+  var IBarometerDataThreshold: abstract new (...args: any[]) => IBarometerDataThreshold;
+
+  interface IBarometerReading {
+    readonly StationPressureInHectopascals: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IBarometerReading: abstract new (...args: any[]) => IBarometerReading;
+
+  interface IBarometerReading2 {
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+  var IBarometerReading2: abstract new (...args: any[]) => IBarometerReading2;
+
+  interface IBarometerReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.BarometerReading;
+  }
+  var IBarometerReadingChangedEventArgs: abstract new (...args: any[]) => IBarometerReadingChangedEventArgs;
+
+  interface IBarometerStatics {
+    GetDefault(): Windows.Devices.Sensors.Barometer;
+  }
+  var IBarometerStatics: abstract new (...args: any[]) => IBarometerStatics;
+
+  interface IBarometerStatics2 {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.Barometer>;
+    GetDeviceSelector(): string;
+  }
+  var IBarometerStatics2: abstract new (...args: any[]) => IBarometerStatics2;
+
+  interface ICompass {
+    GetCurrentReading(): Windows.Devices.Sensors.CompassReading;
+    readonly MinimumReportInterval: number;
+    ReportInterval: number;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Compass, Windows.Devices.Sensors.CompassReadingChangedEventArgs> | null;
+  }
+  var ICompass: abstract new (...args: any[]) => ICompass;
+
+  interface ICompass2 {
+    ReadingTransform: number;
+  }
+  var ICompass2: abstract new (...args: any[]) => ICompass2;
+
+  interface ICompass3 {
+    readonly MaxBatchSize: number;
+    ReportLatency: number;
+  }
+  var ICompass3: abstract new (...args: any[]) => ICompass3;
+
+  interface ICompass4 {
+    readonly ReportThreshold: Windows.Devices.Sensors.CompassDataThreshold;
+  }
+  var ICompass4: abstract new (...args: any[]) => ICompass4;
+
+  interface ICompassDataThreshold {
+    Degrees: number;
+  }
+  var ICompassDataThreshold: abstract new (...args: any[]) => ICompassDataThreshold;
+
+  interface ICompassDeviceId {
+    readonly DeviceId: string;
+  }
+  var ICompassDeviceId: abstract new (...args: any[]) => ICompassDeviceId;
+
+  interface ICompassReading {
+    readonly HeadingMagneticNorth: number;
+    readonly HeadingTrueNorth: number | null;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var ICompassReading: abstract new (...args: any[]) => ICompassReading;
+
+  interface ICompassReading2 {
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+  var ICompassReading2: abstract new (...args: any[]) => ICompassReading2;
+
+  interface ICompassReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.CompassReading;
+  }
+  var ICompassReadingChangedEventArgs: abstract new (...args: any[]) => ICompassReadingChangedEventArgs;
+
+  interface ICompassReadingHeadingAccuracy {
+    readonly HeadingAccuracy: number;
+  }
+  var ICompassReadingHeadingAccuracy: abstract new (...args: any[]) => ICompassReadingHeadingAccuracy;
+
+  interface ICompassStatics {
+    GetDefault(): Windows.Devices.Sensors.Compass;
+  }
+  var ICompassStatics: abstract new (...args: any[]) => ICompassStatics;
+
+  interface ICompassStatics2 {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.Compass>;
+    GetDeviceSelector(): string;
+  }
+  var ICompassStatics2: abstract new (...args: any[]) => ICompassStatics2;
+
+  interface IDetectedPerson {
+    readonly DistanceInMillimeters: number | null;
+    readonly Engagement: number;
+    readonly HeadOrientation: Windows.Devices.Sensors.HeadOrientation;
+    readonly HeadPosition: Windows.Devices.Sensors.HeadPosition;
+    readonly PersonId: number | null;
+  }
+  var IDetectedPerson: abstract new (...args: any[]) => IDetectedPerson;
+
+  interface IGyrometer {
+    GetCurrentReading(): Windows.Devices.Sensors.GyrometerReading;
+    readonly MinimumReportInterval: number;
+    ReportInterval: number;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Gyrometer, Windows.Devices.Sensors.GyrometerReadingChangedEventArgs> | null;
+  }
+  var IGyrometer: abstract new (...args: any[]) => IGyrometer;
+
+  interface IGyrometer2 {
+    ReadingTransform: number;
+  }
+  var IGyrometer2: abstract new (...args: any[]) => IGyrometer2;
+
+  interface IGyrometer3 {
+    readonly MaxBatchSize: number;
+    ReportLatency: number;
+  }
+  var IGyrometer3: abstract new (...args: any[]) => IGyrometer3;
+
+  interface IGyrometer4 {
+    readonly ReportThreshold: Windows.Devices.Sensors.GyrometerDataThreshold;
+  }
+  var IGyrometer4: abstract new (...args: any[]) => IGyrometer4;
+
+  interface IGyrometerDataThreshold {
+    XAxisInDegreesPerSecond: number;
+    YAxisInDegreesPerSecond: number;
+    ZAxisInDegreesPerSecond: number;
+  }
+  var IGyrometerDataThreshold: abstract new (...args: any[]) => IGyrometerDataThreshold;
+
+  interface IGyrometerDeviceId {
+    readonly DeviceId: string;
+  }
+  var IGyrometerDeviceId: abstract new (...args: any[]) => IGyrometerDeviceId;
+
+  interface IGyrometerReading {
+    readonly AngularVelocityX: number;
+    readonly AngularVelocityY: number;
+    readonly AngularVelocityZ: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IGyrometerReading: abstract new (...args: any[]) => IGyrometerReading;
+
+  interface IGyrometerReading2 {
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+  var IGyrometerReading2: abstract new (...args: any[]) => IGyrometerReading2;
+
+  interface IGyrometerReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.GyrometerReading;
+  }
+  var IGyrometerReadingChangedEventArgs: abstract new (...args: any[]) => IGyrometerReadingChangedEventArgs;
+
+  interface IGyrometerStatics {
+    GetDefault(): Windows.Devices.Sensors.Gyrometer;
+  }
+  var IGyrometerStatics: abstract new (...args: any[]) => IGyrometerStatics;
+
+  interface IGyrometerStatics2 {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.Gyrometer>;
+    GetDeviceSelector(): string;
+  }
+  var IGyrometerStatics2: abstract new (...args: any[]) => IGyrometerStatics2;
+
+  interface IHeadOrientation {
+    readonly PitchInDegrees: number | null;
+    readonly RollInDegrees: number | null;
+    readonly YawInDegrees: number | null;
+  }
+  var IHeadOrientation: abstract new (...args: any[]) => IHeadOrientation;
+
+  interface IHeadPosition {
+    readonly AltitudeInDegrees: number | null;
+    readonly AzimuthInDegrees: number | null;
+  }
+  var IHeadPosition: abstract new (...args: any[]) => IHeadPosition;
+
+  interface IHingeAngleReading {
+    readonly AngleInDegrees: number;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IHingeAngleReading: abstract new (...args: any[]) => IHingeAngleReading;
+
+  interface IHingeAngleSensor {
+    GetCurrentReadingAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.HingeAngleReading>;
+    readonly DeviceId: string;
+    readonly MinReportThresholdInDegrees: number;
+    ReportThresholdInDegrees: number;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.HingeAngleSensor, Windows.Devices.Sensors.HingeAngleSensorReadingChangedEventArgs> | null;
+  }
+  var IHingeAngleSensor: abstract new (...args: any[]) => IHingeAngleSensor;
+
+  interface IHingeAngleSensorReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.HingeAngleReading;
+  }
+  var IHingeAngleSensorReadingChangedEventArgs: abstract new (...args: any[]) => IHingeAngleSensorReadingChangedEventArgs;
+
+  interface IHingeAngleSensorStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.HingeAngleSensor>;
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.HingeAngleSensor>;
+    GetDeviceSelector(): string;
+    GetRelatedToAdjacentPanelsAsync(firstPanelId: string, secondPanelId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.HingeAngleSensor>;
+  }
+  var IHingeAngleSensorStatics: abstract new (...args: any[]) => IHingeAngleSensorStatics;
+
+  interface IHumanPresenceFeatures {
+    readonly IsAttentionAwareDimmingSupported: boolean;
+    readonly IsLockOnLeaveSupported: boolean;
+    readonly IsWakeOnApproachSupported: boolean;
+    readonly SensorId: string;
+    readonly SupportedWakeOrLockDistancesInMillimeters: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IHumanPresenceFeatures: abstract new (...args: any[]) => IHumanPresenceFeatures;
+
+  interface IHumanPresenceFeatures2 {
+    readonly IsAdaptiveDimmingSupported: boolean;
+  }
+  var IHumanPresenceFeatures2: abstract new (...args: any[]) => IHumanPresenceFeatures2;
+
+  interface IHumanPresenceFeatures3 {
+    readonly IsOnlookerDetectionSupported: boolean;
+  }
+  var IHumanPresenceFeatures3: abstract new (...args: any[]) => IHumanPresenceFeatures3;
+
+  interface IHumanPresenceSensor {
+    GetCurrentReading(): Windows.Devices.Sensors.HumanPresenceSensorReading;
+    readonly DeviceId: string;
+    readonly MaxDetectableDistanceInMillimeters: number | null;
+    readonly MinDetectableDistanceInMillimeters: number | null;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.HumanPresenceSensor, Windows.Devices.Sensors.HumanPresenceSensorReadingChangedEventArgs> | null;
+  }
+  var IHumanPresenceSensor: abstract new (...args: any[]) => IHumanPresenceSensor;
+
+  interface IHumanPresenceSensor2 {
+    readonly IsEngagementSupported: boolean;
+    readonly IsPresenceSupported: boolean;
+  }
+  var IHumanPresenceSensor2: abstract new (...args: any[]) => IHumanPresenceSensor2;
+
+  interface IHumanPresenceSensor3 {
+    readonly MaxDetectableAltitudeInDegrees: number | null;
+    readonly MaxDetectableAzimuthInDegrees: number | null;
+    readonly MaxDetectablePersons: number;
+    readonly MinDetectableAltitudeInDegrees: number | null;
+    readonly MinDetectableAzimuthInDegrees: number | null;
+  }
+  var IHumanPresenceSensor3: abstract new (...args: any[]) => IHumanPresenceSensor3;
+
+  interface IHumanPresenceSensorExtension {
+    Initialize(deviceInterface: string): void;
+    ProcessReading(reading: Windows.Devices.Sensors.HumanPresenceSensorReading): Windows.Devices.Sensors.HumanPresenceSensorReadingUpdate;
+    ProcessReadingTimeoutExpired(reading: Windows.Devices.Sensors.HumanPresenceSensorReading): void;
+    Reset(): void;
+    Start(): void;
+    Stop(): void;
+    Uninitialize(): void;
+  }
+  var IHumanPresenceSensorExtension: abstract new (...args: any[]) => IHumanPresenceSensorExtension;
+
+  interface IHumanPresenceSensorReading {
+    readonly DistanceInMillimeters: number | null;
+    readonly Engagement: number;
+    readonly Presence: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IHumanPresenceSensorReading: abstract new (...args: any[]) => IHumanPresenceSensorReading;
+
+  interface IHumanPresenceSensorReading2 {
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+  var IHumanPresenceSensorReading2: abstract new (...args: any[]) => IHumanPresenceSensorReading2;
+
+  interface IHumanPresenceSensorReading3 {
+    readonly DetectedPersons: Windows.Foundation.Collections.IVectorView<Windows.Devices.Sensors.DetectedPerson> | Windows.Devices.Sensors.DetectedPerson[];
+    readonly OnlookerPresence: number;
+  }
+  var IHumanPresenceSensorReading3: abstract new (...args: any[]) => IHumanPresenceSensorReading3;
+
+  interface IHumanPresenceSensorReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.HumanPresenceSensorReading;
+  }
+  var IHumanPresenceSensorReadingChangedEventArgs: abstract new (...args: any[]) => IHumanPresenceSensorReadingChangedEventArgs;
+
+  interface IHumanPresenceSensorReadingUpdate {
+    DistanceInMillimeters: number | null;
+    Engagement: number | null;
+    Presence: number | null;
+    Timestamp: Windows.Foundation.DateTime | null;
+  }
+  var IHumanPresenceSensorReadingUpdate: abstract new (...args: any[]) => IHumanPresenceSensorReadingUpdate;
+
+  interface IHumanPresenceSensorReadingUpdate2 {
+    OnlookerPresence: number | null;
+  }
+  var IHumanPresenceSensorReadingUpdate2: abstract new (...args: any[]) => IHumanPresenceSensorReadingUpdate2;
+
+  interface IHumanPresenceSensorStatics {
+    FromIdAsync(sensorId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.HumanPresenceSensor>;
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.HumanPresenceSensor>;
+    GetDeviceSelector(): string;
+  }
+  var IHumanPresenceSensorStatics: abstract new (...args: any[]) => IHumanPresenceSensorStatics;
+
+  interface IHumanPresenceSensorStatics2 {
+    FromId(sensorId: string): Windows.Devices.Sensors.HumanPresenceSensor;
+    GetDefault(): Windows.Devices.Sensors.HumanPresenceSensor;
+  }
+  var IHumanPresenceSensorStatics2: abstract new (...args: any[]) => IHumanPresenceSensorStatics2;
+
+  interface IHumanPresenceSettings {
+    IsAttentionAwareDimmingEnabled: boolean;
+    IsLockOnLeaveEnabled: boolean;
+    IsWakeOnApproachEnabled: boolean;
+    LockOnLeaveDistanceInMillimeters: number | null;
+    LockOnLeaveTimeout: Windows.Foundation.TimeSpan;
+    SensorId: string;
+    WakeOnApproachDistanceInMillimeters: number | null;
+  }
+  var IHumanPresenceSettings: abstract new (...args: any[]) => IHumanPresenceSettings;
+
+  interface IHumanPresenceSettings2 {
+    readonly DimmingOptions: Windows.Devices.Sensors.AdaptiveDimmingOptions;
+    IsAdaptiveDimmingEnabled: boolean;
+    readonly LockOptions: Windows.Devices.Sensors.LockOnLeaveOptions;
+    readonly WakeOptions: Windows.Devices.Sensors.WakeOnApproachOptions;
+  }
+  var IHumanPresenceSettings2: abstract new (...args: any[]) => IHumanPresenceSettings2;
+
+  interface IHumanPresenceSettings3 {
+    IsOnlookerDetectionEnabled: boolean;
+    readonly OnlookerDetectionOptions: Windows.Devices.Sensors.OnlookerDetectionOptions;
+  }
+  var IHumanPresenceSettings3: abstract new (...args: any[]) => IHumanPresenceSettings3;
+
+  interface IHumanPresenceSettingsStatics {
+    GetCurrentSettings(): Windows.Devices.Sensors.HumanPresenceSettings;
+    GetCurrentSettingsAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.HumanPresenceSettings>;
+    GetSupportedFeaturesForSensorId(sensorId: string): Windows.Devices.Sensors.HumanPresenceFeatures;
+    GetSupportedFeaturesForSensorIdAsync(sensorId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.HumanPresenceFeatures>;
+    GetSupportedLockOnLeaveTimeouts(): Windows.Foundation.Collections.IVectorView<Windows.Foundation.TimeSpan> | Windows.Foundation.TimeSpan[];
+    UpdateSettings(settings: Windows.Devices.Sensors.HumanPresenceSettings): void;
+    UpdateSettingsAsync(settings: Windows.Devices.Sensors.HumanPresenceSettings): Windows.Foundation.IAsyncAction;
+    SettingsChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IHumanPresenceSettingsStatics: abstract new (...args: any[]) => IHumanPresenceSettingsStatics;
+
+  interface IInclinometer {
+    GetCurrentReading(): Windows.Devices.Sensors.InclinometerReading;
+    readonly MinimumReportInterval: number;
+    ReportInterval: number;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Inclinometer, Windows.Devices.Sensors.InclinometerReadingChangedEventArgs> | null;
+  }
+  var IInclinometer: abstract new (...args: any[]) => IInclinometer;
+
+  interface IInclinometer2 {
+    ReadingTransform: number;
+    readonly ReadingType: number;
+  }
+  var IInclinometer2: abstract new (...args: any[]) => IInclinometer2;
+
+  interface IInclinometer3 {
+    readonly MaxBatchSize: number;
+    ReportLatency: number;
+  }
+  var IInclinometer3: abstract new (...args: any[]) => IInclinometer3;
+
+  interface IInclinometer4 {
+    readonly ReportThreshold: Windows.Devices.Sensors.InclinometerDataThreshold;
+  }
+  var IInclinometer4: abstract new (...args: any[]) => IInclinometer4;
+
+  interface IInclinometerDataThreshold {
+    PitchInDegrees: number;
+    RollInDegrees: number;
+    YawInDegrees: number;
+  }
+  var IInclinometerDataThreshold: abstract new (...args: any[]) => IInclinometerDataThreshold;
+
+  interface IInclinometerDeviceId {
+    readonly DeviceId: string;
+  }
+  var IInclinometerDeviceId: abstract new (...args: any[]) => IInclinometerDeviceId;
+
+  interface IInclinometerReading {
+    readonly PitchDegrees: number;
+    readonly RollDegrees: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+    readonly YawDegrees: number;
+  }
+  var IInclinometerReading: abstract new (...args: any[]) => IInclinometerReading;
+
+  interface IInclinometerReading2 {
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+  var IInclinometerReading2: abstract new (...args: any[]) => IInclinometerReading2;
+
+  interface IInclinometerReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.InclinometerReading;
+  }
+  var IInclinometerReadingChangedEventArgs: abstract new (...args: any[]) => IInclinometerReadingChangedEventArgs;
+
+  interface IInclinometerReadingYawAccuracy {
+    readonly YawAccuracy: number;
+  }
+  var IInclinometerReadingYawAccuracy: abstract new (...args: any[]) => IInclinometerReadingYawAccuracy;
+
+  interface IInclinometerStatics {
+    GetDefault(): Windows.Devices.Sensors.Inclinometer;
+  }
+  var IInclinometerStatics: abstract new (...args: any[]) => IInclinometerStatics;
+
+  interface IInclinometerStatics2 {
+    GetDefaultForRelativeReadings(): Windows.Devices.Sensors.Inclinometer;
+  }
+  var IInclinometerStatics2: abstract new (...args: any[]) => IInclinometerStatics2;
+
+  interface IInclinometerStatics3 {
+    GetDefault(sensorReadingtype: number): Windows.Devices.Sensors.Inclinometer;
+  }
+  var IInclinometerStatics3: abstract new (...args: any[]) => IInclinometerStatics3;
+
+  interface IInclinometerStatics4 {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.Inclinometer>;
+    GetDeviceSelector(readingType: number): string;
+  }
+  var IInclinometerStatics4: abstract new (...args: any[]) => IInclinometerStatics4;
+
+  interface ILightSensor {
+    GetCurrentReading(): Windows.Devices.Sensors.LightSensorReading;
+    readonly MinimumReportInterval: number;
+    ReportInterval: number;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.LightSensor, Windows.Devices.Sensors.LightSensorReadingChangedEventArgs> | null;
+  }
+  var ILightSensor: abstract new (...args: any[]) => ILightSensor;
+
+  interface ILightSensor2 {
+    readonly MaxBatchSize: number;
+    ReportLatency: number;
+  }
+  var ILightSensor2: abstract new (...args: any[]) => ILightSensor2;
+
+  interface ILightSensor3 {
+    readonly ReportThreshold: Windows.Devices.Sensors.LightSensorDataThreshold;
+  }
+  var ILightSensor3: abstract new (...args: any[]) => ILightSensor3;
+
+  interface ILightSensor4 {
+    IsChromaticitySupported(): boolean;
+  }
+  var ILightSensor4: abstract new (...args: any[]) => ILightSensor4;
+
+  interface ILightSensorDataThreshold {
+    AbsoluteLux: number;
+    LuxPercentage: number;
+  }
+  var ILightSensorDataThreshold: abstract new (...args: any[]) => ILightSensorDataThreshold;
+
+  interface ILightSensorDataThreshold2 {
+    Chromaticity: Windows.Devices.Sensors.LightSensorChromaticity;
+  }
+  var ILightSensorDataThreshold2: abstract new (...args: any[]) => ILightSensorDataThreshold2;
+
+  interface ILightSensorDeviceId {
+    readonly DeviceId: string;
+  }
+  var ILightSensorDeviceId: abstract new (...args: any[]) => ILightSensorDeviceId;
+
+  interface ILightSensorReading {
+    readonly IlluminanceInLux: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var ILightSensorReading: abstract new (...args: any[]) => ILightSensorReading;
+
+  interface ILightSensorReading2 {
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+  var ILightSensorReading2: abstract new (...args: any[]) => ILightSensorReading2;
+
+  interface ILightSensorReading3 {
+    readonly Chromaticity: Windows.Devices.Sensors.LightSensorChromaticity;
+  }
+  var ILightSensorReading3: abstract new (...args: any[]) => ILightSensorReading3;
+
+  interface ILightSensorReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.LightSensorReading;
+  }
+  var ILightSensorReadingChangedEventArgs: abstract new (...args: any[]) => ILightSensorReadingChangedEventArgs;
+
+  interface ILightSensorStatics {
+    GetDefault(): Windows.Devices.Sensors.LightSensor;
+  }
+  var ILightSensorStatics: abstract new (...args: any[]) => ILightSensorStatics;
+
+  interface ILightSensorStatics2 {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.LightSensor>;
+    GetDeviceSelector(): string;
+  }
+  var ILightSensorStatics2: abstract new (...args: any[]) => ILightSensorStatics2;
+
+  interface ILockOnLeaveOptions {
+    AllowWhenExternalDisplayConnected: boolean;
+  }
+  var ILockOnLeaveOptions: abstract new (...args: any[]) => ILockOnLeaveOptions;
+
+  interface IMagnetometer {
+    GetCurrentReading(): Windows.Devices.Sensors.MagnetometerReading;
+    readonly MinimumReportInterval: number;
+    ReportInterval: number;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Magnetometer, Windows.Devices.Sensors.MagnetometerReadingChangedEventArgs> | null;
+  }
+  var IMagnetometer: abstract new (...args: any[]) => IMagnetometer;
+
+  interface IMagnetometer2 {
+    ReadingTransform: number;
+  }
+  var IMagnetometer2: abstract new (...args: any[]) => IMagnetometer2;
+
+  interface IMagnetometer3 {
+    readonly MaxBatchSize: number;
+    ReportLatency: number;
+  }
+  var IMagnetometer3: abstract new (...args: any[]) => IMagnetometer3;
+
+  interface IMagnetometer4 {
+    readonly ReportThreshold: Windows.Devices.Sensors.MagnetometerDataThreshold;
+  }
+  var IMagnetometer4: abstract new (...args: any[]) => IMagnetometer4;
+
+  interface IMagnetometerDataThreshold {
+    XAxisMicroteslas: number;
+    YAxisMicroteslas: number;
+    ZAxisMicroteslas: number;
+  }
+  var IMagnetometerDataThreshold: abstract new (...args: any[]) => IMagnetometerDataThreshold;
+
+  interface IMagnetometerDeviceId {
+    readonly DeviceId: string;
+  }
+  var IMagnetometerDeviceId: abstract new (...args: any[]) => IMagnetometerDeviceId;
+
+  interface IMagnetometerReading {
+    readonly DirectionalAccuracy: number;
+    readonly MagneticFieldX: number;
+    readonly MagneticFieldY: number;
+    readonly MagneticFieldZ: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IMagnetometerReading: abstract new (...args: any[]) => IMagnetometerReading;
+
+  interface IMagnetometerReading2 {
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+  var IMagnetometerReading2: abstract new (...args: any[]) => IMagnetometerReading2;
+
+  interface IMagnetometerReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.MagnetometerReading;
+  }
+  var IMagnetometerReadingChangedEventArgs: abstract new (...args: any[]) => IMagnetometerReadingChangedEventArgs;
+
+  interface IMagnetometerStatics {
+    GetDefault(): Windows.Devices.Sensors.Magnetometer;
+  }
+  var IMagnetometerStatics: abstract new (...args: any[]) => IMagnetometerStatics;
+
+  interface IMagnetometerStatics2 {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.Magnetometer>;
+    GetDeviceSelector(): string;
+  }
+  var IMagnetometerStatics2: abstract new (...args: any[]) => IMagnetometerStatics2;
+
+  interface IOnlookerDetectionOptions {
+    Action: number;
+    BackOnMode: number;
+  }
+  var IOnlookerDetectionOptions: abstract new (...args: any[]) => IOnlookerDetectionOptions;
+
+  interface IOrientationSensor {
+    GetCurrentReading(): Windows.Devices.Sensors.OrientationSensorReading;
+    readonly MinimumReportInterval: number;
+    ReportInterval: number;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.OrientationSensor, Windows.Devices.Sensors.OrientationSensorReadingChangedEventArgs> | null;
+  }
+  var IOrientationSensor: abstract new (...args: any[]) => IOrientationSensor;
+
+  interface IOrientationSensor2 {
+    ReadingTransform: number;
+    readonly ReadingType: number;
+  }
+  var IOrientationSensor2: abstract new (...args: any[]) => IOrientationSensor2;
+
+  interface IOrientationSensor3 {
+    readonly MaxBatchSize: number;
+    ReportLatency: number;
+  }
+  var IOrientationSensor3: abstract new (...args: any[]) => IOrientationSensor3;
+
+  interface IOrientationSensorDeviceId {
+    readonly DeviceId: string;
+  }
+  var IOrientationSensorDeviceId: abstract new (...args: any[]) => IOrientationSensorDeviceId;
+
+  interface IOrientationSensorReading {
+    readonly Quaternion: Windows.Devices.Sensors.SensorQuaternion;
+    readonly RotationMatrix: Windows.Devices.Sensors.SensorRotationMatrix;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IOrientationSensorReading: abstract new (...args: any[]) => IOrientationSensorReading;
+
+  interface IOrientationSensorReading2 {
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+  var IOrientationSensorReading2: abstract new (...args: any[]) => IOrientationSensorReading2;
+
+  interface IOrientationSensorReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.OrientationSensorReading;
+  }
+  var IOrientationSensorReadingChangedEventArgs: abstract new (...args: any[]) => IOrientationSensorReadingChangedEventArgs;
+
+  interface IOrientationSensorReadingYawAccuracy {
+    readonly YawAccuracy: number;
+  }
+  var IOrientationSensorReadingYawAccuracy: abstract new (...args: any[]) => IOrientationSensorReadingYawAccuracy;
+
+  interface IOrientationSensorStatics {
+    GetDefault(): Windows.Devices.Sensors.OrientationSensor;
+  }
+  var IOrientationSensorStatics: abstract new (...args: any[]) => IOrientationSensorStatics;
+
+  interface IOrientationSensorStatics2 {
+    GetDefaultForRelativeReadings(): Windows.Devices.Sensors.OrientationSensor;
+  }
+  var IOrientationSensorStatics2: abstract new (...args: any[]) => IOrientationSensorStatics2;
+
+  interface IOrientationSensorStatics3 {
+    GetDefault(sensorReadingtype: number): Windows.Devices.Sensors.OrientationSensor;
+    GetDefault(sensorReadingType: number, optimizationGoal: number): Windows.Devices.Sensors.OrientationSensor;
+  }
+  var IOrientationSensorStatics3: abstract new (...args: any[]) => IOrientationSensorStatics3;
+
+  interface IOrientationSensorStatics4 {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.OrientationSensor>;
+    GetDeviceSelector(readingType: number): string;
+    GetDeviceSelector(readingType: number, optimizationGoal: number): string;
+  }
+  var IOrientationSensorStatics4: abstract new (...args: any[]) => IOrientationSensorStatics4;
+
+  interface IPedometer {
+    readonly DeviceId: string;
+    readonly MinimumReportInterval: number;
+    readonly PowerInMilliwatts: number;
+    ReportInterval: number;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Pedometer, Windows.Devices.Sensors.PedometerReadingChangedEventArgs> | null;
+  }
+  var IPedometer: abstract new (...args: any[]) => IPedometer;
+
+  interface IPedometer2 {
+    GetCurrentReadings(): Windows.Foundation.Collections.IMapView<number, Windows.Devices.Sensors.PedometerReading>;
+  }
+  var IPedometer2: abstract new (...args: any[]) => IPedometer2;
+
+  interface IPedometerDataThresholdFactory {
+    Create(sensor: Windows.Devices.Sensors.Pedometer, stepGoal: number): Windows.Devices.Sensors.PedometerDataThreshold;
+  }
+  var IPedometerDataThresholdFactory: abstract new (...args: any[]) => IPedometerDataThresholdFactory;
+
+  interface IPedometerReading {
+    readonly CumulativeSteps: number;
+    readonly CumulativeStepsDuration: Windows.Foundation.TimeSpan;
+    readonly StepKind: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IPedometerReading: abstract new (...args: any[]) => IPedometerReading;
+
+  interface IPedometerReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.PedometerReading;
+  }
+  var IPedometerReadingChangedEventArgs: abstract new (...args: any[]) => IPedometerReadingChangedEventArgs;
+
+  interface IPedometerStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.Pedometer>;
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.Pedometer>;
+    GetDeviceSelector(): string;
+    GetSystemHistoryAsync(fromTime: Windows.Foundation.DateTime): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Sensors.PedometerReading> | Windows.Devices.Sensors.PedometerReading[]>;
+    GetSystemHistoryAsync(fromTime: Windows.Foundation.DateTime, duration: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Sensors.PedometerReading> | Windows.Devices.Sensors.PedometerReading[]>;
+  }
+  var IPedometerStatics: abstract new (...args: any[]) => IPedometerStatics;
+
+  interface IPedometerStatics2 {
+    GetReadingsFromTriggerDetails(triggerDetails: Windows.Devices.Sensors.SensorDataThresholdTriggerDetails): Windows.Foundation.Collections.IVectorView<Windows.Devices.Sensors.PedometerReading> | Windows.Devices.Sensors.PedometerReading[];
+  }
+  var IPedometerStatics2: abstract new (...args: any[]) => IPedometerStatics2;
+
+  interface IProximitySensor {
+    CreateDisplayOnOffController(): Windows.Devices.Sensors.ProximitySensorDisplayOnOffController;
+    GetCurrentReading(): Windows.Devices.Sensors.ProximitySensorReading;
+    readonly DeviceId: string;
+    readonly MaxDistanceInMillimeters: number | null;
+    readonly MinDistanceInMillimeters: number | null;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.ProximitySensor, Windows.Devices.Sensors.ProximitySensorReadingChangedEventArgs> | null;
+  }
+  var IProximitySensor: abstract new (...args: any[]) => IProximitySensor;
+
+  interface IProximitySensorDataThresholdFactory {
+    Create(sensor: Windows.Devices.Sensors.ProximitySensor): Windows.Devices.Sensors.ProximitySensorDataThreshold;
+  }
+  var IProximitySensorDataThresholdFactory: abstract new (...args: any[]) => IProximitySensorDataThresholdFactory;
+
+  interface IProximitySensorReading {
+    readonly DistanceInMillimeters: number | null;
+    readonly IsDetected: boolean;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IProximitySensorReading: abstract new (...args: any[]) => IProximitySensorReading;
+
+  interface IProximitySensorReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.ProximitySensorReading;
+  }
+  var IProximitySensorReadingChangedEventArgs: abstract new (...args: any[]) => IProximitySensorReadingChangedEventArgs;
+
+  interface IProximitySensorStatics {
+    FromId(sensorId: string): Windows.Devices.Sensors.ProximitySensor;
+    GetDeviceSelector(): string;
+  }
+  var IProximitySensorStatics: abstract new (...args: any[]) => IProximitySensorStatics;
+
+  interface IProximitySensorStatics2 {
+    GetReadingsFromTriggerDetails(triggerDetails: Windows.Devices.Sensors.SensorDataThresholdTriggerDetails): Windows.Foundation.Collections.IVectorView<Windows.Devices.Sensors.ProximitySensorReading> | Windows.Devices.Sensors.ProximitySensorReading[];
+  }
+  var IProximitySensorStatics2: abstract new (...args: any[]) => IProximitySensorStatics2;
+
+  interface ISensorDataThreshold {
+  }
+  var ISensorDataThreshold: abstract new (...args: any[]) => ISensorDataThreshold;
+
+  interface ISensorDataThresholdTriggerDetails {
+    readonly DeviceId: string;
+    readonly SensorType: number;
+  }
+  var ISensorDataThresholdTriggerDetails: abstract new (...args: any[]) => ISensorDataThresholdTriggerDetails;
+
+  interface ISensorQuaternion {
+    readonly W: number;
+    readonly X: number;
+    readonly Y: number;
+    readonly Z: number;
+  }
+  var ISensorQuaternion: abstract new (...args: any[]) => ISensorQuaternion;
+
+  interface ISensorRotationMatrix {
+    readonly M11: number;
+    readonly M12: number;
+    readonly M13: number;
+    readonly M21: number;
+    readonly M22: number;
+    readonly M23: number;
+    readonly M31: number;
+    readonly M32: number;
+    readonly M33: number;
+  }
+  var ISensorRotationMatrix: abstract new (...args: any[]) => ISensorRotationMatrix;
+
+  interface ISimpleOrientationSensor {
+    GetCurrentOrientation(): number;
+    OrientationChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.SimpleOrientationSensor, Windows.Devices.Sensors.SimpleOrientationSensorOrientationChangedEventArgs> | null;
+  }
+  var ISimpleOrientationSensor: abstract new (...args: any[]) => ISimpleOrientationSensor;
+
+  interface ISimpleOrientationSensor2 {
+    ReadingTransform: number;
+  }
+  var ISimpleOrientationSensor2: abstract new (...args: any[]) => ISimpleOrientationSensor2;
+
+  interface ISimpleOrientationSensorDeviceId {
+    readonly DeviceId: string;
+  }
+  var ISimpleOrientationSensorDeviceId: abstract new (...args: any[]) => ISimpleOrientationSensorDeviceId;
+
+  interface ISimpleOrientationSensorOrientationChangedEventArgs {
+    readonly Orientation: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var ISimpleOrientationSensorOrientationChangedEventArgs: abstract new (...args: any[]) => ISimpleOrientationSensorOrientationChangedEventArgs;
+
+  interface ISimpleOrientationSensorStatics {
+    GetDefault(): Windows.Devices.Sensors.SimpleOrientationSensor;
+  }
+  var ISimpleOrientationSensorStatics: abstract new (...args: any[]) => ISimpleOrientationSensorStatics;
+
+  interface ISimpleOrientationSensorStatics2 {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.SimpleOrientationSensor>;
+    GetDeviceSelector(): string;
+  }
+  var ISimpleOrientationSensorStatics2: abstract new (...args: any[]) => ISimpleOrientationSensorStatics2;
+
+  interface IWakeOnApproachOptions {
+    AllowWhenExternalDisplayConnected: boolean;
+    DisableWhenBatterySaverOn: boolean;
+  }
+  var IWakeOnApproachOptions: abstract new (...args: any[]) => IWakeOnApproachOptions;
+
+  interface LightSensorChromaticity {
+    X: number;
+    Y: number;
+  }
+  var LightSensorChromaticity: {
+    new(x: number, y: number): LightSensorChromaticity;
+    new(fields: { X?: number; Y?: number }): LightSensorChromaticity;
+  };
+
+}
+
+declare namespace Windows.Devices.Sensors.Custom {
+  class CustomSensor implements Windows.Devices.Sensors.Custom.ICustomSensor, Windows.Devices.Sensors.Custom.ICustomSensor2 {
+    static FromIdAsync(sensorId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.Custom.CustomSensor>;
+    GetCurrentReading(): Windows.Devices.Sensors.Custom.CustomSensorReading;
+    static GetDeviceSelector(interfaceId: Guid): string;
+    readonly DeviceId: string;
+    readonly MaxBatchSize: number;
+    readonly MinimumReportInterval: number;
+    ReportInterval: number;
+    ReportLatency: number;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Custom.CustomSensor, Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs> | null;
+  }
+
+  class CustomSensorReading implements Windows.Devices.Sensors.Custom.ICustomSensorReading, Windows.Devices.Sensors.Custom.ICustomSensorReading2 {
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class CustomSensorReadingChangedEventArgs implements Windows.Devices.Sensors.Custom.ICustomSensorReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.Custom.CustomSensorReading;
+  }
+
+  interface ICustomSensor {
+    GetCurrentReading(): Windows.Devices.Sensors.Custom.CustomSensorReading;
+    readonly DeviceId: string;
+    readonly MinimumReportInterval: number;
+    ReportInterval: number;
+    ReadingChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sensors.Custom.CustomSensor, Windows.Devices.Sensors.Custom.CustomSensorReadingChangedEventArgs> | null;
+  }
+  var ICustomSensor: abstract new (...args: any[]) => ICustomSensor;
+
+  interface ICustomSensor2 {
+    readonly MaxBatchSize: number;
+    ReportLatency: number;
+  }
+  var ICustomSensor2: abstract new (...args: any[]) => ICustomSensor2;
+
+  interface ICustomSensorReading {
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var ICustomSensorReading: abstract new (...args: any[]) => ICustomSensorReading;
+
+  interface ICustomSensorReading2 {
+    readonly PerformanceCount: Windows.Foundation.TimeSpan | null;
+  }
+  var ICustomSensorReading2: abstract new (...args: any[]) => ICustomSensorReading2;
+
+  interface ICustomSensorReadingChangedEventArgs {
+    readonly Reading: Windows.Devices.Sensors.Custom.CustomSensorReading;
+  }
+  var ICustomSensorReadingChangedEventArgs: abstract new (...args: any[]) => ICustomSensorReadingChangedEventArgs;
+
+  interface ICustomSensorStatics {
+    FromIdAsync(sensorId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sensors.Custom.CustomSensor>;
+    GetDeviceSelector(interfaceId: Guid): string;
+  }
+  var ICustomSensorStatics: abstract new (...args: any[]) => ICustomSensorStatics;
+
+}
+
+declare namespace Windows.Devices.SerialCommunication {
+  class ErrorReceivedEventArgs implements Windows.Devices.SerialCommunication.IErrorReceivedEventArgs {
+    readonly Error: number;
+  }
+
+  class PinChangedEventArgs implements Windows.Devices.SerialCommunication.IPinChangedEventArgs {
+    readonly PinChange: number;
+  }
+
+  class SerialDevice implements Windows.Devices.SerialCommunication.ISerialDevice, Windows.Foundation.IClosable {
+    Close(): void;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.SerialCommunication.SerialDevice>;
+    static GetDeviceSelector(): string;
+    static GetDeviceSelector(portName: string): string;
+    static GetDeviceSelectorFromUsbVidPid(vendorId: number, productId: number): string;
+    BaudRate: number;
+    BreakSignalState: boolean;
+    readonly BytesReceived: number;
+    readonly CarrierDetectState: boolean;
+    readonly ClearToSendState: boolean;
+    DataBits: number;
+    readonly DataSetReadyState: boolean;
+    Handshake: number;
+    readonly InputStream: Windows.Storage.Streams.IInputStream;
+    IsDataTerminalReadyEnabled: boolean;
+    IsRequestToSendEnabled: boolean;
+    readonly OutputStream: Windows.Storage.Streams.IOutputStream;
+    Parity: number;
+    readonly PortName: string;
+    ReadTimeout: Windows.Foundation.TimeSpan;
+    StopBits: number;
+    readonly UsbProductId: number;
+    readonly UsbVendorId: number;
+    WriteTimeout: Windows.Foundation.TimeSpan;
+    ErrorReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.SerialCommunication.SerialDevice, Windows.Devices.SerialCommunication.ErrorReceivedEventArgs> | null;
+    PinChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.SerialCommunication.SerialDevice, Windows.Devices.SerialCommunication.PinChangedEventArgs> | null;
+  }
+
+  enum SerialError {
+    Frame = 0,
+    BufferOverrun = 1,
+    ReceiveFull = 2,
+    ReceiveParity = 3,
+    TransmitFull = 4,
+  }
+
+  enum SerialHandshake {
+    None = 0,
+    RequestToSend = 1,
+    XOnXOff = 2,
+    RequestToSendXOnXOff = 3,
+  }
+
+  enum SerialParity {
+    None = 0,
+    Odd = 1,
+    Even = 2,
+    Mark = 3,
+    Space = 4,
+  }
+
+  enum SerialPinChange {
+    BreakSignal = 0,
+    CarrierDetect = 1,
+    ClearToSend = 2,
+    DataSetReady = 3,
+    RingIndicator = 4,
+  }
+
+  enum SerialStopBitCount {
+    One = 0,
+    OnePointFive = 1,
+    Two = 2,
+  }
+
+  interface IErrorReceivedEventArgs {
+    readonly Error: number;
+  }
+  var IErrorReceivedEventArgs: abstract new (...args: any[]) => IErrorReceivedEventArgs;
+
+  interface IPinChangedEventArgs {
+    readonly PinChange: number;
+  }
+  var IPinChangedEventArgs: abstract new (...args: any[]) => IPinChangedEventArgs;
+
+  interface ISerialDevice extends Windows.Foundation.IClosable {
+    Close(): void;
+    BaudRate: number;
+    BreakSignalState: boolean;
+    readonly BytesReceived: number;
+    readonly CarrierDetectState: boolean;
+    readonly ClearToSendState: boolean;
+    DataBits: number;
+    readonly DataSetReadyState: boolean;
+    Handshake: number;
+    readonly InputStream: Windows.Storage.Streams.IInputStream;
+    IsDataTerminalReadyEnabled: boolean;
+    IsRequestToSendEnabled: boolean;
+    readonly OutputStream: Windows.Storage.Streams.IOutputStream;
+    Parity: number;
+    readonly PortName: string;
+    ReadTimeout: Windows.Foundation.TimeSpan;
+    StopBits: number;
+    readonly UsbProductId: number;
+    readonly UsbVendorId: number;
+    WriteTimeout: Windows.Foundation.TimeSpan;
+    ErrorReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.SerialCommunication.SerialDevice, Windows.Devices.SerialCommunication.ErrorReceivedEventArgs> | null;
+    PinChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.SerialCommunication.SerialDevice, Windows.Devices.SerialCommunication.PinChangedEventArgs> | null;
+  }
+  var ISerialDevice: abstract new (...args: any[]) => ISerialDevice;
+
+  interface ISerialDeviceStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.SerialCommunication.SerialDevice>;
+    GetDeviceSelector(): string;
+    GetDeviceSelector(portName: string): string;
+    GetDeviceSelectorFromUsbVidPid(vendorId: number, productId: number): string;
+  }
+  var ISerialDeviceStatics: abstract new (...args: any[]) => ISerialDeviceStatics;
+
+}
+
+declare namespace Windows.Devices.SmartCards {
+  class CardAddedEventArgs implements Windows.Devices.SmartCards.ICardAddedEventArgs {
+    readonly SmartCard: Windows.Devices.SmartCards.SmartCard;
+  }
+
+  class CardRemovedEventArgs implements Windows.Devices.SmartCards.ICardRemovedEventArgs {
+    readonly SmartCard: Windows.Devices.SmartCards.SmartCard;
+  }
+
+  class KnownSmartCardAppletIds {
+    static readonly PaymentSystemEnvironment: Windows.Storage.Streams.IBuffer;
+    static readonly ProximityPaymentSystemEnvironment: Windows.Storage.Streams.IBuffer;
+  }
+
+  class SmartCard implements Windows.Devices.SmartCards.ISmartCard, Windows.Devices.SmartCards.ISmartCardConnect {
+    ConnectAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardConnection>;
+    GetAnswerToResetAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    GetStatusAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly Reader: Windows.Devices.SmartCards.SmartCardReader;
+  }
+
+  class SmartCardAppletIdGroup implements Windows.Devices.SmartCards.ISmartCardAppletIdGroup, Windows.Devices.SmartCards.ISmartCardAppletIdGroup2 {
+    constructor(displayName: string, appletIds: Windows.Foundation.Collections.IVector<Windows.Storage.Streams.IBuffer> | Windows.Storage.Streams.IBuffer[], emulationCategory: number, emulationType: number);
+    constructor();
+    readonly AppletIds: Windows.Foundation.Collections.IVector<Windows.Storage.Streams.IBuffer> | Windows.Storage.Streams.IBuffer[];
+    AutomaticEnablement: boolean;
+    Description: string;
+    DisplayName: string;
+    Logo: Windows.Storage.Streams.IRandomAccessStreamReference;
+    static readonly MaxAppletIds: number;
+    readonly Properties: Windows.Foundation.Collections.ValueSet;
+    SecureUserAuthenticationRequired: boolean;
+    SmartCardEmulationCategory: number;
+    SmartCardEmulationType: number;
+  }
+
+  class SmartCardAppletIdGroupRegistration implements Windows.Devices.SmartCards.ISmartCardAppletIdGroupRegistration, Windows.Devices.SmartCards.ISmartCardAppletIdGroupRegistration2 {
+    RequestActivationPolicyChangeAsync(policy: number): Windows.Foundation.IAsyncOperation<number>;
+    SetAutomaticResponseApdusAsync(apdus: Windows.Foundation.Collections.IIterable<Windows.Devices.SmartCards.SmartCardAutomaticResponseApdu> | Windows.Devices.SmartCards.SmartCardAutomaticResponseApdu[]): Windows.Foundation.IAsyncAction;
+    SetPropertiesAsync(props: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncAction;
+    readonly ActivationPolicy: number;
+    readonly AppletIdGroup: Windows.Devices.SmartCards.SmartCardAppletIdGroup;
+    readonly Id: Guid;
+    readonly SmartCardReaderId: string;
+  }
+
+  class SmartCardAutomaticResponseApdu implements Windows.Devices.SmartCards.ISmartCardAutomaticResponseApdu, Windows.Devices.SmartCards.ISmartCardAutomaticResponseApdu2, Windows.Devices.SmartCards.ISmartCardAutomaticResponseApdu3 {
+    constructor(commandApdu: Windows.Storage.Streams.IBuffer, responseApdu: Windows.Storage.Streams.IBuffer);
+    AllowWhenCryptogramGeneratorNotPrepared: boolean;
+    AppletId: Windows.Storage.Streams.IBuffer;
+    CommandApdu: Windows.Storage.Streams.IBuffer;
+    CommandApduBitMask: Windows.Storage.Streams.IBuffer;
+    InputState: number | null;
+    OutputState: number | null;
+    ResponseApdu: Windows.Storage.Streams.IBuffer;
+    ShouldMatchLength: boolean;
+  }
+
+  class SmartCardChallengeContext implements Windows.Devices.SmartCards.ISmartCardChallengeContext, Windows.Foundation.IClosable {
+    ChangeAdministrativeKeyAsync(response: Windows.Storage.Streams.IBuffer, newAdministrativeKey: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncAction;
+    Close(): void;
+    ProvisionAsync(response: Windows.Storage.Streams.IBuffer, formatCard: boolean): Windows.Foundation.IAsyncAction;
+    ProvisionAsync(response: Windows.Storage.Streams.IBuffer, formatCard: boolean, newCardId: Guid): Windows.Foundation.IAsyncAction;
+    VerifyResponseAsync(response: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Challenge: Windows.Storage.Streams.IBuffer;
+  }
+
+  class SmartCardConnection implements Windows.Devices.SmartCards.ISmartCardConnection, Windows.Foundation.IClosable {
+    Close(): void;
+    TransmitAsync(command: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+  }
+
+  class SmartCardCryptogramGenerator implements Windows.Devices.SmartCards.ISmartCardCryptogramGenerator, Windows.Devices.SmartCards.ISmartCardCryptogramGenerator2 {
+    CreateCryptogramMaterialStorageKeyAsync(promptingBehavior: number, storageKeyName: string, algorithm: number, capabilities: number): Windows.Foundation.IAsyncOperation<number>;
+    DeleteCryptogramMaterialPackageAsync(materialPackageName: string): Windows.Foundation.IAsyncOperation<number>;
+    DeleteCryptogramMaterialStorageKeyAsync(storageKeyName: string): Windows.Foundation.IAsyncOperation<number>;
+    GetAllCryptogramMaterialCharacteristicsAsync(promptingBehavior: number, materialPackageName: string): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult>;
+    GetAllCryptogramMaterialPackageCharacteristicsAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult>;
+    GetAllCryptogramMaterialPackageCharacteristicsAsync(storageKeyName: string): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult>;
+    GetAllCryptogramStorageKeyCharacteristicsAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult>;
+    static GetSmartCardCryptogramGeneratorAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardCryptogramGenerator>;
+    ImportCryptogramMaterialPackageAsync(format: number, storageKeyName: string, materialPackageName: string, cryptogramMaterialPackage: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<number>;
+    static IsSupported(): boolean;
+    RequestCryptogramMaterialStorageKeyInfoAsync(promptingBehavior: number, storageKeyName: string, format: number): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardCryptogramStorageKeyInfo>;
+    RequestUnlockCryptogramMaterialForUseAsync(promptingBehavior: number): Windows.Foundation.IAsyncOperation<number>;
+    TryProvePossessionOfCryptogramMaterialPackageAsync(promptingBehavior: number, responseFormat: number, materialPackageName: string, materialName: string, challenge: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardCryptogramMaterialPossessionProof>;
+    ValidateRequestApduAsync(promptingBehavior: number, apduToValidate: Windows.Storage.Streams.IBuffer, cryptogramPlacementSteps: Windows.Foundation.Collections.IIterable<Windows.Devices.SmartCards.SmartCardCryptogramPlacementStep> | Windows.Devices.SmartCards.SmartCardCryptogramPlacementStep[]): Windows.Foundation.IAsyncOperation<number>;
+    readonly SupportedCryptogramAlgorithms: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedCryptogramMaterialPackageConfirmationResponseFormats: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedCryptogramMaterialPackageFormats: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedCryptogramMaterialTypes: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedSmartCardCryptogramStorageKeyCapabilities: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult implements Windows.Devices.SmartCards.ISmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult {
+    constructor();
+    readonly Characteristics: Windows.Foundation.Collections.IVectorView<Windows.Devices.SmartCards.SmartCardCryptogramMaterialCharacteristics> | Windows.Devices.SmartCards.SmartCardCryptogramMaterialCharacteristics[];
+    readonly OperationStatus: number;
+  }
+
+  class SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult implements Windows.Devices.SmartCards.ISmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult {
+    constructor();
+    readonly Characteristics: Windows.Foundation.Collections.IVectorView<Windows.Devices.SmartCards.SmartCardCryptogramMaterialPackageCharacteristics> | Windows.Devices.SmartCards.SmartCardCryptogramMaterialPackageCharacteristics[];
+    readonly OperationStatus: number;
+  }
+
+  class SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult implements Windows.Devices.SmartCards.ISmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult {
+    constructor();
+    readonly Characteristics: Windows.Foundation.Collections.IVectorView<Windows.Devices.SmartCards.SmartCardCryptogramStorageKeyCharacteristics> | Windows.Devices.SmartCards.SmartCardCryptogramStorageKeyCharacteristics[];
+    readonly OperationStatus: number;
+  }
+
+  class SmartCardCryptogramMaterialCharacteristics implements Windows.Devices.SmartCards.ISmartCardCryptogramMaterialCharacteristics {
+    constructor();
+    readonly AllowedAlgorithms: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly AllowedProofOfPossessionAlgorithms: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly AllowedValidations: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly MaterialLength: number;
+    readonly MaterialName: string;
+    readonly MaterialType: number;
+    readonly ProtectionMethod: number;
+    readonly ProtectionVersion: number;
+  }
+
+  class SmartCardCryptogramMaterialPackageCharacteristics implements Windows.Devices.SmartCards.ISmartCardCryptogramMaterialPackageCharacteristics {
+    constructor();
+    readonly DateImported: Windows.Foundation.DateTime;
+    readonly PackageFormat: number;
+    readonly PackageName: string;
+    readonly StorageKeyName: string;
+  }
+
+  class SmartCardCryptogramMaterialPossessionProof implements Windows.Devices.SmartCards.ISmartCardCryptogramMaterialPossessionProof {
+    readonly OperationStatus: number;
+    readonly Proof: Windows.Storage.Streams.IBuffer;
+  }
+
+  class SmartCardCryptogramPlacementStep implements Windows.Devices.SmartCards.ISmartCardCryptogramPlacementStep {
+    constructor();
+    Algorithm: number;
+    ChainedOutputStep: Windows.Devices.SmartCards.SmartCardCryptogramPlacementStep;
+    CryptogramLength: number;
+    CryptogramMaterialName: string;
+    CryptogramMaterialPackageName: string;
+    CryptogramOffset: number;
+    CryptogramPlacementOptions: number;
+    SourceData: Windows.Storage.Streams.IBuffer;
+    TemplateOffset: number;
+  }
+
+  class SmartCardCryptogramStorageKeyCharacteristics implements Windows.Devices.SmartCards.ISmartCardCryptogramStorageKeyCharacteristics {
+    constructor();
+    readonly Algorithm: number;
+    readonly Capabilities: number;
+    readonly DateCreated: Windows.Foundation.DateTime;
+    readonly StorageKeyName: string;
+  }
+
+  class SmartCardCryptogramStorageKeyInfo implements Windows.Devices.SmartCards.ISmartCardCryptogramStorageKeyInfo, Windows.Devices.SmartCards.ISmartCardCryptogramStorageKeyInfo2 {
+    readonly Attestation: Windows.Storage.Streams.IBuffer;
+    readonly AttestationCertificateChain: Windows.Storage.Streams.IBuffer;
+    readonly AttestationStatus: number;
+    readonly Capabilities: number;
+    readonly OperationStatus: number;
+    readonly OperationalRequirements: string;
+    readonly PublicKey: Windows.Storage.Streams.IBuffer;
+    readonly PublicKeyBlobType: number;
+  }
+
+  class SmartCardEmulator implements Windows.Devices.SmartCards.ISmartCardEmulator, Windows.Devices.SmartCards.ISmartCardEmulator2 {
+    static GetAppletIdGroupRegistrationsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.SmartCards.SmartCardAppletIdGroupRegistration> | Windows.Devices.SmartCards.SmartCardAppletIdGroupRegistration[]>;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardEmulator>;
+    IsHostCardEmulationSupported(): boolean;
+    static IsSupported(): boolean;
+    static RegisterAppletIdGroupAsync(appletIdGroup: Windows.Devices.SmartCards.SmartCardAppletIdGroup): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardAppletIdGroupRegistration>;
+    Start(): void;
+    static UnregisterAppletIdGroupAsync(registration: Windows.Devices.SmartCards.SmartCardAppletIdGroupRegistration): Windows.Foundation.IAsyncAction;
+    readonly EnablementPolicy: number;
+    static readonly MaxAppletIdGroupRegistrations: number;
+    ApduReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.SmartCards.SmartCardEmulator, Windows.Devices.SmartCards.SmartCardEmulatorApduReceivedEventArgs> | null;
+    ConnectionDeactivated: Windows.Foundation.TypedEventHandler<Windows.Devices.SmartCards.SmartCardEmulator, Windows.Devices.SmartCards.SmartCardEmulatorConnectionDeactivatedEventArgs> | null;
+  }
+
+  class SmartCardEmulatorApduReceivedEventArgs implements Windows.Devices.SmartCards.ISmartCardEmulatorApduReceivedEventArgs, Windows.Devices.SmartCards.ISmartCardEmulatorApduReceivedEventArgs2, Windows.Devices.SmartCards.ISmartCardEmulatorApduReceivedEventArgsWithCryptograms {
+    TryRespondAsync(responseApdu: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<boolean>;
+    TryRespondAsync(responseApdu: Windows.Storage.Streams.IBuffer, nextState: number | null): Windows.Foundation.IAsyncOperation<boolean>;
+    TryRespondWithCryptogramsAsync(responseTemplate: Windows.Storage.Streams.IBuffer, cryptogramPlacementSteps: Windows.Foundation.Collections.IIterable<Windows.Devices.SmartCards.SmartCardCryptogramPlacementStep> | Windows.Devices.SmartCards.SmartCardCryptogramPlacementStep[]): Windows.Foundation.IAsyncOperation<number>;
+    TryRespondWithCryptogramsAsync(responseTemplate: Windows.Storage.Streams.IBuffer, cryptogramPlacementSteps: Windows.Foundation.Collections.IIterable<Windows.Devices.SmartCards.SmartCardCryptogramPlacementStep> | Windows.Devices.SmartCards.SmartCardCryptogramPlacementStep[], nextState: number | null): Windows.Foundation.IAsyncOperation<number>;
+    readonly AutomaticResponseStatus: number;
+    readonly CommandApdu: Windows.Storage.Streams.IBuffer;
+    readonly ConnectionProperties: Windows.Devices.SmartCards.SmartCardEmulatorConnectionProperties;
+    readonly State: number;
+  }
+
+  class SmartCardEmulatorConnectionDeactivatedEventArgs implements Windows.Devices.SmartCards.ISmartCardEmulatorConnectionDeactivatedEventArgs {
+    readonly ConnectionProperties: Windows.Devices.SmartCards.SmartCardEmulatorConnectionProperties;
+    readonly Reason: number;
+  }
+
+  class SmartCardEmulatorConnectionProperties implements Windows.Devices.SmartCards.ISmartCardEmulatorConnectionProperties {
+    readonly Id: Guid;
+    readonly Source: number;
+  }
+
+  class SmartCardPinPolicy implements Windows.Devices.SmartCards.ISmartCardPinPolicy {
+    constructor();
+    Digits: number;
+    LowercaseLetters: number;
+    MaxLength: number;
+    MinLength: number;
+    SpecialCharacters: number;
+    UppercaseLetters: number;
+  }
+
+  class SmartCardPinResetDeferral implements Windows.Devices.SmartCards.ISmartCardPinResetDeferral {
+    Complete(): void;
+  }
+
+  class SmartCardPinResetRequest implements Windows.Devices.SmartCards.ISmartCardPinResetRequest {
+    GetDeferral(): Windows.Devices.SmartCards.SmartCardPinResetDeferral;
+    SetResponse(response: Windows.Storage.Streams.IBuffer): void;
+    readonly Challenge: Windows.Storage.Streams.IBuffer;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+
+  class SmartCardProvisioning implements Windows.Devices.SmartCards.ISmartCardProvisioning, Windows.Devices.SmartCards.ISmartCardProvisioning2 {
+    static FromSmartCardAsync(card: Windows.Devices.SmartCards.SmartCard): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardProvisioning>;
+    GetAuthorityKeyContainerNameAsync(): Windows.Foundation.IAsyncOperation<string>;
+    GetChallengeContextAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardChallengeContext>;
+    GetIdAsync(): Windows.Foundation.IAsyncOperation<Guid>;
+    GetNameAsync(): Windows.Foundation.IAsyncOperation<string>;
+    static RequestAttestedVirtualSmartCardCreationAsync(friendlyName: string, administrativeKey: Windows.Storage.Streams.IBuffer, pinPolicy: Windows.Devices.SmartCards.SmartCardPinPolicy): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardProvisioning>;
+    static RequestAttestedVirtualSmartCardCreationAsync(friendlyName: string, administrativeKey: Windows.Storage.Streams.IBuffer, pinPolicy: Windows.Devices.SmartCards.SmartCardPinPolicy, cardId: Guid): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardProvisioning>;
+    RequestPinChangeAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestPinResetAsync(handler: Windows.Devices.SmartCards.SmartCardPinResetHandler): Windows.Foundation.IAsyncOperation<boolean>;
+    static RequestVirtualSmartCardCreationAsync(friendlyName: string, administrativeKey: Windows.Storage.Streams.IBuffer, pinPolicy: Windows.Devices.SmartCards.SmartCardPinPolicy): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardProvisioning>;
+    static RequestVirtualSmartCardCreationAsync(friendlyName: string, administrativeKey: Windows.Storage.Streams.IBuffer, pinPolicy: Windows.Devices.SmartCards.SmartCardPinPolicy, cardId: Guid): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardProvisioning>;
+    static RequestVirtualSmartCardDeletionAsync(card: Windows.Devices.SmartCards.SmartCard): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly SmartCard: Windows.Devices.SmartCards.SmartCard;
+  }
+
+  class SmartCardReader implements Windows.Devices.SmartCards.ISmartCardReader {
+    FindAllCardsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.SmartCards.SmartCard> | Windows.Devices.SmartCards.SmartCard[]>;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardReader>;
+    static GetDeviceSelector(): string;
+    static GetDeviceSelector(kind: number): string;
+    GetStatusAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly DeviceId: string;
+    readonly Kind: number;
+    readonly Name: string;
+    CardAdded: Windows.Foundation.TypedEventHandler<Windows.Devices.SmartCards.SmartCardReader, Windows.Devices.SmartCards.CardAddedEventArgs> | null;
+    CardRemoved: Windows.Foundation.TypedEventHandler<Windows.Devices.SmartCards.SmartCardReader, Windows.Devices.SmartCards.CardRemovedEventArgs> | null;
+  }
+
+  class SmartCardTriggerDetails implements Windows.Devices.SmartCards.ISmartCardTriggerDetails, Windows.Devices.SmartCards.ISmartCardTriggerDetails2, Windows.Devices.SmartCards.ISmartCardTriggerDetails3 {
+    TryLaunchCurrentAppAsync(arguments_: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryLaunchCurrentAppAsync(arguments_: string, behavior: number): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Emulator: Windows.Devices.SmartCards.SmartCardEmulator;
+    readonly SmartCard: Windows.Devices.SmartCards.SmartCard;
+    readonly SourceAppletId: Windows.Storage.Streams.IBuffer;
+    readonly TriggerData: Windows.Storage.Streams.IBuffer;
+    readonly TriggerType: number;
+  }
+
+  enum SmartCardActivationPolicyChangeResult {
+    Denied = 0,
+    Allowed = 1,
+  }
+
+  enum SmartCardAppletIdGroupActivationPolicy {
+    Disabled = 0,
+    ForegroundOverride = 1,
+    Enabled = 2,
+  }
+
+  enum SmartCardAutomaticResponseStatus {
+    None = 0,
+    Success = 1,
+    UnknownError = 2,
+  }
+
+  enum SmartCardCryptogramAlgorithm {
+    None = 0,
+    CbcMac = 1,
+    Cvc3Umd = 2,
+    DecimalizedMsd = 3,
+    Cvc3MD = 4,
+    Sha1 = 5,
+    SignedDynamicApplicationData = 6,
+    RsaPkcs1 = 7,
+    Sha256Hmac = 8,
+  }
+
+  enum 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,
+  }
+
+  enum SmartCardCryptogramMaterialPackageConfirmationResponseFormat {
+    None = 0,
+    VisaHmac = 1,
+  }
+
+  enum SmartCardCryptogramMaterialPackageFormat {
+    None = 0,
+    JweRsaPki = 1,
+  }
+
+  enum SmartCardCryptogramMaterialProtectionMethod {
+    None = 0,
+    WhiteBoxing = 1,
+  }
+
+  enum SmartCardCryptogramMaterialType {
+    None = 0,
+    StaticDataAuthentication = 1,
+    TripleDes112 = 2,
+    Aes = 3,
+    RsaPkcs1 = 4,
+  }
+
+  enum SmartCardCryptogramPlacementOptions {
+    None = 0,
+    UnitsAreInNibbles = 1,
+    ChainOutput = 2,
+  }
+
+  enum SmartCardCryptogramStorageKeyAlgorithm {
+    None = 0,
+    Rsa2048 = 1,
+  }
+
+  enum SmartCardCryptogramStorageKeyCapabilities {
+    None = 0,
+    HardwareProtection = 1,
+    UnlockPrompt = 2,
+  }
+
+  enum SmartCardCryptographicKeyAttestationStatus {
+    NoAttestation = 0,
+    SoftwareKeyWithoutTpm = 1,
+    SoftwareKeyWithTpm = 2,
+    TpmKeyUnknownAttestationStatus = 3,
+    TpmKeyWithoutAttestationCapability = 4,
+    TpmKeyWithTemporaryAttestationFailure = 5,
+    TpmKeyWithLongTermAttestationFailure = 6,
+    TpmKeyWithAttestation = 7,
+  }
+
+  enum SmartCardEmulationCategory {
+    Other = 0,
+    Payment = 1,
+  }
+
+  enum SmartCardEmulationType {
+    Host = 0,
+    Uicc = 1,
+    EmbeddedSE = 2,
+  }
+
+  enum SmartCardEmulatorConnectionDeactivatedReason {
+    ConnectionLost = 0,
+    ConnectionRedirected = 1,
+  }
+
+  enum SmartCardEmulatorConnectionSource {
+    Unknown = 0,
+    NfcReader = 1,
+  }
+
+  enum SmartCardEmulatorEnablementPolicy {
+    Never = 0,
+    Always = 1,
+    ScreenOn = 2,
+    ScreenUnlocked = 3,
+  }
+
+  enum SmartCardLaunchBehavior {
+    Default = 0,
+    AboveLock = 1,
+  }
+
+  enum SmartCardPinCharacterPolicyOption {
+    Allow = 0,
+    RequireAtLeastOne = 1,
+    Disallow = 2,
+  }
+
+  enum SmartCardReaderKind {
+    Any = 0,
+    Generic = 1,
+    Tpm = 2,
+    Nfc = 3,
+    Uicc = 4,
+    EmbeddedSE = 5,
+  }
+
+  enum SmartCardReaderStatus {
+    Disconnected = 0,
+    Ready = 1,
+    Exclusive = 2,
+  }
+
+  enum SmartCardStatus {
+    Disconnected = 0,
+    Ready = 1,
+    Shared = 2,
+    Exclusive = 3,
+    Unresponsive = 4,
+  }
+
+  enum SmartCardTriggerType {
+    EmulatorTransaction = 0,
+    EmulatorNearFieldEntry = 1,
+    EmulatorNearFieldExit = 2,
+    EmulatorHostApplicationActivated = 3,
+    EmulatorAppletIdGroupRegistrationChanged = 4,
+    ReaderCardAdded = 5,
+  }
+
+  enum SmartCardUnlockPromptingBehavior {
+    AllowUnlockPrompt = 0,
+    RequireUnlockPrompt = 1,
+    PreventUnlockPrompt = 2,
+  }
+
+  interface ICardAddedEventArgs {
+    readonly SmartCard: Windows.Devices.SmartCards.SmartCard;
+  }
+  var ICardAddedEventArgs: abstract new (...args: any[]) => ICardAddedEventArgs;
+
+  interface ICardRemovedEventArgs {
+    readonly SmartCard: Windows.Devices.SmartCards.SmartCard;
+  }
+  var ICardRemovedEventArgs: abstract new (...args: any[]) => ICardRemovedEventArgs;
+
+  interface IKnownSmartCardAppletIds {
+    readonly PaymentSystemEnvironment: Windows.Storage.Streams.IBuffer;
+    readonly ProximityPaymentSystemEnvironment: Windows.Storage.Streams.IBuffer;
+  }
+  var IKnownSmartCardAppletIds: abstract new (...args: any[]) => IKnownSmartCardAppletIds;
+
+  interface ISmartCard {
+    GetAnswerToResetAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    GetStatusAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly Reader: Windows.Devices.SmartCards.SmartCardReader;
+  }
+  var ISmartCard: abstract new (...args: any[]) => ISmartCard;
+
+  interface ISmartCardAppletIdGroup {
+    readonly AppletIds: Windows.Foundation.Collections.IVector<Windows.Storage.Streams.IBuffer> | Windows.Storage.Streams.IBuffer[];
+    AutomaticEnablement: boolean;
+    DisplayName: string;
+    SmartCardEmulationCategory: number;
+    SmartCardEmulationType: number;
+  }
+  var ISmartCardAppletIdGroup: abstract new (...args: any[]) => ISmartCardAppletIdGroup;
+
+  interface ISmartCardAppletIdGroup2 {
+    Description: string;
+    Logo: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly Properties: Windows.Foundation.Collections.ValueSet;
+    SecureUserAuthenticationRequired: boolean;
+  }
+  var ISmartCardAppletIdGroup2: abstract new (...args: any[]) => ISmartCardAppletIdGroup2;
+
+  interface ISmartCardAppletIdGroupFactory {
+    Create(displayName: string, appletIds: Windows.Foundation.Collections.IVector<Windows.Storage.Streams.IBuffer> | Windows.Storage.Streams.IBuffer[], emulationCategory: number, emulationType: number): Windows.Devices.SmartCards.SmartCardAppletIdGroup;
+  }
+  var ISmartCardAppletIdGroupFactory: abstract new (...args: any[]) => ISmartCardAppletIdGroupFactory;
+
+  interface ISmartCardAppletIdGroupRegistration {
+    RequestActivationPolicyChangeAsync(policy: number): Windows.Foundation.IAsyncOperation<number>;
+    SetAutomaticResponseApdusAsync(apdus: Windows.Foundation.Collections.IIterable<Windows.Devices.SmartCards.SmartCardAutomaticResponseApdu> | Windows.Devices.SmartCards.SmartCardAutomaticResponseApdu[]): Windows.Foundation.IAsyncAction;
+    readonly ActivationPolicy: number;
+    readonly AppletIdGroup: Windows.Devices.SmartCards.SmartCardAppletIdGroup;
+    readonly Id: Guid;
+  }
+  var ISmartCardAppletIdGroupRegistration: abstract new (...args: any[]) => ISmartCardAppletIdGroupRegistration;
+
+  interface ISmartCardAppletIdGroupRegistration2 {
+    SetPropertiesAsync(props: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncAction;
+    readonly SmartCardReaderId: string;
+  }
+  var ISmartCardAppletIdGroupRegistration2: abstract new (...args: any[]) => ISmartCardAppletIdGroupRegistration2;
+
+  interface ISmartCardAppletIdGroupStatics {
+    readonly MaxAppletIds: number;
+  }
+  var ISmartCardAppletIdGroupStatics: abstract new (...args: any[]) => ISmartCardAppletIdGroupStatics;
+
+  interface ISmartCardAutomaticResponseApdu {
+    AppletId: Windows.Storage.Streams.IBuffer;
+    CommandApdu: Windows.Storage.Streams.IBuffer;
+    CommandApduBitMask: Windows.Storage.Streams.IBuffer;
+    ResponseApdu: Windows.Storage.Streams.IBuffer;
+    ShouldMatchLength: boolean;
+  }
+  var ISmartCardAutomaticResponseApdu: abstract new (...args: any[]) => ISmartCardAutomaticResponseApdu;
+
+  interface ISmartCardAutomaticResponseApdu2 {
+    InputState: number | null;
+    OutputState: number | null;
+  }
+  var ISmartCardAutomaticResponseApdu2: abstract new (...args: any[]) => ISmartCardAutomaticResponseApdu2;
+
+  interface ISmartCardAutomaticResponseApdu3 {
+    AllowWhenCryptogramGeneratorNotPrepared: boolean;
+  }
+  var ISmartCardAutomaticResponseApdu3: abstract new (...args: any[]) => ISmartCardAutomaticResponseApdu3;
+
+  interface ISmartCardAutomaticResponseApduFactory {
+    Create(commandApdu: Windows.Storage.Streams.IBuffer, responseApdu: Windows.Storage.Streams.IBuffer): Windows.Devices.SmartCards.SmartCardAutomaticResponseApdu;
+  }
+  var ISmartCardAutomaticResponseApduFactory: abstract new (...args: any[]) => ISmartCardAutomaticResponseApduFactory;
+
+  interface ISmartCardChallengeContext extends Windows.Foundation.IClosable {
+    ChangeAdministrativeKeyAsync(response: Windows.Storage.Streams.IBuffer, newAdministrativeKey: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncAction;
+    Close(): void;
+    ProvisionAsync(response: Windows.Storage.Streams.IBuffer, formatCard: boolean): Windows.Foundation.IAsyncAction;
+    ProvisionAsync(response: Windows.Storage.Streams.IBuffer, formatCard: boolean, newCardId: Guid): Windows.Foundation.IAsyncAction;
+    VerifyResponseAsync(response: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Challenge: Windows.Storage.Streams.IBuffer;
+  }
+  var ISmartCardChallengeContext: abstract new (...args: any[]) => ISmartCardChallengeContext;
+
+  interface ISmartCardConnect {
+    ConnectAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardConnection>;
+  }
+  var ISmartCardConnect: abstract new (...args: any[]) => ISmartCardConnect;
+
+  interface ISmartCardConnection extends Windows.Foundation.IClosable {
+    Close(): void;
+    TransmitAsync(command: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+  }
+  var ISmartCardConnection: abstract new (...args: any[]) => ISmartCardConnection;
+
+  interface ISmartCardCryptogramGenerator {
+    CreateCryptogramMaterialStorageKeyAsync(promptingBehavior: number, storageKeyName: string, algorithm: number, capabilities: number): Windows.Foundation.IAsyncOperation<number>;
+    DeleteCryptogramMaterialPackageAsync(materialPackageName: string): Windows.Foundation.IAsyncOperation<number>;
+    DeleteCryptogramMaterialStorageKeyAsync(storageKeyName: string): Windows.Foundation.IAsyncOperation<number>;
+    ImportCryptogramMaterialPackageAsync(format: number, storageKeyName: string, materialPackageName: string, cryptogramMaterialPackage: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<number>;
+    RequestCryptogramMaterialStorageKeyInfoAsync(promptingBehavior: number, storageKeyName: string, format: number): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardCryptogramStorageKeyInfo>;
+    RequestUnlockCryptogramMaterialForUseAsync(promptingBehavior: number): Windows.Foundation.IAsyncOperation<number>;
+    TryProvePossessionOfCryptogramMaterialPackageAsync(promptingBehavior: number, responseFormat: number, materialPackageName: string, materialName: string, challenge: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardCryptogramMaterialPossessionProof>;
+    readonly SupportedCryptogramAlgorithms: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedCryptogramMaterialPackageConfirmationResponseFormats: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedCryptogramMaterialPackageFormats: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedCryptogramMaterialTypes: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedSmartCardCryptogramStorageKeyCapabilities: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var ISmartCardCryptogramGenerator: abstract new (...args: any[]) => ISmartCardCryptogramGenerator;
+
+  interface ISmartCardCryptogramGenerator2 {
+    GetAllCryptogramMaterialCharacteristicsAsync(promptingBehavior: number, materialPackageName: string): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult>;
+    GetAllCryptogramMaterialPackageCharacteristicsAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult>;
+    GetAllCryptogramMaterialPackageCharacteristicsAsync(storageKeyName: string): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult>;
+    GetAllCryptogramStorageKeyCharacteristicsAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult>;
+    ValidateRequestApduAsync(promptingBehavior: number, apduToValidate: Windows.Storage.Streams.IBuffer, cryptogramPlacementSteps: Windows.Foundation.Collections.IIterable<Windows.Devices.SmartCards.SmartCardCryptogramPlacementStep> | Windows.Devices.SmartCards.SmartCardCryptogramPlacementStep[]): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var ISmartCardCryptogramGenerator2: abstract new (...args: any[]) => ISmartCardCryptogramGenerator2;
+
+  interface ISmartCardCryptogramGeneratorStatics {
+    GetSmartCardCryptogramGeneratorAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardCryptogramGenerator>;
+  }
+  var ISmartCardCryptogramGeneratorStatics: abstract new (...args: any[]) => ISmartCardCryptogramGeneratorStatics;
+
+  interface ISmartCardCryptogramGeneratorStatics2 {
+    IsSupported(): boolean;
+  }
+  var ISmartCardCryptogramGeneratorStatics2: abstract new (...args: any[]) => ISmartCardCryptogramGeneratorStatics2;
+
+  interface ISmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult {
+    readonly Characteristics: Windows.Foundation.Collections.IVectorView<Windows.Devices.SmartCards.SmartCardCryptogramMaterialCharacteristics> | Windows.Devices.SmartCards.SmartCardCryptogramMaterialCharacteristics[];
+    readonly OperationStatus: number;
+  }
+  var ISmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult: abstract new (...args: any[]) => ISmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult;
+
+  interface ISmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult {
+    readonly Characteristics: Windows.Foundation.Collections.IVectorView<Windows.Devices.SmartCards.SmartCardCryptogramMaterialPackageCharacteristics> | Windows.Devices.SmartCards.SmartCardCryptogramMaterialPackageCharacteristics[];
+    readonly OperationStatus: number;
+  }
+  var ISmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult: abstract new (...args: any[]) => ISmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult;
+
+  interface ISmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult {
+    readonly Characteristics: Windows.Foundation.Collections.IVectorView<Windows.Devices.SmartCards.SmartCardCryptogramStorageKeyCharacteristics> | Windows.Devices.SmartCards.SmartCardCryptogramStorageKeyCharacteristics[];
+    readonly OperationStatus: number;
+  }
+  var ISmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult: abstract new (...args: any[]) => ISmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult;
+
+  interface ISmartCardCryptogramMaterialCharacteristics {
+    readonly AllowedAlgorithms: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly AllowedProofOfPossessionAlgorithms: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly AllowedValidations: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly MaterialLength: number;
+    readonly MaterialName: string;
+    readonly MaterialType: number;
+    readonly ProtectionMethod: number;
+    readonly ProtectionVersion: number;
+  }
+  var ISmartCardCryptogramMaterialCharacteristics: abstract new (...args: any[]) => ISmartCardCryptogramMaterialCharacteristics;
+
+  interface ISmartCardCryptogramMaterialPackageCharacteristics {
+    readonly DateImported: Windows.Foundation.DateTime;
+    readonly PackageFormat: number;
+    readonly PackageName: string;
+    readonly StorageKeyName: string;
+  }
+  var ISmartCardCryptogramMaterialPackageCharacteristics: abstract new (...args: any[]) => ISmartCardCryptogramMaterialPackageCharacteristics;
+
+  interface ISmartCardCryptogramMaterialPossessionProof {
+    readonly OperationStatus: number;
+    readonly Proof: Windows.Storage.Streams.IBuffer;
+  }
+  var ISmartCardCryptogramMaterialPossessionProof: abstract new (...args: any[]) => ISmartCardCryptogramMaterialPossessionProof;
+
+  interface ISmartCardCryptogramPlacementStep {
+    Algorithm: number;
+    ChainedOutputStep: Windows.Devices.SmartCards.SmartCardCryptogramPlacementStep;
+    CryptogramLength: number;
+    CryptogramMaterialName: string;
+    CryptogramMaterialPackageName: string;
+    CryptogramOffset: number;
+    CryptogramPlacementOptions: number;
+    SourceData: Windows.Storage.Streams.IBuffer;
+    TemplateOffset: number;
+  }
+  var ISmartCardCryptogramPlacementStep: abstract new (...args: any[]) => ISmartCardCryptogramPlacementStep;
+
+  interface ISmartCardCryptogramStorageKeyCharacteristics {
+    readonly Algorithm: number;
+    readonly Capabilities: number;
+    readonly DateCreated: Windows.Foundation.DateTime;
+    readonly StorageKeyName: string;
+  }
+  var ISmartCardCryptogramStorageKeyCharacteristics: abstract new (...args: any[]) => ISmartCardCryptogramStorageKeyCharacteristics;
+
+  interface ISmartCardCryptogramStorageKeyInfo {
+    readonly Attestation: Windows.Storage.Streams.IBuffer;
+    readonly AttestationCertificateChain: Windows.Storage.Streams.IBuffer;
+    readonly AttestationStatus: number;
+    readonly Capabilities: number;
+    readonly OperationStatus: number;
+    readonly PublicKey: Windows.Storage.Streams.IBuffer;
+    readonly PublicKeyBlobType: number;
+  }
+  var ISmartCardCryptogramStorageKeyInfo: abstract new (...args: any[]) => ISmartCardCryptogramStorageKeyInfo;
+
+  interface ISmartCardCryptogramStorageKeyInfo2 {
+    readonly OperationalRequirements: string;
+  }
+  var ISmartCardCryptogramStorageKeyInfo2: abstract new (...args: any[]) => ISmartCardCryptogramStorageKeyInfo2;
+
+  interface ISmartCardEmulator {
+    readonly EnablementPolicy: number;
+  }
+  var ISmartCardEmulator: abstract new (...args: any[]) => ISmartCardEmulator;
+
+  interface ISmartCardEmulator2 {
+    IsHostCardEmulationSupported(): boolean;
+    Start(): void;
+    ApduReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.SmartCards.SmartCardEmulator, Windows.Devices.SmartCards.SmartCardEmulatorApduReceivedEventArgs> | null;
+    ConnectionDeactivated: Windows.Foundation.TypedEventHandler<Windows.Devices.SmartCards.SmartCardEmulator, Windows.Devices.SmartCards.SmartCardEmulatorConnectionDeactivatedEventArgs> | null;
+  }
+  var ISmartCardEmulator2: abstract new (...args: any[]) => ISmartCardEmulator2;
+
+  interface ISmartCardEmulatorApduReceivedEventArgs {
+    TryRespondAsync(responseApdu: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly AutomaticResponseStatus: number;
+    readonly CommandApdu: Windows.Storage.Streams.IBuffer;
+    readonly ConnectionProperties: Windows.Devices.SmartCards.SmartCardEmulatorConnectionProperties;
+  }
+  var ISmartCardEmulatorApduReceivedEventArgs: abstract new (...args: any[]) => ISmartCardEmulatorApduReceivedEventArgs;
+
+  interface ISmartCardEmulatorApduReceivedEventArgs2 {
+    TryRespondAsync(responseApdu: Windows.Storage.Streams.IBuffer, nextState: number | null): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly State: number;
+  }
+  var ISmartCardEmulatorApduReceivedEventArgs2: abstract new (...args: any[]) => ISmartCardEmulatorApduReceivedEventArgs2;
+
+  interface ISmartCardEmulatorApduReceivedEventArgsWithCryptograms {
+    TryRespondWithCryptogramsAsync(responseTemplate: Windows.Storage.Streams.IBuffer, cryptogramPlacementSteps: Windows.Foundation.Collections.IIterable<Windows.Devices.SmartCards.SmartCardCryptogramPlacementStep> | Windows.Devices.SmartCards.SmartCardCryptogramPlacementStep[]): Windows.Foundation.IAsyncOperation<number>;
+    TryRespondWithCryptogramsAsync(responseTemplate: Windows.Storage.Streams.IBuffer, cryptogramPlacementSteps: Windows.Foundation.Collections.IIterable<Windows.Devices.SmartCards.SmartCardCryptogramPlacementStep> | Windows.Devices.SmartCards.SmartCardCryptogramPlacementStep[], nextState: number | null): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var ISmartCardEmulatorApduReceivedEventArgsWithCryptograms: abstract new (...args: any[]) => ISmartCardEmulatorApduReceivedEventArgsWithCryptograms;
+
+  interface ISmartCardEmulatorConnectionDeactivatedEventArgs {
+    readonly ConnectionProperties: Windows.Devices.SmartCards.SmartCardEmulatorConnectionProperties;
+    readonly Reason: number;
+  }
+  var ISmartCardEmulatorConnectionDeactivatedEventArgs: abstract new (...args: any[]) => ISmartCardEmulatorConnectionDeactivatedEventArgs;
+
+  interface ISmartCardEmulatorConnectionProperties {
+    readonly Id: Guid;
+    readonly Source: number;
+  }
+  var ISmartCardEmulatorConnectionProperties: abstract new (...args: any[]) => ISmartCardEmulatorConnectionProperties;
+
+  interface ISmartCardEmulatorStatics {
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardEmulator>;
+  }
+  var ISmartCardEmulatorStatics: abstract new (...args: any[]) => ISmartCardEmulatorStatics;
+
+  interface ISmartCardEmulatorStatics2 {
+    GetAppletIdGroupRegistrationsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.SmartCards.SmartCardAppletIdGroupRegistration> | Windows.Devices.SmartCards.SmartCardAppletIdGroupRegistration[]>;
+    RegisterAppletIdGroupAsync(appletIdGroup: Windows.Devices.SmartCards.SmartCardAppletIdGroup): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardAppletIdGroupRegistration>;
+    UnregisterAppletIdGroupAsync(registration: Windows.Devices.SmartCards.SmartCardAppletIdGroupRegistration): Windows.Foundation.IAsyncAction;
+    readonly MaxAppletIdGroupRegistrations: number;
+  }
+  var ISmartCardEmulatorStatics2: abstract new (...args: any[]) => ISmartCardEmulatorStatics2;
+
+  interface ISmartCardEmulatorStatics3 {
+    IsSupported(): boolean;
+  }
+  var ISmartCardEmulatorStatics3: abstract new (...args: any[]) => ISmartCardEmulatorStatics3;
+
+  interface ISmartCardPinPolicy {
+    Digits: number;
+    LowercaseLetters: number;
+    MaxLength: number;
+    MinLength: number;
+    SpecialCharacters: number;
+    UppercaseLetters: number;
+  }
+  var ISmartCardPinPolicy: abstract new (...args: any[]) => ISmartCardPinPolicy;
+
+  interface ISmartCardPinResetDeferral {
+    Complete(): void;
+  }
+  var ISmartCardPinResetDeferral: abstract new (...args: any[]) => ISmartCardPinResetDeferral;
+
+  interface ISmartCardPinResetRequest {
+    GetDeferral(): Windows.Devices.SmartCards.SmartCardPinResetDeferral;
+    SetResponse(response: Windows.Storage.Streams.IBuffer): void;
+    readonly Challenge: Windows.Storage.Streams.IBuffer;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+  var ISmartCardPinResetRequest: abstract new (...args: any[]) => ISmartCardPinResetRequest;
+
+  interface ISmartCardProvisioning {
+    GetChallengeContextAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardChallengeContext>;
+    GetIdAsync(): Windows.Foundation.IAsyncOperation<Guid>;
+    GetNameAsync(): Windows.Foundation.IAsyncOperation<string>;
+    RequestPinChangeAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestPinResetAsync(handler: Windows.Devices.SmartCards.SmartCardPinResetHandler): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly SmartCard: Windows.Devices.SmartCards.SmartCard;
+  }
+  var ISmartCardProvisioning: abstract new (...args: any[]) => ISmartCardProvisioning;
+
+  interface ISmartCardProvisioning2 {
+    GetAuthorityKeyContainerNameAsync(): Windows.Foundation.IAsyncOperation<string>;
+  }
+  var ISmartCardProvisioning2: abstract new (...args: any[]) => ISmartCardProvisioning2;
+
+  interface ISmartCardProvisioningStatics {
+    FromSmartCardAsync(card: Windows.Devices.SmartCards.SmartCard): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardProvisioning>;
+    RequestVirtualSmartCardCreationAsync(friendlyName: string, administrativeKey: Windows.Storage.Streams.IBuffer, pinPolicy: Windows.Devices.SmartCards.SmartCardPinPolicy): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardProvisioning>;
+    RequestVirtualSmartCardCreationAsync(friendlyName: string, administrativeKey: Windows.Storage.Streams.IBuffer, pinPolicy: Windows.Devices.SmartCards.SmartCardPinPolicy, cardId: Guid): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardProvisioning>;
+    RequestVirtualSmartCardDeletionAsync(card: Windows.Devices.SmartCards.SmartCard): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var ISmartCardProvisioningStatics: abstract new (...args: any[]) => ISmartCardProvisioningStatics;
+
+  interface ISmartCardProvisioningStatics2 {
+    RequestAttestedVirtualSmartCardCreationAsync(friendlyName: string, administrativeKey: Windows.Storage.Streams.IBuffer, pinPolicy: Windows.Devices.SmartCards.SmartCardPinPolicy): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardProvisioning>;
+    RequestAttestedVirtualSmartCardCreationAsync(friendlyName: string, administrativeKey: Windows.Storage.Streams.IBuffer, pinPolicy: Windows.Devices.SmartCards.SmartCardPinPolicy, cardId: Guid): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardProvisioning>;
+  }
+  var ISmartCardProvisioningStatics2: abstract new (...args: any[]) => ISmartCardProvisioningStatics2;
+
+  interface ISmartCardReader {
+    FindAllCardsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.SmartCards.SmartCard> | Windows.Devices.SmartCards.SmartCard[]>;
+    GetStatusAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly DeviceId: string;
+    readonly Kind: number;
+    readonly Name: string;
+    CardAdded: Windows.Foundation.TypedEventHandler<Windows.Devices.SmartCards.SmartCardReader, Windows.Devices.SmartCards.CardAddedEventArgs> | null;
+    CardRemoved: Windows.Foundation.TypedEventHandler<Windows.Devices.SmartCards.SmartCardReader, Windows.Devices.SmartCards.CardRemovedEventArgs> | null;
+  }
+  var ISmartCardReader: abstract new (...args: any[]) => ISmartCardReader;
+
+  interface ISmartCardReaderStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.SmartCards.SmartCardReader>;
+    GetDeviceSelector(): string;
+    GetDeviceSelector(kind: number): string;
+  }
+  var ISmartCardReaderStatics: abstract new (...args: any[]) => ISmartCardReaderStatics;
+
+  interface ISmartCardTriggerDetails {
+    readonly SourceAppletId: Windows.Storage.Streams.IBuffer;
+    readonly TriggerData: Windows.Storage.Streams.IBuffer;
+    readonly TriggerType: number;
+  }
+  var ISmartCardTriggerDetails: abstract new (...args: any[]) => ISmartCardTriggerDetails;
+
+  interface ISmartCardTriggerDetails2 {
+    TryLaunchCurrentAppAsync(arguments_: string): Windows.Foundation.IAsyncOperation<boolean>;
+    TryLaunchCurrentAppAsync(arguments_: string, behavior: number): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Emulator: Windows.Devices.SmartCards.SmartCardEmulator;
+  }
+  var ISmartCardTriggerDetails2: abstract new (...args: any[]) => ISmartCardTriggerDetails2;
+
+  interface ISmartCardTriggerDetails3 {
+    readonly SmartCard: Windows.Devices.SmartCards.SmartCard;
+  }
+  var ISmartCardTriggerDetails3: abstract new (...args: any[]) => ISmartCardTriggerDetails3;
+
+  interface SmartCardBackgroundTriggerContract {
+  }
+  var SmartCardBackgroundTriggerContract: {
+    new(fields: {  }): SmartCardBackgroundTriggerContract;
+  };
+
+  interface SmartCardEmulatorContract {
+  }
+  var SmartCardEmulatorContract: {
+    new(fields: {  }): SmartCardEmulatorContract;
+  };
+
+  interface SmartCardPinResetHandler {
+    (sender: Windows.Devices.SmartCards.SmartCardProvisioning, request: Windows.Devices.SmartCards.SmartCardPinResetRequest): void;
+  }
+  var SmartCardPinResetHandler: {
+    new(callback: (sender: Windows.Devices.SmartCards.SmartCardProvisioning, request: Windows.Devices.SmartCards.SmartCardPinResetRequest) => void): SmartCardPinResetHandler;
+  };
+
+}
+
+declare namespace Windows.Devices.Sms {
+  class DeleteSmsMessageOperation implements Windows.Foundation.IAsyncAction, Windows.Foundation.IAsyncInfo {
+    Cancel(): void;
+    Close(): void;
+    GetResults(): void;
+    Completed: Windows.Foundation.AsyncActionCompletedHandler;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly Id: number;
+    readonly Status: number;
+  }
+
+  class DeleteSmsMessagesOperation implements Windows.Foundation.IAsyncAction, Windows.Foundation.IAsyncInfo {
+    Cancel(): void;
+    Close(): void;
+    GetResults(): void;
+    Completed: Windows.Foundation.AsyncActionCompletedHandler;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly Id: number;
+    readonly Status: number;
+  }
+
+  class GetSmsDeviceOperation implements Windows.Foundation.IAsyncInfo {
+    Cancel(): void;
+    Close(): void;
+    GetResults(): Windows.Devices.Sms.SmsDevice;
+    Completed: Windows.Foundation.AsyncOperationCompletedHandler<Windows.Devices.Sms.SmsDevice>;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly Id: number;
+    readonly Status: number;
+  }
+
+  class GetSmsMessageOperation implements Windows.Foundation.IAsyncInfo {
+    Cancel(): void;
+    Close(): void;
+    GetResults(): Windows.Devices.Sms.ISmsMessage;
+    Completed: Windows.Foundation.AsyncOperationCompletedHandler<Windows.Devices.Sms.ISmsMessage>;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly Id: number;
+    readonly Status: number;
+  }
+
+  class GetSmsMessagesOperation implements Windows.Foundation.IAsyncInfo {
+    Cancel(): void;
+    Close(): void;
+    GetResults(): Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsMessage> | Windows.Devices.Sms.ISmsMessage[];
+    Completed: Windows.Foundation.AsyncOperationWithProgressCompletedHandler<Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsMessage> | Windows.Devices.Sms.ISmsMessage[], number>;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly Id: number;
+    Progress: Windows.Foundation.AsyncOperationProgressHandler<Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsMessage> | Windows.Devices.Sms.ISmsMessage[], number>;
+    readonly Status: number;
+  }
+
+  class SendSmsMessageOperation implements Windows.Foundation.IAsyncAction, Windows.Foundation.IAsyncInfo {
+    Cancel(): void;
+    Close(): void;
+    GetResults(): void;
+    Completed: Windows.Foundation.AsyncActionCompletedHandler;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly Id: number;
+    readonly Status: number;
+  }
+
+  class SmsAppMessage implements Windows.Devices.Sms.ISmsAppMessage, Windows.Devices.Sms.ISmsMessageBase {
+    constructor();
+    BinaryBody: Windows.Storage.Streams.IBuffer;
+    Body: string;
+    CallbackNumber: string;
+    readonly CellularClass: number;
+    readonly DeviceId: string;
+    Encoding: number;
+    readonly From: string;
+    IsDeliveryNotificationEnabled: boolean;
+    readonly MessageClass: number;
+    readonly MessageType: number;
+    PortNumber: number;
+    ProtocolId: number;
+    RetryAttemptCount: number;
+    readonly SimIccId: string;
+    TeleserviceId: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+    To: string;
+  }
+
+  class SmsBinaryMessage implements Windows.Devices.Sms.ISmsBinaryMessage, Windows.Devices.Sms.ISmsMessage {
+    constructor();
+    GetData(): number[];
+    SetData(value: number[]): void;
+    Format: number;
+    readonly Id: number;
+    readonly MessageClass: number;
+  }
+
+  class SmsBroadcastMessage implements Windows.Devices.Sms.ISmsBroadcastMessage, Windows.Devices.Sms.ISmsMessageBase {
+    readonly Body: string;
+    readonly BroadcastType: number;
+    readonly CellularClass: number;
+    readonly Channel: number;
+    readonly DeviceId: string;
+    readonly GeographicalScope: number;
+    readonly IsEmergencyAlert: boolean;
+    readonly IsUserPopupRequested: boolean;
+    readonly MessageClass: number;
+    readonly MessageCode: number;
+    readonly MessageType: number;
+    readonly SimIccId: string;
+    readonly Timestamp: Windows.Foundation.DateTime;
+    readonly To: string;
+    readonly UpdateNumber: number;
+  }
+
+  class SmsDevice implements Windows.Devices.Sms.ISmsDevice {
+    CalculateLength(message: Windows.Devices.Sms.SmsTextMessage): Windows.Devices.Sms.SmsEncodedLength;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sms.SmsDevice>;
+    static FromNetworkAccountIdAsync(networkAccountId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sms.SmsDevice>;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Sms.SmsDevice>;
+    static GetDeviceSelector(): string;
+    SendMessageAsync(message: Windows.Devices.Sms.ISmsMessage): Windows.Devices.Sms.SendSmsMessageOperation;
+    readonly AccountPhoneNumber: string;
+    readonly CellularClass: number;
+    readonly DeviceStatus: number;
+    readonly MessageStore: Windows.Devices.Sms.SmsDeviceMessageStore;
+    SmsDeviceStatusChanged: Windows.Devices.Sms.SmsDeviceStatusChangedEventHandler | null;
+    SmsMessageReceived: Windows.Devices.Sms.SmsMessageReceivedEventHandler | null;
+  }
+
+  class SmsDevice2 implements Windows.Devices.Sms.ISmsDevice2 {
+    CalculateLength(message: Windows.Devices.Sms.ISmsMessageBase): Windows.Devices.Sms.SmsEncodedLength;
+    static FromId(deviceId: string): Windows.Devices.Sms.SmsDevice2;
+    static FromParentId(parentDeviceId: string): Windows.Devices.Sms.SmsDevice2;
+    static GetDefault(): Windows.Devices.Sms.SmsDevice2;
+    static GetDeviceSelector(): string;
+    SendMessageAndGetResultAsync(message: Windows.Devices.Sms.ISmsMessageBase): Windows.Foundation.IAsyncOperation<Windows.Devices.Sms.SmsSendMessageResult>;
+    readonly AccountPhoneNumber: string;
+    readonly CellularClass: number;
+    readonly DeviceId: string;
+    readonly DeviceStatus: number;
+    readonly ParentDeviceId: string;
+    SmscAddress: string;
+    DeviceStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sms.SmsDevice2, Object> | null;
+  }
+
+  class SmsDeviceMessageStore implements Windows.Devices.Sms.ISmsDeviceMessageStore {
+    DeleteMessageAsync(messageId: number): Windows.Foundation.IAsyncAction;
+    DeleteMessagesAsync(messageFilter: number): Windows.Foundation.IAsyncAction;
+    GetMessageAsync(messageId: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Sms.ISmsMessage>;
+    GetMessagesAsync(messageFilter: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsMessage> | Windows.Devices.Sms.ISmsMessage[], number>;
+    readonly MaxMessages: number;
+  }
+
+  class SmsFilterRule implements Windows.Devices.Sms.ISmsFilterRule {
+    constructor(messageType: number);
+    readonly BroadcastChannels: Windows.Foundation.Collections.IVector<number> | number[];
+    readonly BroadcastTypes: Windows.Foundation.Collections.IVector<number> | number[];
+    CellularClass: number;
+    readonly DeviceIds: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly ImsiPrefixes: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly MessageType: number;
+    readonly PortNumbers: Windows.Foundation.Collections.IVector<number> | number[];
+    readonly ProtocolIds: Windows.Foundation.Collections.IVector<number> | number[];
+    readonly SenderNumbers: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly TeleserviceIds: Windows.Foundation.Collections.IVector<number> | number[];
+    readonly TextMessagePrefixes: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly WapApplicationIds: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly WapContentTypes: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+
+  class SmsFilterRules implements Windows.Devices.Sms.ISmsFilterRules {
+    constructor(actionType: number);
+    readonly ActionType: number;
+    readonly Rules: Windows.Foundation.Collections.IVector<Windows.Devices.Sms.SmsFilterRule> | Windows.Devices.Sms.SmsFilterRule[];
+  }
+
+  class SmsMessageReceivedEventArgs implements Windows.Devices.Sms.ISmsMessageReceivedEventArgs {
+    readonly BinaryMessage: Windows.Devices.Sms.SmsBinaryMessage;
+    readonly TextMessage: Windows.Devices.Sms.SmsTextMessage;
+  }
+
+  class SmsMessageReceivedTriggerDetails implements Windows.Devices.Sms.ISmsMessageReceivedTriggerDetails {
+    Accept(): void;
+    Drop(): void;
+    readonly AppMessage: Windows.Devices.Sms.SmsAppMessage;
+    readonly BroadcastMessage: Windows.Devices.Sms.SmsBroadcastMessage;
+    readonly MessageType: number;
+    readonly StatusMessage: Windows.Devices.Sms.SmsStatusMessage;
+    readonly TextMessage: Windows.Devices.Sms.SmsTextMessage2;
+    readonly VoicemailMessage: Windows.Devices.Sms.SmsVoicemailMessage;
+    readonly WapMessage: Windows.Devices.Sms.SmsWapMessage;
+  }
+
+  class SmsMessageRegistration implements Windows.Devices.Sms.ISmsMessageRegistration {
+    static Register(id: string, filterRules: Windows.Devices.Sms.SmsFilterRules): Windows.Devices.Sms.SmsMessageRegistration;
+    Unregister(): void;
+    static readonly AllRegistrations: Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.SmsMessageRegistration> | Windows.Devices.Sms.SmsMessageRegistration[];
+    readonly Id: string;
+    MessageReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.Sms.SmsMessageRegistration, Windows.Devices.Sms.SmsMessageReceivedTriggerDetails> | null;
+  }
+
+  class SmsReceivedEventDetails implements Windows.Devices.Sms.ISmsReceivedEventDetails, Windows.Devices.Sms.ISmsReceivedEventDetails2 {
+    readonly BinaryMessage: Windows.Devices.Sms.SmsBinaryMessage;
+    readonly DeviceId: string;
+    readonly MessageClass: number;
+    readonly MessageIndex: number;
+  }
+
+  class SmsSendMessageResult implements Windows.Devices.Sms.ISmsSendMessageResult {
+    readonly CellularClass: number;
+    readonly IsErrorTransient: boolean;
+    readonly IsSuccessful: boolean;
+    readonly MessageReferenceNumbers: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly ModemErrorCode: number;
+    readonly NetworkCauseCode: number;
+    readonly TransportFailureCause: number;
+  }
+
+  class SmsStatusMessage implements Windows.Devices.Sms.ISmsMessageBase, Windows.Devices.Sms.ISmsStatusMessage {
+    readonly Body: string;
+    readonly CellularClass: number;
+    readonly DeviceId: string;
+    readonly DischargeTime: Windows.Foundation.DateTime;
+    readonly From: string;
+    readonly MessageClass: number;
+    readonly MessageReferenceNumber: number;
+    readonly MessageType: number;
+    readonly ServiceCenterTimestamp: Windows.Foundation.DateTime;
+    readonly SimIccId: string;
+    readonly Status: number;
+    readonly To: string;
+  }
+
+  class SmsTextMessage implements Windows.Devices.Sms.ISmsMessage, Windows.Devices.Sms.ISmsTextMessage {
+    constructor();
+    static FromBinaryData(format: number, value: number[]): Windows.Devices.Sms.SmsTextMessage;
+    static FromBinaryMessage(binaryMessage: Windows.Devices.Sms.SmsBinaryMessage): Windows.Devices.Sms.SmsTextMessage;
+    ToBinaryMessages(format: number): Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsBinaryMessage> | Windows.Devices.Sms.ISmsBinaryMessage[];
+    Body: string;
+    Encoding: number;
+    From: string;
+    readonly Id: number;
+    readonly MessageClass: number;
+    readonly PartCount: number;
+    readonly PartNumber: number;
+    readonly PartReferenceId: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+    To: string;
+  }
+
+  class SmsTextMessage2 implements Windows.Devices.Sms.ISmsMessageBase, Windows.Devices.Sms.ISmsTextMessage2 {
+    constructor();
+    Body: string;
+    CallbackNumber: string;
+    readonly CellularClass: number;
+    readonly DeviceId: string;
+    Encoding: number;
+    readonly From: string;
+    IsDeliveryNotificationEnabled: boolean;
+    readonly MessageClass: number;
+    readonly MessageType: number;
+    readonly ProtocolId: number;
+    RetryAttemptCount: number;
+    readonly SimIccId: string;
+    readonly TeleserviceId: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+    To: string;
+  }
+
+  class SmsVoicemailMessage implements Windows.Devices.Sms.ISmsMessageBase, Windows.Devices.Sms.ISmsVoicemailMessage {
+    readonly Body: string;
+    readonly CellularClass: number;
+    readonly DeviceId: string;
+    readonly MessageClass: number;
+    readonly MessageCount: number | null;
+    readonly MessageType: number;
+    readonly SimIccId: string;
+    readonly Timestamp: Windows.Foundation.DateTime;
+    readonly To: string;
+  }
+
+  class SmsWapMessage implements Windows.Devices.Sms.ISmsMessageBase, Windows.Devices.Sms.ISmsWapMessage {
+    readonly ApplicationId: string;
+    readonly BinaryBody: Windows.Storage.Streams.IBuffer;
+    readonly CellularClass: number;
+    readonly ContentType: string;
+    readonly DeviceId: string;
+    readonly From: string;
+    readonly Headers: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    readonly MessageClass: number;
+    readonly MessageType: number;
+    readonly SimIccId: string;
+    readonly Timestamp: Windows.Foundation.DateTime;
+    readonly To: string;
+  }
+
+  enum CellularClass {
+    None = 0,
+    Gsm = 1,
+    Cdma = 2,
+  }
+
+  enum SmsBroadcastType {
+    Other = 0,
+    CmasPresidential = 1,
+    CmasExtreme = 2,
+    CmasSevere = 3,
+    CmasAmber = 4,
+    CmasTest = 5,
+    EUAlert1 = 6,
+    EUAlert2 = 7,
+    EUAlert3 = 8,
+    EUAlertAmber = 9,
+    EUAlertInfo = 10,
+    EtwsEarthquake = 11,
+    EtwsTsunami = 12,
+    EtwsTsunamiAndEarthquake = 13,
+    LatAlertLocal = 14,
+  }
+
+  enum SmsDataFormat {
+    Unknown = 0,
+    CdmaSubmit = 1,
+    GsmSubmit = 2,
+    CdmaDeliver = 3,
+    GsmDeliver = 4,
+  }
+
+  enum SmsDeviceStatus {
+    Off = 0,
+    Ready = 1,
+    SimNotInserted = 2,
+    BadSim = 3,
+    DeviceFailure = 4,
+    SubscriptionNotActivated = 5,
+    DeviceLocked = 6,
+    DeviceBlocked = 7,
+  }
+
+  enum SmsEncoding {
+    Unknown = 0,
+    Optimal = 1,
+    SevenBitAscii = 2,
+    Unicode = 3,
+    GsmSevenBit = 4,
+    EightBit = 5,
+    Latin = 6,
+    Korean = 7,
+    IA5 = 8,
+    ShiftJis = 9,
+    LatinHebrew = 10,
+  }
+
+  enum SmsFilterActionType {
+    AcceptImmediately = 0,
+    Drop = 1,
+    Peek = 2,
+    Accept = 3,
+  }
+
+  enum SmsGeographicalScope {
+    None = 0,
+    CellWithImmediateDisplay = 1,
+    LocationArea = 2,
+    Plmn = 3,
+    Cell = 4,
+  }
+
+  enum SmsMessageClass {
+    None = 0,
+    Class0 = 1,
+    Class1 = 2,
+    Class2 = 3,
+    Class3 = 4,
+  }
+
+  enum SmsMessageFilter {
+    All = 0,
+    Unread = 1,
+    Read = 2,
+    Sent = 3,
+    Draft = 4,
+  }
+
+  enum SmsMessageType {
+    Binary = 0,
+    Text = 1,
+    Wap = 2,
+    App = 3,
+    Broadcast = 4,
+    Voicemail = 5,
+    Status = 6,
+  }
+
+  enum SmsModemErrorCode {
+    Other = 0,
+    MessagingNetworkError = 1,
+    SmsOperationNotSupportedByDevice = 2,
+    SmsServiceNotSupportedByNetwork = 3,
+    DeviceFailure = 4,
+    MessageNotEncodedProperly = 5,
+    MessageTooLarge = 6,
+    DeviceNotReady = 7,
+    NetworkNotReady = 8,
+    InvalidSmscAddress = 9,
+    NetworkFailure = 10,
+    FixedDialingNumberRestricted = 11,
+  }
+
+  interface ISmsAppMessage extends Windows.Devices.Sms.ISmsMessageBase {
+    BinaryBody: Windows.Storage.Streams.IBuffer;
+    Body: string;
+    CallbackNumber: string;
+    Encoding: number;
+    readonly From: string;
+    IsDeliveryNotificationEnabled: boolean;
+    PortNumber: number;
+    ProtocolId: number;
+    RetryAttemptCount: number;
+    TeleserviceId: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+    To: string;
+  }
+  var ISmsAppMessage: abstract new (...args: any[]) => ISmsAppMessage;
+
+  interface ISmsBinaryMessage extends Windows.Devices.Sms.ISmsMessage {
+    GetData(): number[];
+    SetData(value: number[]): void;
+    Format: number;
+  }
+  var ISmsBinaryMessage: abstract new (...args: any[]) => ISmsBinaryMessage;
+
+  interface ISmsBroadcastMessage extends Windows.Devices.Sms.ISmsMessageBase {
+    readonly Body: string;
+    readonly BroadcastType: number;
+    readonly Channel: number;
+    readonly GeographicalScope: number;
+    readonly IsEmergencyAlert: boolean;
+    readonly IsUserPopupRequested: boolean;
+    readonly MessageCode: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+    readonly To: string;
+    readonly UpdateNumber: number;
+  }
+  var ISmsBroadcastMessage: abstract new (...args: any[]) => ISmsBroadcastMessage;
+
+  interface ISmsDevice {
+    CalculateLength(message: Windows.Devices.Sms.SmsTextMessage): Windows.Devices.Sms.SmsEncodedLength;
+    SendMessageAsync(message: Windows.Devices.Sms.ISmsMessage): Windows.Devices.Sms.SendSmsMessageOperation;
+    readonly AccountPhoneNumber: string;
+    readonly CellularClass: number;
+    readonly DeviceStatus: number;
+    readonly MessageStore: Windows.Devices.Sms.SmsDeviceMessageStore;
+    SmsDeviceStatusChanged: Windows.Devices.Sms.SmsDeviceStatusChangedEventHandler | null;
+    SmsMessageReceived: Windows.Devices.Sms.SmsMessageReceivedEventHandler | null;
+  }
+  var ISmsDevice: abstract new (...args: any[]) => ISmsDevice;
+
+  interface ISmsDevice2 {
+    CalculateLength(message: Windows.Devices.Sms.ISmsMessageBase): Windows.Devices.Sms.SmsEncodedLength;
+    SendMessageAndGetResultAsync(message: Windows.Devices.Sms.ISmsMessageBase): Windows.Foundation.IAsyncOperation<Windows.Devices.Sms.SmsSendMessageResult>;
+    readonly AccountPhoneNumber: string;
+    readonly CellularClass: number;
+    readonly DeviceId: string;
+    readonly DeviceStatus: number;
+    readonly ParentDeviceId: string;
+    SmscAddress: string;
+    DeviceStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.Sms.SmsDevice2, Object> | null;
+  }
+  var ISmsDevice2: abstract new (...args: any[]) => ISmsDevice2;
+
+  interface ISmsDevice2Statics {
+    FromId(deviceId: string): Windows.Devices.Sms.SmsDevice2;
+    FromParentId(parentDeviceId: string): Windows.Devices.Sms.SmsDevice2;
+    GetDefault(): Windows.Devices.Sms.SmsDevice2;
+    GetDeviceSelector(): string;
+  }
+  var ISmsDevice2Statics: abstract new (...args: any[]) => ISmsDevice2Statics;
+
+  interface ISmsDeviceMessageStore {
+    DeleteMessageAsync(messageId: number): Windows.Foundation.IAsyncAction;
+    DeleteMessagesAsync(messageFilter: number): Windows.Foundation.IAsyncAction;
+    GetMessageAsync(messageId: number): Windows.Foundation.IAsyncOperation<Windows.Devices.Sms.ISmsMessage>;
+    GetMessagesAsync(messageFilter: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsMessage> | Windows.Devices.Sms.ISmsMessage[], number>;
+    readonly MaxMessages: number;
+  }
+  var ISmsDeviceMessageStore: abstract new (...args: any[]) => ISmsDeviceMessageStore;
+
+  interface ISmsDeviceStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sms.SmsDevice>;
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Sms.SmsDevice>;
+    GetDeviceSelector(): string;
+  }
+  var ISmsDeviceStatics: abstract new (...args: any[]) => ISmsDeviceStatics;
+
+  interface ISmsDeviceStatics2 {
+    FromNetworkAccountIdAsync(networkAccountId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Sms.SmsDevice>;
+  }
+  var ISmsDeviceStatics2: abstract new (...args: any[]) => ISmsDeviceStatics2;
+
+  interface ISmsFilterRule {
+    readonly BroadcastChannels: Windows.Foundation.Collections.IVector<number> | number[];
+    readonly BroadcastTypes: Windows.Foundation.Collections.IVector<number> | number[];
+    CellularClass: number;
+    readonly DeviceIds: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly ImsiPrefixes: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly MessageType: number;
+    readonly PortNumbers: Windows.Foundation.Collections.IVector<number> | number[];
+    readonly ProtocolIds: Windows.Foundation.Collections.IVector<number> | number[];
+    readonly SenderNumbers: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly TeleserviceIds: Windows.Foundation.Collections.IVector<number> | number[];
+    readonly TextMessagePrefixes: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly WapApplicationIds: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly WapContentTypes: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var ISmsFilterRule: abstract new (...args: any[]) => ISmsFilterRule;
+
+  interface ISmsFilterRuleFactory {
+    CreateFilterRule(messageType: number): Windows.Devices.Sms.SmsFilterRule;
+  }
+  var ISmsFilterRuleFactory: abstract new (...args: any[]) => ISmsFilterRuleFactory;
+
+  interface ISmsFilterRules {
+    readonly ActionType: number;
+    readonly Rules: Windows.Foundation.Collections.IVector<Windows.Devices.Sms.SmsFilterRule> | Windows.Devices.Sms.SmsFilterRule[];
+  }
+  var ISmsFilterRules: abstract new (...args: any[]) => ISmsFilterRules;
+
+  interface ISmsFilterRulesFactory {
+    CreateFilterRules(actionType: number): Windows.Devices.Sms.SmsFilterRules;
+  }
+  var ISmsFilterRulesFactory: abstract new (...args: any[]) => ISmsFilterRulesFactory;
+
+  interface ISmsMessage {
+    readonly Id: number;
+    readonly MessageClass: number;
+  }
+  var ISmsMessage: abstract new (...args: any[]) => ISmsMessage;
+
+  interface ISmsMessageBase {
+    readonly CellularClass: number;
+    readonly DeviceId: string;
+    readonly MessageClass: number;
+    readonly MessageType: number;
+    readonly SimIccId: string;
+  }
+  var ISmsMessageBase: abstract new (...args: any[]) => ISmsMessageBase;
+
+  interface ISmsMessageReceivedEventArgs {
+    readonly BinaryMessage: Windows.Devices.Sms.SmsBinaryMessage;
+    readonly TextMessage: Windows.Devices.Sms.SmsTextMessage;
+  }
+  var ISmsMessageReceivedEventArgs: abstract new (...args: any[]) => ISmsMessageReceivedEventArgs;
+
+  interface ISmsMessageReceivedTriggerDetails {
+    Accept(): void;
+    Drop(): void;
+    readonly AppMessage: Windows.Devices.Sms.SmsAppMessage;
+    readonly BroadcastMessage: Windows.Devices.Sms.SmsBroadcastMessage;
+    readonly MessageType: number;
+    readonly StatusMessage: Windows.Devices.Sms.SmsStatusMessage;
+    readonly TextMessage: Windows.Devices.Sms.SmsTextMessage2;
+    readonly VoicemailMessage: Windows.Devices.Sms.SmsVoicemailMessage;
+    readonly WapMessage: Windows.Devices.Sms.SmsWapMessage;
+  }
+  var ISmsMessageReceivedTriggerDetails: abstract new (...args: any[]) => ISmsMessageReceivedTriggerDetails;
+
+  interface ISmsMessageRegistration {
+    Unregister(): void;
+    readonly Id: string;
+    MessageReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.Sms.SmsMessageRegistration, Windows.Devices.Sms.SmsMessageReceivedTriggerDetails> | null;
+  }
+  var ISmsMessageRegistration: abstract new (...args: any[]) => ISmsMessageRegistration;
+
+  interface ISmsMessageRegistrationStatics {
+    Register(id: string, filterRules: Windows.Devices.Sms.SmsFilterRules): Windows.Devices.Sms.SmsMessageRegistration;
+    readonly AllRegistrations: Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.SmsMessageRegistration> | Windows.Devices.Sms.SmsMessageRegistration[];
+  }
+  var ISmsMessageRegistrationStatics: abstract new (...args: any[]) => ISmsMessageRegistrationStatics;
+
+  interface ISmsReceivedEventDetails {
+    readonly DeviceId: string;
+    readonly MessageIndex: number;
+  }
+  var ISmsReceivedEventDetails: abstract new (...args: any[]) => ISmsReceivedEventDetails;
+
+  interface ISmsReceivedEventDetails2 {
+    readonly BinaryMessage: Windows.Devices.Sms.SmsBinaryMessage;
+    readonly MessageClass: number;
+  }
+  var ISmsReceivedEventDetails2: abstract new (...args: any[]) => ISmsReceivedEventDetails2;
+
+  interface ISmsSendMessageResult {
+    readonly CellularClass: number;
+    readonly IsErrorTransient: boolean;
+    readonly IsSuccessful: boolean;
+    readonly MessageReferenceNumbers: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly ModemErrorCode: number;
+    readonly NetworkCauseCode: number;
+    readonly TransportFailureCause: number;
+  }
+  var ISmsSendMessageResult: abstract new (...args: any[]) => ISmsSendMessageResult;
+
+  interface ISmsStatusMessage extends Windows.Devices.Sms.ISmsMessageBase {
+    readonly Body: string;
+    readonly DischargeTime: Windows.Foundation.DateTime;
+    readonly From: string;
+    readonly MessageReferenceNumber: number;
+    readonly ServiceCenterTimestamp: Windows.Foundation.DateTime;
+    readonly Status: number;
+    readonly To: string;
+  }
+  var ISmsStatusMessage: abstract new (...args: any[]) => ISmsStatusMessage;
+
+  interface ISmsTextMessage extends Windows.Devices.Sms.ISmsMessage {
+    ToBinaryMessages(format: number): Windows.Foundation.Collections.IVectorView<Windows.Devices.Sms.ISmsBinaryMessage> | Windows.Devices.Sms.ISmsBinaryMessage[];
+    Body: string;
+    Encoding: number;
+    From: string;
+    readonly PartCount: number;
+    readonly PartNumber: number;
+    readonly PartReferenceId: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+    To: string;
+  }
+  var ISmsTextMessage: abstract new (...args: any[]) => ISmsTextMessage;
+
+  interface ISmsTextMessage2 extends Windows.Devices.Sms.ISmsMessageBase {
+    Body: string;
+    CallbackNumber: string;
+    Encoding: number;
+    readonly From: string;
+    IsDeliveryNotificationEnabled: boolean;
+    readonly ProtocolId: number;
+    RetryAttemptCount: number;
+    readonly TeleserviceId: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+    To: string;
+  }
+  var ISmsTextMessage2: abstract new (...args: any[]) => ISmsTextMessage2;
+
+  interface ISmsTextMessageStatics {
+    FromBinaryData(format: number, value: number[]): Windows.Devices.Sms.SmsTextMessage;
+    FromBinaryMessage(binaryMessage: Windows.Devices.Sms.SmsBinaryMessage): Windows.Devices.Sms.SmsTextMessage;
+  }
+  var ISmsTextMessageStatics: abstract new (...args: any[]) => ISmsTextMessageStatics;
+
+  interface ISmsVoicemailMessage extends Windows.Devices.Sms.ISmsMessageBase {
+    readonly Body: string;
+    readonly MessageCount: number | null;
+    readonly Timestamp: Windows.Foundation.DateTime;
+    readonly To: string;
+  }
+  var ISmsVoicemailMessage: abstract new (...args: any[]) => ISmsVoicemailMessage;
+
+  interface ISmsWapMessage extends Windows.Devices.Sms.ISmsMessageBase {
+    readonly ApplicationId: string;
+    readonly BinaryBody: Windows.Storage.Streams.IBuffer;
+    readonly ContentType: string;
+    readonly From: string;
+    readonly Headers: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    readonly Timestamp: Windows.Foundation.DateTime;
+    readonly To: string;
+  }
+  var ISmsWapMessage: abstract new (...args: any[]) => ISmsWapMessage;
+
+  interface LegacySmsApiContract {
+  }
+  var LegacySmsApiContract: {
+    new(fields: {  }): LegacySmsApiContract;
+  };
+
+  interface SmsDeviceStatusChangedEventHandler {
+    (sender: Windows.Devices.Sms.SmsDevice): void;
+  }
+  var SmsDeviceStatusChangedEventHandler: {
+    new(callback: (sender: Windows.Devices.Sms.SmsDevice) => void): SmsDeviceStatusChangedEventHandler;
+  };
+
+  interface SmsEncodedLength {
+    SegmentCount: number;
+    CharacterCountLastSegment: number;
+    CharactersPerSegment: number;
+    ByteCountLastSegment: number;
+    BytesPerSegment: number;
+  }
+  var SmsEncodedLength: {
+    new(segmentCount: number, characterCountLastSegment: number, charactersPerSegment: number, byteCountLastSegment: number, bytesPerSegment: number): SmsEncodedLength;
+    new(fields: { SegmentCount?: number; CharacterCountLastSegment?: number; CharactersPerSegment?: number; ByteCountLastSegment?: number; BytesPerSegment?: number }): SmsEncodedLength;
+  };
+
+  interface SmsMessageReceivedEventHandler {
+    (sender: Windows.Devices.Sms.SmsDevice, e: Windows.Devices.Sms.SmsMessageReceivedEventArgs): void;
+  }
+  var SmsMessageReceivedEventHandler: {
+    new(callback: (sender: Windows.Devices.Sms.SmsDevice, e: Windows.Devices.Sms.SmsMessageReceivedEventArgs) => void): SmsMessageReceivedEventHandler;
+  };
+
+}
+
+declare namespace Windows.Devices.Spi {
+  class SpiBusInfo implements Windows.Devices.Spi.ISpiBusInfo {
+    readonly ChipSelectLineCount: number;
+    readonly MaxClockFrequency: number;
+    readonly MinClockFrequency: number;
+    readonly SupportedDataBitLengths: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class SpiConnectionSettings implements Windows.Devices.Spi.ISpiConnectionSettings {
+    constructor(chipSelectLine: number);
+    ChipSelectLine: number;
+    ClockFrequency: number;
+    DataBitLength: number;
+    Mode: number;
+    SharingMode: number;
+  }
+
+  class SpiController implements Windows.Devices.Spi.ISpiController {
+    static GetControllersAsync(provider: Windows.Devices.Spi.Provider.ISpiProvider): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Spi.SpiController> | Windows.Devices.Spi.SpiController[]>;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Spi.SpiController>;
+    GetDevice(settings: Windows.Devices.Spi.SpiConnectionSettings): Windows.Devices.Spi.SpiDevice;
+  }
+
+  class SpiDevice implements Windows.Devices.Spi.ISpiDevice, Windows.Foundation.IClosable {
+    Close(): void;
+    static FromIdAsync(busId: string, settings: Windows.Devices.Spi.SpiConnectionSettings): Windows.Foundation.IAsyncOperation<Windows.Devices.Spi.SpiDevice>;
+    static GetBusInfo(busId: string): Windows.Devices.Spi.SpiBusInfo;
+    static GetDeviceSelector(): string;
+    static GetDeviceSelector(friendlyName: string): string;
+    Read(buffer: number[]): void;
+    TransferFullDuplex(writeBuffer: number[], readBuffer: number[]): void;
+    TransferSequential(writeBuffer: number[], readBuffer: number[]): void;
+    Write(buffer: number[]): void;
+    readonly ConnectionSettings: Windows.Devices.Spi.SpiConnectionSettings;
+    readonly DeviceId: string;
+  }
+
+  enum SpiMode {
+    Mode0 = 0,
+    Mode1 = 1,
+    Mode2 = 2,
+    Mode3 = 3,
+  }
+
+  enum SpiSharingMode {
+    Exclusive = 0,
+    Shared = 1,
+  }
+
+  interface ISpiBusInfo {
+    readonly ChipSelectLineCount: number;
+    readonly MaxClockFrequency: number;
+    readonly MinClockFrequency: number;
+    readonly SupportedDataBitLengths: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var ISpiBusInfo: abstract new (...args: any[]) => ISpiBusInfo;
+
+  interface ISpiConnectionSettings {
+    ChipSelectLine: number;
+    ClockFrequency: number;
+    DataBitLength: number;
+    Mode: number;
+    SharingMode: number;
+  }
+  var ISpiConnectionSettings: abstract new (...args: any[]) => ISpiConnectionSettings;
+
+  interface ISpiConnectionSettingsFactory {
+    Create(chipSelectLine: number): Windows.Devices.Spi.SpiConnectionSettings;
+  }
+  var ISpiConnectionSettingsFactory: abstract new (...args: any[]) => ISpiConnectionSettingsFactory;
+
+  interface ISpiController {
+    GetDevice(settings: Windows.Devices.Spi.SpiConnectionSettings): Windows.Devices.Spi.SpiDevice;
+  }
+  var ISpiController: abstract new (...args: any[]) => ISpiController;
+
+  interface ISpiControllerStatics {
+    GetControllersAsync(provider: Windows.Devices.Spi.Provider.ISpiProvider): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Spi.SpiController> | Windows.Devices.Spi.SpiController[]>;
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.Spi.SpiController>;
+  }
+  var ISpiControllerStatics: abstract new (...args: any[]) => ISpiControllerStatics;
+
+  interface ISpiDevice extends Windows.Foundation.IClosable {
+    Close(): void;
+    Read(buffer: number[]): void;
+    TransferFullDuplex(writeBuffer: number[], readBuffer: number[]): void;
+    TransferSequential(writeBuffer: number[], readBuffer: number[]): void;
+    Write(buffer: number[]): void;
+    readonly ConnectionSettings: Windows.Devices.Spi.SpiConnectionSettings;
+    readonly DeviceId: string;
+  }
+  var ISpiDevice: abstract new (...args: any[]) => ISpiDevice;
+
+  interface ISpiDeviceStatics {
+    FromIdAsync(busId: string, settings: Windows.Devices.Spi.SpiConnectionSettings): Windows.Foundation.IAsyncOperation<Windows.Devices.Spi.SpiDevice>;
+    GetBusInfo(busId: string): Windows.Devices.Spi.SpiBusInfo;
+    GetDeviceSelector(): string;
+    GetDeviceSelector(friendlyName: string): string;
+  }
+  var ISpiDeviceStatics: abstract new (...args: any[]) => ISpiDeviceStatics;
+
+}
+
+declare namespace Windows.Devices.Spi.Provider {
+  class ProviderSpiConnectionSettings implements Windows.Devices.Spi.Provider.IProviderSpiConnectionSettings {
+    constructor(chipSelectLine: number);
+    ChipSelectLine: number;
+    ClockFrequency: number;
+    DataBitLength: number;
+    Mode: number;
+    SharingMode: number;
+  }
+
+  enum ProviderSpiMode {
+    Mode0 = 0,
+    Mode1 = 1,
+    Mode2 = 2,
+    Mode3 = 3,
+  }
+
+  enum ProviderSpiSharingMode {
+    Exclusive = 0,
+    Shared = 1,
+  }
+
+  interface IProviderSpiConnectionSettings {
+    ChipSelectLine: number;
+    ClockFrequency: number;
+    DataBitLength: number;
+    Mode: number;
+    SharingMode: number;
+  }
+  var IProviderSpiConnectionSettings: abstract new (...args: any[]) => IProviderSpiConnectionSettings;
+
+  interface IProviderSpiConnectionSettingsFactory {
+    Create(chipSelectLine: number): Windows.Devices.Spi.Provider.ProviderSpiConnectionSettings;
+  }
+  var IProviderSpiConnectionSettingsFactory: abstract new (...args: any[]) => IProviderSpiConnectionSettingsFactory;
+
+  interface ISpiControllerProvider {
+    GetDeviceProvider(settings: Windows.Devices.Spi.Provider.ProviderSpiConnectionSettings): Windows.Devices.Spi.Provider.ISpiDeviceProvider;
+  }
+  var ISpiControllerProvider: abstract new (...args: any[]) => ISpiControllerProvider;
+
+  interface ISpiDeviceProvider extends Windows.Foundation.IClosable {
+    Close(): void;
+    Read(buffer: number[]): void;
+    TransferFullDuplex(writeBuffer: number[], readBuffer: number[]): void;
+    TransferSequential(writeBuffer: number[], readBuffer: number[]): void;
+    Write(buffer: number[]): void;
+    readonly ConnectionSettings: Windows.Devices.Spi.Provider.ProviderSpiConnectionSettings;
+    readonly DeviceId: string;
+  }
+  var ISpiDeviceProvider: abstract new (...args: any[]) => ISpiDeviceProvider;
+
+  interface ISpiProvider {
+    GetControllersAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.Spi.Provider.ISpiControllerProvider> | Windows.Devices.Spi.Provider.ISpiControllerProvider[]>;
+  }
+  var ISpiProvider: abstract new (...args: any[]) => ISpiProvider;
+
+}
+
+declare namespace Windows.Devices.Usb {
+  class UsbBulkInEndpointDescriptor implements Windows.Devices.Usb.IUsbBulkInEndpointDescriptor {
+    readonly EndpointNumber: number;
+    readonly MaxPacketSize: number;
+    readonly Pipe: Windows.Devices.Usb.UsbBulkInPipe;
+  }
+
+  class UsbBulkInPipe implements Windows.Devices.Usb.IUsbBulkInPipe {
+    ClearStallAsync(): Windows.Foundation.IAsyncAction;
+    FlushBuffer(): void;
+    readonly EndpointDescriptor: Windows.Devices.Usb.UsbBulkInEndpointDescriptor;
+    readonly InputStream: Windows.Storage.Streams.IInputStream;
+    readonly MaxTransferSizeBytes: number;
+    ReadOptions: number;
+  }
+
+  class UsbBulkOutEndpointDescriptor implements Windows.Devices.Usb.IUsbBulkOutEndpointDescriptor {
+    readonly EndpointNumber: number;
+    readonly MaxPacketSize: number;
+    readonly Pipe: Windows.Devices.Usb.UsbBulkOutPipe;
+  }
+
+  class UsbBulkOutPipe implements Windows.Devices.Usb.IUsbBulkOutPipe {
+    ClearStallAsync(): Windows.Foundation.IAsyncAction;
+    readonly EndpointDescriptor: Windows.Devices.Usb.UsbBulkOutEndpointDescriptor;
+    readonly OutputStream: Windows.Storage.Streams.IOutputStream;
+    WriteOptions: number;
+  }
+
+  class UsbConfiguration implements Windows.Devices.Usb.IUsbConfiguration {
+    readonly ConfigurationDescriptor: Windows.Devices.Usb.UsbConfigurationDescriptor;
+    readonly Descriptors: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbDescriptor> | Windows.Devices.Usb.UsbDescriptor[];
+    readonly UsbInterfaces: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbInterface> | Windows.Devices.Usb.UsbInterface[];
+  }
+
+  class UsbConfigurationDescriptor implements Windows.Devices.Usb.IUsbConfigurationDescriptor {
+    static Parse(descriptor: Windows.Devices.Usb.UsbDescriptor): Windows.Devices.Usb.UsbConfigurationDescriptor;
+    static TryParse(descriptor: Windows.Devices.Usb.UsbDescriptor, parsed: Windows.Devices.Usb.UsbConfigurationDescriptor): boolean;
+    readonly ConfigurationValue: number;
+    readonly MaxPowerMilliamps: number;
+    readonly RemoteWakeup: boolean;
+    readonly SelfPowered: boolean;
+  }
+
+  class UsbControlRequestType implements Windows.Devices.Usb.IUsbControlRequestType {
+    constructor();
+    AsByte: number;
+    ControlTransferType: number;
+    Direction: number;
+    Recipient: number;
+  }
+
+  class UsbDescriptor implements Windows.Devices.Usb.IUsbDescriptor {
+    ReadDescriptorBuffer(buffer: Windows.Storage.Streams.IBuffer): void;
+    readonly DescriptorType: number;
+    readonly Length: number;
+  }
+
+  class UsbDevice implements Windows.Devices.Usb.IUsbDevice, Windows.Foundation.IClosable {
+    Close(): void;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Usb.UsbDevice>;
+    static GetDeviceClassSelector(usbClass: Windows.Devices.Usb.UsbDeviceClass): string;
+    static GetDeviceSelector(vendorId: number, productId: number, winUsbInterfaceClass: Guid): string;
+    static GetDeviceSelector(winUsbInterfaceClass: Guid): string;
+    static GetDeviceSelector(vendorId: number, productId: number): string;
+    SendControlInTransferAsync(setupPacket: Windows.Devices.Usb.UsbSetupPacket, buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    SendControlInTransferAsync(setupPacket: Windows.Devices.Usb.UsbSetupPacket): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    SendControlOutTransferAsync(setupPacket: Windows.Devices.Usb.UsbSetupPacket, buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<number>;
+    SendControlOutTransferAsync(setupPacket: Windows.Devices.Usb.UsbSetupPacket): Windows.Foundation.IAsyncOperation<number>;
+    readonly Configuration: Windows.Devices.Usb.UsbConfiguration;
+    readonly DefaultInterface: Windows.Devices.Usb.UsbInterface;
+    readonly DeviceDescriptor: Windows.Devices.Usb.UsbDeviceDescriptor;
+  }
+
+  class UsbDeviceClass implements Windows.Devices.Usb.IUsbDeviceClass {
+    constructor();
+    ClassCode: number;
+    ProtocolCode: number | null;
+    SubclassCode: number | null;
+  }
+
+  class UsbDeviceClasses implements Windows.Devices.Usb.IUsbDeviceClasses {
+    static readonly ActiveSync: Windows.Devices.Usb.UsbDeviceClass;
+    static readonly CdcControl: Windows.Devices.Usb.UsbDeviceClass;
+    static readonly DeviceFirmwareUpdate: Windows.Devices.Usb.UsbDeviceClass;
+    static readonly Irda: Windows.Devices.Usb.UsbDeviceClass;
+    static readonly Measurement: Windows.Devices.Usb.UsbDeviceClass;
+    static readonly PalmSync: Windows.Devices.Usb.UsbDeviceClass;
+    static readonly PersonalHealthcare: Windows.Devices.Usb.UsbDeviceClass;
+    static readonly Physical: Windows.Devices.Usb.UsbDeviceClass;
+    static readonly VendorSpecific: Windows.Devices.Usb.UsbDeviceClass;
+  }
+
+  class UsbDeviceDescriptor implements Windows.Devices.Usb.IUsbDeviceDescriptor {
+    readonly BcdDeviceRevision: number;
+    readonly BcdUsb: number;
+    readonly MaxPacketSize0: number;
+    readonly NumberOfConfigurations: number;
+    readonly ProductId: number;
+    readonly VendorId: number;
+  }
+
+  class UsbEndpointDescriptor implements Windows.Devices.Usb.IUsbEndpointDescriptor {
+    static Parse(descriptor: Windows.Devices.Usb.UsbDescriptor): Windows.Devices.Usb.UsbEndpointDescriptor;
+    static TryParse(descriptor: Windows.Devices.Usb.UsbDescriptor, parsed: Windows.Devices.Usb.UsbEndpointDescriptor): boolean;
+    readonly AsBulkInEndpointDescriptor: Windows.Devices.Usb.UsbBulkInEndpointDescriptor;
+    readonly AsBulkOutEndpointDescriptor: Windows.Devices.Usb.UsbBulkOutEndpointDescriptor;
+    readonly AsInterruptInEndpointDescriptor: Windows.Devices.Usb.UsbInterruptInEndpointDescriptor;
+    readonly AsInterruptOutEndpointDescriptor: Windows.Devices.Usb.UsbInterruptOutEndpointDescriptor;
+    readonly Direction: number;
+    readonly EndpointNumber: number;
+    readonly EndpointType: number;
+  }
+
+  class UsbInterface implements Windows.Devices.Usb.IUsbInterface {
+    readonly BulkInPipes: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbBulkInPipe> | Windows.Devices.Usb.UsbBulkInPipe[];
+    readonly BulkOutPipes: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbBulkOutPipe> | Windows.Devices.Usb.UsbBulkOutPipe[];
+    readonly Descriptors: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbDescriptor> | Windows.Devices.Usb.UsbDescriptor[];
+    readonly InterfaceNumber: number;
+    readonly InterfaceSettings: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbInterfaceSetting> | Windows.Devices.Usb.UsbInterfaceSetting[];
+    readonly InterruptInPipes: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbInterruptInPipe> | Windows.Devices.Usb.UsbInterruptInPipe[];
+    readonly InterruptOutPipes: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbInterruptOutPipe> | Windows.Devices.Usb.UsbInterruptOutPipe[];
+  }
+
+  class UsbInterfaceDescriptor implements Windows.Devices.Usb.IUsbInterfaceDescriptor {
+    static Parse(descriptor: Windows.Devices.Usb.UsbDescriptor): Windows.Devices.Usb.UsbInterfaceDescriptor;
+    static TryParse(descriptor: Windows.Devices.Usb.UsbDescriptor, parsed: Windows.Devices.Usb.UsbInterfaceDescriptor): boolean;
+    readonly AlternateSettingNumber: number;
+    readonly ClassCode: number;
+    readonly InterfaceNumber: number;
+    readonly ProtocolCode: number;
+    readonly SubclassCode: number;
+  }
+
+  class UsbInterfaceSetting implements Windows.Devices.Usb.IUsbInterfaceSetting {
+    SelectSettingAsync(): Windows.Foundation.IAsyncAction;
+    readonly BulkInEndpoints: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbBulkInEndpointDescriptor> | Windows.Devices.Usb.UsbBulkInEndpointDescriptor[];
+    readonly BulkOutEndpoints: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbBulkOutEndpointDescriptor> | Windows.Devices.Usb.UsbBulkOutEndpointDescriptor[];
+    readonly Descriptors: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbDescriptor> | Windows.Devices.Usb.UsbDescriptor[];
+    readonly InterfaceDescriptor: Windows.Devices.Usb.UsbInterfaceDescriptor;
+    readonly InterruptInEndpoints: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbInterruptInEndpointDescriptor> | Windows.Devices.Usb.UsbInterruptInEndpointDescriptor[];
+    readonly InterruptOutEndpoints: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbInterruptOutEndpointDescriptor> | Windows.Devices.Usb.UsbInterruptOutEndpointDescriptor[];
+    readonly Selected: boolean;
+  }
+
+  class UsbInterruptInEndpointDescriptor implements Windows.Devices.Usb.IUsbInterruptInEndpointDescriptor {
+    readonly EndpointNumber: number;
+    readonly Interval: Windows.Foundation.TimeSpan;
+    readonly MaxPacketSize: number;
+    readonly Pipe: Windows.Devices.Usb.UsbInterruptInPipe;
+  }
+
+  class UsbInterruptInEventArgs implements Windows.Devices.Usb.IUsbInterruptInEventArgs {
+    readonly InterruptData: Windows.Storage.Streams.IBuffer;
+  }
+
+  class UsbInterruptInPipe implements Windows.Devices.Usb.IUsbInterruptInPipe {
+    ClearStallAsync(): Windows.Foundation.IAsyncAction;
+    readonly EndpointDescriptor: Windows.Devices.Usb.UsbInterruptInEndpointDescriptor;
+    DataReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.Usb.UsbInterruptInPipe, Windows.Devices.Usb.UsbInterruptInEventArgs> | null;
+  }
+
+  class UsbInterruptOutEndpointDescriptor implements Windows.Devices.Usb.IUsbInterruptOutEndpointDescriptor {
+    readonly EndpointNumber: number;
+    readonly Interval: Windows.Foundation.TimeSpan;
+    readonly MaxPacketSize: number;
+    readonly Pipe: Windows.Devices.Usb.UsbInterruptOutPipe;
+  }
+
+  class UsbInterruptOutPipe implements Windows.Devices.Usb.IUsbInterruptOutPipe {
+    ClearStallAsync(): Windows.Foundation.IAsyncAction;
+    readonly EndpointDescriptor: Windows.Devices.Usb.UsbInterruptOutEndpointDescriptor;
+    readonly OutputStream: Windows.Storage.Streams.IOutputStream;
+    WriteOptions: number;
+  }
+
+  class UsbSetupPacket implements Windows.Devices.Usb.IUsbSetupPacket {
+    constructor(eightByteBuffer: Windows.Storage.Streams.IBuffer);
+    constructor();
+    Index: number;
+    Length: number;
+    Request: number;
+    RequestType: Windows.Devices.Usb.UsbControlRequestType;
+    Value: number;
+  }
+
+  enum UsbControlRecipient {
+    Device = 0,
+    SpecifiedInterface = 1,
+    Endpoint = 2,
+    Other = 3,
+    DefaultInterface = 4,
+  }
+
+  enum UsbControlTransferType {
+    Standard = 0,
+    Class = 1,
+    Vendor = 2,
+  }
+
+  enum UsbEndpointType {
+    Control = 0,
+    Isochronous = 1,
+    Bulk = 2,
+    Interrupt = 3,
+  }
+
+  enum UsbReadOptions {
+    None = 0,
+    AutoClearStall = 1,
+    OverrideAutomaticBufferManagement = 2,
+    IgnoreShortPacket = 4,
+    AllowPartialReads = 8,
+  }
+
+  enum UsbTransferDirection {
+    Out = 0,
+    In = 1,
+  }
+
+  enum UsbWriteOptions {
+    None = 0,
+    AutoClearStall = 1,
+    ShortPacketTerminate = 2,
+  }
+
+  interface IUsbBulkInEndpointDescriptor {
+    readonly EndpointNumber: number;
+    readonly MaxPacketSize: number;
+    readonly Pipe: Windows.Devices.Usb.UsbBulkInPipe;
+  }
+  var IUsbBulkInEndpointDescriptor: abstract new (...args: any[]) => IUsbBulkInEndpointDescriptor;
+
+  interface IUsbBulkInPipe {
+    ClearStallAsync(): Windows.Foundation.IAsyncAction;
+    FlushBuffer(): void;
+    readonly EndpointDescriptor: Windows.Devices.Usb.UsbBulkInEndpointDescriptor;
+    readonly InputStream: Windows.Storage.Streams.IInputStream;
+    readonly MaxTransferSizeBytes: number;
+    ReadOptions: number;
+  }
+  var IUsbBulkInPipe: abstract new (...args: any[]) => IUsbBulkInPipe;
+
+  interface IUsbBulkOutEndpointDescriptor {
+    readonly EndpointNumber: number;
+    readonly MaxPacketSize: number;
+    readonly Pipe: Windows.Devices.Usb.UsbBulkOutPipe;
+  }
+  var IUsbBulkOutEndpointDescriptor: abstract new (...args: any[]) => IUsbBulkOutEndpointDescriptor;
+
+  interface IUsbBulkOutPipe {
+    ClearStallAsync(): Windows.Foundation.IAsyncAction;
+    readonly EndpointDescriptor: Windows.Devices.Usb.UsbBulkOutEndpointDescriptor;
+    readonly OutputStream: Windows.Storage.Streams.IOutputStream;
+    WriteOptions: number;
+  }
+  var IUsbBulkOutPipe: abstract new (...args: any[]) => IUsbBulkOutPipe;
+
+  interface IUsbConfiguration {
+    readonly ConfigurationDescriptor: Windows.Devices.Usb.UsbConfigurationDescriptor;
+    readonly Descriptors: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbDescriptor> | Windows.Devices.Usb.UsbDescriptor[];
+    readonly UsbInterfaces: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbInterface> | Windows.Devices.Usb.UsbInterface[];
+  }
+  var IUsbConfiguration: abstract new (...args: any[]) => IUsbConfiguration;
+
+  interface IUsbConfigurationDescriptor {
+    readonly ConfigurationValue: number;
+    readonly MaxPowerMilliamps: number;
+    readonly RemoteWakeup: boolean;
+    readonly SelfPowered: boolean;
+  }
+  var IUsbConfigurationDescriptor: abstract new (...args: any[]) => IUsbConfigurationDescriptor;
+
+  interface IUsbConfigurationDescriptorStatics {
+    Parse(descriptor: Windows.Devices.Usb.UsbDescriptor): Windows.Devices.Usb.UsbConfigurationDescriptor;
+    TryParse(descriptor: Windows.Devices.Usb.UsbDescriptor, parsed: Windows.Devices.Usb.UsbConfigurationDescriptor): boolean;
+  }
+  var IUsbConfigurationDescriptorStatics: abstract new (...args: any[]) => IUsbConfigurationDescriptorStatics;
+
+  interface IUsbControlRequestType {
+    AsByte: number;
+    ControlTransferType: number;
+    Direction: number;
+    Recipient: number;
+  }
+  var IUsbControlRequestType: abstract new (...args: any[]) => IUsbControlRequestType;
+
+  interface IUsbDescriptor {
+    ReadDescriptorBuffer(buffer: Windows.Storage.Streams.IBuffer): void;
+    readonly DescriptorType: number;
+    readonly Length: number;
+  }
+  var IUsbDescriptor: abstract new (...args: any[]) => IUsbDescriptor;
+
+  interface IUsbDevice extends Windows.Foundation.IClosable {
+    Close(): void;
+    SendControlInTransferAsync(setupPacket: Windows.Devices.Usb.UsbSetupPacket, buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    SendControlInTransferAsync(setupPacket: Windows.Devices.Usb.UsbSetupPacket): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    SendControlOutTransferAsync(setupPacket: Windows.Devices.Usb.UsbSetupPacket, buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<number>;
+    SendControlOutTransferAsync(setupPacket: Windows.Devices.Usb.UsbSetupPacket): Windows.Foundation.IAsyncOperation<number>;
+    readonly Configuration: Windows.Devices.Usb.UsbConfiguration;
+    readonly DefaultInterface: Windows.Devices.Usb.UsbInterface;
+    readonly DeviceDescriptor: Windows.Devices.Usb.UsbDeviceDescriptor;
+  }
+  var IUsbDevice: abstract new (...args: any[]) => IUsbDevice;
+
+  interface IUsbDeviceClass {
+    ClassCode: number;
+    ProtocolCode: number | null;
+    SubclassCode: number | null;
+  }
+  var IUsbDeviceClass: abstract new (...args: any[]) => IUsbDeviceClass;
+
+  interface IUsbDeviceClasses {
+  }
+  var IUsbDeviceClasses: abstract new (...args: any[]) => IUsbDeviceClasses;
+
+  interface IUsbDeviceClassesStatics {
+    readonly ActiveSync: Windows.Devices.Usb.UsbDeviceClass;
+    readonly CdcControl: Windows.Devices.Usb.UsbDeviceClass;
+    readonly DeviceFirmwareUpdate: Windows.Devices.Usb.UsbDeviceClass;
+    readonly Irda: Windows.Devices.Usb.UsbDeviceClass;
+    readonly Measurement: Windows.Devices.Usb.UsbDeviceClass;
+    readonly PalmSync: Windows.Devices.Usb.UsbDeviceClass;
+    readonly PersonalHealthcare: Windows.Devices.Usb.UsbDeviceClass;
+    readonly Physical: Windows.Devices.Usb.UsbDeviceClass;
+    readonly VendorSpecific: Windows.Devices.Usb.UsbDeviceClass;
+  }
+  var IUsbDeviceClassesStatics: abstract new (...args: any[]) => IUsbDeviceClassesStatics;
+
+  interface IUsbDeviceDescriptor {
+    readonly BcdDeviceRevision: number;
+    readonly BcdUsb: number;
+    readonly MaxPacketSize0: number;
+    readonly NumberOfConfigurations: number;
+    readonly ProductId: number;
+    readonly VendorId: number;
+  }
+  var IUsbDeviceDescriptor: abstract new (...args: any[]) => IUsbDeviceDescriptor;
+
+  interface IUsbDeviceStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.Usb.UsbDevice>;
+    GetDeviceClassSelector(usbClass: Windows.Devices.Usb.UsbDeviceClass): string;
+    GetDeviceSelector(vendorId: number, productId: number, winUsbInterfaceClass: Guid): string;
+    GetDeviceSelector(winUsbInterfaceClass: Guid): string;
+    GetDeviceSelector(vendorId: number, productId: number): string;
+  }
+  var IUsbDeviceStatics: abstract new (...args: any[]) => IUsbDeviceStatics;
+
+  interface IUsbEndpointDescriptor {
+    readonly AsBulkInEndpointDescriptor: Windows.Devices.Usb.UsbBulkInEndpointDescriptor;
+    readonly AsBulkOutEndpointDescriptor: Windows.Devices.Usb.UsbBulkOutEndpointDescriptor;
+    readonly AsInterruptInEndpointDescriptor: Windows.Devices.Usb.UsbInterruptInEndpointDescriptor;
+    readonly AsInterruptOutEndpointDescriptor: Windows.Devices.Usb.UsbInterruptOutEndpointDescriptor;
+    readonly Direction: number;
+    readonly EndpointNumber: number;
+    readonly EndpointType: number;
+  }
+  var IUsbEndpointDescriptor: abstract new (...args: any[]) => IUsbEndpointDescriptor;
+
+  interface IUsbEndpointDescriptorStatics {
+    Parse(descriptor: Windows.Devices.Usb.UsbDescriptor): Windows.Devices.Usb.UsbEndpointDescriptor;
+    TryParse(descriptor: Windows.Devices.Usb.UsbDescriptor, parsed: Windows.Devices.Usb.UsbEndpointDescriptor): boolean;
+  }
+  var IUsbEndpointDescriptorStatics: abstract new (...args: any[]) => IUsbEndpointDescriptorStatics;
+
+  interface IUsbInterface {
+    readonly BulkInPipes: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbBulkInPipe> | Windows.Devices.Usb.UsbBulkInPipe[];
+    readonly BulkOutPipes: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbBulkOutPipe> | Windows.Devices.Usb.UsbBulkOutPipe[];
+    readonly Descriptors: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbDescriptor> | Windows.Devices.Usb.UsbDescriptor[];
+    readonly InterfaceNumber: number;
+    readonly InterfaceSettings: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbInterfaceSetting> | Windows.Devices.Usb.UsbInterfaceSetting[];
+    readonly InterruptInPipes: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbInterruptInPipe> | Windows.Devices.Usb.UsbInterruptInPipe[];
+    readonly InterruptOutPipes: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbInterruptOutPipe> | Windows.Devices.Usb.UsbInterruptOutPipe[];
+  }
+  var IUsbInterface: abstract new (...args: any[]) => IUsbInterface;
+
+  interface IUsbInterfaceDescriptor {
+    readonly AlternateSettingNumber: number;
+    readonly ClassCode: number;
+    readonly InterfaceNumber: number;
+    readonly ProtocolCode: number;
+    readonly SubclassCode: number;
+  }
+  var IUsbInterfaceDescriptor: abstract new (...args: any[]) => IUsbInterfaceDescriptor;
+
+  interface IUsbInterfaceDescriptorStatics {
+    Parse(descriptor: Windows.Devices.Usb.UsbDescriptor): Windows.Devices.Usb.UsbInterfaceDescriptor;
+    TryParse(descriptor: Windows.Devices.Usb.UsbDescriptor, parsed: Windows.Devices.Usb.UsbInterfaceDescriptor): boolean;
+  }
+  var IUsbInterfaceDescriptorStatics: abstract new (...args: any[]) => IUsbInterfaceDescriptorStatics;
+
+  interface IUsbInterfaceSetting {
+    SelectSettingAsync(): Windows.Foundation.IAsyncAction;
+    readonly BulkInEndpoints: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbBulkInEndpointDescriptor> | Windows.Devices.Usb.UsbBulkInEndpointDescriptor[];
+    readonly BulkOutEndpoints: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbBulkOutEndpointDescriptor> | Windows.Devices.Usb.UsbBulkOutEndpointDescriptor[];
+    readonly Descriptors: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbDescriptor> | Windows.Devices.Usb.UsbDescriptor[];
+    readonly InterfaceDescriptor: Windows.Devices.Usb.UsbInterfaceDescriptor;
+    readonly InterruptInEndpoints: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbInterruptInEndpointDescriptor> | Windows.Devices.Usb.UsbInterruptInEndpointDescriptor[];
+    readonly InterruptOutEndpoints: Windows.Foundation.Collections.IVectorView<Windows.Devices.Usb.UsbInterruptOutEndpointDescriptor> | Windows.Devices.Usb.UsbInterruptOutEndpointDescriptor[];
+    readonly Selected: boolean;
+  }
+  var IUsbInterfaceSetting: abstract new (...args: any[]) => IUsbInterfaceSetting;
+
+  interface IUsbInterruptInEndpointDescriptor {
+    readonly EndpointNumber: number;
+    readonly Interval: Windows.Foundation.TimeSpan;
+    readonly MaxPacketSize: number;
+    readonly Pipe: Windows.Devices.Usb.UsbInterruptInPipe;
+  }
+  var IUsbInterruptInEndpointDescriptor: abstract new (...args: any[]) => IUsbInterruptInEndpointDescriptor;
+
+  interface IUsbInterruptInEventArgs {
+    readonly InterruptData: Windows.Storage.Streams.IBuffer;
+  }
+  var IUsbInterruptInEventArgs: abstract new (...args: any[]) => IUsbInterruptInEventArgs;
+
+  interface IUsbInterruptInPipe {
+    ClearStallAsync(): Windows.Foundation.IAsyncAction;
+    readonly EndpointDescriptor: Windows.Devices.Usb.UsbInterruptInEndpointDescriptor;
+    DataReceived: Windows.Foundation.TypedEventHandler<Windows.Devices.Usb.UsbInterruptInPipe, Windows.Devices.Usb.UsbInterruptInEventArgs> | null;
+  }
+  var IUsbInterruptInPipe: abstract new (...args: any[]) => IUsbInterruptInPipe;
+
+  interface IUsbInterruptOutEndpointDescriptor {
+    readonly EndpointNumber: number;
+    readonly Interval: Windows.Foundation.TimeSpan;
+    readonly MaxPacketSize: number;
+    readonly Pipe: Windows.Devices.Usb.UsbInterruptOutPipe;
+  }
+  var IUsbInterruptOutEndpointDescriptor: abstract new (...args: any[]) => IUsbInterruptOutEndpointDescriptor;
+
+  interface IUsbInterruptOutPipe {
+    ClearStallAsync(): Windows.Foundation.IAsyncAction;
+    readonly EndpointDescriptor: Windows.Devices.Usb.UsbInterruptOutEndpointDescriptor;
+    readonly OutputStream: Windows.Storage.Streams.IOutputStream;
+    WriteOptions: number;
+  }
+  var IUsbInterruptOutPipe: abstract new (...args: any[]) => IUsbInterruptOutPipe;
+
+  interface IUsbSetupPacket {
+    Index: number;
+    Length: number;
+    Request: number;
+    RequestType: Windows.Devices.Usb.UsbControlRequestType;
+    Value: number;
+  }
+  var IUsbSetupPacket: abstract new (...args: any[]) => IUsbSetupPacket;
+
+  interface IUsbSetupPacketFactory {
+    CreateWithEightByteBuffer(eightByteBuffer: Windows.Storage.Streams.IBuffer): Windows.Devices.Usb.UsbSetupPacket;
+  }
+  var IUsbSetupPacketFactory: abstract new (...args: any[]) => IUsbSetupPacketFactory;
+
+}
+
+declare namespace Windows.Devices.WiFi {
+  class WiFiAdapter implements Windows.Devices.WiFi.IWiFiAdapter, Windows.Devices.WiFi.IWiFiAdapter2 {
+    ConnectAsync(availableNetwork: Windows.Devices.WiFi.WiFiAvailableNetwork, reconnectionKind: number): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFi.WiFiConnectionResult>;
+    ConnectAsync(availableNetwork: Windows.Devices.WiFi.WiFiAvailableNetwork, reconnectionKind: number, passwordCredential: Windows.Security.Credentials.PasswordCredential): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFi.WiFiConnectionResult>;
+    ConnectAsync(availableNetwork: Windows.Devices.WiFi.WiFiAvailableNetwork, reconnectionKind: number, passwordCredential: Windows.Security.Credentials.PasswordCredential, ssid: string): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFi.WiFiConnectionResult>;
+    ConnectAsync(availableNetwork: Windows.Devices.WiFi.WiFiAvailableNetwork, reconnectionKind: number, passwordCredential: Windows.Security.Credentials.PasswordCredential, ssid: string, connectionMethod: number): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFi.WiFiConnectionResult>;
+    Disconnect(): void;
+    static FindAllAdaptersAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.WiFi.WiFiAdapter> | Windows.Devices.WiFi.WiFiAdapter[]>;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFi.WiFiAdapter>;
+    static GetDeviceSelector(): string;
+    GetWpsConfigurationAsync(availableNetwork: Windows.Devices.WiFi.WiFiAvailableNetwork): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFi.WiFiWpsConfigurationResult>;
+    static RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    ScanAsync(): Windows.Foundation.IAsyncAction;
+    readonly NetworkAdapter: Windows.Networking.Connectivity.NetworkAdapter;
+    readonly NetworkReport: Windows.Devices.WiFi.WiFiNetworkReport;
+    AvailableNetworksChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFi.WiFiAdapter, Object> | null;
+  }
+
+  class WiFiAvailableNetwork implements Windows.Devices.WiFi.IWiFiAvailableNetwork {
+    readonly BeaconInterval: Windows.Foundation.TimeSpan;
+    readonly Bssid: string;
+    readonly ChannelCenterFrequencyInKilohertz: number;
+    readonly IsWiFiDirect: boolean;
+    readonly NetworkKind: number;
+    readonly NetworkRssiInDecibelMilliwatts: number;
+    readonly PhyKind: number;
+    readonly SecuritySettings: Windows.Networking.Connectivity.NetworkSecuritySettings;
+    readonly SignalBars: number;
+    readonly Ssid: string;
+    readonly Uptime: Windows.Foundation.TimeSpan;
+  }
+
+  class WiFiConnectionResult implements Windows.Devices.WiFi.IWiFiConnectionResult {
+    readonly ConnectionStatus: number;
+  }
+
+  class WiFiNetworkReport implements Windows.Devices.WiFi.IWiFiNetworkReport {
+    readonly AvailableNetworks: Windows.Foundation.Collections.IVectorView<Windows.Devices.WiFi.WiFiAvailableNetwork> | Windows.Devices.WiFi.WiFiAvailableNetwork[];
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class WiFiOnDemandHotspotConnectTriggerDetails implements Windows.Devices.WiFi.IWiFiOnDemandHotspotConnectTriggerDetails {
+    Connect(): Windows.Devices.WiFi.WiFiOnDemandHotspotConnectionResult;
+    ConnectAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFi.WiFiOnDemandHotspotConnectionResult>;
+    ReportError(status: number): void;
+    readonly RequestedNetwork: Windows.Devices.WiFi.WiFiOnDemandHotspotNetwork;
+  }
+
+  class WiFiOnDemandHotspotConnectionResult implements Windows.Devices.WiFi.IWiFiOnDemandHotspotConnectionResult {
+    readonly Status: number;
+  }
+
+  class WiFiOnDemandHotspotNetwork implements Windows.Devices.WiFi.IWiFiOnDemandHotspotNetwork {
+    static GetOrCreateById(networkId: Guid): Windows.Devices.WiFi.WiFiOnDemandHotspotNetwork;
+    GetProperties(): Windows.Devices.WiFi.WiFiOnDemandHotspotNetworkProperties;
+    UpdateProperties(newProperties: Windows.Devices.WiFi.WiFiOnDemandHotspotNetworkProperties): void;
+    readonly Id: Guid;
+  }
+
+  class WiFiOnDemandHotspotNetworkProperties implements Windows.Devices.WiFi.IWiFiOnDemandHotspotNetworkProperties {
+    Availability: number;
+    CellularBars: number | null;
+    DisplayName: string;
+    IsMetered: boolean;
+    Password: Windows.Security.Credentials.PasswordCredential;
+    RemainingBatteryPercent: number | null;
+    Ssid: string;
+  }
+
+  class WiFiWpsConfigurationResult implements Windows.Devices.WiFi.IWiFiWpsConfigurationResult {
+    readonly Status: number;
+    readonly SupportedWpsKinds: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  enum WiFiAccessStatus {
+    Unspecified = 0,
+    Allowed = 1,
+    DeniedByUser = 2,
+    DeniedBySystem = 3,
+  }
+
+  enum WiFiConnectionMethod {
+    Default = 0,
+    WpsPin = 1,
+    WpsPushButton = 2,
+  }
+
+  enum WiFiConnectionStatus {
+    UnspecifiedFailure = 0,
+    Success = 1,
+    AccessRevoked = 2,
+    InvalidCredential = 3,
+    NetworkNotAvailable = 4,
+    Timeout = 5,
+    UnsupportedAuthenticationProtocol = 6,
+  }
+
+  enum WiFiNetworkKind {
+    Any = 0,
+    Infrastructure = 1,
+    Adhoc = 2,
+  }
+
+  enum WiFiOnDemandHotspotAvailability {
+    Available = 0,
+    Unavailable = 1,
+  }
+
+  enum WiFiOnDemandHotspotCellularBars {
+    ZeroBars = 0,
+    OneBar = 1,
+    TwoBars = 2,
+    ThreeBars = 3,
+    FourBars = 4,
+    FiveBars = 5,
+  }
+
+  enum WiFiOnDemandHotspotConnectStatus {
+    UnspecifiedFailure = 0,
+    Success = 1,
+    AppTimedOut = 2,
+    InvalidCredential = 3,
+    NetworkNotAvailable = 4,
+    UnsupportedAuthenticationProtocol = 5,
+    BluetoothConnectFailed = 6,
+    BluetoothTransmissionError = 7,
+    OperationCanceledByUser = 8,
+    EntitlementCheckFailed = 9,
+    NoCellularSignal = 10,
+    CellularDataTurnedOff = 11,
+    WlanConnectFailed = 12,
+    WlanNotVisible = 13,
+    AccessPointCannotConnect = 14,
+    CellularConnectTimedOut = 15,
+    RoamingNotAllowed = 16,
+    PairingRequired = 17,
+    DataLimitReached = 18,
+  }
+
+  enum WiFiPhyKind {
+    Unknown = 0,
+    Fhss = 1,
+    Dsss = 2,
+    IRBaseband = 3,
+    Ofdm = 4,
+    Hrdsss = 5,
+    Erp = 6,
+    HT = 7,
+    Vht = 8,
+    Dmg = 9,
+    HE = 10,
+    Eht = 11,
+  }
+
+  enum WiFiReconnectionKind {
+    Automatic = 0,
+    Manual = 1,
+  }
+
+  enum WiFiWpsConfigurationStatus {
+    UnspecifiedFailure = 0,
+    Success = 1,
+    Timeout = 2,
+  }
+
+  enum WiFiWpsKind {
+    Unknown = 0,
+    Pin = 1,
+    PushButton = 2,
+    Nfc = 3,
+    Ethernet = 4,
+    Usb = 5,
+  }
+
+  interface IWiFiAdapter {
+    ConnectAsync(availableNetwork: Windows.Devices.WiFi.WiFiAvailableNetwork, reconnectionKind: number): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFi.WiFiConnectionResult>;
+    ConnectAsync(availableNetwork: Windows.Devices.WiFi.WiFiAvailableNetwork, reconnectionKind: number, passwordCredential: Windows.Security.Credentials.PasswordCredential): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFi.WiFiConnectionResult>;
+    ConnectAsync(availableNetwork: Windows.Devices.WiFi.WiFiAvailableNetwork, reconnectionKind: number, passwordCredential: Windows.Security.Credentials.PasswordCredential, ssid: string): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFi.WiFiConnectionResult>;
+    Disconnect(): void;
+    ScanAsync(): Windows.Foundation.IAsyncAction;
+    readonly NetworkAdapter: Windows.Networking.Connectivity.NetworkAdapter;
+    readonly NetworkReport: Windows.Devices.WiFi.WiFiNetworkReport;
+    AvailableNetworksChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFi.WiFiAdapter, Object> | null;
+  }
+  var IWiFiAdapter: abstract new (...args: any[]) => IWiFiAdapter;
+
+  interface IWiFiAdapter2 {
+    ConnectAsync(availableNetwork: Windows.Devices.WiFi.WiFiAvailableNetwork, reconnectionKind: number, passwordCredential: Windows.Security.Credentials.PasswordCredential, ssid: string, connectionMethod: number): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFi.WiFiConnectionResult>;
+    GetWpsConfigurationAsync(availableNetwork: Windows.Devices.WiFi.WiFiAvailableNetwork): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFi.WiFiWpsConfigurationResult>;
+  }
+  var IWiFiAdapter2: abstract new (...args: any[]) => IWiFiAdapter2;
+
+  interface IWiFiAdapterStatics {
+    FindAllAdaptersAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Devices.WiFi.WiFiAdapter> | Windows.Devices.WiFi.WiFiAdapter[]>;
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFi.WiFiAdapter>;
+    GetDeviceSelector(): string;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IWiFiAdapterStatics: abstract new (...args: any[]) => IWiFiAdapterStatics;
+
+  interface IWiFiAvailableNetwork {
+    readonly BeaconInterval: Windows.Foundation.TimeSpan;
+    readonly Bssid: string;
+    readonly ChannelCenterFrequencyInKilohertz: number;
+    readonly IsWiFiDirect: boolean;
+    readonly NetworkKind: number;
+    readonly NetworkRssiInDecibelMilliwatts: number;
+    readonly PhyKind: number;
+    readonly SecuritySettings: Windows.Networking.Connectivity.NetworkSecuritySettings;
+    readonly SignalBars: number;
+    readonly Ssid: string;
+    readonly Uptime: Windows.Foundation.TimeSpan;
+  }
+  var IWiFiAvailableNetwork: abstract new (...args: any[]) => IWiFiAvailableNetwork;
+
+  interface IWiFiConnectionResult {
+    readonly ConnectionStatus: number;
+  }
+  var IWiFiConnectionResult: abstract new (...args: any[]) => IWiFiConnectionResult;
+
+  interface IWiFiNetworkReport {
+    readonly AvailableNetworks: Windows.Foundation.Collections.IVectorView<Windows.Devices.WiFi.WiFiAvailableNetwork> | Windows.Devices.WiFi.WiFiAvailableNetwork[];
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IWiFiNetworkReport: abstract new (...args: any[]) => IWiFiNetworkReport;
+
+  interface IWiFiOnDemandHotspotConnectTriggerDetails {
+    Connect(): Windows.Devices.WiFi.WiFiOnDemandHotspotConnectionResult;
+    ConnectAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFi.WiFiOnDemandHotspotConnectionResult>;
+    ReportError(status: number): void;
+    readonly RequestedNetwork: Windows.Devices.WiFi.WiFiOnDemandHotspotNetwork;
+  }
+  var IWiFiOnDemandHotspotConnectTriggerDetails: abstract new (...args: any[]) => IWiFiOnDemandHotspotConnectTriggerDetails;
+
+  interface IWiFiOnDemandHotspotConnectionResult {
+    readonly Status: number;
+  }
+  var IWiFiOnDemandHotspotConnectionResult: abstract new (...args: any[]) => IWiFiOnDemandHotspotConnectionResult;
+
+  interface IWiFiOnDemandHotspotNetwork {
+    GetProperties(): Windows.Devices.WiFi.WiFiOnDemandHotspotNetworkProperties;
+    UpdateProperties(newProperties: Windows.Devices.WiFi.WiFiOnDemandHotspotNetworkProperties): void;
+    readonly Id: Guid;
+  }
+  var IWiFiOnDemandHotspotNetwork: abstract new (...args: any[]) => IWiFiOnDemandHotspotNetwork;
+
+  interface IWiFiOnDemandHotspotNetworkProperties {
+    Availability: number;
+    CellularBars: number | null;
+    DisplayName: string;
+    IsMetered: boolean;
+    Password: Windows.Security.Credentials.PasswordCredential;
+    RemainingBatteryPercent: number | null;
+    Ssid: string;
+  }
+  var IWiFiOnDemandHotspotNetworkProperties: abstract new (...args: any[]) => IWiFiOnDemandHotspotNetworkProperties;
+
+  interface IWiFiOnDemandHotspotNetworkStatics {
+    GetOrCreateById(networkId: Guid): Windows.Devices.WiFi.WiFiOnDemandHotspotNetwork;
+  }
+  var IWiFiOnDemandHotspotNetworkStatics: abstract new (...args: any[]) => IWiFiOnDemandHotspotNetworkStatics;
+
+  interface IWiFiWpsConfigurationResult {
+    readonly Status: number;
+    readonly SupportedWpsKinds: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IWiFiWpsConfigurationResult: abstract new (...args: any[]) => IWiFiWpsConfigurationResult;
+
+}
+
+declare namespace Windows.Devices.WiFiDirect {
+  class WiFiDirectAdvertisement implements Windows.Devices.WiFiDirect.IWiFiDirectAdvertisement, Windows.Devices.WiFiDirect.IWiFiDirectAdvertisement2 {
+    InformationElements: Windows.Foundation.Collections.IVector<Windows.Devices.WiFiDirect.WiFiDirectInformationElement> | Windows.Devices.WiFiDirect.WiFiDirectInformationElement[];
+    IsAutonomousGroupOwnerEnabled: boolean;
+    readonly LegacySettings: Windows.Devices.WiFiDirect.WiFiDirectLegacySettings;
+    ListenStateDiscoverability: number;
+    readonly SupportedConfigurationMethods: Windows.Foundation.Collections.IVector<number> | number[];
+  }
+
+  class WiFiDirectAdvertisementPublisher implements Windows.Devices.WiFiDirect.IWiFiDirectAdvertisementPublisher {
+    constructor();
+    Start(): void;
+    Stop(): void;
+    readonly Advertisement: Windows.Devices.WiFiDirect.WiFiDirectAdvertisement;
+    readonly Status: number;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher, Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs> | null;
+  }
+
+  class WiFiDirectAdvertisementPublisherStatusChangedEventArgs implements Windows.Devices.WiFiDirect.IWiFiDirectAdvertisementPublisherStatusChangedEventArgs {
+    readonly Error: number;
+    readonly Status: number;
+  }
+
+  class WiFiDirectConnectionListener implements Windows.Devices.WiFiDirect.IWiFiDirectConnectionListener {
+    constructor();
+    ConnectionRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFiDirect.WiFiDirectConnectionListener, Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs> | null;
+  }
+
+  class WiFiDirectConnectionParameters implements Windows.Devices.Enumeration.IDevicePairingSettings, Windows.Devices.WiFiDirect.IWiFiDirectConnectionParameters, Windows.Devices.WiFiDirect.IWiFiDirectConnectionParameters2 {
+    constructor();
+    static GetDevicePairingKinds(configurationMethod: number): number;
+    GroupOwnerIntent: number;
+    readonly PreferenceOrderedConfigurationMethods: Windows.Foundation.Collections.IVector<number> | number[];
+    PreferredPairingProcedure: number;
+  }
+
+  class WiFiDirectConnectionRequest implements Windows.Devices.WiFiDirect.IWiFiDirectConnectionRequest, Windows.Foundation.IClosable {
+    Close(): void;
+    readonly DeviceInformation: Windows.Devices.Enumeration.DeviceInformation;
+  }
+
+  class WiFiDirectConnectionRequestedEventArgs implements Windows.Devices.WiFiDirect.IWiFiDirectConnectionRequestedEventArgs {
+    GetConnectionRequest(): Windows.Devices.WiFiDirect.WiFiDirectConnectionRequest;
+  }
+
+  class WiFiDirectDevice implements Windows.Devices.WiFiDirect.IWiFiDirectDevice, Windows.Foundation.IClosable {
+    Close(): void;
+    static FromIdAsync(deviceId: string, connectionParameters: Windows.Devices.WiFiDirect.WiFiDirectConnectionParameters): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFiDirect.WiFiDirectDevice>;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFiDirect.WiFiDirectDevice>;
+    GetConnectionEndpointPairs(): Windows.Foundation.Collections.IVectorView<Windows.Networking.EndpointPair> | Windows.Networking.EndpointPair[];
+    static GetDeviceSelector(type: number): string;
+    static GetDeviceSelector(): string;
+    readonly ConnectionStatus: number;
+    readonly DeviceId: string;
+    ConnectionStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFiDirect.WiFiDirectDevice, Object> | null;
+  }
+
+  class WiFiDirectInformationElement implements Windows.Devices.WiFiDirect.IWiFiDirectInformationElement {
+    constructor();
+    static CreateFromBuffer(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.Collections.IVector<Windows.Devices.WiFiDirect.WiFiDirectInformationElement> | Windows.Devices.WiFiDirect.WiFiDirectInformationElement[];
+    static CreateFromDeviceInformation(deviceInformation: Windows.Devices.Enumeration.DeviceInformation): Windows.Foundation.Collections.IVector<Windows.Devices.WiFiDirect.WiFiDirectInformationElement> | Windows.Devices.WiFiDirect.WiFiDirectInformationElement[];
+    Oui: Windows.Storage.Streams.IBuffer;
+    OuiType: number;
+    Value: Windows.Storage.Streams.IBuffer;
+  }
+
+  class WiFiDirectLegacySettings implements Windows.Devices.WiFiDirect.IWiFiDirectLegacySettings {
+    IsEnabled: boolean;
+    Passphrase: Windows.Security.Credentials.PasswordCredential;
+    Ssid: string;
+  }
+
+  enum WiFiDirectAdvertisementListenStateDiscoverability {
+    None = 0,
+    Normal = 1,
+    Intensive = 2,
+  }
+
+  enum WiFiDirectAdvertisementPublisherStatus {
+    Created = 0,
+    Started = 1,
+    Stopped = 2,
+    Aborted = 3,
+  }
+
+  enum WiFiDirectConfigurationMethod {
+    ProvidePin = 0,
+    DisplayPin = 1,
+    PushButton = 2,
+  }
+
+  enum WiFiDirectConnectionStatus {
+    Disconnected = 0,
+    Connected = 1,
+  }
+
+  enum WiFiDirectDeviceSelectorType {
+    DeviceInterface = 0,
+    AssociationEndpoint = 1,
+  }
+
+  enum WiFiDirectError {
+    Success = 0,
+    RadioNotAvailable = 1,
+    ResourceInUse = 2,
+  }
+
+  enum WiFiDirectPairingProcedure {
+    GroupOwnerNegotiation = 0,
+    Invitation = 1,
+  }
+
+  interface IWiFiDirectAdvertisement {
+    InformationElements: Windows.Foundation.Collections.IVector<Windows.Devices.WiFiDirect.WiFiDirectInformationElement> | Windows.Devices.WiFiDirect.WiFiDirectInformationElement[];
+    IsAutonomousGroupOwnerEnabled: boolean;
+    readonly LegacySettings: Windows.Devices.WiFiDirect.WiFiDirectLegacySettings;
+    ListenStateDiscoverability: number;
+  }
+  var IWiFiDirectAdvertisement: abstract new (...args: any[]) => IWiFiDirectAdvertisement;
+
+  interface IWiFiDirectAdvertisement2 {
+    readonly SupportedConfigurationMethods: Windows.Foundation.Collections.IVector<number> | number[];
+  }
+  var IWiFiDirectAdvertisement2: abstract new (...args: any[]) => IWiFiDirectAdvertisement2;
+
+  interface IWiFiDirectAdvertisementPublisher {
+    Start(): void;
+    Stop(): void;
+    readonly Advertisement: Windows.Devices.WiFiDirect.WiFiDirectAdvertisement;
+    readonly Status: number;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisher, Windows.Devices.WiFiDirect.WiFiDirectAdvertisementPublisherStatusChangedEventArgs> | null;
+  }
+  var IWiFiDirectAdvertisementPublisher: abstract new (...args: any[]) => IWiFiDirectAdvertisementPublisher;
+
+  interface IWiFiDirectAdvertisementPublisherStatusChangedEventArgs {
+    readonly Error: number;
+    readonly Status: number;
+  }
+  var IWiFiDirectAdvertisementPublisherStatusChangedEventArgs: abstract new (...args: any[]) => IWiFiDirectAdvertisementPublisherStatusChangedEventArgs;
+
+  interface IWiFiDirectConnectionListener {
+    ConnectionRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFiDirect.WiFiDirectConnectionListener, Windows.Devices.WiFiDirect.WiFiDirectConnectionRequestedEventArgs> | null;
+  }
+  var IWiFiDirectConnectionListener: abstract new (...args: any[]) => IWiFiDirectConnectionListener;
+
+  interface IWiFiDirectConnectionParameters {
+    GroupOwnerIntent: number;
+  }
+  var IWiFiDirectConnectionParameters: abstract new (...args: any[]) => IWiFiDirectConnectionParameters;
+
+  interface IWiFiDirectConnectionParameters2 {
+    readonly PreferenceOrderedConfigurationMethods: Windows.Foundation.Collections.IVector<number> | number[];
+    PreferredPairingProcedure: number;
+  }
+  var IWiFiDirectConnectionParameters2: abstract new (...args: any[]) => IWiFiDirectConnectionParameters2;
+
+  interface IWiFiDirectConnectionParametersStatics {
+    GetDevicePairingKinds(configurationMethod: number): number;
+  }
+  var IWiFiDirectConnectionParametersStatics: abstract new (...args: any[]) => IWiFiDirectConnectionParametersStatics;
+
+  interface IWiFiDirectConnectionRequest extends Windows.Foundation.IClosable {
+    Close(): void;
+    readonly DeviceInformation: Windows.Devices.Enumeration.DeviceInformation;
+  }
+  var IWiFiDirectConnectionRequest: abstract new (...args: any[]) => IWiFiDirectConnectionRequest;
+
+  interface IWiFiDirectConnectionRequestedEventArgs {
+    GetConnectionRequest(): Windows.Devices.WiFiDirect.WiFiDirectConnectionRequest;
+  }
+  var IWiFiDirectConnectionRequestedEventArgs: abstract new (...args: any[]) => IWiFiDirectConnectionRequestedEventArgs;
+
+  interface IWiFiDirectDevice extends Windows.Foundation.IClosable {
+    Close(): void;
+    GetConnectionEndpointPairs(): Windows.Foundation.Collections.IVectorView<Windows.Networking.EndpointPair> | Windows.Networking.EndpointPair[];
+    readonly ConnectionStatus: number;
+    readonly DeviceId: string;
+    ConnectionStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFiDirect.WiFiDirectDevice, Object> | null;
+  }
+  var IWiFiDirectDevice: abstract new (...args: any[]) => IWiFiDirectDevice;
+
+  interface IWiFiDirectDeviceStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFiDirect.WiFiDirectDevice>;
+    GetDeviceSelector(): string;
+  }
+  var IWiFiDirectDeviceStatics: abstract new (...args: any[]) => IWiFiDirectDeviceStatics;
+
+  interface IWiFiDirectDeviceStatics2 {
+    FromIdAsync(deviceId: string, connectionParameters: Windows.Devices.WiFiDirect.WiFiDirectConnectionParameters): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFiDirect.WiFiDirectDevice>;
+    GetDeviceSelector(type: number): string;
+  }
+  var IWiFiDirectDeviceStatics2: abstract new (...args: any[]) => IWiFiDirectDeviceStatics2;
+
+  interface IWiFiDirectInformationElement {
+    Oui: Windows.Storage.Streams.IBuffer;
+    OuiType: number;
+    Value: Windows.Storage.Streams.IBuffer;
+  }
+  var IWiFiDirectInformationElement: abstract new (...args: any[]) => IWiFiDirectInformationElement;
+
+  interface IWiFiDirectInformationElementStatics {
+    CreateFromBuffer(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.Collections.IVector<Windows.Devices.WiFiDirect.WiFiDirectInformationElement> | Windows.Devices.WiFiDirect.WiFiDirectInformationElement[];
+    CreateFromDeviceInformation(deviceInformation: Windows.Devices.Enumeration.DeviceInformation): Windows.Foundation.Collections.IVector<Windows.Devices.WiFiDirect.WiFiDirectInformationElement> | Windows.Devices.WiFiDirect.WiFiDirectInformationElement[];
+  }
+  var IWiFiDirectInformationElementStatics: abstract new (...args: any[]) => IWiFiDirectInformationElementStatics;
+
+  interface IWiFiDirectLegacySettings {
+    IsEnabled: boolean;
+    Passphrase: Windows.Security.Credentials.PasswordCredential;
+    Ssid: string;
+  }
+  var IWiFiDirectLegacySettings: abstract new (...args: any[]) => IWiFiDirectLegacySettings;
+
+}
+
+declare namespace Windows.Devices.WiFiDirect.Services {
+  class WiFiDirectService implements Windows.Devices.WiFiDirect.Services.IWiFiDirectService {
+    ConnectAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession>;
+    ConnectAsync(pin: string): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession>;
+    static FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFiDirect.Services.WiFiDirectService>;
+    GetProvisioningInfoAsync(selectedConfigurationMethod: number): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceProvisioningInfo>;
+    static GetSelector(serviceName: string): string;
+    static GetSelector(serviceName: string, serviceInfoFilter: Windows.Storage.Streams.IBuffer): string;
+    PreferGroupOwnerMode: boolean;
+    readonly RemoteServiceInfo: Windows.Storage.Streams.IBuffer;
+    readonly ServiceError: number;
+    SessionInfo: Windows.Storage.Streams.IBuffer;
+    readonly SupportedConfigurationMethods: Windows.Foundation.Collections.IVectorView<number> | number[];
+    SessionDeferred: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFiDirect.Services.WiFiDirectService, Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs> | null;
+  }
+
+  class WiFiDirectServiceAdvertiser implements Windows.Devices.WiFiDirect.Services.IWiFiDirectServiceAdvertiser {
+    constructor(serviceName: string);
+    ConnectAsync(deviceInfo: Windows.Devices.Enumeration.DeviceInformation): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession>;
+    ConnectAsync(deviceInfo: Windows.Devices.Enumeration.DeviceInformation, pin: string): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession>;
+    Start(): void;
+    Stop(): void;
+    readonly AdvertisementStatus: number;
+    AutoAcceptSession: boolean;
+    CustomServiceStatusCode: number;
+    DeferredSessionInfo: Windows.Storage.Streams.IBuffer;
+    PreferGroupOwnerMode: boolean;
+    readonly PreferredConfigurationMethods: Windows.Foundation.Collections.IVector<number> | number[];
+    readonly ServiceError: number;
+    ServiceInfo: Windows.Storage.Streams.IBuffer;
+    readonly ServiceName: string;
+    readonly ServiceNamePrefixes: Windows.Foundation.Collections.IVector<string> | string[];
+    ServiceStatus: number;
+    AdvertisementStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser, Object> | null;
+    AutoAcceptSessionConnected: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser, Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs> | null;
+    SessionRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser, Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs> | null;
+  }
+
+  class WiFiDirectServiceAutoAcceptSessionConnectedEventArgs implements Windows.Devices.WiFiDirect.Services.IWiFiDirectServiceAutoAcceptSessionConnectedEventArgs {
+    readonly Session: Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession;
+    readonly SessionInfo: Windows.Storage.Streams.IBuffer;
+  }
+
+  class WiFiDirectServiceProvisioningInfo implements Windows.Devices.WiFiDirect.Services.IWiFiDirectServiceProvisioningInfo {
+    readonly IsGroupFormationNeeded: boolean;
+    readonly SelectedConfigurationMethod: number;
+  }
+
+  class WiFiDirectServiceRemotePortAddedEventArgs implements Windows.Devices.WiFiDirect.Services.IWiFiDirectServiceRemotePortAddedEventArgs {
+    readonly EndpointPairs: Windows.Foundation.Collections.IVectorView<Windows.Networking.EndpointPair> | Windows.Networking.EndpointPair[];
+    readonly Protocol: number;
+  }
+
+  class WiFiDirectServiceSession implements Windows.Devices.WiFiDirect.Services.IWiFiDirectServiceSession, Windows.Foundation.IClosable {
+    AddDatagramSocketAsync(value: Windows.Networking.Sockets.DatagramSocket): Windows.Foundation.IAsyncAction;
+    AddStreamSocketListenerAsync(value: Windows.Networking.Sockets.StreamSocketListener): Windows.Foundation.IAsyncAction;
+    Close(): void;
+    GetConnectionEndpointPairs(): Windows.Foundation.Collections.IVectorView<Windows.Networking.EndpointPair> | Windows.Networking.EndpointPair[];
+    readonly AdvertisementId: number;
+    readonly ErrorStatus: number;
+    readonly ServiceAddress: string;
+    readonly ServiceName: string;
+    readonly SessionAddress: string;
+    readonly SessionId: number;
+    readonly Status: number;
+    RemotePortAdded: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession, Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs> | null;
+    SessionStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession, Object> | null;
+  }
+
+  class WiFiDirectServiceSessionDeferredEventArgs implements Windows.Devices.WiFiDirect.Services.IWiFiDirectServiceSessionDeferredEventArgs {
+    readonly DeferredSessionInfo: Windows.Storage.Streams.IBuffer;
+  }
+
+  class WiFiDirectServiceSessionRequest implements Windows.Devices.WiFiDirect.Services.IWiFiDirectServiceSessionRequest, Windows.Foundation.IClosable {
+    Close(): void;
+    readonly DeviceInformation: Windows.Devices.Enumeration.DeviceInformation;
+    readonly ProvisioningInfo: Windows.Devices.WiFiDirect.Services.WiFiDirectServiceProvisioningInfo;
+    readonly SessionInfo: Windows.Storage.Streams.IBuffer;
+  }
+
+  class WiFiDirectServiceSessionRequestedEventArgs implements Windows.Devices.WiFiDirect.Services.IWiFiDirectServiceSessionRequestedEventArgs {
+    GetSessionRequest(): Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequest;
+  }
+
+  enum WiFiDirectServiceAdvertisementStatus {
+    Created = 0,
+    Started = 1,
+    Stopped = 2,
+    Aborted = 3,
+  }
+
+  enum WiFiDirectServiceConfigurationMethod {
+    Default = 0,
+    PinDisplay = 1,
+    PinEntry = 2,
+  }
+
+  enum WiFiDirectServiceError {
+    Success = 0,
+    RadioNotAvailable = 1,
+    ResourceInUse = 2,
+    UnsupportedHardware = 3,
+    NoHardware = 4,
+  }
+
+  enum WiFiDirectServiceIPProtocol {
+    Tcp = 6,
+    Udp = 17,
+  }
+
+  enum WiFiDirectServiceSessionErrorStatus {
+    Ok = 0,
+    Disassociated = 1,
+    LocalClose = 2,
+    RemoteClose = 3,
+    SystemFailure = 4,
+    NoResponseFromRemote = 5,
+  }
+
+  enum WiFiDirectServiceSessionStatus {
+    Closed = 0,
+    Initiated = 1,
+    Requested = 2,
+    Open = 3,
+  }
+
+  enum WiFiDirectServiceStatus {
+    Available = 0,
+    Busy = 1,
+    Custom = 2,
+  }
+
+  interface IWiFiDirectService {
+    ConnectAsync(): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession>;
+    ConnectAsync(pin: string): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession>;
+    GetProvisioningInfoAsync(selectedConfigurationMethod: number): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceProvisioningInfo>;
+    PreferGroupOwnerMode: boolean;
+    readonly RemoteServiceInfo: Windows.Storage.Streams.IBuffer;
+    readonly ServiceError: number;
+    SessionInfo: Windows.Storage.Streams.IBuffer;
+    readonly SupportedConfigurationMethods: Windows.Foundation.Collections.IVectorView<number> | number[];
+    SessionDeferred: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFiDirect.Services.WiFiDirectService, Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionDeferredEventArgs> | null;
+  }
+  var IWiFiDirectService: abstract new (...args: any[]) => IWiFiDirectService;
+
+  interface IWiFiDirectServiceAdvertiser {
+    ConnectAsync(deviceInfo: Windows.Devices.Enumeration.DeviceInformation): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession>;
+    ConnectAsync(deviceInfo: Windows.Devices.Enumeration.DeviceInformation, pin: string): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession>;
+    Start(): void;
+    Stop(): void;
+    readonly AdvertisementStatus: number;
+    AutoAcceptSession: boolean;
+    CustomServiceStatusCode: number;
+    DeferredSessionInfo: Windows.Storage.Streams.IBuffer;
+    PreferGroupOwnerMode: boolean;
+    readonly PreferredConfigurationMethods: Windows.Foundation.Collections.IVector<number> | number[];
+    readonly ServiceError: number;
+    ServiceInfo: Windows.Storage.Streams.IBuffer;
+    readonly ServiceName: string;
+    readonly ServiceNamePrefixes: Windows.Foundation.Collections.IVector<string> | string[];
+    ServiceStatus: number;
+    AdvertisementStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser, Object> | null;
+    AutoAcceptSessionConnected: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser, Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAutoAcceptSessionConnectedEventArgs> | null;
+    SessionRequested: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser, Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequestedEventArgs> | null;
+  }
+  var IWiFiDirectServiceAdvertiser: abstract new (...args: any[]) => IWiFiDirectServiceAdvertiser;
+
+  interface IWiFiDirectServiceAdvertiserFactory {
+    CreateWiFiDirectServiceAdvertiser(serviceName: string): Windows.Devices.WiFiDirect.Services.WiFiDirectServiceAdvertiser;
+  }
+  var IWiFiDirectServiceAdvertiserFactory: abstract new (...args: any[]) => IWiFiDirectServiceAdvertiserFactory;
+
+  interface IWiFiDirectServiceAutoAcceptSessionConnectedEventArgs {
+    readonly Session: Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession;
+    readonly SessionInfo: Windows.Storage.Streams.IBuffer;
+  }
+  var IWiFiDirectServiceAutoAcceptSessionConnectedEventArgs: abstract new (...args: any[]) => IWiFiDirectServiceAutoAcceptSessionConnectedEventArgs;
+
+  interface IWiFiDirectServiceProvisioningInfo {
+    readonly IsGroupFormationNeeded: boolean;
+    readonly SelectedConfigurationMethod: number;
+  }
+  var IWiFiDirectServiceProvisioningInfo: abstract new (...args: any[]) => IWiFiDirectServiceProvisioningInfo;
+
+  interface IWiFiDirectServiceRemotePortAddedEventArgs {
+    readonly EndpointPairs: Windows.Foundation.Collections.IVectorView<Windows.Networking.EndpointPair> | Windows.Networking.EndpointPair[];
+    readonly Protocol: number;
+  }
+  var IWiFiDirectServiceRemotePortAddedEventArgs: abstract new (...args: any[]) => IWiFiDirectServiceRemotePortAddedEventArgs;
+
+  interface IWiFiDirectServiceSession extends Windows.Foundation.IClosable {
+    AddDatagramSocketAsync(value: Windows.Networking.Sockets.DatagramSocket): Windows.Foundation.IAsyncAction;
+    AddStreamSocketListenerAsync(value: Windows.Networking.Sockets.StreamSocketListener): Windows.Foundation.IAsyncAction;
+    Close(): void;
+    GetConnectionEndpointPairs(): Windows.Foundation.Collections.IVectorView<Windows.Networking.EndpointPair> | Windows.Networking.EndpointPair[];
+    readonly AdvertisementId: number;
+    readonly ErrorStatus: number;
+    readonly ServiceAddress: string;
+    readonly ServiceName: string;
+    readonly SessionAddress: string;
+    readonly SessionId: number;
+    readonly Status: number;
+    RemotePortAdded: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession, Windows.Devices.WiFiDirect.Services.WiFiDirectServiceRemotePortAddedEventArgs> | null;
+    SessionStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSession, Object> | null;
+  }
+  var IWiFiDirectServiceSession: abstract new (...args: any[]) => IWiFiDirectServiceSession;
+
+  interface IWiFiDirectServiceSessionDeferredEventArgs {
+    readonly DeferredSessionInfo: Windows.Storage.Streams.IBuffer;
+  }
+  var IWiFiDirectServiceSessionDeferredEventArgs: abstract new (...args: any[]) => IWiFiDirectServiceSessionDeferredEventArgs;
+
+  interface IWiFiDirectServiceSessionRequest extends Windows.Foundation.IClosable {
+    Close(): void;
+    readonly DeviceInformation: Windows.Devices.Enumeration.DeviceInformation;
+    readonly ProvisioningInfo: Windows.Devices.WiFiDirect.Services.WiFiDirectServiceProvisioningInfo;
+    readonly SessionInfo: Windows.Storage.Streams.IBuffer;
+  }
+  var IWiFiDirectServiceSessionRequest: abstract new (...args: any[]) => IWiFiDirectServiceSessionRequest;
+
+  interface IWiFiDirectServiceSessionRequestedEventArgs {
+    GetSessionRequest(): Windows.Devices.WiFiDirect.Services.WiFiDirectServiceSessionRequest;
+  }
+  var IWiFiDirectServiceSessionRequestedEventArgs: abstract new (...args: any[]) => IWiFiDirectServiceSessionRequestedEventArgs;
+
+  interface IWiFiDirectServiceStatics {
+    FromIdAsync(deviceId: string): Windows.Foundation.IAsyncOperation<Windows.Devices.WiFiDirect.Services.WiFiDirectService>;
+    GetSelector(serviceName: string): string;
+    GetSelector(serviceName: string, serviceInfoFilter: Windows.Storage.Streams.IBuffer): string;
+  }
+  var IWiFiDirectServiceStatics: abstract new (...args: any[]) => IWiFiDirectServiceStatics;
+
+}
+
+declare namespace Windows.Foundation {
+  class Deferral implements Windows.Foundation.IClosable, Windows.Foundation.IDeferral {
+    constructor(handler: Windows.Foundation.DeferralCompletedHandler);
+    Close(): void;
+    Complete(): void;
+  }
+
+  class GuidHelper {
+    static CreateNewGuid(): Guid;
+    static Equals(target: Object, value: Object): boolean;
+    static readonly Empty: Guid;
+  }
+
+  class MemoryBuffer implements Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+    constructor(capacity: number);
+    Close(): void;
+    CreateReference(): Windows.Foundation.IMemoryBufferReference;
+  }
+
+  class PropertyValue {
+    static CreateBoolean(value: boolean): Object;
+    static CreateBooleanArray(value: boolean[]): Object;
+    static CreateChar16(value: string): Object;
+    static CreateChar16Array(value: string[]): Object;
+    static CreateDateTime(value: Windows.Foundation.DateTime): Object;
+    static CreateDateTimeArray(value: Windows.Foundation.DateTime[]): Object;
+    static CreateDouble(value: number): Object;
+    static CreateDoubleArray(value: number[]): Object;
+    static CreateEmpty(): Object;
+    static CreateGuid(value: Guid): Object;
+    static CreateGuidArray(value: Guid[]): Object;
+    static CreateInspectable(value: Object): Object;
+    static CreateInspectableArray(value: Object[]): Object;
+    static CreateInt16(value: number): Object;
+    static CreateInt16Array(value: number[]): Object;
+    static CreateInt32(value: number): Object;
+    static CreateInt32Array(value: number[]): Object;
+    static CreateInt64(value: number | bigint): Object;
+    static CreateInt64Array(value: number | bigint[]): Object;
+    static CreatePoint(value: Windows.Foundation.Point): Object;
+    static CreatePointArray(value: Windows.Foundation.Point[]): Object;
+    static CreateRect(value: Windows.Foundation.Rect): Object;
+    static CreateRectArray(value: Windows.Foundation.Rect[]): Object;
+    static CreateSingle(value: number): Object;
+    static CreateSingleArray(value: number[]): Object;
+    static CreateSize(value: Windows.Foundation.Size): Object;
+    static CreateSizeArray(value: Windows.Foundation.Size[]): Object;
+    static CreateString(value: string): Object;
+    static CreateStringArray(value: string[]): Object;
+    static CreateTimeSpan(value: Windows.Foundation.TimeSpan): Object;
+    static CreateTimeSpanArray(value: Windows.Foundation.TimeSpan[]): Object;
+    static CreateUInt16(value: number): Object;
+    static CreateUInt16Array(value: number[]): Object;
+    static CreateUInt32(value: number): Object;
+    static CreateUInt32Array(value: number[]): Object;
+    static CreateUInt64(value: number | bigint): Object;
+    static CreateUInt64Array(value: number | bigint[]): Object;
+    static CreateUInt8(value: number): Object;
+    static CreateUInt8Array(value: number[]): Object;
+  }
+
+  class Uri implements Windows.Foundation.IStringable, Windows.Foundation.IUriRuntimeClass, Windows.Foundation.IUriRuntimeClassWithAbsoluteCanonicalUri {
+    constructor(uri: string);
+    constructor(baseUri: string, relativeUri: string);
+    CombineUri(relativeUri: string): Windows.Foundation.Uri;
+    Equals(pUri: Windows.Foundation.Uri): boolean;
+    static EscapeComponent(toEscape: string): string;
+    ToString(): string;
+    static UnescapeComponent(toUnescape: string): string;
+    readonly AbsoluteCanonicalUri: string;
+    readonly AbsoluteUri: string;
+    readonly DisplayIri: string;
+    readonly DisplayUri: string;
+    readonly Domain: string;
+    readonly Extension: string;
+    readonly Fragment: string;
+    readonly Host: string;
+    readonly Password: string;
+    readonly Path: string;
+    readonly Port: number;
+    readonly Query: string;
+    readonly QueryParsed: Windows.Foundation.WwwFormUrlDecoder;
+    readonly RawUri: string;
+    readonly SchemeName: string;
+    readonly Suspicious: boolean;
+    readonly UserName: string;
+  }
+
+  class WwwFormUrlDecoder implements Windows.Foundation.IWwwFormUrlDecoderRuntimeClass {
+    constructor(query: string);
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.IWwwFormUrlDecoderEntry>;
+    GetAt(index: number): Windows.Foundation.IWwwFormUrlDecoderEntry;
+    GetFirstValueByName(name: string): string;
+    GetMany(startIndex: number, items: Windows.Foundation.IWwwFormUrlDecoderEntry[]): number;
+    IndexOf(value: Windows.Foundation.IWwwFormUrlDecoderEntry, index: number): boolean;
+    readonly Size: number;
+  }
+
+  class WwwFormUrlDecoderEntry implements Windows.Foundation.IWwwFormUrlDecoderEntry {
+    readonly Name: string;
+    readonly Value: string;
+  }
+
+  enum AsyncStatus {
+    Canceled = 2,
+    Completed = 1,
+    Error = 3,
+    Started = 0,
+  }
+
+  enum PropertyType {
+    Empty = 0,
+    UInt8 = 1,
+    Int16 = 2,
+    UInt16 = 3,
+    Int32 = 4,
+    UInt32 = 5,
+    Int64 = 6,
+    UInt64 = 7,
+    Single = 8,
+    Double = 9,
+    Char16 = 10,
+    Boolean = 11,
+    String = 12,
+    Inspectable = 13,
+    DateTime = 14,
+    TimeSpan = 15,
+    Guid = 16,
+    Point = 17,
+    Size = 18,
+    Rect = 19,
+    OtherType = 20,
+    UInt8Array = 1025,
+    Int16Array = 1026,
+    UInt16Array = 1027,
+    Int32Array = 1028,
+    UInt32Array = 1029,
+    Int64Array = 1030,
+    UInt64Array = 1031,
+    SingleArray = 1032,
+    DoubleArray = 1033,
+    Char16Array = 1034,
+    BooleanArray = 1035,
+    StringArray = 1036,
+    InspectableArray = 1037,
+    DateTimeArray = 1038,
+    TimeSpanArray = 1039,
+    GuidArray = 1040,
+    PointArray = 1041,
+    SizeArray = 1042,
+    RectArray = 1043,
+    OtherTypeArray = 1044,
+  }
+
+  interface AsyncActionCompletedHandler {
+    (asyncInfo: Windows.Foundation.IAsyncAction, asyncStatus: number): void;
+  }
+  var AsyncActionCompletedHandler: {
+    new(callback: (asyncInfo: Windows.Foundation.IAsyncAction, asyncStatus: number) => void): AsyncActionCompletedHandler;
+  };
+
+  interface AsyncActionProgressHandler<T1> {
+    (asyncInfo: Windows.Foundation.IAsyncActionWithProgress<T1>, progressInfo: T1): void;
+  }
+  var AsyncActionProgressHandler: {
+    new<T1>(callback: (asyncInfo: Windows.Foundation.IAsyncActionWithProgress<T1>, progressInfo: T1) => void): AsyncActionProgressHandler<T1>;
+  };
+
+  interface AsyncActionWithProgressCompletedHandler<T1> {
+    (asyncInfo: Windows.Foundation.IAsyncActionWithProgress<T1>, asyncStatus: number): void;
+  }
+  var AsyncActionWithProgressCompletedHandler: {
+    new<T1>(callback: (asyncInfo: Windows.Foundation.IAsyncActionWithProgress<T1>, asyncStatus: number) => void): AsyncActionWithProgressCompletedHandler<T1>;
+  };
+
+  interface AsyncOperationCompletedHandler<T1> {
+    (asyncInfo: Windows.Foundation.IAsyncOperation<T1>, asyncStatus: number): void;
+  }
+  var AsyncOperationCompletedHandler: {
+    new<T1>(callback: (asyncInfo: Windows.Foundation.IAsyncOperation<T1>, asyncStatus: number) => void): AsyncOperationCompletedHandler<T1>;
+  };
+
+  interface AsyncOperationProgressHandler<T1, T2> {
+    (asyncInfo: Windows.Foundation.IAsyncOperationWithProgress<T1, T2>, progressInfo: T2): void;
+  }
+  var AsyncOperationProgressHandler: {
+    new<T1, T2>(callback: (asyncInfo: Windows.Foundation.IAsyncOperationWithProgress<T1, T2>, progressInfo: T2) => void): AsyncOperationProgressHandler<T1, T2>;
+  };
+
+  interface AsyncOperationWithProgressCompletedHandler<T1, T2> {
+    (asyncInfo: Windows.Foundation.IAsyncOperationWithProgress<T1, T2>, asyncStatus: number): void;
+  }
+  var AsyncOperationWithProgressCompletedHandler: {
+    new<T1, T2>(callback: (asyncInfo: Windows.Foundation.IAsyncOperationWithProgress<T1, T2>, asyncStatus: number) => void): AsyncOperationWithProgressCompletedHandler<T1, T2>;
+  };
+
+  interface DateTime {
+    UniversalTime: number | bigint;
+  }
+  var DateTime: {
+    new(universalTime: number | bigint): DateTime;
+    new(fields: { UniversalTime?: number | bigint }): DateTime;
+  };
+
+  interface DeferralCompletedHandler {
+    (): void;
+  }
+  var DeferralCompletedHandler: {
+    new(callback: () => void): DeferralCompletedHandler;
+  };
+
+  interface EventHandler<T1> {
+    (sender: Object, args: T1): void;
+  }
+  var EventHandler: {
+    new<T1>(callback: (sender: Object, args: T1) => void): EventHandler<T1>;
+  };
+
+  interface EventRegistrationToken {
+    Value: number | bigint;
+  }
+  var EventRegistrationToken: {
+    new(value: number | bigint): EventRegistrationToken;
+    new(fields: { Value?: number | bigint }): EventRegistrationToken;
+  };
+
+  interface FoundationContract {
+  }
+  var FoundationContract: {
+    new(fields: {  }): FoundationContract;
+  };
+
+  interface HResult {
+    Value: number;
+  }
+  var HResult: {
+    new(value: number): HResult;
+    new(fields: { Value?: number }): HResult;
+  };
+
+  interface IAsyncAction extends Windows.Foundation.IAsyncInfo {
+    Cancel(): void;
+    Close(): void;
+    GetResults(): void;
+    Completed: Windows.Foundation.AsyncActionCompletedHandler;
+  }
+  var IAsyncAction: abstract new (...args: any[]) => IAsyncAction;
+
+  interface IAsyncActionWithProgress<T1> extends Windows.Foundation.IAsyncInfo {
+    GetResults(): void;
+    Completed: Windows.Foundation.AsyncActionWithProgressCompletedHandler<T1>;
+    Progress: Windows.Foundation.AsyncActionProgressHandler<T1>;
+  }
+
+  interface IAsyncInfo {
+    Cancel(): void;
+    Close(): void;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly Id: number;
+    readonly Status: number;
+  }
+  var IAsyncInfo: abstract new (...args: any[]) => IAsyncInfo;
+
+  interface IAsyncOperation<T1> extends Windows.Foundation.IAsyncInfo {
+    GetResults(): T1;
+    Completed: Windows.Foundation.AsyncOperationCompletedHandler<T1>;
+  }
+
+  interface IAsyncOperationWithProgress<T1, T2> extends Windows.Foundation.IAsyncInfo {
+    GetResults(): T1;
+    Completed: Windows.Foundation.AsyncOperationWithProgressCompletedHandler<T1, T2>;
+    Progress: Windows.Foundation.AsyncOperationProgressHandler<T1, T2>;
+  }
+
+  interface IClosable {
+    Close(): void;
+  }
+  var IClosable: abstract new (...args: any[]) => IClosable;
+
+  interface IDeferral extends Windows.Foundation.IClosable {
+    Close(): void;
+    Complete(): void;
+  }
+  var IDeferral: abstract new (...args: any[]) => IDeferral;
+
+  interface IDeferralFactory {
+    Create(handler: Windows.Foundation.DeferralCompletedHandler): Windows.Foundation.Deferral;
+  }
+  var IDeferralFactory: abstract new (...args: any[]) => IDeferralFactory;
+
+  interface IGetActivationFactory {
+    GetActivationFactory(activatableClassId: string): Object;
+  }
+  var IGetActivationFactory: abstract new (...args: any[]) => IGetActivationFactory;
+
+  interface IGuidHelperStatics {
+    CreateNewGuid(): Guid;
+    Equals(target: Object, value: Object): boolean;
+    readonly Empty: Guid;
+  }
+  var IGuidHelperStatics: abstract new (...args: any[]) => IGuidHelperStatics;
+
+  interface IMemoryBuffer extends Windows.Foundation.IClosable {
+    Close(): void;
+    CreateReference(): Windows.Foundation.IMemoryBufferReference;
+  }
+  var IMemoryBuffer: abstract new (...args: any[]) => IMemoryBuffer;
+
+  interface IMemoryBufferFactory {
+    Create(capacity: number): Windows.Foundation.MemoryBuffer;
+  }
+  var IMemoryBufferFactory: abstract new (...args: any[]) => IMemoryBufferFactory;
+
+  interface IMemoryBufferReference extends Windows.Foundation.IClosable {
+    Close(): void;
+    readonly Capacity: number;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Foundation.IMemoryBufferReference, Object> | null;
+  }
+  var IMemoryBufferReference: abstract new (...args: any[]) => IMemoryBufferReference;
+
+  interface IPropertyValue {
+    GetBoolean(): boolean;
+    GetBooleanArray(value: boolean[]): void;
+    GetChar16(): string;
+    GetChar16Array(value: string[]): void;
+    GetDateTime(): Windows.Foundation.DateTime;
+    GetDateTimeArray(value: Windows.Foundation.DateTime[]): void;
+    GetDouble(): number;
+    GetDoubleArray(value: number[]): void;
+    GetGuid(): Guid;
+    GetGuidArray(value: Guid[]): void;
+    GetInspectableArray(value: Object[]): void;
+    GetInt16(): number;
+    GetInt16Array(value: number[]): void;
+    GetInt32(): number;
+    GetInt32Array(value: number[]): void;
+    GetInt64(): number | bigint;
+    GetInt64Array(value: number | bigint[]): void;
+    GetPoint(): Windows.Foundation.Point;
+    GetPointArray(value: Windows.Foundation.Point[]): void;
+    GetRect(): Windows.Foundation.Rect;
+    GetRectArray(value: Windows.Foundation.Rect[]): void;
+    GetSingle(): number;
+    GetSingleArray(value: number[]): void;
+    GetSize(): Windows.Foundation.Size;
+    GetSizeArray(value: Windows.Foundation.Size[]): void;
+    GetString(): string;
+    GetStringArray(value: string[]): void;
+    GetTimeSpan(): Windows.Foundation.TimeSpan;
+    GetTimeSpanArray(value: Windows.Foundation.TimeSpan[]): void;
+    GetUInt16(): number;
+    GetUInt16Array(value: number[]): void;
+    GetUInt32(): number;
+    GetUInt32Array(value: number[]): void;
+    GetUInt64(): number | bigint;
+    GetUInt64Array(value: number | bigint[]): void;
+    GetUInt8(): number;
+    GetUInt8Array(value: number[]): void;
+    readonly IsNumericScalar: boolean;
+    readonly Type: number;
+  }
+  var IPropertyValue: abstract new (...args: any[]) => IPropertyValue;
+
+  interface IPropertyValueStatics {
+    CreateBoolean(value: boolean): Object;
+    CreateBooleanArray(value: boolean[]): Object;
+    CreateChar16(value: string): Object;
+    CreateChar16Array(value: string[]): Object;
+    CreateDateTime(value: Windows.Foundation.DateTime): Object;
+    CreateDateTimeArray(value: Windows.Foundation.DateTime[]): Object;
+    CreateDouble(value: number): Object;
+    CreateDoubleArray(value: number[]): Object;
+    CreateEmpty(): Object;
+    CreateGuid(value: Guid): Object;
+    CreateGuidArray(value: Guid[]): Object;
+    CreateInspectable(value: Object): Object;
+    CreateInspectableArray(value: Object[]): Object;
+    CreateInt16(value: number): Object;
+    CreateInt16Array(value: number[]): Object;
+    CreateInt32(value: number): Object;
+    CreateInt32Array(value: number[]): Object;
+    CreateInt64(value: number | bigint): Object;
+    CreateInt64Array(value: number | bigint[]): Object;
+    CreatePoint(value: Windows.Foundation.Point): Object;
+    CreatePointArray(value: Windows.Foundation.Point[]): Object;
+    CreateRect(value: Windows.Foundation.Rect): Object;
+    CreateRectArray(value: Windows.Foundation.Rect[]): Object;
+    CreateSingle(value: number): Object;
+    CreateSingleArray(value: number[]): Object;
+    CreateSize(value: Windows.Foundation.Size): Object;
+    CreateSizeArray(value: Windows.Foundation.Size[]): Object;
+    CreateString(value: string): Object;
+    CreateStringArray(value: string[]): Object;
+    CreateTimeSpan(value: Windows.Foundation.TimeSpan): Object;
+    CreateTimeSpanArray(value: Windows.Foundation.TimeSpan[]): Object;
+    CreateUInt16(value: number): Object;
+    CreateUInt16Array(value: number[]): Object;
+    CreateUInt32(value: number): Object;
+    CreateUInt32Array(value: number[]): Object;
+    CreateUInt64(value: number | bigint): Object;
+    CreateUInt64Array(value: number | bigint[]): Object;
+    CreateUInt8(value: number): Object;
+    CreateUInt8Array(value: number[]): Object;
+  }
+  var IPropertyValueStatics: abstract new (...args: any[]) => IPropertyValueStatics;
+
+  interface IReference<T1> extends Windows.Foundation.IPropertyValue {
+    readonly Value: T1;
+  }
+
+  interface IReferenceArray<T1> extends Windows.Foundation.IPropertyValue {
+    readonly Value: T1[];
+  }
+
+  interface IStringable {
+    ToString(): string;
+  }
+  var IStringable: abstract new (...args: any[]) => IStringable;
+
+  interface IUriEscapeStatics {
+    EscapeComponent(toEscape: string): string;
+    UnescapeComponent(toUnescape: string): string;
+  }
+  var IUriEscapeStatics: abstract new (...args: any[]) => IUriEscapeStatics;
+
+  interface IUriRuntimeClass {
+    CombineUri(relativeUri: string): Windows.Foundation.Uri;
+    Equals(pUri: Windows.Foundation.Uri): boolean;
+    readonly AbsoluteUri: string;
+    readonly DisplayUri: string;
+    readonly Domain: string;
+    readonly Extension: string;
+    readonly Fragment: string;
+    readonly Host: string;
+    readonly Password: string;
+    readonly Path: string;
+    readonly Port: number;
+    readonly Query: string;
+    readonly QueryParsed: Windows.Foundation.WwwFormUrlDecoder;
+    readonly RawUri: string;
+    readonly SchemeName: string;
+    readonly Suspicious: boolean;
+    readonly UserName: string;
+  }
+  var IUriRuntimeClass: abstract new (...args: any[]) => IUriRuntimeClass;
+
+  interface IUriRuntimeClassFactory {
+    CreateUri(uri: string): Windows.Foundation.Uri;
+    CreateWithRelativeUri(baseUri: string, relativeUri: string): Windows.Foundation.Uri;
+  }
+  var IUriRuntimeClassFactory: abstract new (...args: any[]) => IUriRuntimeClassFactory;
+
+  interface IUriRuntimeClassWithAbsoluteCanonicalUri {
+    readonly AbsoluteCanonicalUri: string;
+    readonly DisplayIri: string;
+  }
+  var IUriRuntimeClassWithAbsoluteCanonicalUri: abstract new (...args: any[]) => IUriRuntimeClassWithAbsoluteCanonicalUri;
+
+  interface IWwwFormUrlDecoderEntry {
+    readonly Name: string;
+    readonly Value: string;
+  }
+  var IWwwFormUrlDecoderEntry: abstract new (...args: any[]) => IWwwFormUrlDecoderEntry;
+
+  interface IWwwFormUrlDecoderRuntimeClass {
+    GetFirstValueByName(name: string): string;
+  }
+  var IWwwFormUrlDecoderRuntimeClass: abstract new (...args: any[]) => IWwwFormUrlDecoderRuntimeClass;
+
+  interface IWwwFormUrlDecoderRuntimeClassFactory {
+    CreateWwwFormUrlDecoder(query: string): Windows.Foundation.WwwFormUrlDecoder;
+  }
+  var IWwwFormUrlDecoderRuntimeClassFactory: abstract new (...args: any[]) => IWwwFormUrlDecoderRuntimeClassFactory;
+
+  interface Point {
+    X: number;
+    Y: number;
+  }
+  var Point: {
+    new(x: number, y: number): Point;
+    new(fields: { X?: number; Y?: number }): Point;
+  };
+
+  interface Rect {
+    X: number;
+    Y: number;
+    Width: number;
+    Height: number;
+  }
+  var Rect: {
+    new(x: number, y: number, width: number, height: number): Rect;
+    new(fields: { X?: number; Y?: number; Width?: number; Height?: number }): Rect;
+  };
+
+  interface Size {
+    Width: number;
+    Height: number;
+  }
+  var Size: {
+    new(width: number, height: number): Size;
+    new(fields: { Width?: number; Height?: number }): Size;
+  };
+
+  interface TimeSpan {
+    Duration: number | bigint;
+  }
+  var TimeSpan: {
+    new(duration: number | bigint): TimeSpan;
+    new(fields: { Duration?: number | bigint }): TimeSpan;
+  };
+
+  interface TypedEventHandler<T1, T2> {
+    (sender: T1, args: T2): void;
+  }
+  var TypedEventHandler: {
+    new<T1, T2>(callback: (sender: T1, args: T2) => void): TypedEventHandler<T1, T2>;
+  };
+
+  interface UniversalApiContract {
+  }
+  var UniversalApiContract: {
+    new(fields: {  }): UniversalApiContract;
+  };
+
+}
+
+declare namespace Windows.Foundation.Collections {
+  class PropertySet implements Windows.Foundation.Collections.IPropertySet {
+    constructor();
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, Object>>;
+    GetView(): Windows.Foundation.Collections.IMapView<string, Object>;
+    HasKey(key: string): boolean;
+    Insert(key: string, value: Object): boolean;
+    Lookup(key: string): Object;
+    Remove(key: string): void;
+    readonly Size: number;
+    MapChanged: Windows.Foundation.Collections.MapChangedEventHandler<string, Object> | null;
+    [key: string]: Object;
+  }
+
+  class StringMap {
+    constructor();
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, string>>;
+    GetView(): Windows.Foundation.Collections.IMapView<string, string>;
+    HasKey(key: string): boolean;
+    Insert(key: string, value: string): boolean;
+    Lookup(key: string): string;
+    Remove(key: string): void;
+    readonly Size: number;
+    MapChanged: Windows.Foundation.Collections.MapChangedEventHandler<string, string> | null;
+    [key: string]: string;
+  }
+
+  class ValueSet implements Windows.Foundation.Collections.IPropertySet {
+    constructor();
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, Object>>;
+    GetView(): Windows.Foundation.Collections.IMapView<string, Object>;
+    HasKey(key: string): boolean;
+    Insert(key: string, value: Object): boolean;
+    Lookup(key: string): Object;
+    Remove(key: string): void;
+    readonly Size: number;
+    MapChanged: Windows.Foundation.Collections.MapChangedEventHandler<string, Object> | null;
+    [key: string]: Object;
+  }
+
+  enum CollectionChange {
+    Reset = 0,
+    ItemInserted = 1,
+    ItemRemoved = 2,
+    ItemChanged = 3,
+  }
+
+  interface IIterable<T1> {
+    First(): Windows.Foundation.Collections.IIterator<T1>;
+  }
+
+  interface IIterator<T1> {
+    GetMany(items: T1[]): number;
+    MoveNext(): boolean;
+    readonly Current: T1;
+    readonly HasCurrent: boolean;
+  }
+
+  interface IKeyValuePair<T1, T2> {
+    readonly Key: T1;
+    readonly Value: T2;
+  }
+
+  interface IMap<T1, T2> {
+    Clear(): void;
+    GetView(): Windows.Foundation.Collections.IMapView<T1, T2>;
+    HasKey(key: T1): boolean;
+    Insert(key: T1, value: T2): boolean;
+    Lookup(key: T1): T2;
+    Remove(key: T1): void;
+    readonly Size: number;
+  }
+
+  interface IMapChangedEventArgs<T1> {
+    readonly CollectionChange: number;
+    readonly Key: T1;
+  }
+
+  interface IMapView<T1, T2> {
+    HasKey(key: T1): boolean;
+    Lookup(key: T1): T2;
+    Split(first: Windows.Foundation.Collections.IMapView<T1, T2>, second: Windows.Foundation.Collections.IMapView<T1, T2>): void;
+    readonly Size: number;
+  }
+
+  interface IObservableMap<T1, T2> {
+    MapChanged: Windows.Foundation.Collections.MapChangedEventHandler<T1, T2> | null;
+  }
+
+  interface IObservableVector<T1> {
+    VectorChanged: Windows.Foundation.Collections.VectorChangedEventHandler<T1> | null;
+  }
+
+  interface IPropertySet extends Windows.Foundation.Collections.IMap<string, Object>, Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Object>> {
+    [key: string]: Object;
+  }
+  var IPropertySet: abstract new (...args: any[]) => IPropertySet;
+
+  interface IVector<T1> {
+    Append(value: T1): void;
+    Clear(): void;
+    GetAt(index: number): T1;
+    GetMany(startIndex: number, items: T1[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<T1> | T1[];
+    IndexOf(value: T1, index: number): boolean;
+    InsertAt(index: number, value: T1): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: T1[]): void;
+    SetAt(index: number, value: T1): void;
+    readonly Size: number;
+  }
+
+  interface IVectorChangedEventArgs {
+    readonly CollectionChange: number;
+    readonly Index: number;
+  }
+  var IVectorChangedEventArgs: abstract new (...args: any[]) => IVectorChangedEventArgs;
+
+  interface IVectorView<T1> {
+    GetAt(index: number): T1;
+    GetMany(startIndex: number, items: T1[]): number;
+    IndexOf(value: T1, index: number): boolean;
+    readonly Size: number;
+  }
+
+  interface MapChangedEventHandler<T1, T2> {
+    (sender: Windows.Foundation.Collections.IObservableMap<T1, T2>, event: Windows.Foundation.Collections.IMapChangedEventArgs<T1>): void;
+  }
+  var MapChangedEventHandler: {
+    new<T1, T2>(callback: (sender: Windows.Foundation.Collections.IObservableMap<T1, T2>, event: Windows.Foundation.Collections.IMapChangedEventArgs<T1>) => void): MapChangedEventHandler<T1, T2>;
+  };
+
+  interface VectorChangedEventHandler<T1> {
+    (sender: Windows.Foundation.Collections.IObservableVector<T1>, event: Windows.Foundation.Collections.IVectorChangedEventArgs): void;
+  }
+  var VectorChangedEventHandler: {
+    new<T1>(callback: (sender: Windows.Foundation.Collections.IObservableVector<T1>, event: Windows.Foundation.Collections.IVectorChangedEventArgs) => void): VectorChangedEventHandler<T1>;
+  };
+
+}
+
+declare namespace Windows.Foundation.Diagnostics {
+  class AsyncCausalityTracer {
+    static TraceOperationCompletion(traceLevel: number, source: number, platformId: Guid, operationId: number | bigint, status: number): void;
+    static TraceOperationCreation(traceLevel: number, source: number, platformId: Guid, operationId: number | bigint, operationName: string, relatedContext: number | bigint): void;
+    static TraceOperationRelation(traceLevel: number, source: number, platformId: Guid, operationId: number | bigint, relation: number): void;
+    static TraceSynchronousWorkCompletion(traceLevel: number, source: number, work: number): void;
+    static TraceSynchronousWorkStart(traceLevel: number, source: number, platformId: Guid, operationId: number | bigint, work: number): void;
+    static TracingStatusChanged: Windows.Foundation.EventHandler<Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs> | null;
+  }
+
+  class ErrorDetails implements Windows.Foundation.Diagnostics.IErrorDetails {
+    static CreateFromHResultAsync(errorCode: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Diagnostics.ErrorDetails>;
+    readonly Description: string;
+    readonly HelpUri: Windows.Foundation.Uri;
+    readonly LongDescription: string;
+  }
+
+  class FileLoggingSession implements Windows.Foundation.Diagnostics.IFileLoggingSession, Windows.Foundation.IClosable {
+    constructor(name: string);
+    AddLoggingChannel(loggingChannel: Windows.Foundation.Diagnostics.ILoggingChannel): void;
+    AddLoggingChannel(loggingChannel: Windows.Foundation.Diagnostics.ILoggingChannel, maxLevel: number): void;
+    Close(): void;
+    CloseAndSaveToFileAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    RemoveLoggingChannel(loggingChannel: Windows.Foundation.Diagnostics.ILoggingChannel): void;
+    readonly Name: string;
+    LogFileGenerated: Windows.Foundation.TypedEventHandler<Windows.Foundation.Diagnostics.IFileLoggingSession, Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs> | null;
+  }
+
+  class LogFileGeneratedEventArgs implements Windows.Foundation.Diagnostics.ILogFileGeneratedEventArgs {
+    readonly File: Windows.Storage.StorageFile;
+  }
+
+  class LoggingActivity implements Windows.Foundation.Diagnostics.ILoggingActivity, Windows.Foundation.Diagnostics.ILoggingActivity2, Windows.Foundation.Diagnostics.ILoggingTarget, Windows.Foundation.IClosable {
+    constructor(activityName: string, loggingChannel: Windows.Foundation.Diagnostics.ILoggingChannel);
+    constructor(activityName: string, loggingChannel: Windows.Foundation.Diagnostics.ILoggingChannel, level: number);
+    Close(): void;
+    IsEnabled(): boolean;
+    IsEnabled(level: number): boolean;
+    IsEnabled(level: number, keywords: number | bigint): boolean;
+    LogEvent(eventName: string): void;
+    LogEvent(eventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields): void;
+    LogEvent(eventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number): void;
+    LogEvent(eventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number, options: Windows.Foundation.Diagnostics.LoggingOptions): void;
+    StartActivity(startEventName: string): Windows.Foundation.Diagnostics.LoggingActivity;
+    StartActivity(startEventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields): Windows.Foundation.Diagnostics.LoggingActivity;
+    StartActivity(startEventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number): Windows.Foundation.Diagnostics.LoggingActivity;
+    StartActivity(startEventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number, options: Windows.Foundation.Diagnostics.LoggingOptions): Windows.Foundation.Diagnostics.LoggingActivity;
+    StopActivity(stopEventName: string): void;
+    StopActivity(stopEventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields): void;
+    StopActivity(stopEventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, options: Windows.Foundation.Diagnostics.LoggingOptions): void;
+    readonly Channel: Windows.Foundation.Diagnostics.LoggingChannel;
+    readonly Id: Guid;
+    readonly Name: string;
+  }
+
+  class LoggingChannel implements Windows.Foundation.Diagnostics.ILoggingChannel, Windows.Foundation.Diagnostics.ILoggingChannel2, Windows.Foundation.Diagnostics.ILoggingTarget, Windows.Foundation.IClosable {
+    constructor(name: string, options: Windows.Foundation.Diagnostics.LoggingChannelOptions);
+    constructor(name: string, options: Windows.Foundation.Diagnostics.LoggingChannelOptions, id: Guid);
+    constructor(name: string);
+    Close(): void;
+    IsEnabled(): boolean;
+    IsEnabled(level: number): boolean;
+    IsEnabled(level: number, keywords: number | bigint): boolean;
+    LogEvent(eventName: string): void;
+    LogEvent(eventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields): void;
+    LogEvent(eventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number): void;
+    LogEvent(eventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number, options: Windows.Foundation.Diagnostics.LoggingOptions): void;
+    LogMessage(eventString: string): void;
+    LogMessage(eventString: string, level: number): void;
+    LogValuePair(value1: string, value2: number): void;
+    LogValuePair(value1: string, value2: number, level: number): void;
+    StartActivity(startEventName: string): Windows.Foundation.Diagnostics.LoggingActivity;
+    StartActivity(startEventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields): Windows.Foundation.Diagnostics.LoggingActivity;
+    StartActivity(startEventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number): Windows.Foundation.Diagnostics.LoggingActivity;
+    StartActivity(startEventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number, options: Windows.Foundation.Diagnostics.LoggingOptions): Windows.Foundation.Diagnostics.LoggingActivity;
+    readonly Enabled: boolean;
+    readonly Id: Guid;
+    readonly Level: number;
+    readonly Name: string;
+    LoggingEnabled: Windows.Foundation.TypedEventHandler<Windows.Foundation.Diagnostics.ILoggingChannel, Object> | null;
+  }
+
+  class LoggingChannelOptions implements Windows.Foundation.Diagnostics.ILoggingChannelOptions {
+    constructor();
+    constructor(group: Guid);
+    Group: Guid;
+  }
+
+  class LoggingFields implements Windows.Foundation.Diagnostics.ILoggingFields {
+    constructor();
+    AddBoolean(name: string, value: boolean): void;
+    AddBoolean(name: string, value: boolean, format: number): void;
+    AddBoolean(name: string, value: boolean, format: number, tags: number): void;
+    AddBooleanArray(name: string, value: boolean[]): void;
+    AddBooleanArray(name: string, value: boolean[], format: number): void;
+    AddBooleanArray(name: string, value: boolean[], format: number, tags: number): void;
+    AddChar16(name: string, value: string): void;
+    AddChar16(name: string, value: string, format: number): void;
+    AddChar16(name: string, value: string, format: number, tags: number): void;
+    AddChar16Array(name: string, value: string[]): void;
+    AddChar16Array(name: string, value: string[], format: number): void;
+    AddChar16Array(name: string, value: string[], format: number, tags: number): void;
+    AddDateTime(name: string, value: Windows.Foundation.DateTime): void;
+    AddDateTime(name: string, value: Windows.Foundation.DateTime, format: number): void;
+    AddDateTime(name: string, value: Windows.Foundation.DateTime, format: number, tags: number): void;
+    AddDateTimeArray(name: string, value: Windows.Foundation.DateTime[]): void;
+    AddDateTimeArray(name: string, value: Windows.Foundation.DateTime[], format: number): void;
+    AddDateTimeArray(name: string, value: Windows.Foundation.DateTime[], format: number, tags: number): void;
+    AddDouble(name: string, value: number): void;
+    AddDouble(name: string, value: number, format: number): void;
+    AddDouble(name: string, value: number, format: number, tags: number): void;
+    AddDoubleArray(name: string, value: number[]): void;
+    AddDoubleArray(name: string, value: number[], format: number): void;
+    AddDoubleArray(name: string, value: number[], format: number, tags: number): void;
+    AddEmpty(name: string): void;
+    AddEmpty(name: string, format: number): void;
+    AddEmpty(name: string, format: number, tags: number): void;
+    AddGuid(name: string, value: Guid): void;
+    AddGuid(name: string, value: Guid, format: number): void;
+    AddGuid(name: string, value: Guid, format: number, tags: number): void;
+    AddGuidArray(name: string, value: Guid[]): void;
+    AddGuidArray(name: string, value: Guid[], format: number): void;
+    AddGuidArray(name: string, value: Guid[], format: number, tags: number): void;
+    AddInt16(name: string, value: number): void;
+    AddInt16(name: string, value: number, format: number): void;
+    AddInt16(name: string, value: number, format: number, tags: number): void;
+    AddInt16Array(name: string, value: number[]): void;
+    AddInt16Array(name: string, value: number[], format: number): void;
+    AddInt16Array(name: string, value: number[], format: number, tags: number): void;
+    AddInt32(name: string, value: number): void;
+    AddInt32(name: string, value: number, format: number): void;
+    AddInt32(name: string, value: number, format: number, tags: number): void;
+    AddInt32Array(name: string, value: number[]): void;
+    AddInt32Array(name: string, value: number[], format: number): void;
+    AddInt32Array(name: string, value: number[], format: number, tags: number): void;
+    AddInt64(name: string, value: number | bigint): void;
+    AddInt64(name: string, value: number | bigint, format: number): void;
+    AddInt64(name: string, value: number | bigint, format: number, tags: number): void;
+    AddInt64Array(name: string, value: number | bigint[]): void;
+    AddInt64Array(name: string, value: number | bigint[], format: number): void;
+    AddInt64Array(name: string, value: number | bigint[], format: number, tags: number): void;
+    AddPoint(name: string, value: Windows.Foundation.Point): void;
+    AddPoint(name: string, value: Windows.Foundation.Point, format: number): void;
+    AddPoint(name: string, value: Windows.Foundation.Point, format: number, tags: number): void;
+    AddPointArray(name: string, value: Windows.Foundation.Point[]): void;
+    AddPointArray(name: string, value: Windows.Foundation.Point[], format: number): void;
+    AddPointArray(name: string, value: Windows.Foundation.Point[], format: number, tags: number): void;
+    AddRect(name: string, value: Windows.Foundation.Rect): void;
+    AddRect(name: string, value: Windows.Foundation.Rect, format: number): void;
+    AddRect(name: string, value: Windows.Foundation.Rect, format: number, tags: number): void;
+    AddRectArray(name: string, value: Windows.Foundation.Rect[]): void;
+    AddRectArray(name: string, value: Windows.Foundation.Rect[], format: number): void;
+    AddRectArray(name: string, value: Windows.Foundation.Rect[], format: number, tags: number): void;
+    AddSingle(name: string, value: number): void;
+    AddSingle(name: string, value: number, format: number): void;
+    AddSingle(name: string, value: number, format: number, tags: number): void;
+    AddSingleArray(name: string, value: number[]): void;
+    AddSingleArray(name: string, value: number[], format: number): void;
+    AddSingleArray(name: string, value: number[], format: number, tags: number): void;
+    AddSize(name: string, value: Windows.Foundation.Size): void;
+    AddSize(name: string, value: Windows.Foundation.Size, format: number): void;
+    AddSize(name: string, value: Windows.Foundation.Size, format: number, tags: number): void;
+    AddSizeArray(name: string, value: Windows.Foundation.Size[]): void;
+    AddSizeArray(name: string, value: Windows.Foundation.Size[], format: number): void;
+    AddSizeArray(name: string, value: Windows.Foundation.Size[], format: number, tags: number): void;
+    AddString(name: string, value: string): void;
+    AddString(name: string, value: string, format: number): void;
+    AddString(name: string, value: string, format: number, tags: number): void;
+    AddStringArray(name: string, value: string[]): void;
+    AddStringArray(name: string, value: string[], format: number): void;
+    AddStringArray(name: string, value: string[], format: number, tags: number): void;
+    AddTimeSpan(name: string, value: Windows.Foundation.TimeSpan): void;
+    AddTimeSpan(name: string, value: Windows.Foundation.TimeSpan, format: number): void;
+    AddTimeSpan(name: string, value: Windows.Foundation.TimeSpan, format: number, tags: number): void;
+    AddTimeSpanArray(name: string, value: Windows.Foundation.TimeSpan[]): void;
+    AddTimeSpanArray(name: string, value: Windows.Foundation.TimeSpan[], format: number): void;
+    AddTimeSpanArray(name: string, value: Windows.Foundation.TimeSpan[], format: number, tags: number): void;
+    AddUInt16(name: string, value: number): void;
+    AddUInt16(name: string, value: number, format: number): void;
+    AddUInt16(name: string, value: number, format: number, tags: number): void;
+    AddUInt16Array(name: string, value: number[]): void;
+    AddUInt16Array(name: string, value: number[], format: number): void;
+    AddUInt16Array(name: string, value: number[], format: number, tags: number): void;
+    AddUInt32(name: string, value: number): void;
+    AddUInt32(name: string, value: number, format: number): void;
+    AddUInt32(name: string, value: number, format: number, tags: number): void;
+    AddUInt32Array(name: string, value: number[]): void;
+    AddUInt32Array(name: string, value: number[], format: number): void;
+    AddUInt32Array(name: string, value: number[], format: number, tags: number): void;
+    AddUInt64(name: string, value: number | bigint): void;
+    AddUInt64(name: string, value: number | bigint, format: number): void;
+    AddUInt64(name: string, value: number | bigint, format: number, tags: number): void;
+    AddUInt64Array(name: string, value: number | bigint[]): void;
+    AddUInt64Array(name: string, value: number | bigint[], format: number): void;
+    AddUInt64Array(name: string, value: number | bigint[], format: number, tags: number): void;
+    AddUInt8(name: string, value: number): void;
+    AddUInt8(name: string, value: number, format: number): void;
+    AddUInt8(name: string, value: number, format: number, tags: number): void;
+    AddUInt8Array(name: string, value: number[]): void;
+    AddUInt8Array(name: string, value: number[], format: number): void;
+    AddUInt8Array(name: string, value: number[], format: number, tags: number): void;
+    BeginStruct(name: string): void;
+    BeginStruct(name: string, tags: number): void;
+    Clear(): void;
+    EndStruct(): void;
+  }
+
+  class LoggingOptions implements Windows.Foundation.Diagnostics.ILoggingOptions {
+    constructor();
+    constructor(keywords: number | bigint);
+    ActivityId: Guid;
+    Keywords: number | bigint;
+    Opcode: number;
+    RelatedActivityId: Guid;
+    Tags: number;
+    Task: number;
+  }
+
+  class LoggingSession implements Windows.Foundation.Diagnostics.ILoggingSession, Windows.Foundation.IClosable {
+    constructor(name: string);
+    AddLoggingChannel(loggingChannel: Windows.Foundation.Diagnostics.ILoggingChannel): void;
+    AddLoggingChannel(loggingChannel: Windows.Foundation.Diagnostics.ILoggingChannel, maxLevel: number): void;
+    Close(): void;
+    RemoveLoggingChannel(loggingChannel: Windows.Foundation.Diagnostics.ILoggingChannel): void;
+    SaveToFileAsync(folder: Windows.Storage.IStorageFolder, fileName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    readonly Name: string;
+  }
+
+  class RuntimeBrokerErrorSettings implements Windows.Foundation.Diagnostics.IErrorReportingSettings {
+    constructor();
+    GetErrorOptions(): number;
+    SetErrorOptions(value: number): void;
+  }
+
+  class TracingStatusChangedEventArgs implements Windows.Foundation.Diagnostics.ITracingStatusChangedEventArgs {
+    readonly Enabled: boolean;
+    readonly TraceLevel: number;
+  }
+
+  enum CausalityRelation {
+    AssignDelegate = 0,
+    Join = 1,
+    Choice = 2,
+    Cancel = 3,
+    Error = 4,
+  }
+
+  enum CausalitySource {
+    Application = 0,
+    Library = 1,
+    System = 2,
+  }
+
+  enum CausalitySynchronousWork {
+    CompletionNotification = 0,
+    ProgressNotification = 1,
+    Execution = 2,
+  }
+
+  enum CausalityTraceLevel {
+    Required = 0,
+    Important = 1,
+    Verbose = 2,
+  }
+
+  enum ErrorOptions {
+    None = 0,
+    SuppressExceptions = 1,
+    ForceExceptions = 2,
+    UseSetErrorInfo = 4,
+    SuppressSetErrorInfo = 8,
+  }
+
+  enum LoggingFieldFormat {
+    Default = 0,
+    Hidden = 1,
+    String = 2,
+    Boolean = 3,
+    Hexadecimal = 4,
+    ProcessId = 5,
+    ThreadId = 6,
+    Port = 7,
+    Ipv4Address = 8,
+    Ipv6Address = 9,
+    SocketAddress = 10,
+    Xml = 11,
+    Json = 12,
+    Win32Error = 13,
+    NTStatus = 14,
+    HResult = 15,
+    FileTime = 16,
+    Signed = 17,
+    Unsigned = 18,
+  }
+
+  enum LoggingLevel {
+    Verbose = 0,
+    Information = 1,
+    Warning = 2,
+    Error = 3,
+    Critical = 4,
+  }
+
+  enum LoggingOpcode {
+    Info = 0,
+    Start = 1,
+    Stop = 2,
+    Reply = 6,
+    Resume = 7,
+    Suspend = 8,
+    Send = 9,
+  }
+
+  interface IAsyncCausalityTracerStatics {
+    TraceOperationCompletion(traceLevel: number, source: number, platformId: Guid, operationId: number | bigint, status: number): void;
+    TraceOperationCreation(traceLevel: number, source: number, platformId: Guid, operationId: number | bigint, operationName: string, relatedContext: number | bigint): void;
+    TraceOperationRelation(traceLevel: number, source: number, platformId: Guid, operationId: number | bigint, relation: number): void;
+    TraceSynchronousWorkCompletion(traceLevel: number, source: number, work: number): void;
+    TraceSynchronousWorkStart(traceLevel: number, source: number, platformId: Guid, operationId: number | bigint, work: number): void;
+    TracingStatusChanged: Windows.Foundation.EventHandler<Windows.Foundation.Diagnostics.TracingStatusChangedEventArgs> | null;
+  }
+  var IAsyncCausalityTracerStatics: abstract new (...args: any[]) => IAsyncCausalityTracerStatics;
+
+  interface IErrorDetails {
+    readonly Description: string;
+    readonly HelpUri: Windows.Foundation.Uri;
+    readonly LongDescription: string;
+  }
+  var IErrorDetails: abstract new (...args: any[]) => IErrorDetails;
+
+  interface IErrorDetailsStatics {
+    CreateFromHResultAsync(errorCode: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Diagnostics.ErrorDetails>;
+  }
+  var IErrorDetailsStatics: abstract new (...args: any[]) => IErrorDetailsStatics;
+
+  interface IErrorReportingSettings {
+    GetErrorOptions(): number;
+    SetErrorOptions(value: number): void;
+  }
+  var IErrorReportingSettings: abstract new (...args: any[]) => IErrorReportingSettings;
+
+  interface IFileLoggingSession extends Windows.Foundation.IClosable {
+    AddLoggingChannel(loggingChannel: Windows.Foundation.Diagnostics.ILoggingChannel): void;
+    AddLoggingChannel(loggingChannel: Windows.Foundation.Diagnostics.ILoggingChannel, maxLevel: number): void;
+    Close(): void;
+    CloseAndSaveToFileAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    RemoveLoggingChannel(loggingChannel: Windows.Foundation.Diagnostics.ILoggingChannel): void;
+    readonly Name: string;
+    LogFileGenerated: Windows.Foundation.TypedEventHandler<Windows.Foundation.Diagnostics.IFileLoggingSession, Windows.Foundation.Diagnostics.LogFileGeneratedEventArgs> | null;
+  }
+  var IFileLoggingSession: abstract new (...args: any[]) => IFileLoggingSession;
+
+  interface IFileLoggingSessionFactory {
+    Create(name: string): Windows.Foundation.Diagnostics.FileLoggingSession;
+  }
+  var IFileLoggingSessionFactory: abstract new (...args: any[]) => IFileLoggingSessionFactory;
+
+  interface ILogFileGeneratedEventArgs {
+    readonly File: Windows.Storage.StorageFile;
+  }
+  var ILogFileGeneratedEventArgs: abstract new (...args: any[]) => ILogFileGeneratedEventArgs;
+
+  interface ILoggingActivity extends Windows.Foundation.IClosable {
+    Close(): void;
+    readonly Id: Guid;
+    readonly Name: string;
+  }
+  var ILoggingActivity: abstract new (...args: any[]) => ILoggingActivity;
+
+  interface ILoggingActivity2 extends Windows.Foundation.Diagnostics.ILoggingActivity, Windows.Foundation.Diagnostics.ILoggingTarget, Windows.Foundation.IClosable {
+    Close(): void;
+    IsEnabled(): boolean;
+    IsEnabled(level: number): boolean;
+    IsEnabled(level: number, keywords: number | bigint): boolean;
+    LogEvent(eventName: string): void;
+    LogEvent(eventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields): void;
+    LogEvent(eventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number): void;
+    LogEvent(eventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number, options: Windows.Foundation.Diagnostics.LoggingOptions): void;
+    StartActivity(startEventName: string): Windows.Foundation.Diagnostics.LoggingActivity;
+    StartActivity(startEventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields): Windows.Foundation.Diagnostics.LoggingActivity;
+    StartActivity(startEventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number): Windows.Foundation.Diagnostics.LoggingActivity;
+    StartActivity(startEventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number, options: Windows.Foundation.Diagnostics.LoggingOptions): Windows.Foundation.Diagnostics.LoggingActivity;
+    StopActivity(stopEventName: string): void;
+    StopActivity(stopEventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields): void;
+    StopActivity(stopEventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, options: Windows.Foundation.Diagnostics.LoggingOptions): void;
+    readonly Channel: Windows.Foundation.Diagnostics.LoggingChannel;
+  }
+  var ILoggingActivity2: abstract new (...args: any[]) => ILoggingActivity2;
+
+  interface ILoggingActivityFactory {
+    CreateLoggingActivity(activityName: string, loggingChannel: Windows.Foundation.Diagnostics.ILoggingChannel): Windows.Foundation.Diagnostics.LoggingActivity;
+    CreateLoggingActivityWithLevel(activityName: string, loggingChannel: Windows.Foundation.Diagnostics.ILoggingChannel, level: number): Windows.Foundation.Diagnostics.LoggingActivity;
+  }
+  var ILoggingActivityFactory: abstract new (...args: any[]) => ILoggingActivityFactory;
+
+  interface ILoggingChannel extends Windows.Foundation.IClosable {
+    Close(): void;
+    LogMessage(eventString: string): void;
+    LogMessage(eventString: string, level: number): void;
+    LogValuePair(value1: string, value2: number): void;
+    LogValuePair(value1: string, value2: number, level: number): void;
+    readonly Enabled: boolean;
+    readonly Level: number;
+    readonly Name: string;
+    LoggingEnabled: Windows.Foundation.TypedEventHandler<Windows.Foundation.Diagnostics.ILoggingChannel, Object> | null;
+  }
+  var ILoggingChannel: abstract new (...args: any[]) => ILoggingChannel;
+
+  interface ILoggingChannel2 extends Windows.Foundation.Diagnostics.ILoggingChannel, Windows.Foundation.Diagnostics.ILoggingTarget, Windows.Foundation.IClosable {
+    Close(): void;
+    IsEnabled(): boolean;
+    IsEnabled(level: number): boolean;
+    IsEnabled(level: number, keywords: number | bigint): boolean;
+    LogEvent(eventName: string): void;
+    LogEvent(eventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields): void;
+    LogEvent(eventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number): void;
+    LogEvent(eventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number, options: Windows.Foundation.Diagnostics.LoggingOptions): void;
+    LogMessage(eventString: string): void;
+    LogMessage(eventString: string, level: number): void;
+    LogValuePair(value1: string, value2: number): void;
+    LogValuePair(value1: string, value2: number, level: number): void;
+    StartActivity(startEventName: string): Windows.Foundation.Diagnostics.LoggingActivity;
+    StartActivity(startEventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields): Windows.Foundation.Diagnostics.LoggingActivity;
+    StartActivity(startEventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number): Windows.Foundation.Diagnostics.LoggingActivity;
+    StartActivity(startEventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number, options: Windows.Foundation.Diagnostics.LoggingOptions): Windows.Foundation.Diagnostics.LoggingActivity;
+    readonly Id: Guid;
+  }
+  var ILoggingChannel2: abstract new (...args: any[]) => ILoggingChannel2;
+
+  interface ILoggingChannelFactory {
+    Create(name: string): Windows.Foundation.Diagnostics.LoggingChannel;
+  }
+  var ILoggingChannelFactory: abstract new (...args: any[]) => ILoggingChannelFactory;
+
+  interface ILoggingChannelFactory2 {
+    CreateWithOptions(name: string, options: Windows.Foundation.Diagnostics.LoggingChannelOptions): Windows.Foundation.Diagnostics.LoggingChannel;
+    CreateWithOptionsAndId(name: string, options: Windows.Foundation.Diagnostics.LoggingChannelOptions, id: Guid): Windows.Foundation.Diagnostics.LoggingChannel;
+  }
+  var ILoggingChannelFactory2: abstract new (...args: any[]) => ILoggingChannelFactory2;
+
+  interface ILoggingChannelOptions {
+    Group: Guid;
+  }
+  var ILoggingChannelOptions: abstract new (...args: any[]) => ILoggingChannelOptions;
+
+  interface ILoggingChannelOptionsFactory {
+    Create(group: Guid): Windows.Foundation.Diagnostics.LoggingChannelOptions;
+  }
+  var ILoggingChannelOptionsFactory: abstract new (...args: any[]) => ILoggingChannelOptionsFactory;
+
+  interface ILoggingFields {
+    AddBoolean(name: string, value: boolean): void;
+    AddBoolean(name: string, value: boolean, format: number): void;
+    AddBoolean(name: string, value: boolean, format: number, tags: number): void;
+    AddBooleanArray(name: string, value: boolean[]): void;
+    AddBooleanArray(name: string, value: boolean[], format: number): void;
+    AddBooleanArray(name: string, value: boolean[], format: number, tags: number): void;
+    AddChar16(name: string, value: string): void;
+    AddChar16(name: string, value: string, format: number): void;
+    AddChar16(name: string, value: string, format: number, tags: number): void;
+    AddChar16Array(name: string, value: string[]): void;
+    AddChar16Array(name: string, value: string[], format: number): void;
+    AddChar16Array(name: string, value: string[], format: number, tags: number): void;
+    AddDateTime(name: string, value: Windows.Foundation.DateTime): void;
+    AddDateTime(name: string, value: Windows.Foundation.DateTime, format: number): void;
+    AddDateTime(name: string, value: Windows.Foundation.DateTime, format: number, tags: number): void;
+    AddDateTimeArray(name: string, value: Windows.Foundation.DateTime[]): void;
+    AddDateTimeArray(name: string, value: Windows.Foundation.DateTime[], format: number): void;
+    AddDateTimeArray(name: string, value: Windows.Foundation.DateTime[], format: number, tags: number): void;
+    AddDouble(name: string, value: number): void;
+    AddDouble(name: string, value: number, format: number): void;
+    AddDouble(name: string, value: number, format: number, tags: number): void;
+    AddDoubleArray(name: string, value: number[]): void;
+    AddDoubleArray(name: string, value: number[], format: number): void;
+    AddDoubleArray(name: string, value: number[], format: number, tags: number): void;
+    AddEmpty(name: string): void;
+    AddEmpty(name: string, format: number): void;
+    AddEmpty(name: string, format: number, tags: number): void;
+    AddGuid(name: string, value: Guid): void;
+    AddGuid(name: string, value: Guid, format: number): void;
+    AddGuid(name: string, value: Guid, format: number, tags: number): void;
+    AddGuidArray(name: string, value: Guid[]): void;
+    AddGuidArray(name: string, value: Guid[], format: number): void;
+    AddGuidArray(name: string, value: Guid[], format: number, tags: number): void;
+    AddInt16(name: string, value: number): void;
+    AddInt16(name: string, value: number, format: number): void;
+    AddInt16(name: string, value: number, format: number, tags: number): void;
+    AddInt16Array(name: string, value: number[]): void;
+    AddInt16Array(name: string, value: number[], format: number): void;
+    AddInt16Array(name: string, value: number[], format: number, tags: number): void;
+    AddInt32(name: string, value: number): void;
+    AddInt32(name: string, value: number, format: number): void;
+    AddInt32(name: string, value: number, format: number, tags: number): void;
+    AddInt32Array(name: string, value: number[]): void;
+    AddInt32Array(name: string, value: number[], format: number): void;
+    AddInt32Array(name: string, value: number[], format: number, tags: number): void;
+    AddInt64(name: string, value: number | bigint): void;
+    AddInt64(name: string, value: number | bigint, format: number): void;
+    AddInt64(name: string, value: number | bigint, format: number, tags: number): void;
+    AddInt64Array(name: string, value: number | bigint[]): void;
+    AddInt64Array(name: string, value: number | bigint[], format: number): void;
+    AddInt64Array(name: string, value: number | bigint[], format: number, tags: number): void;
+    AddPoint(name: string, value: Windows.Foundation.Point): void;
+    AddPoint(name: string, value: Windows.Foundation.Point, format: number): void;
+    AddPoint(name: string, value: Windows.Foundation.Point, format: number, tags: number): void;
+    AddPointArray(name: string, value: Windows.Foundation.Point[]): void;
+    AddPointArray(name: string, value: Windows.Foundation.Point[], format: number): void;
+    AddPointArray(name: string, value: Windows.Foundation.Point[], format: number, tags: number): void;
+    AddRect(name: string, value: Windows.Foundation.Rect): void;
+    AddRect(name: string, value: Windows.Foundation.Rect, format: number): void;
+    AddRect(name: string, value: Windows.Foundation.Rect, format: number, tags: number): void;
+    AddRectArray(name: string, value: Windows.Foundation.Rect[]): void;
+    AddRectArray(name: string, value: Windows.Foundation.Rect[], format: number): void;
+    AddRectArray(name: string, value: Windows.Foundation.Rect[], format: number, tags: number): void;
+    AddSingle(name: string, value: number): void;
+    AddSingle(name: string, value: number, format: number): void;
+    AddSingle(name: string, value: number, format: number, tags: number): void;
+    AddSingleArray(name: string, value: number[]): void;
+    AddSingleArray(name: string, value: number[], format: number): void;
+    AddSingleArray(name: string, value: number[], format: number, tags: number): void;
+    AddSize(name: string, value: Windows.Foundation.Size): void;
+    AddSize(name: string, value: Windows.Foundation.Size, format: number): void;
+    AddSize(name: string, value: Windows.Foundation.Size, format: number, tags: number): void;
+    AddSizeArray(name: string, value: Windows.Foundation.Size[]): void;
+    AddSizeArray(name: string, value: Windows.Foundation.Size[], format: number): void;
+    AddSizeArray(name: string, value: Windows.Foundation.Size[], format: number, tags: number): void;
+    AddString(name: string, value: string): void;
+    AddString(name: string, value: string, format: number): void;
+    AddString(name: string, value: string, format: number, tags: number): void;
+    AddStringArray(name: string, value: string[]): void;
+    AddStringArray(name: string, value: string[], format: number): void;
+    AddStringArray(name: string, value: string[], format: number, tags: number): void;
+    AddTimeSpan(name: string, value: Windows.Foundation.TimeSpan): void;
+    AddTimeSpan(name: string, value: Windows.Foundation.TimeSpan, format: number): void;
+    AddTimeSpan(name: string, value: Windows.Foundation.TimeSpan, format: number, tags: number): void;
+    AddTimeSpanArray(name: string, value: Windows.Foundation.TimeSpan[]): void;
+    AddTimeSpanArray(name: string, value: Windows.Foundation.TimeSpan[], format: number): void;
+    AddTimeSpanArray(name: string, value: Windows.Foundation.TimeSpan[], format: number, tags: number): void;
+    AddUInt16(name: string, value: number): void;
+    AddUInt16(name: string, value: number, format: number): void;
+    AddUInt16(name: string, value: number, format: number, tags: number): void;
+    AddUInt16Array(name: string, value: number[]): void;
+    AddUInt16Array(name: string, value: number[], format: number): void;
+    AddUInt16Array(name: string, value: number[], format: number, tags: number): void;
+    AddUInt32(name: string, value: number): void;
+    AddUInt32(name: string, value: number, format: number): void;
+    AddUInt32(name: string, value: number, format: number, tags: number): void;
+    AddUInt32Array(name: string, value: number[]): void;
+    AddUInt32Array(name: string, value: number[], format: number): void;
+    AddUInt32Array(name: string, value: number[], format: number, tags: number): void;
+    AddUInt64(name: string, value: number | bigint): void;
+    AddUInt64(name: string, value: number | bigint, format: number): void;
+    AddUInt64(name: string, value: number | bigint, format: number, tags: number): void;
+    AddUInt64Array(name: string, value: number | bigint[]): void;
+    AddUInt64Array(name: string, value: number | bigint[], format: number): void;
+    AddUInt64Array(name: string, value: number | bigint[], format: number, tags: number): void;
+    AddUInt8(name: string, value: number): void;
+    AddUInt8(name: string, value: number, format: number): void;
+    AddUInt8(name: string, value: number, format: number, tags: number): void;
+    AddUInt8Array(name: string, value: number[]): void;
+    AddUInt8Array(name: string, value: number[], format: number): void;
+    AddUInt8Array(name: string, value: number[], format: number, tags: number): void;
+    BeginStruct(name: string): void;
+    BeginStruct(name: string, tags: number): void;
+    Clear(): void;
+    EndStruct(): void;
+  }
+  var ILoggingFields: abstract new (...args: any[]) => ILoggingFields;
+
+  interface ILoggingOptions {
+    ActivityId: Guid;
+    Keywords: number | bigint;
+    Opcode: number;
+    RelatedActivityId: Guid;
+    Tags: number;
+    Task: number;
+  }
+  var ILoggingOptions: abstract new (...args: any[]) => ILoggingOptions;
+
+  interface ILoggingOptionsFactory {
+    CreateWithKeywords(keywords: number | bigint): Windows.Foundation.Diagnostics.LoggingOptions;
+  }
+  var ILoggingOptionsFactory: abstract new (...args: any[]) => ILoggingOptionsFactory;
+
+  interface ILoggingSession extends Windows.Foundation.IClosable {
+    AddLoggingChannel(loggingChannel: Windows.Foundation.Diagnostics.ILoggingChannel): void;
+    AddLoggingChannel(loggingChannel: Windows.Foundation.Diagnostics.ILoggingChannel, maxLevel: number): void;
+    Close(): void;
+    RemoveLoggingChannel(loggingChannel: Windows.Foundation.Diagnostics.ILoggingChannel): void;
+    SaveToFileAsync(folder: Windows.Storage.IStorageFolder, fileName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    readonly Name: string;
+  }
+  var ILoggingSession: abstract new (...args: any[]) => ILoggingSession;
+
+  interface ILoggingSessionFactory {
+    Create(name: string): Windows.Foundation.Diagnostics.LoggingSession;
+  }
+  var ILoggingSessionFactory: abstract new (...args: any[]) => ILoggingSessionFactory;
+
+  interface ILoggingTarget {
+    IsEnabled(): boolean;
+    IsEnabled(level: number): boolean;
+    IsEnabled(level: number, keywords: number | bigint): boolean;
+    LogEvent(eventName: string): void;
+    LogEvent(eventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields): void;
+    LogEvent(eventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number): void;
+    LogEvent(eventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number, options: Windows.Foundation.Diagnostics.LoggingOptions): void;
+    StartActivity(startEventName: string): Windows.Foundation.Diagnostics.LoggingActivity;
+    StartActivity(startEventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields): Windows.Foundation.Diagnostics.LoggingActivity;
+    StartActivity(startEventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number): Windows.Foundation.Diagnostics.LoggingActivity;
+    StartActivity(startEventName: string, fields: Windows.Foundation.Diagnostics.LoggingFields, level: number, options: Windows.Foundation.Diagnostics.LoggingOptions): Windows.Foundation.Diagnostics.LoggingActivity;
+  }
+  var ILoggingTarget: abstract new (...args: any[]) => ILoggingTarget;
+
+  interface ITracingStatusChangedEventArgs {
+    readonly Enabled: boolean;
+    readonly TraceLevel: number;
+  }
+  var ITracingStatusChangedEventArgs: abstract new (...args: any[]) => ITracingStatusChangedEventArgs;
+
+}
+
+declare namespace Windows.Foundation.Metadata {
+  class ActivatableAttribute extends System.Attribute {
+    constructor(version: number);
+    constructor(version: number, type: string);
+    constructor(version: number, platform: number);
+    constructor(type: System.Type, version: number);
+    constructor(type: System.Type, version: number, contractName: string);
+    constructor(type: System.Type, version: number, platform: number);
+  }
+
+  class AllowForWebAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class AllowMultipleAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class ApiContractAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class ApiInformation {
+    static IsApiContractPresent(contractName: string, majorVersion: number): boolean;
+    static IsApiContractPresent(contractName: string, majorVersion: number, minorVersion: number): boolean;
+    static IsEnumNamedValuePresent(enumTypeName: string, valueName: string): boolean;
+    static IsEventPresent(typeName: string, eventName: string): boolean;
+    static IsMethodPresent(typeName: string, methodName: string): boolean;
+    static IsMethodPresent(typeName: string, methodName: string, inputParameterCount: number): boolean;
+    static IsPropertyPresent(typeName: string, propertyName: string): boolean;
+    static IsReadOnlyPropertyPresent(typeName: string, propertyName: string): boolean;
+    static IsTypePresent(typeName: string): boolean;
+    static IsWriteablePropertyPresent(typeName: string, propertyName: string): boolean;
+  }
+
+  class AttributeNameAttribute extends System.Attribute {
+    constructor(A_0: string);
+  }
+
+  class AttributeUsageAttribute extends System.Attribute {
+    constructor(A_0: number);
+  }
+
+  class ComposableAttribute extends System.Attribute {
+    constructor(type: System.Type, compositionType: number, version: number);
+    constructor(type: System.Type, compositionType: number, version: number, platform: number);
+    constructor(type: System.Type, compositionType: number, version: number, contract: string);
+  }
+
+  class ContractVersionAttribute extends System.Attribute {
+    constructor(version: number);
+    constructor(contract: System.Type, version: number);
+    constructor(contract: string, version: number);
+  }
+
+  class CreateFromStringAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class DefaultAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class DefaultOverloadAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class DeprecatedAttribute extends System.Attribute {
+    constructor(message: string, type: number, version: number);
+    constructor(message: string, type: number, version: number, platform: number);
+    constructor(message: string, type: number, version: number, contract: string);
+  }
+
+  class DualApiPartitionAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class ExclusiveToAttribute extends System.Attribute {
+    constructor(typeName: System.Type);
+  }
+
+  class ExperimentalAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class FastAbiAttribute extends System.Attribute {
+    constructor(version: number);
+    constructor(version: number, platform: number);
+    constructor(version: number, contractName: string);
+  }
+
+  class FeatureAttribute extends System.Attribute {
+    constructor(featureStage: number, validInAllBranches: boolean);
+  }
+
+  class GCPressureAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class GuidAttribute extends System.Attribute {
+    constructor(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number);
+  }
+
+  class HasVariantAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class InternalAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class LengthIsAttribute extends System.Attribute {
+    constructor(indexLengthParameter: number);
+  }
+
+  class MarshalingBehaviorAttribute extends System.Attribute {
+    constructor(behavior: number);
+  }
+
+  class MetadataMarshalAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class MuseAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class NoExceptionAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class OverloadAttribute extends System.Attribute {
+    constructor(method: string);
+  }
+
+  class OverridableAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class PlatformAttribute extends System.Attribute {
+    constructor(platform: number);
+  }
+
+  class PreviousContractVersionAttribute extends System.Attribute {
+    constructor(contract: string, versionLow: number, versionHigh: number, newContract: string);
+    constructor(contract: string, versionLow: number, versionHigh: number);
+  }
+
+  class ProtectedAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class RangeAttribute extends System.Attribute {
+    constructor(minValue: number, maxValue: number);
+  }
+
+  class RemoteAsyncAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class StaticAttribute extends System.Attribute {
+    constructor(type: System.Type, version: number);
+    constructor(type: System.Type, version: number, platform: number);
+    constructor(type: System.Type, version: number, contractName: string);
+  }
+
+  class ThreadingAttribute extends System.Attribute {
+    constructor(model: number);
+  }
+
+  class VariantAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class VersionAttribute extends System.Attribute {
+    constructor(version: number);
+    constructor(version: number, platform: number);
+  }
+
+  class WebHostHiddenAttribute extends System.Attribute {
+    constructor();
+  }
+
+  enum AttributeTargets {
+    All = 4294967295,
+    Delegate = 1,
+    Enum = 2,
+    Event = 4,
+    Field = 8,
+    Interface = 16,
+    Method = 64,
+    Parameter = 128,
+    Property = 256,
+    RuntimeClass = 512,
+    Struct = 1024,
+    InterfaceImpl = 2048,
+    ApiContract = 8192,
+  }
+
+  enum CompositionType {
+    Protected = 1,
+    Public = 2,
+  }
+
+  enum DeprecationType {
+    Deprecate = 0,
+    Remove = 1,
+  }
+
+  enum FeatureStage {
+    AlwaysDisabled = 0,
+    DisabledByDefault = 1,
+    EnabledByDefault = 2,
+    AlwaysEnabled = 3,
+  }
+
+  enum GCPressureAmount {
+    Low = 0,
+    Medium = 1,
+    High = 2,
+  }
+
+  enum MarshalingType {
+    None = 1,
+    Agile = 2,
+    Standard = 3,
+    InvalidMarshaling = 0,
+  }
+
+  enum Platform {
+    Windows = 0,
+    WindowsPhone = 1,
+  }
+
+  enum ThreadingModel {
+    STA = 1,
+    MTA = 2,
+    Both = 3,
+    InvalidThreading = 0,
+  }
+
+  interface IApiInformationStatics {
+    IsApiContractPresent(contractName: string, majorVersion: number): boolean;
+    IsApiContractPresent(contractName: string, majorVersion: number, minorVersion: number): boolean;
+    IsEnumNamedValuePresent(enumTypeName: string, valueName: string): boolean;
+    IsEventPresent(typeName: string, eventName: string): boolean;
+    IsMethodPresent(typeName: string, methodName: string): boolean;
+    IsMethodPresent(typeName: string, methodName: string, inputParameterCount: number): boolean;
+    IsPropertyPresent(typeName: string, propertyName: string): boolean;
+    IsReadOnlyPropertyPresent(typeName: string, propertyName: string): boolean;
+    IsTypePresent(typeName: string): boolean;
+    IsWriteablePropertyPresent(typeName: string, propertyName: string): boolean;
+  }
+  var IApiInformationStatics: abstract new (...args: any[]) => IApiInformationStatics;
+
+}
+
+declare namespace Windows.Foundation.Numerics {
+  interface Matrix3x2 {
+    M11: number;
+    M12: number;
+    M21: number;
+    M22: number;
+    M31: number;
+    M32: number;
+  }
+  var Matrix3x2: {
+    new(m11: number, m12: number, m21: number, m22: number, m31: number, m32: number): Matrix3x2;
+    new(fields: { M11?: number; M12?: number; M21?: number; M22?: number; M31?: number; M32?: number }): Matrix3x2;
+  };
+
+  interface Matrix4x4 {
+    M11: number;
+    M12: number;
+    M13: number;
+    M14: number;
+    M21: number;
+    M22: number;
+    M23: number;
+    M24: number;
+    M31: number;
+    M32: number;
+    M33: number;
+    M34: number;
+    M41: number;
+    M42: number;
+    M43: number;
+    M44: number;
+  }
+  var Matrix4x4: {
+    new(m11: number, m12: number, m13: number, m14: number, m21: number, m22: number, m23: number, m24: number, m31: number, m32: number, m33: number, m34: number, m41: number, m42: number, m43: number, m44: number): Matrix4x4;
+    new(fields: { M11?: number; M12?: number; M13?: number; M14?: number; M21?: number; M22?: number; M23?: number; M24?: number; M31?: number; M32?: number; M33?: number; M34?: number; M41?: number; M42?: number; M43?: number; M44?: number }): Matrix4x4;
+  };
+
+  interface Plane {
+    Normal: Windows.Foundation.Numerics.Vector3;
+    D: number;
+  }
+  var Plane: {
+    new(normal: Windows.Foundation.Numerics.Vector3, d: number): Plane;
+    new(fields: { Normal?: Windows.Foundation.Numerics.Vector3; D?: number }): Plane;
+  };
+
+  interface Quaternion {
+    X: number;
+    Y: number;
+    Z: number;
+    W: number;
+  }
+  var Quaternion: {
+    new(x: number, y: number, z: number, w: number): Quaternion;
+    new(fields: { X?: number; Y?: number; Z?: number; W?: number }): Quaternion;
+  };
+
+  interface Rational {
+    Numerator: number;
+    Denominator: number;
+  }
+  var Rational: {
+    new(numerator: number, denominator: number): Rational;
+    new(fields: { Numerator?: number; Denominator?: number }): Rational;
+  };
+
+  interface Vector2 {
+    X: number;
+    Y: number;
+  }
+  var Vector2: {
+    new(x: number, y: number): Vector2;
+    new(fields: { X?: number; Y?: number }): Vector2;
+  };
+
+  interface Vector3 {
+    X: number;
+    Y: number;
+    Z: number;
+  }
+  var Vector3: {
+    new(x: number, y: number, z: number): Vector3;
+    new(fields: { X?: number; Y?: number; Z?: number }): Vector3;
+  };
+
+  interface Vector4 {
+    X: number;
+    Y: number;
+    Z: number;
+    W: number;
+  }
+  var Vector4: {
+    new(x: number, y: number, z: number, w: number): Vector4;
+    new(fields: { X?: number; Y?: number; Z?: number; W?: number }): Vector4;
+  };
+
+}
+
+declare namespace Windows.Gaming.Input {
+  class ArcadeStick implements Windows.Gaming.Input.IArcadeStick, Windows.Gaming.Input.IGameController, Windows.Gaming.Input.IGameControllerBatteryInfo {
+    static FromGameController(gameController: Windows.Gaming.Input.IGameController): Windows.Gaming.Input.ArcadeStick;
+    GetButtonLabel(button: number): number;
+    GetCurrentReading(): Windows.Gaming.Input.ArcadeStickReading;
+    TryGetBatteryReport(): Windows.Devices.Power.BatteryReport;
+    static readonly ArcadeSticks: Windows.Foundation.Collections.IVectorView<Windows.Gaming.Input.ArcadeStick> | Windows.Gaming.Input.ArcadeStick[];
+    readonly Headset: Windows.Gaming.Input.Headset;
+    readonly IsWireless: boolean;
+    readonly User: Windows.System.User;
+    HeadsetConnected: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.Gaming.Input.Headset> | null;
+    HeadsetDisconnected: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.Gaming.Input.Headset> | null;
+    UserChanged: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.System.UserChangedEventArgs> | null;
+    static ArcadeStickAdded: Windows.Foundation.EventHandler<Windows.Gaming.Input.ArcadeStick> | null;
+    static ArcadeStickRemoved: Windows.Foundation.EventHandler<Windows.Gaming.Input.ArcadeStick> | null;
+  }
+
+  class FlightStick implements Windows.Gaming.Input.IFlightStick, Windows.Gaming.Input.IGameController, Windows.Gaming.Input.IGameControllerBatteryInfo {
+    static FromGameController(gameController: Windows.Gaming.Input.IGameController): Windows.Gaming.Input.FlightStick;
+    GetButtonLabel(button: number): number;
+    GetCurrentReading(): Windows.Gaming.Input.FlightStickReading;
+    TryGetBatteryReport(): Windows.Devices.Power.BatteryReport;
+    static readonly FlightSticks: Windows.Foundation.Collections.IVectorView<Windows.Gaming.Input.FlightStick> | Windows.Gaming.Input.FlightStick[];
+    readonly HatSwitchKind: number;
+    readonly Headset: Windows.Gaming.Input.Headset;
+    readonly IsWireless: boolean;
+    readonly User: Windows.System.User;
+    HeadsetConnected: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.Gaming.Input.Headset> | null;
+    HeadsetDisconnected: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.Gaming.Input.Headset> | null;
+    UserChanged: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.System.UserChangedEventArgs> | null;
+    static FlightStickAdded: Windows.Foundation.EventHandler<Windows.Gaming.Input.FlightStick> | null;
+    static FlightStickRemoved: Windows.Foundation.EventHandler<Windows.Gaming.Input.FlightStick> | null;
+  }
+
+  class Gamepad implements Windows.Gaming.Input.IGameController, Windows.Gaming.Input.IGameControllerBatteryInfo, Windows.Gaming.Input.IGamepad, Windows.Gaming.Input.IGamepad2 {
+    static FromGameController(gameController: Windows.Gaming.Input.IGameController): Windows.Gaming.Input.Gamepad;
+    GetButtonLabel(button: number): number;
+    GetCurrentReading(): Windows.Gaming.Input.GamepadReading;
+    TryGetBatteryReport(): Windows.Devices.Power.BatteryReport;
+    static readonly Gamepads: Windows.Foundation.Collections.IVectorView<Windows.Gaming.Input.Gamepad> | Windows.Gaming.Input.Gamepad[];
+    readonly Headset: Windows.Gaming.Input.Headset;
+    readonly IsWireless: boolean;
+    readonly User: Windows.System.User;
+    Vibration: Windows.Gaming.Input.GamepadVibration;
+    HeadsetConnected: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.Gaming.Input.Headset> | null;
+    HeadsetDisconnected: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.Gaming.Input.Headset> | null;
+    UserChanged: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.System.UserChangedEventArgs> | null;
+    static GamepadAdded: Windows.Foundation.EventHandler<Windows.Gaming.Input.Gamepad> | null;
+    static GamepadRemoved: Windows.Foundation.EventHandler<Windows.Gaming.Input.Gamepad> | null;
+  }
+
+  class Headset implements Windows.Gaming.Input.IGameControllerBatteryInfo, Windows.Gaming.Input.IHeadset {
+    TryGetBatteryReport(): Windows.Devices.Power.BatteryReport;
+    readonly CaptureDeviceId: string;
+    readonly RenderDeviceId: string;
+  }
+
+  class RacingWheel implements Windows.Gaming.Input.IGameController, Windows.Gaming.Input.IGameControllerBatteryInfo, Windows.Gaming.Input.IRacingWheel {
+    static FromGameController(gameController: Windows.Gaming.Input.IGameController): Windows.Gaming.Input.RacingWheel;
+    GetButtonLabel(button: number): number;
+    GetCurrentReading(): Windows.Gaming.Input.RacingWheelReading;
+    TryGetBatteryReport(): Windows.Devices.Power.BatteryReport;
+    readonly HasClutch: boolean;
+    readonly HasHandbrake: boolean;
+    readonly HasPatternShifter: boolean;
+    readonly Headset: Windows.Gaming.Input.Headset;
+    readonly IsWireless: boolean;
+    readonly MaxPatternShifterGear: number;
+    readonly MaxWheelAngle: number;
+    static readonly RacingWheels: Windows.Foundation.Collections.IVectorView<Windows.Gaming.Input.RacingWheel> | Windows.Gaming.Input.RacingWheel[];
+    readonly User: Windows.System.User;
+    readonly WheelMotor: Windows.Gaming.Input.ForceFeedback.ForceFeedbackMotor;
+    HeadsetConnected: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.Gaming.Input.Headset> | null;
+    HeadsetDisconnected: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.Gaming.Input.Headset> | null;
+    UserChanged: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.System.UserChangedEventArgs> | null;
+    static RacingWheelAdded: Windows.Foundation.EventHandler<Windows.Gaming.Input.RacingWheel> | null;
+    static RacingWheelRemoved: Windows.Foundation.EventHandler<Windows.Gaming.Input.RacingWheel> | null;
+  }
+
+  class RawGameController implements Windows.Gaming.Input.IGameController, Windows.Gaming.Input.IGameControllerBatteryInfo, Windows.Gaming.Input.IRawGameController, Windows.Gaming.Input.IRawGameController2 {
+    static FromGameController(gameController: Windows.Gaming.Input.IGameController): Windows.Gaming.Input.RawGameController;
+    GetButtonLabel(buttonIndex: number): number;
+    GetCurrentReading(buttonArray: boolean[], switchArray: number[], axisArray: number[]): number | bigint;
+    GetSwitchKind(switchIndex: number): number;
+    TryGetBatteryReport(): Windows.Devices.Power.BatteryReport;
+    readonly AxisCount: number;
+    readonly ButtonCount: number;
+    readonly DisplayName: string;
+    readonly ForceFeedbackMotors: Windows.Foundation.Collections.IVectorView<Windows.Gaming.Input.ForceFeedback.ForceFeedbackMotor> | Windows.Gaming.Input.ForceFeedback.ForceFeedbackMotor[];
+    readonly HardwareProductId: number;
+    readonly HardwareVendorId: number;
+    readonly Headset: Windows.Gaming.Input.Headset;
+    readonly IsWireless: boolean;
+    readonly NonRoamableId: string;
+    static readonly RawGameControllers: Windows.Foundation.Collections.IVectorView<Windows.Gaming.Input.RawGameController> | Windows.Gaming.Input.RawGameController[];
+    readonly SimpleHapticsControllers: Windows.Foundation.Collections.IVectorView<Windows.Devices.Haptics.SimpleHapticsController> | Windows.Devices.Haptics.SimpleHapticsController[];
+    readonly SwitchCount: number;
+    readonly User: Windows.System.User;
+    HeadsetConnected: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.Gaming.Input.Headset> | null;
+    HeadsetDisconnected: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.Gaming.Input.Headset> | null;
+    UserChanged: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.System.UserChangedEventArgs> | null;
+    static RawGameControllerAdded: Windows.Foundation.EventHandler<Windows.Gaming.Input.RawGameController> | null;
+    static RawGameControllerRemoved: Windows.Foundation.EventHandler<Windows.Gaming.Input.RawGameController> | null;
+  }
+
+  class UINavigationController implements Windows.Gaming.Input.IGameController, Windows.Gaming.Input.IGameControllerBatteryInfo, Windows.Gaming.Input.IUINavigationController {
+    static FromGameController(gameController: Windows.Gaming.Input.IGameController): Windows.Gaming.Input.UINavigationController;
+    GetCurrentReading(): Windows.Gaming.Input.UINavigationReading;
+    GetOptionalButtonLabel(button: number): number;
+    GetRequiredButtonLabel(button: number): number;
+    TryGetBatteryReport(): Windows.Devices.Power.BatteryReport;
+    readonly Headset: Windows.Gaming.Input.Headset;
+    readonly IsWireless: boolean;
+    static readonly UINavigationControllers: Windows.Foundation.Collections.IVectorView<Windows.Gaming.Input.UINavigationController> | Windows.Gaming.Input.UINavigationController[];
+    readonly User: Windows.System.User;
+    HeadsetConnected: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.Gaming.Input.Headset> | null;
+    HeadsetDisconnected: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.Gaming.Input.Headset> | null;
+    UserChanged: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.System.UserChangedEventArgs> | null;
+    static UINavigationControllerAdded: Windows.Foundation.EventHandler<Windows.Gaming.Input.UINavigationController> | null;
+    static UINavigationControllerRemoved: Windows.Foundation.EventHandler<Windows.Gaming.Input.UINavigationController> | null;
+  }
+
+  enum ArcadeStickButtons {
+    None = 0,
+    StickUp = 1,
+    StickDown = 2,
+    StickLeft = 4,
+    StickRight = 8,
+    Action1 = 16,
+    Action2 = 32,
+    Action3 = 64,
+    Action4 = 128,
+    Action5 = 256,
+    Action6 = 512,
+    Special1 = 1024,
+    Special2 = 2048,
+  }
+
+  enum FlightStickButtons {
+    None = 0,
+    FirePrimary = 1,
+    FireSecondary = 2,
+  }
+
+  enum GameControllerButtonLabel {
+    None = 0,
+    XboxBack = 1,
+    XboxStart = 2,
+    XboxMenu = 3,
+    XboxView = 4,
+    XboxUp = 5,
+    XboxDown = 6,
+    XboxLeft = 7,
+    XboxRight = 8,
+    XboxA = 9,
+    XboxB = 10,
+    XboxX = 11,
+    XboxY = 12,
+    XboxLeftBumper = 13,
+    XboxLeftTrigger = 14,
+    XboxLeftStickButton = 15,
+    XboxRightBumper = 16,
+    XboxRightTrigger = 17,
+    XboxRightStickButton = 18,
+    XboxPaddle1 = 19,
+    XboxPaddle2 = 20,
+    XboxPaddle3 = 21,
+    XboxPaddle4 = 22,
+    Mode = 23,
+    Select = 24,
+    Menu = 25,
+    View = 26,
+    Back = 27,
+    Start = 28,
+    Options = 29,
+    Share = 30,
+    Up = 31,
+    Down = 32,
+    Left = 33,
+    Right = 34,
+    LetterA = 35,
+    LetterB = 36,
+    LetterC = 37,
+    LetterL = 38,
+    LetterR = 39,
+    LetterX = 40,
+    LetterY = 41,
+    LetterZ = 42,
+    Cross = 43,
+    Circle = 44,
+    Square = 45,
+    Triangle = 46,
+    LeftBumper = 47,
+    LeftTrigger = 48,
+    LeftStickButton = 49,
+    Left1 = 50,
+    Left2 = 51,
+    Left3 = 52,
+    RightBumper = 53,
+    RightTrigger = 54,
+    RightStickButton = 55,
+    Right1 = 56,
+    Right2 = 57,
+    Right3 = 58,
+    Paddle1 = 59,
+    Paddle2 = 60,
+    Paddle3 = 61,
+    Paddle4 = 62,
+    Plus = 63,
+    Minus = 64,
+    DownLeftArrow = 65,
+    DialLeft = 66,
+    DialRight = 67,
+    Suspension = 68,
+  }
+
+  enum GameControllerSwitchKind {
+    TwoWay = 0,
+    FourWay = 1,
+    EightWay = 2,
+  }
+
+  enum GameControllerSwitchPosition {
+    Center = 0,
+    Up = 1,
+    UpRight = 2,
+    Right = 3,
+    DownRight = 4,
+    Down = 5,
+    DownLeft = 6,
+    Left = 7,
+    UpLeft = 8,
+  }
+
+  enum GamepadButtons {
+    None = 0,
+    Menu = 1,
+    View = 2,
+    A = 4,
+    B = 8,
+    X = 16,
+    Y = 32,
+    DPadUp = 64,
+    DPadDown = 128,
+    DPadLeft = 256,
+    DPadRight = 512,
+    LeftShoulder = 1024,
+    RightShoulder = 2048,
+    LeftThumbstick = 4096,
+    RightThumbstick = 8192,
+    Paddle1 = 16384,
+    Paddle2 = 32768,
+    Paddle3 = 65536,
+    Paddle4 = 131072,
+  }
+
+  enum OptionalUINavigationButtons {
+    None = 0,
+    Context1 = 1,
+    Context2 = 2,
+    Context3 = 4,
+    Context4 = 8,
+    PageUp = 16,
+    PageDown = 32,
+    PageLeft = 64,
+    PageRight = 128,
+    ScrollUp = 256,
+    ScrollDown = 512,
+    ScrollLeft = 1024,
+    ScrollRight = 2048,
+  }
+
+  enum RacingWheelButtons {
+    None = 0,
+    PreviousGear = 1,
+    NextGear = 2,
+    DPadUp = 4,
+    DPadDown = 8,
+    DPadLeft = 16,
+    DPadRight = 32,
+    Button1 = 64,
+    Button2 = 128,
+    Button3 = 256,
+    Button4 = 512,
+    Button5 = 1024,
+    Button6 = 2048,
+    Button7 = 4096,
+    Button8 = 8192,
+    Button9 = 16384,
+    Button10 = 32768,
+    Button11 = 65536,
+    Button12 = 131072,
+    Button13 = 262144,
+    Button14 = 524288,
+    Button15 = 1048576,
+    Button16 = 2097152,
+  }
+
+  enum RequiredUINavigationButtons {
+    None = 0,
+    Menu = 1,
+    View = 2,
+    Accept = 4,
+    Cancel = 8,
+    Up = 16,
+    Down = 32,
+    Left = 64,
+    Right = 128,
+  }
+
+  interface ArcadeStickReading {
+    Timestamp: number | bigint;
+    Buttons: number;
+  }
+  var ArcadeStickReading: {
+    new(timestamp: number | bigint, buttons: number): ArcadeStickReading;
+    new(fields: { Timestamp?: number | bigint; Buttons?: number }): ArcadeStickReading;
+  };
+
+  interface FlightStickReading {
+    Timestamp: number | bigint;
+    Buttons: number;
+    HatSwitch: number;
+    Roll: number;
+    Pitch: number;
+    Yaw: number;
+    Throttle: number;
+  }
+  var FlightStickReading: {
+    new(timestamp: number | bigint, buttons: number, hatSwitch: number, roll: number, pitch: number, yaw: number, throttle: number): FlightStickReading;
+    new(fields: { Timestamp?: number | bigint; Buttons?: number; HatSwitch?: number; Roll?: number; Pitch?: number; Yaw?: number; Throttle?: number }): FlightStickReading;
+  };
+
+  interface GamepadReading {
+    Timestamp: number | bigint;
+    Buttons: number;
+    LeftTrigger: number;
+    RightTrigger: number;
+    LeftThumbstickX: number;
+    LeftThumbstickY: number;
+    RightThumbstickX: number;
+    RightThumbstickY: number;
+  }
+  var GamepadReading: {
+    new(timestamp: number | bigint, buttons: number, leftTrigger: number, rightTrigger: number, leftThumbstickX: number, leftThumbstickY: number, rightThumbstickX: number, rightThumbstickY: number): GamepadReading;
+    new(fields: { Timestamp?: number | bigint; Buttons?: number; LeftTrigger?: number; RightTrigger?: number; LeftThumbstickX?: number; LeftThumbstickY?: number; RightThumbstickX?: number; RightThumbstickY?: number }): GamepadReading;
+  };
+
+  interface GamepadVibration {
+    LeftMotor: number;
+    RightMotor: number;
+    LeftTrigger: number;
+    RightTrigger: number;
+  }
+  var GamepadVibration: {
+    new(leftMotor: number, rightMotor: number, leftTrigger: number, rightTrigger: number): GamepadVibration;
+    new(fields: { LeftMotor?: number; RightMotor?: number; LeftTrigger?: number; RightTrigger?: number }): GamepadVibration;
+  };
+
+  interface GamingInputPreviewContract {
+  }
+  var GamingInputPreviewContract: {
+    new(fields: {  }): GamingInputPreviewContract;
+  };
+
+  interface IArcadeStick extends Windows.Gaming.Input.IGameController {
+    GetButtonLabel(button: number): number;
+    GetCurrentReading(): Windows.Gaming.Input.ArcadeStickReading;
+  }
+  var IArcadeStick: abstract new (...args: any[]) => IArcadeStick;
+
+  interface IArcadeStickStatics {
+    readonly ArcadeSticks: Windows.Foundation.Collections.IVectorView<Windows.Gaming.Input.ArcadeStick> | Windows.Gaming.Input.ArcadeStick[];
+    ArcadeStickAdded: Windows.Foundation.EventHandler<Windows.Gaming.Input.ArcadeStick> | null;
+    ArcadeStickRemoved: Windows.Foundation.EventHandler<Windows.Gaming.Input.ArcadeStick> | null;
+  }
+  var IArcadeStickStatics: abstract new (...args: any[]) => IArcadeStickStatics;
+
+  interface IArcadeStickStatics2 extends Windows.Gaming.Input.IArcadeStickStatics {
+    FromGameController(gameController: Windows.Gaming.Input.IGameController): Windows.Gaming.Input.ArcadeStick;
+  }
+  var IArcadeStickStatics2: abstract new (...args: any[]) => IArcadeStickStatics2;
+
+  interface IFlightStick extends Windows.Gaming.Input.IGameController {
+    GetButtonLabel(button: number): number;
+    GetCurrentReading(): Windows.Gaming.Input.FlightStickReading;
+    readonly HatSwitchKind: number;
+  }
+  var IFlightStick: abstract new (...args: any[]) => IFlightStick;
+
+  interface IFlightStickStatics {
+    FromGameController(gameController: Windows.Gaming.Input.IGameController): Windows.Gaming.Input.FlightStick;
+    readonly FlightSticks: Windows.Foundation.Collections.IVectorView<Windows.Gaming.Input.FlightStick> | Windows.Gaming.Input.FlightStick[];
+    FlightStickAdded: Windows.Foundation.EventHandler<Windows.Gaming.Input.FlightStick> | null;
+    FlightStickRemoved: Windows.Foundation.EventHandler<Windows.Gaming.Input.FlightStick> | null;
+  }
+  var IFlightStickStatics: abstract new (...args: any[]) => IFlightStickStatics;
+
+  interface IGameController {
+    readonly Headset: Windows.Gaming.Input.Headset;
+    readonly IsWireless: boolean;
+    readonly User: Windows.System.User;
+    HeadsetConnected: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.Gaming.Input.Headset> | null;
+    HeadsetDisconnected: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.Gaming.Input.Headset> | null;
+    UserChanged: Windows.Foundation.TypedEventHandler<Windows.Gaming.Input.IGameController, Windows.System.UserChangedEventArgs> | null;
+  }
+  var IGameController: abstract new (...args: any[]) => IGameController;
+
+  interface IGameControllerBatteryInfo {
+    TryGetBatteryReport(): Windows.Devices.Power.BatteryReport;
+  }
+  var IGameControllerBatteryInfo: abstract new (...args: any[]) => IGameControllerBatteryInfo;
+
+  interface IGamepad extends Windows.Gaming.Input.IGameController {
+    GetCurrentReading(): Windows.Gaming.Input.GamepadReading;
+    Vibration: Windows.Gaming.Input.GamepadVibration;
+  }
+  var IGamepad: abstract new (...args: any[]) => IGamepad;
+
+  interface IGamepad2 extends Windows.Gaming.Input.IGameController, Windows.Gaming.Input.IGamepad {
+    GetButtonLabel(button: number): number;
+    GetCurrentReading(): Windows.Gaming.Input.GamepadReading;
+  }
+  var IGamepad2: abstract new (...args: any[]) => IGamepad2;
+
+  interface IGamepadStatics {
+    readonly Gamepads: Windows.Foundation.Collections.IVectorView<Windows.Gaming.Input.Gamepad> | Windows.Gaming.Input.Gamepad[];
+    GamepadAdded: Windows.Foundation.EventHandler<Windows.Gaming.Input.Gamepad> | null;
+    GamepadRemoved: Windows.Foundation.EventHandler<Windows.Gaming.Input.Gamepad> | null;
+  }
+  var IGamepadStatics: abstract new (...args: any[]) => IGamepadStatics;
+
+  interface IGamepadStatics2 extends Windows.Gaming.Input.IGamepadStatics {
+    FromGameController(gameController: Windows.Gaming.Input.IGameController): Windows.Gaming.Input.Gamepad;
+  }
+  var IGamepadStatics2: abstract new (...args: any[]) => IGamepadStatics2;
+
+  interface IHeadset {
+    readonly CaptureDeviceId: string;
+    readonly RenderDeviceId: string;
+  }
+  var IHeadset: abstract new (...args: any[]) => IHeadset;
+
+  interface IRacingWheel extends Windows.Gaming.Input.IGameController {
+    GetButtonLabel(button: number): number;
+    GetCurrentReading(): Windows.Gaming.Input.RacingWheelReading;
+    readonly HasClutch: boolean;
+    readonly HasHandbrake: boolean;
+    readonly HasPatternShifter: boolean;
+    readonly MaxPatternShifterGear: number;
+    readonly MaxWheelAngle: number;
+    readonly WheelMotor: Windows.Gaming.Input.ForceFeedback.ForceFeedbackMotor;
+  }
+  var IRacingWheel: abstract new (...args: any[]) => IRacingWheel;
+
+  interface IRacingWheelStatics {
+    readonly RacingWheels: Windows.Foundation.Collections.IVectorView<Windows.Gaming.Input.RacingWheel> | Windows.Gaming.Input.RacingWheel[];
+    RacingWheelAdded: Windows.Foundation.EventHandler<Windows.Gaming.Input.RacingWheel> | null;
+    RacingWheelRemoved: Windows.Foundation.EventHandler<Windows.Gaming.Input.RacingWheel> | null;
+  }
+  var IRacingWheelStatics: abstract new (...args: any[]) => IRacingWheelStatics;
+
+  interface IRacingWheelStatics2 extends Windows.Gaming.Input.IRacingWheelStatics {
+    FromGameController(gameController: Windows.Gaming.Input.IGameController): Windows.Gaming.Input.RacingWheel;
+  }
+  var IRacingWheelStatics2: abstract new (...args: any[]) => IRacingWheelStatics2;
+
+  interface IRawGameController extends Windows.Gaming.Input.IGameController {
+    GetButtonLabel(buttonIndex: number): number;
+    GetCurrentReading(buttonArray: boolean[], switchArray: number[], axisArray: number[]): number | bigint;
+    GetSwitchKind(switchIndex: number): number;
+    readonly AxisCount: number;
+    readonly ButtonCount: number;
+    readonly ForceFeedbackMotors: Windows.Foundation.Collections.IVectorView<Windows.Gaming.Input.ForceFeedback.ForceFeedbackMotor> | Windows.Gaming.Input.ForceFeedback.ForceFeedbackMotor[];
+    readonly HardwareProductId: number;
+    readonly HardwareVendorId: number;
+    readonly SwitchCount: number;
+  }
+  var IRawGameController: abstract new (...args: any[]) => IRawGameController;
+
+  interface IRawGameController2 extends Windows.Gaming.Input.IGameController, Windows.Gaming.Input.IRawGameController {
+    GetButtonLabel(buttonIndex: number): number;
+    GetCurrentReading(buttonArray: boolean[], switchArray: number[], axisArray: number[]): number | bigint;
+    GetSwitchKind(switchIndex: number): number;
+    readonly DisplayName: string;
+    readonly NonRoamableId: string;
+    readonly SimpleHapticsControllers: Windows.Foundation.Collections.IVectorView<Windows.Devices.Haptics.SimpleHapticsController> | Windows.Devices.Haptics.SimpleHapticsController[];
+  }
+  var IRawGameController2: abstract new (...args: any[]) => IRawGameController2;
+
+  interface IRawGameControllerStatics {
+    FromGameController(gameController: Windows.Gaming.Input.IGameController): Windows.Gaming.Input.RawGameController;
+    readonly RawGameControllers: Windows.Foundation.Collections.IVectorView<Windows.Gaming.Input.RawGameController> | Windows.Gaming.Input.RawGameController[];
+    RawGameControllerAdded: Windows.Foundation.EventHandler<Windows.Gaming.Input.RawGameController> | null;
+    RawGameControllerRemoved: Windows.Foundation.EventHandler<Windows.Gaming.Input.RawGameController> | null;
+  }
+  var IRawGameControllerStatics: abstract new (...args: any[]) => IRawGameControllerStatics;
+
+  interface IUINavigationController extends Windows.Gaming.Input.IGameController {
+    GetCurrentReading(): Windows.Gaming.Input.UINavigationReading;
+    GetOptionalButtonLabel(button: number): number;
+    GetRequiredButtonLabel(button: number): number;
+  }
+  var IUINavigationController: abstract new (...args: any[]) => IUINavigationController;
+
+  interface IUINavigationControllerStatics {
+    readonly UINavigationControllers: Windows.Foundation.Collections.IVectorView<Windows.Gaming.Input.UINavigationController> | Windows.Gaming.Input.UINavigationController[];
+    UINavigationControllerAdded: Windows.Foundation.EventHandler<Windows.Gaming.Input.UINavigationController> | null;
+    UINavigationControllerRemoved: Windows.Foundation.EventHandler<Windows.Gaming.Input.UINavigationController> | null;
+  }
+  var IUINavigationControllerStatics: abstract new (...args: any[]) => IUINavigationControllerStatics;
+
+  interface IUINavigationControllerStatics2 extends Windows.Gaming.Input.IUINavigationControllerStatics {
+    FromGameController(gameController: Windows.Gaming.Input.IGameController): Windows.Gaming.Input.UINavigationController;
+  }
+  var IUINavigationControllerStatics2: abstract new (...args: any[]) => IUINavigationControllerStatics2;
+
+  interface RacingWheelReading {
+    Timestamp: number | bigint;
+    Buttons: number;
+    PatternShifterGear: number;
+    Wheel: number;
+    Throttle: number;
+    Brake: number;
+    Clutch: number;
+    Handbrake: number;
+  }
+  var RacingWheelReading: {
+    new(timestamp: number | bigint, buttons: number, patternShifterGear: number, wheel: number, throttle: number, brake: number, clutch: number, handbrake: number): RacingWheelReading;
+    new(fields: { Timestamp?: number | bigint; Buttons?: number; PatternShifterGear?: number; Wheel?: number; Throttle?: number; Brake?: number; Clutch?: number; Handbrake?: number }): RacingWheelReading;
+  };
+
+  interface UINavigationReading {
+    Timestamp: number | bigint;
+    RequiredButtons: number;
+    OptionalButtons: number;
+  }
+  var UINavigationReading: {
+    new(timestamp: number | bigint, requiredButtons: number, optionalButtons: number): UINavigationReading;
+    new(fields: { Timestamp?: number | bigint; RequiredButtons?: number; OptionalButtons?: number }): UINavigationReading;
+  };
+
+}
+
+declare namespace Windows.Gaming.Input.Custom {
+  class GameControllerFactoryManager {
+    static RegisterCustomFactoryForGipInterface(factory: Windows.Gaming.Input.Custom.ICustomGameControllerFactory, interfaceId: Guid): void;
+    static RegisterCustomFactoryForHardwareId(factory: Windows.Gaming.Input.Custom.ICustomGameControllerFactory, hardwareVendorId: number, hardwareProductId: number): void;
+    static RegisterCustomFactoryForXusbType(factory: Windows.Gaming.Input.Custom.ICustomGameControllerFactory, xusbType: number, xusbSubtype: number): void;
+    static TryGetFactoryControllerFromGameController(factory: Windows.Gaming.Input.Custom.ICustomGameControllerFactory, gameController: Windows.Gaming.Input.IGameController): Windows.Gaming.Input.IGameController;
+  }
+
+  class GipFirmwareUpdateResult implements Windows.Gaming.Input.Custom.IGipFirmwareUpdateResult {
+    readonly ExtendedErrorCode: number;
+    readonly FinalComponentId: number;
+    readonly Status: number;
+  }
+
+  class GipGameControllerProvider implements Windows.Gaming.Input.Custom.IGameControllerProvider, Windows.Gaming.Input.Custom.IGipGameControllerProvider {
+    SendMessage(messageClass: number, messageId: number, messageBuffer: number[]): void;
+    SendReceiveMessage(messageClass: number, messageId: number, requestMessageBuffer: number[], responseMessageBuffer: number[]): void;
+    UpdateFirmwareAsync(firmwareImage: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncOperationWithProgress<Windows.Gaming.Input.Custom.GipFirmwareUpdateResult, Windows.Gaming.Input.Custom.GipFirmwareUpdateProgress>;
+    readonly FirmwareVersionInfo: Windows.Gaming.Input.Custom.GameControllerVersionInfo;
+    readonly HardwareProductId: number;
+    readonly HardwareVendorId: number;
+    readonly HardwareVersionInfo: Windows.Gaming.Input.Custom.GameControllerVersionInfo;
+    readonly IsConnected: boolean;
+  }
+
+  class HidGameControllerProvider implements Windows.Gaming.Input.Custom.IGameControllerProvider, Windows.Gaming.Input.Custom.IHidGameControllerProvider {
+    GetFeatureReport(reportId: number, reportBuffer: number[]): void;
+    SendFeatureReport(reportId: number, reportBuffer: number[]): void;
+    SendOutputReport(reportId: number, reportBuffer: number[]): void;
+    readonly FirmwareVersionInfo: Windows.Gaming.Input.Custom.GameControllerVersionInfo;
+    readonly HardwareProductId: number;
+    readonly HardwareVendorId: number;
+    readonly HardwareVersionInfo: Windows.Gaming.Input.Custom.GameControllerVersionInfo;
+    readonly IsConnected: boolean;
+    readonly UsageId: number;
+    readonly UsagePage: number;
+  }
+
+  class XusbGameControllerProvider implements Windows.Gaming.Input.Custom.IGameControllerProvider, Windows.Gaming.Input.Custom.IXusbGameControllerProvider {
+    SetVibration(lowFrequencyMotorSpeed: number, highFrequencyMotorSpeed: number): void;
+    readonly FirmwareVersionInfo: Windows.Gaming.Input.Custom.GameControllerVersionInfo;
+    readonly HardwareProductId: number;
+    readonly HardwareVendorId: number;
+    readonly HardwareVersionInfo: Windows.Gaming.Input.Custom.GameControllerVersionInfo;
+    readonly IsConnected: boolean;
+  }
+
+  enum GipFirmwareUpdateStatus {
+    Completed = 0,
+    UpToDate = 1,
+    Failed = 2,
+  }
+
+  enum GipMessageClass {
+    Command = 0,
+    LowLatency = 1,
+    StandardLatency = 2,
+  }
+
+  enum XusbDeviceSubtype {
+    Unknown = 0,
+    Gamepad = 1,
+    ArcadePad = 2,
+    ArcadeStick = 3,
+    FlightStick = 4,
+    Wheel = 5,
+    Guitar = 6,
+    GuitarAlternate = 7,
+    GuitarBass = 8,
+    DrumKit = 9,
+    DancePad = 10,
+  }
+
+  enum XusbDeviceType {
+    Unknown = 0,
+    Gamepad = 1,
+  }
+
+  interface GameControllerVersionInfo {
+    Major: number;
+    Minor: number;
+    Build: number;
+    Revision: number;
+  }
+  var GameControllerVersionInfo: {
+    new(major: number, minor: number, build: number, revision: number): GameControllerVersionInfo;
+    new(fields: { Major?: number; Minor?: number; Build?: number; Revision?: number }): GameControllerVersionInfo;
+  };
+
+  interface GipFirmwareUpdateProgress {
+    PercentCompleted: number;
+    CurrentComponentId: number;
+  }
+  var GipFirmwareUpdateProgress: {
+    new(percentCompleted: number, currentComponentId: number): GipFirmwareUpdateProgress;
+    new(fields: { PercentCompleted?: number; CurrentComponentId?: number }): GipFirmwareUpdateProgress;
+  };
+
+  interface ICustomGameControllerFactory {
+    CreateGameController(provider: Windows.Gaming.Input.Custom.IGameControllerProvider): Object;
+    OnGameControllerAdded(value: Windows.Gaming.Input.IGameController): void;
+    OnGameControllerRemoved(value: Windows.Gaming.Input.IGameController): void;
+  }
+  var ICustomGameControllerFactory: abstract new (...args: any[]) => ICustomGameControllerFactory;
+
+  interface IGameControllerFactoryManagerStatics {
+    RegisterCustomFactoryForGipInterface(factory: Windows.Gaming.Input.Custom.ICustomGameControllerFactory, interfaceId: Guid): void;
+    RegisterCustomFactoryForHardwareId(factory: Windows.Gaming.Input.Custom.ICustomGameControllerFactory, hardwareVendorId: number, hardwareProductId: number): void;
+    RegisterCustomFactoryForXusbType(factory: Windows.Gaming.Input.Custom.ICustomGameControllerFactory, xusbType: number, xusbSubtype: number): void;
+  }
+  var IGameControllerFactoryManagerStatics: abstract new (...args: any[]) => IGameControllerFactoryManagerStatics;
+
+  interface IGameControllerFactoryManagerStatics2 extends Windows.Gaming.Input.Custom.IGameControllerFactoryManagerStatics {
+    RegisterCustomFactoryForGipInterface(factory: Windows.Gaming.Input.Custom.ICustomGameControllerFactory, interfaceId: Guid): void;
+    RegisterCustomFactoryForHardwareId(factory: Windows.Gaming.Input.Custom.ICustomGameControllerFactory, hardwareVendorId: number, hardwareProductId: number): void;
+    RegisterCustomFactoryForXusbType(factory: Windows.Gaming.Input.Custom.ICustomGameControllerFactory, xusbType: number, xusbSubtype: number): void;
+    TryGetFactoryControllerFromGameController(factory: Windows.Gaming.Input.Custom.ICustomGameControllerFactory, gameController: Windows.Gaming.Input.IGameController): Windows.Gaming.Input.IGameController;
+  }
+  var IGameControllerFactoryManagerStatics2: abstract new (...args: any[]) => IGameControllerFactoryManagerStatics2;
+
+  interface IGameControllerInputSink {
+    OnInputResumed(timestamp: number | bigint): void;
+    OnInputSuspended(timestamp: number | bigint): void;
+  }
+  var IGameControllerInputSink: abstract new (...args: any[]) => IGameControllerInputSink;
+
+  interface IGameControllerProvider {
+    readonly FirmwareVersionInfo: Windows.Gaming.Input.Custom.GameControllerVersionInfo;
+    readonly HardwareProductId: number;
+    readonly HardwareVendorId: number;
+    readonly HardwareVersionInfo: Windows.Gaming.Input.Custom.GameControllerVersionInfo;
+    readonly IsConnected: boolean;
+  }
+  var IGameControllerProvider: abstract new (...args: any[]) => IGameControllerProvider;
+
+  interface IGipFirmwareUpdateResult {
+    readonly ExtendedErrorCode: number;
+    readonly FinalComponentId: number;
+    readonly Status: number;
+  }
+  var IGipFirmwareUpdateResult: abstract new (...args: any[]) => IGipFirmwareUpdateResult;
+
+  interface IGipGameControllerInputSink extends Windows.Gaming.Input.Custom.IGameControllerInputSink {
+    OnInputResumed(timestamp: number | bigint): void;
+    OnInputSuspended(timestamp: number | bigint): void;
+    OnKeyReceived(timestamp: number | bigint, keyCode: number, isPressed: boolean): void;
+    OnMessageReceived(timestamp: number | bigint, messageClass: number, messageId: number, sequenceId: number, messageBuffer: number[]): void;
+  }
+  var IGipGameControllerInputSink: abstract new (...args: any[]) => IGipGameControllerInputSink;
+
+  interface IGipGameControllerProvider extends Windows.Gaming.Input.Custom.IGameControllerProvider {
+    SendMessage(messageClass: number, messageId: number, messageBuffer: number[]): void;
+    SendReceiveMessage(messageClass: number, messageId: number, requestMessageBuffer: number[], responseMessageBuffer: number[]): void;
+    UpdateFirmwareAsync(firmwareImage: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncOperationWithProgress<Windows.Gaming.Input.Custom.GipFirmwareUpdateResult, Windows.Gaming.Input.Custom.GipFirmwareUpdateProgress>;
+  }
+  var IGipGameControllerProvider: abstract new (...args: any[]) => IGipGameControllerProvider;
+
+  interface IHidGameControllerInputSink extends Windows.Gaming.Input.Custom.IGameControllerInputSink {
+    OnInputReportReceived(timestamp: number | bigint, reportId: number, reportBuffer: number[]): void;
+    OnInputResumed(timestamp: number | bigint): void;
+    OnInputSuspended(timestamp: number | bigint): void;
+  }
+  var IHidGameControllerInputSink: abstract new (...args: any[]) => IHidGameControllerInputSink;
+
+  interface IHidGameControllerProvider extends Windows.Gaming.Input.Custom.IGameControllerProvider {
+    GetFeatureReport(reportId: number, reportBuffer: number[]): void;
+    SendFeatureReport(reportId: number, reportBuffer: number[]): void;
+    SendOutputReport(reportId: number, reportBuffer: number[]): void;
+    readonly UsageId: number;
+    readonly UsagePage: number;
+  }
+  var IHidGameControllerProvider: abstract new (...args: any[]) => IHidGameControllerProvider;
+
+  interface IXusbGameControllerInputSink extends Windows.Gaming.Input.Custom.IGameControllerInputSink {
+    OnInputReceived(timestamp: number | bigint, reportId: number, inputBuffer: number[]): void;
+    OnInputResumed(timestamp: number | bigint): void;
+    OnInputSuspended(timestamp: number | bigint): void;
+  }
+  var IXusbGameControllerInputSink: abstract new (...args: any[]) => IXusbGameControllerInputSink;
+
+  interface IXusbGameControllerProvider extends Windows.Gaming.Input.Custom.IGameControllerProvider {
+    SetVibration(lowFrequencyMotorSpeed: number, highFrequencyMotorSpeed: number): void;
+  }
+  var IXusbGameControllerProvider: abstract new (...args: any[]) => IXusbGameControllerProvider;
+
+}
+
+declare namespace Windows.Gaming.Input.ForceFeedback {
+  class ConditionForceEffect implements Windows.Gaming.Input.ForceFeedback.IConditionForceEffect, Windows.Gaming.Input.ForceFeedback.IForceFeedbackEffect {
+    constructor(effectKind: number);
+    SetParameters(direction: Windows.Foundation.Numerics.Vector3, positiveCoefficient: number, negativeCoefficient: number, maxPositiveMagnitude: number, maxNegativeMagnitude: number, deadZone: number, bias: number): void;
+    Start(): void;
+    Stop(): void;
+    Gain: number;
+    readonly Kind: number;
+    readonly State: number;
+  }
+
+  class ConstantForceEffect implements Windows.Gaming.Input.ForceFeedback.IConstantForceEffect, Windows.Gaming.Input.ForceFeedback.IForceFeedbackEffect {
+    constructor();
+    SetParameters(vector: Windows.Foundation.Numerics.Vector3, duration: Windows.Foundation.TimeSpan): void;
+    SetParametersWithEnvelope(vector: Windows.Foundation.Numerics.Vector3, attackGain: number, sustainGain: number, releaseGain: number, startDelay: Windows.Foundation.TimeSpan, attackDuration: Windows.Foundation.TimeSpan, sustainDuration: Windows.Foundation.TimeSpan, releaseDuration: Windows.Foundation.TimeSpan, repeatCount: number): void;
+    Start(): void;
+    Stop(): void;
+    Gain: number;
+    readonly State: number;
+  }
+
+  class ForceFeedbackMotor implements Windows.Gaming.Input.ForceFeedback.IForceFeedbackMotor {
+    LoadEffectAsync(effect: Windows.Gaming.Input.ForceFeedback.IForceFeedbackEffect): Windows.Foundation.IAsyncOperation<number>;
+    PauseAllEffects(): void;
+    ResumeAllEffects(): void;
+    StopAllEffects(): void;
+    TryDisableAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryEnableAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryResetAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryUnloadEffectAsync(effect: Windows.Gaming.Input.ForceFeedback.IForceFeedbackEffect): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly AreEffectsPaused: boolean;
+    readonly IsEnabled: boolean;
+    MasterGain: number;
+    readonly SupportedAxes: number;
+  }
+
+  class PeriodicForceEffect implements Windows.Gaming.Input.ForceFeedback.IForceFeedbackEffect, Windows.Gaming.Input.ForceFeedback.IPeriodicForceEffect {
+    constructor(effectKind: number);
+    SetParameters(vector: Windows.Foundation.Numerics.Vector3, frequency: number, phase: number, bias: number, duration: Windows.Foundation.TimeSpan): void;
+    SetParametersWithEnvelope(vector: Windows.Foundation.Numerics.Vector3, frequency: number, phase: number, bias: number, attackGain: number, sustainGain: number, releaseGain: number, startDelay: Windows.Foundation.TimeSpan, attackDuration: Windows.Foundation.TimeSpan, sustainDuration: Windows.Foundation.TimeSpan, releaseDuration: Windows.Foundation.TimeSpan, repeatCount: number): void;
+    Start(): void;
+    Stop(): void;
+    Gain: number;
+    readonly Kind: number;
+    readonly State: number;
+  }
+
+  class RampForceEffect implements Windows.Gaming.Input.ForceFeedback.IForceFeedbackEffect, Windows.Gaming.Input.ForceFeedback.IRampForceEffect {
+    constructor();
+    SetParameters(startVector: Windows.Foundation.Numerics.Vector3, endVector: Windows.Foundation.Numerics.Vector3, duration: Windows.Foundation.TimeSpan): void;
+    SetParametersWithEnvelope(startVector: Windows.Foundation.Numerics.Vector3, endVector: Windows.Foundation.Numerics.Vector3, attackGain: number, sustainGain: number, releaseGain: number, startDelay: Windows.Foundation.TimeSpan, attackDuration: Windows.Foundation.TimeSpan, sustainDuration: Windows.Foundation.TimeSpan, releaseDuration: Windows.Foundation.TimeSpan, repeatCount: number): void;
+    Start(): void;
+    Stop(): void;
+    Gain: number;
+    readonly State: number;
+  }
+
+  enum ConditionForceEffectKind {
+    Spring = 0,
+    Damper = 1,
+    Inertia = 2,
+    Friction = 3,
+  }
+
+  enum ForceFeedbackEffectAxes {
+    None = 0,
+    X = 1,
+    Y = 2,
+    Z = 4,
+  }
+
+  enum ForceFeedbackEffectState {
+    Stopped = 0,
+    Running = 1,
+    Paused = 2,
+    Faulted = 3,
+  }
+
+  enum ForceFeedbackLoadEffectResult {
+    Succeeded = 0,
+    EffectStorageFull = 1,
+    EffectNotSupported = 2,
+  }
+
+  enum PeriodicForceEffectKind {
+    SquareWave = 0,
+    SineWave = 1,
+    TriangleWave = 2,
+    SawtoothWaveUp = 3,
+    SawtoothWaveDown = 4,
+  }
+
+  interface IConditionForceEffect extends Windows.Gaming.Input.ForceFeedback.IForceFeedbackEffect {
+    SetParameters(direction: Windows.Foundation.Numerics.Vector3, positiveCoefficient: number, negativeCoefficient: number, maxPositiveMagnitude: number, maxNegativeMagnitude: number, deadZone: number, bias: number): void;
+    Start(): void;
+    Stop(): void;
+    readonly Kind: number;
+  }
+  var IConditionForceEffect: abstract new (...args: any[]) => IConditionForceEffect;
+
+  interface IConditionForceEffectFactory {
+    CreateInstance(effectKind: number): Windows.Gaming.Input.ForceFeedback.ConditionForceEffect;
+  }
+  var IConditionForceEffectFactory: abstract new (...args: any[]) => IConditionForceEffectFactory;
+
+  interface IConstantForceEffect extends Windows.Gaming.Input.ForceFeedback.IForceFeedbackEffect {
+    SetParameters(vector: Windows.Foundation.Numerics.Vector3, duration: Windows.Foundation.TimeSpan): void;
+    SetParametersWithEnvelope(vector: Windows.Foundation.Numerics.Vector3, attackGain: number, sustainGain: number, releaseGain: number, startDelay: Windows.Foundation.TimeSpan, attackDuration: Windows.Foundation.TimeSpan, sustainDuration: Windows.Foundation.TimeSpan, releaseDuration: Windows.Foundation.TimeSpan, repeatCount: number): void;
+    Start(): void;
+    Stop(): void;
+  }
+  var IConstantForceEffect: abstract new (...args: any[]) => IConstantForceEffect;
+
+  interface IForceFeedbackEffect {
+    Start(): void;
+    Stop(): void;
+    Gain: number;
+    readonly State: number;
+  }
+  var IForceFeedbackEffect: abstract new (...args: any[]) => IForceFeedbackEffect;
+
+  interface IForceFeedbackMotor {
+    LoadEffectAsync(effect: Windows.Gaming.Input.ForceFeedback.IForceFeedbackEffect): Windows.Foundation.IAsyncOperation<number>;
+    PauseAllEffects(): void;
+    ResumeAllEffects(): void;
+    StopAllEffects(): void;
+    TryDisableAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryEnableAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryResetAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryUnloadEffectAsync(effect: Windows.Gaming.Input.ForceFeedback.IForceFeedbackEffect): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly AreEffectsPaused: boolean;
+    readonly IsEnabled: boolean;
+    MasterGain: number;
+    readonly SupportedAxes: number;
+  }
+  var IForceFeedbackMotor: abstract new (...args: any[]) => IForceFeedbackMotor;
+
+  interface IPeriodicForceEffect extends Windows.Gaming.Input.ForceFeedback.IForceFeedbackEffect {
+    SetParameters(vector: Windows.Foundation.Numerics.Vector3, frequency: number, phase: number, bias: number, duration: Windows.Foundation.TimeSpan): void;
+    SetParametersWithEnvelope(vector: Windows.Foundation.Numerics.Vector3, frequency: number, phase: number, bias: number, attackGain: number, sustainGain: number, releaseGain: number, startDelay: Windows.Foundation.TimeSpan, attackDuration: Windows.Foundation.TimeSpan, sustainDuration: Windows.Foundation.TimeSpan, releaseDuration: Windows.Foundation.TimeSpan, repeatCount: number): void;
+    Start(): void;
+    Stop(): void;
+    readonly Kind: number;
+  }
+  var IPeriodicForceEffect: abstract new (...args: any[]) => IPeriodicForceEffect;
+
+  interface IPeriodicForceEffectFactory {
+    CreateInstance(effectKind: number): Windows.Gaming.Input.ForceFeedback.PeriodicForceEffect;
+  }
+  var IPeriodicForceEffectFactory: abstract new (...args: any[]) => IPeriodicForceEffectFactory;
+
+  interface IRampForceEffect extends Windows.Gaming.Input.ForceFeedback.IForceFeedbackEffect {
+    SetParameters(startVector: Windows.Foundation.Numerics.Vector3, endVector: Windows.Foundation.Numerics.Vector3, duration: Windows.Foundation.TimeSpan): void;
+    SetParametersWithEnvelope(startVector: Windows.Foundation.Numerics.Vector3, endVector: Windows.Foundation.Numerics.Vector3, attackGain: number, sustainGain: number, releaseGain: number, startDelay: Windows.Foundation.TimeSpan, attackDuration: Windows.Foundation.TimeSpan, sustainDuration: Windows.Foundation.TimeSpan, releaseDuration: Windows.Foundation.TimeSpan, repeatCount: number): void;
+    Start(): void;
+    Stop(): void;
+  }
+  var IRampForceEffect: abstract new (...args: any[]) => IRampForceEffect;
+
+}
+
+declare namespace Windows.Gaming.Input.Preview {
+  class GameControllerProviderInfo {
+    static GetParentProviderId(provider: Windows.Gaming.Input.Custom.IGameControllerProvider): string;
+    static GetProviderId(provider: Windows.Gaming.Input.Custom.IGameControllerProvider): string;
+  }
+
+  class LegacyGipGameControllerProvider implements Windows.Gaming.Input.Preview.ILegacyGipGameControllerProvider {
+    static ClearPairing(user: Windows.System.User, controllerProviderId: string): void;
+    ExecuteCommand(command: number): void;
+    static FromGameController(controller: Windows.Gaming.Input.IGameController): Windows.Gaming.Input.Preview.LegacyGipGameControllerProvider;
+    static FromGameControllerProvider(provider: Windows.Gaming.Input.Custom.IGameControllerProvider): Windows.Gaming.Input.Preview.LegacyGipGameControllerProvider;
+    GetDeviceFirmwareCorruptionState(): number;
+    GetExtendedDeviceInfo(): number[];
+    GetHeadsetOperation(operation: number): number[];
+    GetStandardControllerButtonRemapping(user: Windows.System.User, previous: boolean): Windows.Foundation.Collections.IMapView<number, Object>;
+    static IsCopilot(user: Windows.System.User, controllerProviderId: string): string;
+    IsInterfaceSupported(interfaceId: Guid): boolean;
+    static IsPilot(user: Windows.System.User, controllerProviderId: string): string;
+    static PairPilotToCopilot(user: Windows.System.User, pilotControllerProviderId: string, copilotControllerProviderId: string): void;
+    SetHeadsetOperation(operation: number, buffer: number[]): void;
+    SetHomeLedIntensity(intensity: number): void;
+    SetStandardControllerButtonRemapping(user: Windows.System.User, previous: boolean, remapping: Windows.Foundation.Collections.IMapView<number, Object>): void;
+    readonly AppCompatVersion: number;
+    readonly BatteryChargingState: number;
+    readonly BatteryKind: number;
+    readonly BatteryLevel: number;
+    readonly IsFirmwareCorrupted: boolean;
+    readonly IsSyntheticDevice: boolean;
+    readonly PreferredTypes: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+
+  enum DeviceCommand {
+    Reset = 0,
+  }
+
+  enum GameControllerBatteryChargingState {
+    Unknown = 0,
+    Inactive = 1,
+    Active = 2,
+    Error = 3,
+  }
+
+  enum GameControllerBatteryKind {
+    Unknown = 0,
+    None = 1,
+    Standard = 2,
+    Rechargeable = 3,
+  }
+
+  enum GameControllerBatteryLevel {
+    Unknown = 0,
+    Critical = 1,
+    Low = 2,
+    Medium = 3,
+    Full = 4,
+  }
+
+  enum GameControllerFirmwareCorruptReason {
+    Unknown = 0,
+    NotCorrupt = 1,
+    TwoUpCorrupt = 2,
+    AppCorrupt = 3,
+    RadioCorrupt = 4,
+    EepromCorrupt = 5,
+    SafeToUpdate = 6,
+  }
+
+  enum HeadsetLevel {
+    Off = 0,
+    Low = 1,
+    Medium = 2,
+    High = 3,
+  }
+
+  enum HeadsetOperation {
+    Geq = 0,
+    BassBoostGain = 1,
+    SmartMute = 2,
+    SideTone = 3,
+    MuteLedBrightness = 4,
+    SwapMixAndVolumeDials = 5,
+  }
+
+  enum RemappingButtonCategory {
+    ButtonSettings = 0,
+    AnalogSettings = 1,
+    VibrationSettings = 2,
+    ShareShortPress = 3,
+    ShareShortPressMetaData = 4,
+    ShareShortPressMetaDataDisplay = 5,
+    ShareLongPress = 6,
+    ShareLongPressMetaData = 7,
+    ShareLongPressMetaDataDisplay = 8,
+    ShareDoublePress = 9,
+    ShareDoublePressMetaData = 10,
+    ShareDoublePressMetaDataDisplay = 11,
+  }
+
+  interface HeadsetGeqGains {
+    band1Gain: number;
+    band2Gain: number;
+    band3Gain: number;
+    band4Gain: number;
+    band5Gain: number;
+  }
+  var HeadsetGeqGains: {
+    new(band1Gain: number, band2Gain: number, band3Gain: number, band4Gain: number, band5Gain: number): HeadsetGeqGains;
+    new(fields: { band1Gain?: number; band2Gain?: number; band3Gain?: number; band4Gain?: number; band5Gain?: number }): HeadsetGeqGains;
+  };
+
+  interface IGameControllerProviderInfoStatics {
+    GetParentProviderId(provider: Windows.Gaming.Input.Custom.IGameControllerProvider): string;
+    GetProviderId(provider: Windows.Gaming.Input.Custom.IGameControllerProvider): string;
+  }
+  var IGameControllerProviderInfoStatics: abstract new (...args: any[]) => IGameControllerProviderInfoStatics;
+
+  interface ILegacyGipGameControllerProvider {
+    ExecuteCommand(command: number): void;
+    GetDeviceFirmwareCorruptionState(): number;
+    GetExtendedDeviceInfo(): number[];
+    GetHeadsetOperation(operation: number): number[];
+    GetStandardControllerButtonRemapping(user: Windows.System.User, previous: boolean): Windows.Foundation.Collections.IMapView<number, Object>;
+    IsInterfaceSupported(interfaceId: Guid): boolean;
+    SetHeadsetOperation(operation: number, buffer: number[]): void;
+    SetHomeLedIntensity(intensity: number): void;
+    SetStandardControllerButtonRemapping(user: Windows.System.User, previous: boolean, remapping: Windows.Foundation.Collections.IMapView<number, Object>): void;
+    readonly AppCompatVersion: number;
+    readonly BatteryChargingState: number;
+    readonly BatteryKind: number;
+    readonly BatteryLevel: number;
+    readonly IsFirmwareCorrupted: boolean;
+    readonly IsSyntheticDevice: boolean;
+    readonly PreferredTypes: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var ILegacyGipGameControllerProvider: abstract new (...args: any[]) => ILegacyGipGameControllerProvider;
+
+  interface ILegacyGipGameControllerProviderStatics {
+    ClearPairing(user: Windows.System.User, controllerProviderId: string): void;
+    FromGameController(controller: Windows.Gaming.Input.IGameController): Windows.Gaming.Input.Preview.LegacyGipGameControllerProvider;
+    FromGameControllerProvider(provider: Windows.Gaming.Input.Custom.IGameControllerProvider): Windows.Gaming.Input.Preview.LegacyGipGameControllerProvider;
+    IsCopilot(user: Windows.System.User, controllerProviderId: string): string;
+    IsPilot(user: Windows.System.User, controllerProviderId: string): string;
+    PairPilotToCopilot(user: Windows.System.User, pilotControllerProviderId: string, copilotControllerProviderId: string): void;
+  }
+  var ILegacyGipGameControllerProviderStatics: abstract new (...args: any[]) => ILegacyGipGameControllerProviderStatics;
+
+}
+
+declare namespace Windows.Gaming.Preview {
+  interface GamesEnumerationContract {
+  }
+  var GamesEnumerationContract: {
+    new(fields: {  }): GamesEnumerationContract;
+  };
+
+}
+
+declare namespace Windows.Gaming.Preview.GamesEnumeration {
+  class GameList {
+    static FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Gaming.Preview.GamesEnumeration.GameListEntry> | Windows.Gaming.Preview.GamesEnumeration.GameListEntry[]>;
+    static FindAllAsync(packageFamilyName: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Gaming.Preview.GamesEnumeration.GameListEntry> | Windows.Gaming.Preview.GamesEnumeration.GameListEntry[]>;
+    static MergeEntriesAsync(left: Windows.Gaming.Preview.GamesEnumeration.GameListEntry, right: Windows.Gaming.Preview.GamesEnumeration.GameListEntry): Windows.Foundation.IAsyncOperation<Windows.Gaming.Preview.GamesEnumeration.GameListEntry>;
+    static UnmergeEntryAsync(mergedEntry: Windows.Gaming.Preview.GamesEnumeration.GameListEntry): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Gaming.Preview.GamesEnumeration.GameListEntry> | Windows.Gaming.Preview.GamesEnumeration.GameListEntry[]>;
+    static GameAdded: Windows.Gaming.Preview.GamesEnumeration.GameListChangedEventHandler | null;
+    static GameRemoved: Windows.Gaming.Preview.GamesEnumeration.GameListRemovedEventHandler | null;
+    static GameUpdated: Windows.Gaming.Preview.GamesEnumeration.GameListChangedEventHandler | null;
+  }
+
+  class GameListEntry implements Windows.Gaming.Preview.GamesEnumeration.IGameListEntry, Windows.Gaming.Preview.GamesEnumeration.IGameListEntry2 {
+    LaunchAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    SetCategoryAsync(value: number): Windows.Foundation.IAsyncAction;
+    SetLauncherExecutableFileAsync(executableFile: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncAction;
+    SetLauncherExecutableFileAsync(executableFile: Windows.Storage.IStorageFile, launchParams: string): Windows.Foundation.IAsyncAction;
+    SetTitleIdAsync(id: string): Windows.Foundation.IAsyncAction;
+    readonly Category: number;
+    readonly DisplayInfo: Windows.ApplicationModel.AppDisplayInfo;
+    readonly GameModeConfiguration: Windows.Gaming.Preview.GamesEnumeration.GameModeConfiguration;
+    readonly LaunchParameters: string;
+    readonly LaunchableState: number;
+    readonly LauncherExecutable: Windows.Storage.IStorageFile;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly TitleId: string;
+  }
+
+  class GameModeConfiguration implements Windows.Gaming.Preview.GamesEnumeration.IGameModeConfiguration {
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    AffinitizeToExclusiveCpus: boolean;
+    CpuExclusivityMaskHigh: number | null;
+    CpuExclusivityMaskLow: number | null;
+    IsEnabled: boolean;
+    MaxCpuCount: number | null;
+    PercentGpuMemoryAllocatedToGame: number | null;
+    PercentGpuMemoryAllocatedToSystemCompositor: number | null;
+    PercentGpuTimeAllocatedToGame: number | null;
+    readonly RelatedProcessNames: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+
+  class GameModeUserConfiguration implements Windows.Gaming.Preview.GamesEnumeration.IGameModeUserConfiguration {
+    static GetDefault(): Windows.Gaming.Preview.GamesEnumeration.GameModeUserConfiguration;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    readonly GamingRelatedProcessNames: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+
+  enum GameListCategory {
+    Candidate = 0,
+    ConfirmedBySystem = 1,
+    ConfirmedByUser = 2,
+  }
+
+  enum GameListEntryLaunchableState {
+    NotLaunchable = 0,
+    ByLastRunningFullPath = 1,
+    ByUserProvidedPath = 2,
+    ByTile = 3,
+  }
+
+  interface GameListChangedEventHandler {
+    (game: Windows.Gaming.Preview.GamesEnumeration.GameListEntry): void;
+  }
+  var GameListChangedEventHandler: {
+    new(callback: (game: Windows.Gaming.Preview.GamesEnumeration.GameListEntry) => void): GameListChangedEventHandler;
+  };
+
+  interface GameListRemovedEventHandler {
+    (identifier: string): void;
+  }
+  var GameListRemovedEventHandler: {
+    new(callback: (identifier: string) => void): GameListRemovedEventHandler;
+  };
+
+  interface IGameListEntry {
+    LaunchAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    SetCategoryAsync(value: number): Windows.Foundation.IAsyncAction;
+    readonly Category: number;
+    readonly DisplayInfo: Windows.ApplicationModel.AppDisplayInfo;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+  var IGameListEntry: abstract new (...args: any[]) => IGameListEntry;
+
+  interface IGameListEntry2 extends Windows.Gaming.Preview.GamesEnumeration.IGameListEntry {
+    LaunchAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    SetCategoryAsync(value: number): Windows.Foundation.IAsyncAction;
+    SetLauncherExecutableFileAsync(executableFile: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncAction;
+    SetLauncherExecutableFileAsync(executableFile: Windows.Storage.IStorageFile, launchParams: string): Windows.Foundation.IAsyncAction;
+    SetTitleIdAsync(id: string): Windows.Foundation.IAsyncAction;
+    readonly GameModeConfiguration: Windows.Gaming.Preview.GamesEnumeration.GameModeConfiguration;
+    readonly LaunchParameters: string;
+    readonly LaunchableState: number;
+    readonly LauncherExecutable: Windows.Storage.IStorageFile;
+    readonly TitleId: string;
+  }
+  var IGameListEntry2: abstract new (...args: any[]) => IGameListEntry2;
+
+  interface IGameListStatics {
+    FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Gaming.Preview.GamesEnumeration.GameListEntry> | Windows.Gaming.Preview.GamesEnumeration.GameListEntry[]>;
+    FindAllAsync(packageFamilyName: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Gaming.Preview.GamesEnumeration.GameListEntry> | Windows.Gaming.Preview.GamesEnumeration.GameListEntry[]>;
+    GameAdded: Windows.Gaming.Preview.GamesEnumeration.GameListChangedEventHandler | null;
+    GameRemoved: Windows.Gaming.Preview.GamesEnumeration.GameListRemovedEventHandler | null;
+    GameUpdated: Windows.Gaming.Preview.GamesEnumeration.GameListChangedEventHandler | null;
+  }
+  var IGameListStatics: abstract new (...args: any[]) => IGameListStatics;
+
+  interface IGameListStatics2 {
+    MergeEntriesAsync(left: Windows.Gaming.Preview.GamesEnumeration.GameListEntry, right: Windows.Gaming.Preview.GamesEnumeration.GameListEntry): Windows.Foundation.IAsyncOperation<Windows.Gaming.Preview.GamesEnumeration.GameListEntry>;
+    UnmergeEntryAsync(mergedEntry: Windows.Gaming.Preview.GamesEnumeration.GameListEntry): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Gaming.Preview.GamesEnumeration.GameListEntry> | Windows.Gaming.Preview.GamesEnumeration.GameListEntry[]>;
+  }
+  var IGameListStatics2: abstract new (...args: any[]) => IGameListStatics2;
+
+  interface IGameModeConfiguration {
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    AffinitizeToExclusiveCpus: boolean;
+    CpuExclusivityMaskHigh: number | null;
+    CpuExclusivityMaskLow: number | null;
+    IsEnabled: boolean;
+    MaxCpuCount: number | null;
+    PercentGpuMemoryAllocatedToGame: number | null;
+    PercentGpuMemoryAllocatedToSystemCompositor: number | null;
+    PercentGpuTimeAllocatedToGame: number | null;
+    readonly RelatedProcessNames: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var IGameModeConfiguration: abstract new (...args: any[]) => IGameModeConfiguration;
+
+  interface IGameModeUserConfiguration {
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    readonly GamingRelatedProcessNames: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var IGameModeUserConfiguration: abstract new (...args: any[]) => IGameModeUserConfiguration;
+
+  interface IGameModeUserConfigurationStatics {
+    GetDefault(): Windows.Gaming.Preview.GamesEnumeration.GameModeUserConfiguration;
+  }
+  var IGameModeUserConfigurationStatics: abstract new (...args: any[]) => IGameModeUserConfigurationStatics;
+
+}
+
+declare namespace Windows.Gaming.UI {
+  class GameBar {
+    static readonly IsInputRedirected: boolean;
+    static readonly Visible: boolean;
+    static IsInputRedirectedChanged: Windows.Foundation.EventHandler<Object> | null;
+    static VisibilityChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class GameChatMessageReceivedEventArgs implements Windows.Gaming.UI.IGameChatMessageReceivedEventArgs {
+    readonly AppDisplayName: string;
+    readonly AppId: string;
+    readonly Message: string;
+    readonly Origin: number;
+    readonly SenderName: string;
+  }
+
+  class GameChatOverlay implements Windows.Gaming.UI.IGameChatOverlay {
+    AddMessage(sender: string, message: string, origin: number): void;
+    static GetDefault(): Windows.Gaming.UI.GameChatOverlay;
+    DesiredPosition: number;
+  }
+
+  class GameChatOverlayMessageSource implements Windows.Gaming.UI.IGameChatOverlayMessageSource {
+    constructor();
+    SetDelayBeforeClosingAfterMessageReceived(value: Windows.Foundation.TimeSpan): void;
+    MessageReceived: Windows.Foundation.TypedEventHandler<Windows.Gaming.UI.GameChatOverlayMessageSource, Windows.Gaming.UI.GameChatMessageReceivedEventArgs> | null;
+  }
+
+  class GameUIProviderActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.Gaming.UI.IGameUIProviderActivatedEventArgs {
+    ReportCompleted(results: Windows.Foundation.Collections.ValueSet): void;
+    readonly GameUIArgs: Windows.Foundation.Collections.ValueSet;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+  }
+
+  enum GameChatMessageOrigin {
+    Voice = 0,
+    Text = 1,
+  }
+
+  enum GameChatOverlayPosition {
+    BottomCenter = 0,
+    BottomLeft = 1,
+    BottomRight = 2,
+    MiddleRight = 3,
+    MiddleLeft = 4,
+    TopCenter = 5,
+    TopLeft = 6,
+    TopRight = 7,
+  }
+
+  interface GameChatOverlayContract {
+  }
+  var GameChatOverlayContract: {
+    new(fields: {  }): GameChatOverlayContract;
+  };
+
+  interface GamingUIProviderContract {
+  }
+  var GamingUIProviderContract: {
+    new(fields: {  }): GamingUIProviderContract;
+  };
+
+  interface IGameBarStatics {
+    readonly IsInputRedirected: boolean;
+    readonly Visible: boolean;
+    IsInputRedirectedChanged: Windows.Foundation.EventHandler<Object> | null;
+    VisibilityChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IGameBarStatics: abstract new (...args: any[]) => IGameBarStatics;
+
+  interface IGameChatMessageReceivedEventArgs {
+    readonly AppDisplayName: string;
+    readonly AppId: string;
+    readonly Message: string;
+    readonly Origin: number;
+    readonly SenderName: string;
+  }
+  var IGameChatMessageReceivedEventArgs: abstract new (...args: any[]) => IGameChatMessageReceivedEventArgs;
+
+  interface IGameChatOverlay {
+    AddMessage(sender: string, message: string, origin: number): void;
+    DesiredPosition: number;
+  }
+  var IGameChatOverlay: abstract new (...args: any[]) => IGameChatOverlay;
+
+  interface IGameChatOverlayMessageSource {
+    SetDelayBeforeClosingAfterMessageReceived(value: Windows.Foundation.TimeSpan): void;
+    MessageReceived: Windows.Foundation.TypedEventHandler<Windows.Gaming.UI.GameChatOverlayMessageSource, Windows.Gaming.UI.GameChatMessageReceivedEventArgs> | null;
+  }
+  var IGameChatOverlayMessageSource: abstract new (...args: any[]) => IGameChatOverlayMessageSource;
+
+  interface IGameChatOverlayStatics {
+    GetDefault(): Windows.Gaming.UI.GameChatOverlay;
+  }
+  var IGameChatOverlayStatics: abstract new (...args: any[]) => IGameChatOverlayStatics;
+
+  interface IGameUIProviderActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs {
+    ReportCompleted(results: Windows.Foundation.Collections.ValueSet): void;
+    readonly GameUIArgs: Windows.Foundation.Collections.ValueSet;
+  }
+  var IGameUIProviderActivatedEventArgs: abstract new (...args: any[]) => IGameUIProviderActivatedEventArgs;
+
+}
+
+declare namespace Windows.Gaming.XboxLive {
+  interface StorageApiContract {
+  }
+  var StorageApiContract: {
+    new(fields: {  }): StorageApiContract;
+  };
+
+}
+
+declare namespace Windows.Gaming.XboxLive.Storage {
+  class GameSaveBlobGetResult implements Windows.Gaming.XboxLive.Storage.IGameSaveBlobGetResult {
+    readonly Status: number;
+    readonly Value: Windows.Foundation.Collections.IMapView<string, Windows.Storage.Streams.IBuffer>;
+  }
+
+  class GameSaveBlobInfo implements Windows.Gaming.XboxLive.Storage.IGameSaveBlobInfo {
+    readonly Name: string;
+    readonly Size: number;
+  }
+
+  class GameSaveBlobInfoGetResult implements Windows.Gaming.XboxLive.Storage.IGameSaveBlobInfoGetResult {
+    readonly Status: number;
+    readonly Value: Windows.Foundation.Collections.IVectorView<Windows.Gaming.XboxLive.Storage.GameSaveBlobInfo> | Windows.Gaming.XboxLive.Storage.GameSaveBlobInfo[];
+  }
+
+  class GameSaveBlobInfoQuery implements Windows.Gaming.XboxLive.Storage.IGameSaveBlobInfoQuery {
+    GetBlobInfoAsync(): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveBlobInfoGetResult>;
+    GetBlobInfoAsync(startIndex: number, maxNumberOfItems: number): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveBlobInfoGetResult>;
+    GetItemCountAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+
+  class GameSaveContainer implements Windows.Gaming.XboxLive.Storage.IGameSaveContainer {
+    CreateBlobInfoQuery(blobNamePrefix: string): Windows.Gaming.XboxLive.Storage.GameSaveBlobInfoQuery;
+    GetAsync(blobsToRead: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveBlobGetResult>;
+    ReadAsync(blobsToRead: Windows.Foundation.Collections.IMapView<string, Windows.Storage.Streams.IBuffer>): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveOperationResult>;
+    SubmitPropertySetUpdatesAsync(blobsToWrite: Windows.Foundation.Collections.IPropertySet, blobsToDelete: Windows.Foundation.Collections.IIterable<string> | string[], displayName: string): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveOperationResult>;
+    SubmitUpdatesAsync(blobsToWrite: Windows.Foundation.Collections.IMapView<string, Windows.Storage.Streams.IBuffer>, blobsToDelete: Windows.Foundation.Collections.IIterable<string> | string[], displayName: string): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveOperationResult>;
+    readonly Name: string;
+    readonly Provider: Windows.Gaming.XboxLive.Storage.GameSaveProvider;
+  }
+
+  class GameSaveContainerInfo implements Windows.Gaming.XboxLive.Storage.IGameSaveContainerInfo {
+    readonly DisplayName: string;
+    readonly LastModifiedTime: Windows.Foundation.DateTime;
+    readonly Name: string;
+    readonly NeedsSync: boolean;
+    readonly TotalSize: number | bigint;
+  }
+
+  class GameSaveContainerInfoGetResult implements Windows.Gaming.XboxLive.Storage.IGameSaveContainerInfoGetResult {
+    readonly Status: number;
+    readonly Value: Windows.Foundation.Collections.IVectorView<Windows.Gaming.XboxLive.Storage.GameSaveContainerInfo> | Windows.Gaming.XboxLive.Storage.GameSaveContainerInfo[];
+  }
+
+  class GameSaveContainerInfoQuery implements Windows.Gaming.XboxLive.Storage.IGameSaveContainerInfoQuery {
+    GetContainerInfoAsync(): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveContainerInfoGetResult>;
+    GetContainerInfoAsync(startIndex: number, maxNumberOfItems: number): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveContainerInfoGetResult>;
+    GetItemCountAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+
+  class GameSaveOperationResult implements Windows.Gaming.XboxLive.Storage.IGameSaveOperationResult {
+    readonly Status: number;
+  }
+
+  class GameSaveProvider implements Windows.Gaming.XboxLive.Storage.IGameSaveProvider {
+    CreateContainer(name: string): Windows.Gaming.XboxLive.Storage.GameSaveContainer;
+    CreateContainerInfoQuery(): Windows.Gaming.XboxLive.Storage.GameSaveContainerInfoQuery;
+    CreateContainerInfoQuery(containerNamePrefix: string): Windows.Gaming.XboxLive.Storage.GameSaveContainerInfoQuery;
+    DeleteContainerAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveOperationResult>;
+    static GetForUserAsync(user: Windows.System.User, serviceConfigId: string): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveProviderGetResult>;
+    GetRemainingBytesInQuotaAsync(): Windows.Foundation.IAsyncOperation<number | bigint>;
+    static GetSyncOnDemandForUserAsync(user: Windows.System.User, serviceConfigId: string): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveProviderGetResult>;
+    readonly ContainersChangedSinceLastSync: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly User: Windows.System.User;
+  }
+
+  class GameSaveProviderGetResult implements Windows.Gaming.XboxLive.Storage.IGameSaveProviderGetResult {
+    readonly Status: number;
+    readonly Value: Windows.Gaming.XboxLive.Storage.GameSaveProvider;
+  }
+
+  enum GameSaveErrorStatus {
+    Ok = 0,
+    Abort = -2147467260,
+    InvalidContainerName = -2138898431,
+    NoAccess = -2138898430,
+    OutOfLocalStorage = -2138898429,
+    UserCanceled = -2138898428,
+    UpdateTooBig = -2138898427,
+    QuotaExceeded = -2138898426,
+    ProvidedBufferTooSmall = -2138898425,
+    BlobNotFound = -2138898424,
+    NoXboxLiveInfo = -2138898423,
+    ContainerNotInSync = -2138898422,
+    ContainerSyncFailed = -2138898421,
+    UserHasNoXboxLiveInfo = -2138898420,
+    ObjectExpired = -2138898419,
+  }
+
+  interface IGameSaveBlobGetResult {
+    readonly Status: number;
+    readonly Value: Windows.Foundation.Collections.IMapView<string, Windows.Storage.Streams.IBuffer>;
+  }
+  var IGameSaveBlobGetResult: abstract new (...args: any[]) => IGameSaveBlobGetResult;
+
+  interface IGameSaveBlobInfo {
+    readonly Name: string;
+    readonly Size: number;
+  }
+  var IGameSaveBlobInfo: abstract new (...args: any[]) => IGameSaveBlobInfo;
+
+  interface IGameSaveBlobInfoGetResult {
+    readonly Status: number;
+    readonly Value: Windows.Foundation.Collections.IVectorView<Windows.Gaming.XboxLive.Storage.GameSaveBlobInfo> | Windows.Gaming.XboxLive.Storage.GameSaveBlobInfo[];
+  }
+  var IGameSaveBlobInfoGetResult: abstract new (...args: any[]) => IGameSaveBlobInfoGetResult;
+
+  interface IGameSaveBlobInfoQuery {
+    GetBlobInfoAsync(): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveBlobInfoGetResult>;
+    GetBlobInfoAsync(startIndex: number, maxNumberOfItems: number): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveBlobInfoGetResult>;
+    GetItemCountAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IGameSaveBlobInfoQuery: abstract new (...args: any[]) => IGameSaveBlobInfoQuery;
+
+  interface IGameSaveContainer {
+    CreateBlobInfoQuery(blobNamePrefix: string): Windows.Gaming.XboxLive.Storage.GameSaveBlobInfoQuery;
+    GetAsync(blobsToRead: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveBlobGetResult>;
+    ReadAsync(blobsToRead: Windows.Foundation.Collections.IMapView<string, Windows.Storage.Streams.IBuffer>): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveOperationResult>;
+    SubmitPropertySetUpdatesAsync(blobsToWrite: Windows.Foundation.Collections.IPropertySet, blobsToDelete: Windows.Foundation.Collections.IIterable<string> | string[], displayName: string): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveOperationResult>;
+    SubmitUpdatesAsync(blobsToWrite: Windows.Foundation.Collections.IMapView<string, Windows.Storage.Streams.IBuffer>, blobsToDelete: Windows.Foundation.Collections.IIterable<string> | string[], displayName: string): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveOperationResult>;
+    readonly Name: string;
+    readonly Provider: Windows.Gaming.XboxLive.Storage.GameSaveProvider;
+  }
+  var IGameSaveContainer: abstract new (...args: any[]) => IGameSaveContainer;
+
+  interface IGameSaveContainerInfo {
+    readonly DisplayName: string;
+    readonly LastModifiedTime: Windows.Foundation.DateTime;
+    readonly Name: string;
+    readonly NeedsSync: boolean;
+    readonly TotalSize: number | bigint;
+  }
+  var IGameSaveContainerInfo: abstract new (...args: any[]) => IGameSaveContainerInfo;
+
+  interface IGameSaveContainerInfoGetResult {
+    readonly Status: number;
+    readonly Value: Windows.Foundation.Collections.IVectorView<Windows.Gaming.XboxLive.Storage.GameSaveContainerInfo> | Windows.Gaming.XboxLive.Storage.GameSaveContainerInfo[];
+  }
+  var IGameSaveContainerInfoGetResult: abstract new (...args: any[]) => IGameSaveContainerInfoGetResult;
+
+  interface IGameSaveContainerInfoQuery {
+    GetContainerInfoAsync(): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveContainerInfoGetResult>;
+    GetContainerInfoAsync(startIndex: number, maxNumberOfItems: number): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveContainerInfoGetResult>;
+    GetItemCountAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IGameSaveContainerInfoQuery: abstract new (...args: any[]) => IGameSaveContainerInfoQuery;
+
+  interface IGameSaveOperationResult {
+    readonly Status: number;
+  }
+  var IGameSaveOperationResult: abstract new (...args: any[]) => IGameSaveOperationResult;
+
+  interface IGameSaveProvider {
+    CreateContainer(name: string): Windows.Gaming.XboxLive.Storage.GameSaveContainer;
+    CreateContainerInfoQuery(): Windows.Gaming.XboxLive.Storage.GameSaveContainerInfoQuery;
+    CreateContainerInfoQuery(containerNamePrefix: string): Windows.Gaming.XboxLive.Storage.GameSaveContainerInfoQuery;
+    DeleteContainerAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveOperationResult>;
+    GetRemainingBytesInQuotaAsync(): Windows.Foundation.IAsyncOperation<number | bigint>;
+    readonly ContainersChangedSinceLastSync: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly User: Windows.System.User;
+  }
+  var IGameSaveProvider: abstract new (...args: any[]) => IGameSaveProvider;
+
+  interface IGameSaveProviderGetResult {
+    readonly Status: number;
+    readonly Value: Windows.Gaming.XboxLive.Storage.GameSaveProvider;
+  }
+  var IGameSaveProviderGetResult: abstract new (...args: any[]) => IGameSaveProviderGetResult;
+
+  interface IGameSaveProviderStatics {
+    GetForUserAsync(user: Windows.System.User, serviceConfigId: string): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveProviderGetResult>;
+    GetSyncOnDemandForUserAsync(user: Windows.System.User, serviceConfigId: string): Windows.Foundation.IAsyncOperation<Windows.Gaming.XboxLive.Storage.GameSaveProviderGetResult>;
+  }
+  var IGameSaveProviderStatics: abstract new (...args: any[]) => IGameSaveProviderStatics;
+
+}
+
+declare namespace Windows.Globalization {
+  class ApplicationLanguages {
+    static GetLanguagesForUser(user: Windows.System.User): Windows.Foundation.Collections.IVectorView<string> | string[];
+    static readonly Languages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    static readonly ManifestLanguages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    static PrimaryLanguageOverride: string;
+  }
+
+  class Calendar implements Windows.Globalization.ICalendar, Windows.Globalization.ITimeZoneOnCalendar {
+    constructor(languages: Windows.Foundation.Collections.IIterable<string> | string[], calendar: string, clock: string, timeZoneId: string);
+    constructor(languages: Windows.Foundation.Collections.IIterable<string> | string[]);
+    constructor(languages: Windows.Foundation.Collections.IIterable<string> | string[], calendar: string, clock: string);
+    constructor();
+    AddDays(days: number): void;
+    AddEras(eras: number): void;
+    AddHours(hours: number): void;
+    AddMinutes(minutes: number): void;
+    AddMonths(months: number): void;
+    AddNanoseconds(nanoseconds: number): void;
+    AddPeriods(periods: number): void;
+    AddSeconds(seconds: number): void;
+    AddWeeks(weeks: number): void;
+    AddYears(years: number): void;
+    ChangeCalendarSystem(value: string): void;
+    ChangeClock(value: string): void;
+    ChangeTimeZone(timeZoneId: string): void;
+    Clone(): Windows.Globalization.Calendar;
+    Compare(other: Windows.Globalization.Calendar): number;
+    CompareDateTime(other: Windows.Foundation.DateTime): number;
+    CopyTo(other: Windows.Globalization.Calendar): void;
+    DayAsPaddedString(minDigits: number): string;
+    DayAsString(): string;
+    DayOfWeekAsSoloString(): string;
+    DayOfWeekAsSoloString(idealLength: number): string;
+    DayOfWeekAsString(): string;
+    DayOfWeekAsString(idealLength: number): string;
+    EraAsString(): string;
+    EraAsString(idealLength: number): string;
+    GetCalendarSystem(): string;
+    GetClock(): string;
+    GetDateTime(): Windows.Foundation.DateTime;
+    GetTimeZone(): string;
+    HourAsPaddedString(minDigits: number): string;
+    HourAsString(): string;
+    MinuteAsPaddedString(minDigits: number): string;
+    MinuteAsString(): string;
+    MonthAsNumericString(): string;
+    MonthAsPaddedNumericString(minDigits: number): string;
+    MonthAsSoloString(): string;
+    MonthAsSoloString(idealLength: number): string;
+    MonthAsString(): string;
+    MonthAsString(idealLength: number): string;
+    NanosecondAsPaddedString(minDigits: number): string;
+    NanosecondAsString(): string;
+    PeriodAsString(): string;
+    PeriodAsString(idealLength: number): string;
+    SecondAsPaddedString(minDigits: number): string;
+    SecondAsString(): string;
+    SetDateTime(value: Windows.Foundation.DateTime): void;
+    SetToMax(): void;
+    SetToMin(): void;
+    SetToNow(): void;
+    TimeZoneAsString(): string;
+    TimeZoneAsString(idealLength: number): string;
+    YearAsPaddedString(minDigits: number): string;
+    YearAsString(): string;
+    YearAsTruncatedString(remainingDigits: number): string;
+    Day: number;
+    readonly DayOfWeek: number;
+    Era: number;
+    readonly FirstDayInThisMonth: number;
+    readonly FirstEra: number;
+    readonly FirstHourInThisPeriod: number;
+    readonly FirstMinuteInThisHour: number;
+    readonly FirstMonthInThisYear: number;
+    readonly FirstPeriodInThisDay: number;
+    readonly FirstSecondInThisMinute: number;
+    readonly FirstYearInThisEra: number;
+    Hour: number;
+    readonly IsDaylightSavingTime: boolean;
+    readonly Languages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly LastDayInThisMonth: number;
+    readonly LastEra: number;
+    readonly LastHourInThisPeriod: number;
+    readonly LastMinuteInThisHour: number;
+    readonly LastMonthInThisYear: number;
+    readonly LastPeriodInThisDay: number;
+    readonly LastSecondInThisMinute: number;
+    readonly LastYearInThisEra: number;
+    Minute: number;
+    Month: number;
+    Nanosecond: number;
+    readonly NumberOfDaysInThisMonth: number;
+    readonly NumberOfEras: number;
+    readonly NumberOfHoursInThisPeriod: number;
+    readonly NumberOfMinutesInThisHour: number;
+    readonly NumberOfMonthsInThisYear: number;
+    readonly NumberOfPeriodsInThisDay: number;
+    readonly NumberOfSecondsInThisMinute: number;
+    readonly NumberOfYearsInThisEra: number;
+    NumeralSystem: string;
+    Period: number;
+    readonly ResolvedLanguage: string;
+    Second: number;
+    Year: number;
+  }
+
+  class CalendarIdentifiers {
+    static readonly ChineseLunar: string;
+    static readonly Gregorian: string;
+    static readonly Hebrew: string;
+    static readonly Hijri: string;
+    static readonly Japanese: string;
+    static readonly JapaneseLunar: string;
+    static readonly Julian: string;
+    static readonly Korean: string;
+    static readonly KoreanLunar: string;
+    static readonly Persian: string;
+    static readonly Taiwan: string;
+    static readonly TaiwanLunar: string;
+    static readonly Thai: string;
+    static readonly UmAlQura: string;
+    static readonly VietnameseLunar: string;
+  }
+
+  class ClockIdentifiers {
+    static readonly TwelveHour: string;
+    static readonly TwentyFourHour: string;
+  }
+
+  class CurrencyAmount implements Windows.Globalization.ICurrencyAmount {
+    constructor(amount: string, currency: string);
+    readonly Amount: string;
+    readonly Currency: string;
+  }
+
+  class CurrencyIdentifiers {
+    static readonly AED: string;
+    static readonly AFN: string;
+    static readonly ALL: string;
+    static readonly AMD: string;
+    static readonly ANG: string;
+    static readonly AOA: string;
+    static readonly ARS: string;
+    static readonly AUD: string;
+    static readonly AWG: string;
+    static readonly AZN: string;
+    static readonly BAM: string;
+    static readonly BBD: string;
+    static readonly BDT: string;
+    static readonly BGN: string;
+    static readonly BHD: string;
+    static readonly BIF: string;
+    static readonly BMD: string;
+    static readonly BND: string;
+    static readonly BOB: string;
+    static readonly BRL: string;
+    static readonly BSD: string;
+    static readonly BTN: string;
+    static readonly BWP: string;
+    static readonly BYN: string;
+    static readonly BYR: string;
+    static readonly BZD: string;
+    static readonly CAD: string;
+    static readonly CDF: string;
+    static readonly CHF: string;
+    static readonly CLP: string;
+    static readonly CNY: string;
+    static readonly COP: string;
+    static readonly CRC: string;
+    static readonly CUP: string;
+    static readonly CVE: string;
+    static readonly CZK: string;
+    static readonly DJF: string;
+    static readonly DKK: string;
+    static readonly DOP: string;
+    static readonly DZD: string;
+    static readonly EGP: string;
+    static readonly ERN: string;
+    static readonly ETB: string;
+    static readonly EUR: string;
+    static readonly FJD: string;
+    static readonly FKP: string;
+    static readonly GBP: string;
+    static readonly GEL: string;
+    static readonly GHS: string;
+    static readonly GIP: string;
+    static readonly GMD: string;
+    static readonly GNF: string;
+    static readonly GTQ: string;
+    static readonly GYD: string;
+    static readonly HKD: string;
+    static readonly HNL: string;
+    static readonly HRK: string;
+    static readonly HTG: string;
+    static readonly HUF: string;
+    static readonly IDR: string;
+    static readonly ILS: string;
+    static readonly INR: string;
+    static readonly IQD: string;
+    static readonly IRR: string;
+    static readonly ISK: string;
+    static readonly JMD: string;
+    static readonly JOD: string;
+    static readonly JPY: string;
+    static readonly KES: string;
+    static readonly KGS: string;
+    static readonly KHR: string;
+    static readonly KMF: string;
+    static readonly KPW: string;
+    static readonly KRW: string;
+    static readonly KWD: string;
+    static readonly KYD: string;
+    static readonly KZT: string;
+    static readonly LAK: string;
+    static readonly LBP: string;
+    static readonly LKR: string;
+    static readonly LRD: string;
+    static readonly LSL: string;
+    static readonly LTL: string;
+    static readonly LVL: string;
+    static readonly LYD: string;
+    static readonly MAD: string;
+    static readonly MDL: string;
+    static readonly MGA: string;
+    static readonly MKD: string;
+    static readonly MMK: string;
+    static readonly MNT: string;
+    static readonly MOP: string;
+    static readonly MRO: string;
+    static readonly MRU: string;
+    static readonly MUR: string;
+    static readonly MVR: string;
+    static readonly MWK: string;
+    static readonly MXN: string;
+    static readonly MYR: string;
+    static readonly MZN: string;
+    static readonly NAD: string;
+    static readonly NGN: string;
+    static readonly NIO: string;
+    static readonly NOK: string;
+    static readonly NPR: string;
+    static readonly NZD: string;
+    static readonly OMR: string;
+    static readonly PAB: string;
+    static readonly PEN: string;
+    static readonly PGK: string;
+    static readonly PHP: string;
+    static readonly PKR: string;
+    static readonly PLN: string;
+    static readonly PYG: string;
+    static readonly QAR: string;
+    static readonly RON: string;
+    static readonly RSD: string;
+    static readonly RUB: string;
+    static readonly RWF: string;
+    static readonly SAR: string;
+    static readonly SBD: string;
+    static readonly SCR: string;
+    static readonly SDG: string;
+    static readonly SEK: string;
+    static readonly SGD: string;
+    static readonly SHP: string;
+    static readonly SLL: string;
+    static readonly SOS: string;
+    static readonly SRD: string;
+    static readonly SSP: string;
+    static readonly STD: string;
+    static readonly STN: string;
+    static readonly SYP: string;
+    static readonly SZL: string;
+    static readonly THB: string;
+    static readonly TJS: string;
+    static readonly TMT: string;
+    static readonly TND: string;
+    static readonly TOP: string;
+    static readonly TRY: string;
+    static readonly TTD: string;
+    static readonly TWD: string;
+    static readonly TZS: string;
+    static readonly UAH: string;
+    static readonly UGX: string;
+    static readonly USD: string;
+    static readonly UYU: string;
+    static readonly UZS: string;
+    static readonly VEF: string;
+    static readonly VES: string;
+    static readonly VND: string;
+    static readonly VUV: string;
+    static readonly WST: string;
+    static readonly XAF: string;
+    static readonly XCD: string;
+    static readonly XOF: string;
+    static readonly XPF: string;
+    static readonly XXX: string;
+    static readonly YER: string;
+    static readonly ZAR: string;
+    static readonly ZMW: string;
+    static readonly ZWL: string;
+  }
+
+  class GeographicRegion implements Windows.Globalization.IGeographicRegion {
+    constructor(geographicRegionCode: string);
+    constructor();
+    static IsSupported(geographicRegionCode: string): boolean;
+    readonly Code: string;
+    readonly CodeThreeDigit: string;
+    readonly CodeThreeLetter: string;
+    readonly CodeTwoLetter: string;
+    readonly CurrenciesInUse: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly DisplayName: string;
+    readonly NativeName: string;
+  }
+
+  class JapanesePhoneme implements Windows.Globalization.IJapanesePhoneme {
+    readonly DisplayText: string;
+    readonly IsPhraseStart: boolean;
+    readonly YomiText: string;
+  }
+
+  class JapanesePhoneticAnalyzer {
+    static GetWords(input: string): Windows.Foundation.Collections.IVectorView<Windows.Globalization.JapanesePhoneme> | Windows.Globalization.JapanesePhoneme[];
+    static GetWords(input: string, monoRuby: boolean): Windows.Foundation.Collections.IVectorView<Windows.Globalization.JapanesePhoneme> | Windows.Globalization.JapanesePhoneme[];
+  }
+
+  class Language implements Windows.Globalization.ILanguage, Windows.Globalization.ILanguage2, Windows.Globalization.ILanguage3, Windows.Globalization.ILanguageExtensionSubtags {
+    constructor(languageTag: string);
+    GetExtensionSubtags(singleton: string): Windows.Foundation.Collections.IVectorView<string> | string[];
+    static GetMuiCompatibleLanguageListFromLanguageTags(languageTags: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.Collections.IVector<string> | string[];
+    static IsWellFormed(languageTag: string): boolean;
+    static TrySetInputMethodLanguageTag(languageTag: string): boolean;
+    readonly AbbreviatedName: string;
+    static readonly CurrentInputMethodLanguageTag: string;
+    readonly DisplayName: string;
+    readonly LanguageTag: string;
+    readonly LayoutDirection: number;
+    readonly NativeName: string;
+    readonly Script: string;
+  }
+
+  class NumeralSystemIdentifiers {
+    static readonly Arab: string;
+    static readonly ArabExt: string;
+    static readonly Bali: string;
+    static readonly Beng: string;
+    static readonly Brah: string;
+    static readonly Cham: string;
+    static readonly Deva: string;
+    static readonly FullWide: string;
+    static readonly Gujr: string;
+    static readonly Guru: string;
+    static readonly HaniDec: string;
+    static readonly Java: string;
+    static readonly Kali: string;
+    static readonly Khmr: string;
+    static readonly Knda: string;
+    static readonly Lana: string;
+    static readonly LanaTham: string;
+    static readonly Laoo: string;
+    static readonly Latn: string;
+    static readonly Lepc: string;
+    static readonly Limb: string;
+    static readonly MathBold: string;
+    static readonly MathDbl: string;
+    static readonly MathMono: string;
+    static readonly MathSanb: string;
+    static readonly MathSans: string;
+    static readonly Mlym: string;
+    static readonly Mong: string;
+    static readonly Mtei: string;
+    static readonly Mymr: string;
+    static readonly MymrShan: string;
+    static readonly Nkoo: string;
+    static readonly Olck: string;
+    static readonly Orya: string;
+    static readonly Osma: string;
+    static readonly Saur: string;
+    static readonly Sund: string;
+    static readonly Talu: string;
+    static readonly TamlDec: string;
+    static readonly Telu: string;
+    static readonly Thai: string;
+    static readonly Tibt: string;
+    static readonly Vaii: string;
+    static readonly ZmthBold: string;
+    static readonly ZmthDbl: string;
+    static readonly ZmthMono: string;
+    static readonly ZmthSanb: string;
+    static readonly ZmthSans: string;
+  }
+
+  enum DayOfWeek {
+    Sunday = 0,
+    Monday = 1,
+    Tuesday = 2,
+    Wednesday = 3,
+    Thursday = 4,
+    Friday = 5,
+    Saturday = 6,
+  }
+
+  enum LanguageLayoutDirection {
+    Ltr = 0,
+    Rtl = 1,
+    TtbLtr = 2,
+    TtbRtl = 3,
+  }
+
+  interface GlobalizationJapanesePhoneticAnalyzerContract {
+  }
+  var GlobalizationJapanesePhoneticAnalyzerContract: {
+    new(fields: {  }): GlobalizationJapanesePhoneticAnalyzerContract;
+  };
+
+  interface IApplicationLanguagesStatics {
+    readonly Languages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly ManifestLanguages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    PrimaryLanguageOverride: string;
+  }
+  var IApplicationLanguagesStatics: abstract new (...args: any[]) => IApplicationLanguagesStatics;
+
+  interface IApplicationLanguagesStatics2 {
+    GetLanguagesForUser(user: Windows.System.User): Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var IApplicationLanguagesStatics2: abstract new (...args: any[]) => IApplicationLanguagesStatics2;
+
+  interface ICalendar {
+    AddDays(days: number): void;
+    AddEras(eras: number): void;
+    AddHours(hours: number): void;
+    AddMinutes(minutes: number): void;
+    AddMonths(months: number): void;
+    AddNanoseconds(nanoseconds: number): void;
+    AddPeriods(periods: number): void;
+    AddSeconds(seconds: number): void;
+    AddWeeks(weeks: number): void;
+    AddYears(years: number): void;
+    ChangeCalendarSystem(value: string): void;
+    ChangeClock(value: string): void;
+    Clone(): Windows.Globalization.Calendar;
+    Compare(other: Windows.Globalization.Calendar): number;
+    CompareDateTime(other: Windows.Foundation.DateTime): number;
+    CopyTo(other: Windows.Globalization.Calendar): void;
+    DayAsPaddedString(minDigits: number): string;
+    DayAsString(): string;
+    DayOfWeekAsSoloString(): string;
+    DayOfWeekAsSoloString(idealLength: number): string;
+    DayOfWeekAsString(): string;
+    DayOfWeekAsString(idealLength: number): string;
+    EraAsString(): string;
+    EraAsString(idealLength: number): string;
+    GetCalendarSystem(): string;
+    GetClock(): string;
+    GetDateTime(): Windows.Foundation.DateTime;
+    HourAsPaddedString(minDigits: number): string;
+    HourAsString(): string;
+    MinuteAsPaddedString(minDigits: number): string;
+    MinuteAsString(): string;
+    MonthAsNumericString(): string;
+    MonthAsPaddedNumericString(minDigits: number): string;
+    MonthAsSoloString(): string;
+    MonthAsSoloString(idealLength: number): string;
+    MonthAsString(): string;
+    MonthAsString(idealLength: number): string;
+    NanosecondAsPaddedString(minDigits: number): string;
+    NanosecondAsString(): string;
+    PeriodAsString(): string;
+    PeriodAsString(idealLength: number): string;
+    SecondAsPaddedString(minDigits: number): string;
+    SecondAsString(): string;
+    SetDateTime(value: Windows.Foundation.DateTime): void;
+    SetToMax(): void;
+    SetToMin(): void;
+    SetToNow(): void;
+    YearAsPaddedString(minDigits: number): string;
+    YearAsString(): string;
+    YearAsTruncatedString(remainingDigits: number): string;
+    Day: number;
+    readonly DayOfWeek: number;
+    Era: number;
+    readonly FirstDayInThisMonth: number;
+    readonly FirstEra: number;
+    readonly FirstHourInThisPeriod: number;
+    readonly FirstMinuteInThisHour: number;
+    readonly FirstMonthInThisYear: number;
+    readonly FirstPeriodInThisDay: number;
+    readonly FirstSecondInThisMinute: number;
+    readonly FirstYearInThisEra: number;
+    Hour: number;
+    readonly IsDaylightSavingTime: boolean;
+    readonly Languages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly LastDayInThisMonth: number;
+    readonly LastEra: number;
+    readonly LastHourInThisPeriod: number;
+    readonly LastMinuteInThisHour: number;
+    readonly LastMonthInThisYear: number;
+    readonly LastPeriodInThisDay: number;
+    readonly LastSecondInThisMinute: number;
+    readonly LastYearInThisEra: number;
+    Minute: number;
+    Month: number;
+    Nanosecond: number;
+    readonly NumberOfDaysInThisMonth: number;
+    readonly NumberOfEras: number;
+    readonly NumberOfHoursInThisPeriod: number;
+    readonly NumberOfMinutesInThisHour: number;
+    readonly NumberOfMonthsInThisYear: number;
+    readonly NumberOfPeriodsInThisDay: number;
+    readonly NumberOfSecondsInThisMinute: number;
+    readonly NumberOfYearsInThisEra: number;
+    NumeralSystem: string;
+    Period: number;
+    readonly ResolvedLanguage: string;
+    Second: number;
+    Year: number;
+  }
+  var ICalendar: abstract new (...args: any[]) => ICalendar;
+
+  interface ICalendarFactory {
+    CreateCalendar(languages: Windows.Foundation.Collections.IIterable<string> | string[], calendar: string, clock: string): Windows.Globalization.Calendar;
+    CreateCalendarDefaultCalendarAndClock(languages: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Globalization.Calendar;
+  }
+  var ICalendarFactory: abstract new (...args: any[]) => ICalendarFactory;
+
+  interface ICalendarFactory2 {
+    CreateCalendarWithTimeZone(languages: Windows.Foundation.Collections.IIterable<string> | string[], calendar: string, clock: string, timeZoneId: string): Windows.Globalization.Calendar;
+  }
+  var ICalendarFactory2: abstract new (...args: any[]) => ICalendarFactory2;
+
+  interface ICalendarIdentifiersStatics {
+    readonly Gregorian: string;
+    readonly Hebrew: string;
+    readonly Hijri: string;
+    readonly Japanese: string;
+    readonly Julian: string;
+    readonly Korean: string;
+    readonly Taiwan: string;
+    readonly Thai: string;
+    readonly UmAlQura: string;
+  }
+  var ICalendarIdentifiersStatics: abstract new (...args: any[]) => ICalendarIdentifiersStatics;
+
+  interface ICalendarIdentifiersStatics2 {
+    readonly Persian: string;
+  }
+  var ICalendarIdentifiersStatics2: abstract new (...args: any[]) => ICalendarIdentifiersStatics2;
+
+  interface ICalendarIdentifiersStatics3 {
+    readonly ChineseLunar: string;
+    readonly JapaneseLunar: string;
+    readonly KoreanLunar: string;
+    readonly TaiwanLunar: string;
+    readonly VietnameseLunar: string;
+  }
+  var ICalendarIdentifiersStatics3: abstract new (...args: any[]) => ICalendarIdentifiersStatics3;
+
+  interface IClockIdentifiersStatics {
+    readonly TwelveHour: string;
+    readonly TwentyFourHour: string;
+  }
+  var IClockIdentifiersStatics: abstract new (...args: any[]) => IClockIdentifiersStatics;
+
+  interface ICurrencyAmount {
+    readonly Amount: string;
+    readonly Currency: string;
+  }
+  var ICurrencyAmount: abstract new (...args: any[]) => ICurrencyAmount;
+
+  interface ICurrencyAmountFactory {
+    Create(amount: string, currency: string): Windows.Globalization.CurrencyAmount;
+  }
+  var ICurrencyAmountFactory: abstract new (...args: any[]) => ICurrencyAmountFactory;
+
+  interface ICurrencyIdentifiersStatics {
+    readonly AED: string;
+    readonly AFN: string;
+    readonly ALL: string;
+    readonly AMD: string;
+    readonly ANG: string;
+    readonly AOA: string;
+    readonly ARS: string;
+    readonly AUD: string;
+    readonly AWG: string;
+    readonly AZN: string;
+    readonly BAM: string;
+    readonly BBD: string;
+    readonly BDT: string;
+    readonly BGN: string;
+    readonly BHD: string;
+    readonly BIF: string;
+    readonly BMD: string;
+    readonly BND: string;
+    readonly BOB: string;
+    readonly BRL: string;
+    readonly BSD: string;
+    readonly BTN: string;
+    readonly BWP: string;
+    readonly BYR: string;
+    readonly BZD: string;
+    readonly CAD: string;
+    readonly CDF: string;
+    readonly CHF: string;
+    readonly CLP: string;
+    readonly CNY: string;
+    readonly COP: string;
+    readonly CRC: string;
+    readonly CUP: string;
+    readonly CVE: string;
+    readonly CZK: string;
+    readonly DJF: string;
+    readonly DKK: string;
+    readonly DOP: string;
+    readonly DZD: string;
+    readonly EGP: string;
+    readonly ERN: string;
+    readonly ETB: string;
+    readonly EUR: string;
+    readonly FJD: string;
+    readonly FKP: string;
+    readonly GBP: string;
+    readonly GEL: string;
+    readonly GHS: string;
+    readonly GIP: string;
+    readonly GMD: string;
+    readonly GNF: string;
+    readonly GTQ: string;
+    readonly GYD: string;
+    readonly HKD: string;
+    readonly HNL: string;
+    readonly HRK: string;
+    readonly HTG: string;
+    readonly HUF: string;
+    readonly IDR: string;
+    readonly ILS: string;
+    readonly INR: string;
+    readonly IQD: string;
+    readonly IRR: string;
+    readonly ISK: string;
+    readonly JMD: string;
+    readonly JOD: string;
+    readonly JPY: string;
+    readonly KES: string;
+    readonly KGS: string;
+    readonly KHR: string;
+    readonly KMF: string;
+    readonly KPW: string;
+    readonly KRW: string;
+    readonly KWD: string;
+    readonly KYD: string;
+    readonly KZT: string;
+    readonly LAK: string;
+    readonly LBP: string;
+    readonly LKR: string;
+    readonly LRD: string;
+    readonly LSL: string;
+    readonly LTL: string;
+    readonly LVL: string;
+    readonly LYD: string;
+    readonly MAD: string;
+    readonly MDL: string;
+    readonly MGA: string;
+    readonly MKD: string;
+    readonly MMK: string;
+    readonly MNT: string;
+    readonly MOP: string;
+    readonly MRO: string;
+    readonly MUR: string;
+    readonly MVR: string;
+    readonly MWK: string;
+    readonly MXN: string;
+    readonly MYR: string;
+    readonly MZN: string;
+    readonly NAD: string;
+    readonly NGN: string;
+    readonly NIO: string;
+    readonly NOK: string;
+    readonly NPR: string;
+    readonly NZD: string;
+    readonly OMR: string;
+    readonly PAB: string;
+    readonly PEN: string;
+    readonly PGK: string;
+    readonly PHP: string;
+    readonly PKR: string;
+    readonly PLN: string;
+    readonly PYG: string;
+    readonly QAR: string;
+    readonly RON: string;
+    readonly RSD: string;
+    readonly RUB: string;
+    readonly RWF: string;
+    readonly SAR: string;
+    readonly SBD: string;
+    readonly SCR: string;
+    readonly SDG: string;
+    readonly SEK: string;
+    readonly SGD: string;
+    readonly SHP: string;
+    readonly SLL: string;
+    readonly SOS: string;
+    readonly SRD: string;
+    readonly STD: string;
+    readonly SYP: string;
+    readonly SZL: string;
+    readonly THB: string;
+    readonly TJS: string;
+    readonly TMT: string;
+    readonly TND: string;
+    readonly TOP: string;
+    readonly TRY: string;
+    readonly TTD: string;
+    readonly TWD: string;
+    readonly TZS: string;
+    readonly UAH: string;
+    readonly UGX: string;
+    readonly USD: string;
+    readonly UYU: string;
+    readonly UZS: string;
+    readonly VEF: string;
+    readonly VND: string;
+    readonly VUV: string;
+    readonly WST: string;
+    readonly XAF: string;
+    readonly XCD: string;
+    readonly XOF: string;
+    readonly XPF: string;
+    readonly XXX: string;
+    readonly YER: string;
+    readonly ZAR: string;
+    readonly ZMW: string;
+    readonly ZWL: string;
+  }
+  var ICurrencyIdentifiersStatics: abstract new (...args: any[]) => ICurrencyIdentifiersStatics;
+
+  interface ICurrencyIdentifiersStatics2 {
+    readonly BYN: string;
+  }
+  var ICurrencyIdentifiersStatics2: abstract new (...args: any[]) => ICurrencyIdentifiersStatics2;
+
+  interface ICurrencyIdentifiersStatics3 {
+    readonly MRU: string;
+    readonly SSP: string;
+    readonly STN: string;
+    readonly VES: string;
+  }
+  var ICurrencyIdentifiersStatics3: abstract new (...args: any[]) => ICurrencyIdentifiersStatics3;
+
+  interface IGeographicRegion {
+    readonly Code: string;
+    readonly CodeThreeDigit: string;
+    readonly CodeThreeLetter: string;
+    readonly CodeTwoLetter: string;
+    readonly CurrenciesInUse: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly DisplayName: string;
+    readonly NativeName: string;
+  }
+  var IGeographicRegion: abstract new (...args: any[]) => IGeographicRegion;
+
+  interface IGeographicRegionFactory {
+    CreateGeographicRegion(geographicRegionCode: string): Windows.Globalization.GeographicRegion;
+  }
+  var IGeographicRegionFactory: abstract new (...args: any[]) => IGeographicRegionFactory;
+
+  interface IGeographicRegionStatics {
+    IsSupported(geographicRegionCode: string): boolean;
+  }
+  var IGeographicRegionStatics: abstract new (...args: any[]) => IGeographicRegionStatics;
+
+  interface IJapanesePhoneme {
+    readonly DisplayText: string;
+    readonly IsPhraseStart: boolean;
+    readonly YomiText: string;
+  }
+  var IJapanesePhoneme: abstract new (...args: any[]) => IJapanesePhoneme;
+
+  interface IJapanesePhoneticAnalyzerStatics {
+    GetWords(input: string): Windows.Foundation.Collections.IVectorView<Windows.Globalization.JapanesePhoneme> | Windows.Globalization.JapanesePhoneme[];
+    GetWords(input: string, monoRuby: boolean): Windows.Foundation.Collections.IVectorView<Windows.Globalization.JapanesePhoneme> | Windows.Globalization.JapanesePhoneme[];
+  }
+  var IJapanesePhoneticAnalyzerStatics: abstract new (...args: any[]) => IJapanesePhoneticAnalyzerStatics;
+
+  interface ILanguage {
+    readonly DisplayName: string;
+    readonly LanguageTag: string;
+    readonly NativeName: string;
+    readonly Script: string;
+  }
+  var ILanguage: abstract new (...args: any[]) => ILanguage;
+
+  interface ILanguage2 {
+    readonly LayoutDirection: number;
+  }
+  var ILanguage2: abstract new (...args: any[]) => ILanguage2;
+
+  interface ILanguage3 {
+    readonly AbbreviatedName: string;
+  }
+  var ILanguage3: abstract new (...args: any[]) => ILanguage3;
+
+  interface ILanguageExtensionSubtags {
+    GetExtensionSubtags(singleton: string): Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var ILanguageExtensionSubtags: abstract new (...args: any[]) => ILanguageExtensionSubtags;
+
+  interface ILanguageFactory {
+    CreateLanguage(languageTag: string): Windows.Globalization.Language;
+  }
+  var ILanguageFactory: abstract new (...args: any[]) => ILanguageFactory;
+
+  interface ILanguageStatics {
+    IsWellFormed(languageTag: string): boolean;
+    readonly CurrentInputMethodLanguageTag: string;
+  }
+  var ILanguageStatics: abstract new (...args: any[]) => ILanguageStatics;
+
+  interface ILanguageStatics2 {
+    TrySetInputMethodLanguageTag(languageTag: string): boolean;
+  }
+  var ILanguageStatics2: abstract new (...args: any[]) => ILanguageStatics2;
+
+  interface ILanguageStatics3 {
+    GetMuiCompatibleLanguageListFromLanguageTags(languageTags: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var ILanguageStatics3: abstract new (...args: any[]) => ILanguageStatics3;
+
+  interface INumeralSystemIdentifiersStatics {
+    readonly Arab: string;
+    readonly ArabExt: string;
+    readonly Bali: string;
+    readonly Beng: string;
+    readonly Cham: string;
+    readonly Deva: string;
+    readonly FullWide: string;
+    readonly Gujr: string;
+    readonly Guru: string;
+    readonly HaniDec: string;
+    readonly Java: string;
+    readonly Kali: string;
+    readonly Khmr: string;
+    readonly Knda: string;
+    readonly Lana: string;
+    readonly LanaTham: string;
+    readonly Laoo: string;
+    readonly Latn: string;
+    readonly Lepc: string;
+    readonly Limb: string;
+    readonly Mlym: string;
+    readonly Mong: string;
+    readonly Mtei: string;
+    readonly Mymr: string;
+    readonly MymrShan: string;
+    readonly Nkoo: string;
+    readonly Olck: string;
+    readonly Orya: string;
+    readonly Saur: string;
+    readonly Sund: string;
+    readonly Talu: string;
+    readonly TamlDec: string;
+    readonly Telu: string;
+    readonly Thai: string;
+    readonly Tibt: string;
+    readonly Vaii: string;
+  }
+  var INumeralSystemIdentifiersStatics: abstract new (...args: any[]) => INumeralSystemIdentifiersStatics;
+
+  interface INumeralSystemIdentifiersStatics2 {
+    readonly Brah: string;
+    readonly MathBold: string;
+    readonly MathDbl: string;
+    readonly MathMono: string;
+    readonly MathSanb: string;
+    readonly MathSans: string;
+    readonly Osma: string;
+    readonly ZmthBold: string;
+    readonly ZmthDbl: string;
+    readonly ZmthMono: string;
+    readonly ZmthSanb: string;
+    readonly ZmthSans: string;
+  }
+  var INumeralSystemIdentifiersStatics2: abstract new (...args: any[]) => INumeralSystemIdentifiersStatics2;
+
+  interface ITimeZoneOnCalendar {
+    ChangeTimeZone(timeZoneId: string): void;
+    GetTimeZone(): string;
+    TimeZoneAsString(): string;
+    TimeZoneAsString(idealLength: number): string;
+  }
+  var ITimeZoneOnCalendar: abstract new (...args: any[]) => ITimeZoneOnCalendar;
+
+}
+
+declare namespace Windows.Globalization.Collation {
+  class CharacterGrouping implements Windows.Globalization.Collation.ICharacterGrouping {
+    readonly First: string;
+    readonly Label: string;
+  }
+
+  class CharacterGroupings implements Windows.Globalization.Collation.ICharacterGroupings {
+    constructor(language: string);
+    constructor();
+    First(): Windows.Foundation.Collections.IIterator<Windows.Globalization.Collation.CharacterGrouping>;
+    GetAt(index: number): Windows.Globalization.Collation.CharacterGrouping;
+    GetMany(startIndex: number, items: Windows.Globalization.Collation.CharacterGrouping[]): number;
+    IndexOf(value: Windows.Globalization.Collation.CharacterGrouping, index: number): boolean;
+    Lookup(text: string): string;
+    readonly Size: number;
+  }
+
+  interface ICharacterGrouping {
+    readonly First: string;
+    readonly Label: string;
+  }
+  var ICharacterGrouping: abstract new (...args: any[]) => ICharacterGrouping;
+
+  interface ICharacterGroupings {
+    Lookup(text: string): string;
+  }
+  var ICharacterGroupings: abstract new (...args: any[]) => ICharacterGroupings;
+
+  interface ICharacterGroupingsFactory {
+    Create(language: string): Windows.Globalization.Collation.CharacterGroupings;
+  }
+  var ICharacterGroupingsFactory: abstract new (...args: any[]) => ICharacterGroupingsFactory;
+
+}
+
+declare namespace Windows.Globalization.DateTimeFormatting {
+  class DateTimeFormatter implements Windows.Globalization.DateTimeFormatting.IDateTimeFormatter, Windows.Globalization.DateTimeFormatting.IDateTimeFormatter2 {
+    constructor(formatTemplate: string);
+    constructor(formatTemplate: string, languages: Windows.Foundation.Collections.IIterable<string> | string[]);
+    constructor(formatTemplate: string, languages: Windows.Foundation.Collections.IIterable<string> | string[], geographicRegion: string, calendar: string, clock: string);
+    constructor(yearFormat: number, monthFormat: number, dayFormat: number, dayOfWeekFormat: number);
+    constructor(hourFormat: number, minuteFormat: number, secondFormat: number);
+    constructor(yearFormat: number, monthFormat: number, dayFormat: number, dayOfWeekFormat: number, hourFormat: number, minuteFormat: number, secondFormat: number, languages: Windows.Foundation.Collections.IIterable<string> | string[]);
+    constructor(yearFormat: number, monthFormat: number, dayFormat: number, dayOfWeekFormat: number, hourFormat: number, minuteFormat: number, secondFormat: number, languages: Windows.Foundation.Collections.IIterable<string> | string[], geographicRegion: string, calendar: string, clock: string);
+    Format(value: Windows.Foundation.DateTime): string;
+    Format(datetime: Windows.Foundation.DateTime, timeZoneId: string): string;
+    readonly Calendar: string;
+    readonly Clock: string;
+    readonly GeographicRegion: string;
+    readonly IncludeDay: number;
+    readonly IncludeDayOfWeek: number;
+    readonly IncludeHour: number;
+    readonly IncludeMinute: number;
+    readonly IncludeMonth: number;
+    readonly IncludeSecond: number;
+    readonly IncludeYear: number;
+    readonly Languages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    static readonly LongDate: Windows.Globalization.DateTimeFormatting.DateTimeFormatter;
+    static readonly LongTime: Windows.Globalization.DateTimeFormatting.DateTimeFormatter;
+    NumeralSystem: string;
+    readonly Patterns: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly ResolvedGeographicRegion: string;
+    readonly ResolvedLanguage: string;
+    static readonly ShortDate: Windows.Globalization.DateTimeFormatting.DateTimeFormatter;
+    static readonly ShortTime: Windows.Globalization.DateTimeFormatting.DateTimeFormatter;
+    readonly Template: string;
+  }
+
+  enum DayFormat {
+    None = 0,
+    Default = 1,
+  }
+
+  enum DayOfWeekFormat {
+    None = 0,
+    Default = 1,
+    Abbreviated = 2,
+    Full = 3,
+  }
+
+  enum HourFormat {
+    None = 0,
+    Default = 1,
+  }
+
+  enum MinuteFormat {
+    None = 0,
+    Default = 1,
+  }
+
+  enum MonthFormat {
+    None = 0,
+    Default = 1,
+    Abbreviated = 2,
+    Full = 3,
+    Numeric = 4,
+  }
+
+  enum SecondFormat {
+    None = 0,
+    Default = 1,
+  }
+
+  enum YearFormat {
+    None = 0,
+    Default = 1,
+    Abbreviated = 2,
+    Full = 3,
+  }
+
+  interface IDateTimeFormatter {
+    Format(value: Windows.Foundation.DateTime): string;
+    readonly Calendar: string;
+    readonly Clock: string;
+    readonly GeographicRegion: string;
+    readonly IncludeDay: number;
+    readonly IncludeDayOfWeek: number;
+    readonly IncludeHour: number;
+    readonly IncludeMinute: number;
+    readonly IncludeMonth: number;
+    readonly IncludeSecond: number;
+    readonly IncludeYear: number;
+    readonly Languages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    NumeralSystem: string;
+    readonly Patterns: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly ResolvedGeographicRegion: string;
+    readonly ResolvedLanguage: string;
+    readonly Template: string;
+  }
+  var IDateTimeFormatter: abstract new (...args: any[]) => IDateTimeFormatter;
+
+  interface IDateTimeFormatter2 {
+    Format(datetime: Windows.Foundation.DateTime, timeZoneId: string): string;
+  }
+  var IDateTimeFormatter2: abstract new (...args: any[]) => IDateTimeFormatter2;
+
+  interface IDateTimeFormatterFactory {
+    CreateDateTimeFormatter(formatTemplate: string): Windows.Globalization.DateTimeFormatting.DateTimeFormatter;
+    CreateDateTimeFormatterContext(formatTemplate: string, languages: Windows.Foundation.Collections.IIterable<string> | string[], geographicRegion: string, calendar: string, clock: string): Windows.Globalization.DateTimeFormatting.DateTimeFormatter;
+    CreateDateTimeFormatterDate(yearFormat: number, monthFormat: number, dayFormat: number, dayOfWeekFormat: number): Windows.Globalization.DateTimeFormatting.DateTimeFormatter;
+    CreateDateTimeFormatterDateTimeContext(yearFormat: number, monthFormat: number, dayFormat: number, dayOfWeekFormat: number, hourFormat: number, minuteFormat: number, secondFormat: number, languages: Windows.Foundation.Collections.IIterable<string> | string[], geographicRegion: string, calendar: string, clock: string): Windows.Globalization.DateTimeFormatting.DateTimeFormatter;
+    CreateDateTimeFormatterDateTimeLanguages(yearFormat: number, monthFormat: number, dayFormat: number, dayOfWeekFormat: number, hourFormat: number, minuteFormat: number, secondFormat: number, languages: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Globalization.DateTimeFormatting.DateTimeFormatter;
+    CreateDateTimeFormatterLanguages(formatTemplate: string, languages: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Globalization.DateTimeFormatting.DateTimeFormatter;
+    CreateDateTimeFormatterTime(hourFormat: number, minuteFormat: number, secondFormat: number): Windows.Globalization.DateTimeFormatting.DateTimeFormatter;
+  }
+  var IDateTimeFormatterFactory: abstract new (...args: any[]) => IDateTimeFormatterFactory;
+
+  interface IDateTimeFormatterStatics {
+    readonly LongDate: Windows.Globalization.DateTimeFormatting.DateTimeFormatter;
+    readonly LongTime: Windows.Globalization.DateTimeFormatting.DateTimeFormatter;
+    readonly ShortDate: Windows.Globalization.DateTimeFormatting.DateTimeFormatter;
+    readonly ShortTime: Windows.Globalization.DateTimeFormatting.DateTimeFormatter;
+  }
+  var IDateTimeFormatterStatics: abstract new (...args: any[]) => IDateTimeFormatterStatics;
+
+}
+
+declare namespace Windows.Globalization.Fonts {
+  class LanguageFont implements Windows.Globalization.Fonts.ILanguageFont {
+    readonly FontFamily: string;
+    readonly FontStretch: number;
+    readonly FontStyle: number;
+    readonly FontWeight: Windows.UI.Text.FontWeight;
+    readonly ScaleFactor: number;
+  }
+
+  class LanguageFontGroup implements Windows.Globalization.Fonts.ILanguageFontGroup {
+    constructor(languageTag: string);
+    readonly DocumentAlternate1Font: Windows.Globalization.Fonts.LanguageFont;
+    readonly DocumentAlternate2Font: Windows.Globalization.Fonts.LanguageFont;
+    readonly DocumentHeadingFont: Windows.Globalization.Fonts.LanguageFont;
+    readonly FixedWidthTextFont: Windows.Globalization.Fonts.LanguageFont;
+    readonly ModernDocumentFont: Windows.Globalization.Fonts.LanguageFont;
+    readonly TraditionalDocumentFont: Windows.Globalization.Fonts.LanguageFont;
+    readonly UICaptionFont: Windows.Globalization.Fonts.LanguageFont;
+    readonly UIHeadingFont: Windows.Globalization.Fonts.LanguageFont;
+    readonly UINotificationHeadingFont: Windows.Globalization.Fonts.LanguageFont;
+    readonly UITextFont: Windows.Globalization.Fonts.LanguageFont;
+    readonly UITitleFont: Windows.Globalization.Fonts.LanguageFont;
+  }
+
+  interface ILanguageFont {
+    readonly FontFamily: string;
+    readonly FontStretch: number;
+    readonly FontStyle: number;
+    readonly FontWeight: Windows.UI.Text.FontWeight;
+    readonly ScaleFactor: number;
+  }
+  var ILanguageFont: abstract new (...args: any[]) => ILanguageFont;
+
+  interface ILanguageFontGroup {
+    readonly DocumentAlternate1Font: Windows.Globalization.Fonts.LanguageFont;
+    readonly DocumentAlternate2Font: Windows.Globalization.Fonts.LanguageFont;
+    readonly DocumentHeadingFont: Windows.Globalization.Fonts.LanguageFont;
+    readonly FixedWidthTextFont: Windows.Globalization.Fonts.LanguageFont;
+    readonly ModernDocumentFont: Windows.Globalization.Fonts.LanguageFont;
+    readonly TraditionalDocumentFont: Windows.Globalization.Fonts.LanguageFont;
+    readonly UICaptionFont: Windows.Globalization.Fonts.LanguageFont;
+    readonly UIHeadingFont: Windows.Globalization.Fonts.LanguageFont;
+    readonly UINotificationHeadingFont: Windows.Globalization.Fonts.LanguageFont;
+    readonly UITextFont: Windows.Globalization.Fonts.LanguageFont;
+    readonly UITitleFont: Windows.Globalization.Fonts.LanguageFont;
+  }
+  var ILanguageFontGroup: abstract new (...args: any[]) => ILanguageFontGroup;
+
+  interface ILanguageFontGroupFactory {
+    CreateLanguageFontGroup(languageTag: string): Windows.Globalization.Fonts.LanguageFontGroup;
+  }
+  var ILanguageFontGroupFactory: abstract new (...args: any[]) => ILanguageFontGroupFactory;
+
+}
+
+declare namespace Windows.Globalization.NumberFormatting {
+  class CurrencyFormatter implements Windows.Globalization.NumberFormatting.ICurrencyFormatter, Windows.Globalization.NumberFormatting.ICurrencyFormatter2, Windows.Globalization.NumberFormatting.INumberFormatter, Windows.Globalization.NumberFormatting.INumberFormatter2, Windows.Globalization.NumberFormatting.INumberFormatterOptions, Windows.Globalization.NumberFormatting.INumberParser, Windows.Globalization.NumberFormatting.INumberRounderOption, Windows.Globalization.NumberFormatting.ISignedZeroOption, Windows.Globalization.NumberFormatting.ISignificantDigitsOption {
+    constructor(currencyCode: string);
+    constructor(currencyCode: string, languages: Windows.Foundation.Collections.IIterable<string> | string[], geographicRegion: string);
+    ApplyRoundingForCurrency(roundingAlgorithm: number): void;
+    Format(value: number | bigint): string;
+    FormatDouble(value: number): string;
+    FormatInt(value: number | bigint): string;
+    FormatUInt(value: number | bigint): string;
+    ParseDouble(text: string): number | null;
+    ParseInt(text: string): number | bigint | null;
+    ParseUInt(text: string): number | bigint | null;
+    Currency: string;
+    FractionDigits: number;
+    readonly GeographicRegion: string;
+    IntegerDigits: number;
+    IsDecimalPointAlwaysDisplayed: boolean;
+    IsGrouped: boolean;
+    IsZeroSigned: boolean;
+    readonly Languages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    Mode: number;
+    NumberRounder: Windows.Globalization.NumberFormatting.INumberRounder;
+    NumeralSystem: string;
+    readonly ResolvedGeographicRegion: string;
+    readonly ResolvedLanguage: string;
+    SignificantDigits: number;
+  }
+
+  class DecimalFormatter implements Windows.Globalization.NumberFormatting.INumberFormatter, Windows.Globalization.NumberFormatting.INumberFormatter2, Windows.Globalization.NumberFormatting.INumberFormatterOptions, Windows.Globalization.NumberFormatting.INumberParser, Windows.Globalization.NumberFormatting.INumberRounderOption, Windows.Globalization.NumberFormatting.ISignedZeroOption, Windows.Globalization.NumberFormatting.ISignificantDigitsOption {
+    constructor(languages: Windows.Foundation.Collections.IIterable<string> | string[], geographicRegion: string);
+    constructor();
+    Format(value: number | bigint): string;
+    FormatDouble(value: number): string;
+    FormatInt(value: number | bigint): string;
+    FormatUInt(value: number | bigint): string;
+    ParseDouble(text: string): number | null;
+    ParseInt(text: string): number | bigint | null;
+    ParseUInt(text: string): number | bigint | null;
+    FractionDigits: number;
+    readonly GeographicRegion: string;
+    IntegerDigits: number;
+    IsDecimalPointAlwaysDisplayed: boolean;
+    IsGrouped: boolean;
+    IsZeroSigned: boolean;
+    readonly Languages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    NumberRounder: Windows.Globalization.NumberFormatting.INumberRounder;
+    NumeralSystem: string;
+    readonly ResolvedGeographicRegion: string;
+    readonly ResolvedLanguage: string;
+    SignificantDigits: number;
+  }
+
+  class IncrementNumberRounder implements Windows.Globalization.NumberFormatting.IIncrementNumberRounder, Windows.Globalization.NumberFormatting.INumberRounder {
+    constructor();
+    RoundDouble(value: number): number;
+    RoundInt32(value: number): number;
+    RoundInt64(value: number | bigint): number | bigint;
+    RoundSingle(value: number): number;
+    RoundUInt32(value: number): number;
+    RoundUInt64(value: number | bigint): number | bigint;
+    Increment: number;
+    RoundingAlgorithm: number;
+  }
+
+  class NumeralSystemTranslator implements Windows.Globalization.NumberFormatting.INumeralSystemTranslator {
+    constructor(languages: Windows.Foundation.Collections.IIterable<string> | string[]);
+    constructor();
+    TranslateNumerals(value: string): string;
+    readonly Languages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    NumeralSystem: string;
+    readonly ResolvedLanguage: string;
+  }
+
+  class PercentFormatter implements Windows.Globalization.NumberFormatting.INumberFormatter, Windows.Globalization.NumberFormatting.INumberFormatter2, Windows.Globalization.NumberFormatting.INumberFormatterOptions, Windows.Globalization.NumberFormatting.INumberParser, Windows.Globalization.NumberFormatting.INumberRounderOption, Windows.Globalization.NumberFormatting.ISignedZeroOption, Windows.Globalization.NumberFormatting.ISignificantDigitsOption {
+    constructor(languages: Windows.Foundation.Collections.IIterable<string> | string[], geographicRegion: string);
+    constructor();
+    Format(value: number | bigint): string;
+    FormatDouble(value: number): string;
+    FormatInt(value: number | bigint): string;
+    FormatUInt(value: number | bigint): string;
+    ParseDouble(text: string): number | null;
+    ParseInt(text: string): number | bigint | null;
+    ParseUInt(text: string): number | bigint | null;
+    FractionDigits: number;
+    readonly GeographicRegion: string;
+    IntegerDigits: number;
+    IsDecimalPointAlwaysDisplayed: boolean;
+    IsGrouped: boolean;
+    IsZeroSigned: boolean;
+    readonly Languages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    NumberRounder: Windows.Globalization.NumberFormatting.INumberRounder;
+    NumeralSystem: string;
+    readonly ResolvedGeographicRegion: string;
+    readonly ResolvedLanguage: string;
+    SignificantDigits: number;
+  }
+
+  class PermilleFormatter implements Windows.Globalization.NumberFormatting.INumberFormatter, Windows.Globalization.NumberFormatting.INumberFormatter2, Windows.Globalization.NumberFormatting.INumberFormatterOptions, Windows.Globalization.NumberFormatting.INumberParser, Windows.Globalization.NumberFormatting.INumberRounderOption, Windows.Globalization.NumberFormatting.ISignedZeroOption, Windows.Globalization.NumberFormatting.ISignificantDigitsOption {
+    constructor(languages: Windows.Foundation.Collections.IIterable<string> | string[], geographicRegion: string);
+    constructor();
+    Format(value: number | bigint): string;
+    FormatDouble(value: number): string;
+    FormatInt(value: number | bigint): string;
+    FormatUInt(value: number | bigint): string;
+    ParseDouble(text: string): number | null;
+    ParseInt(text: string): number | bigint | null;
+    ParseUInt(text: string): number | bigint | null;
+    FractionDigits: number;
+    readonly GeographicRegion: string;
+    IntegerDigits: number;
+    IsDecimalPointAlwaysDisplayed: boolean;
+    IsGrouped: boolean;
+    IsZeroSigned: boolean;
+    readonly Languages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    NumberRounder: Windows.Globalization.NumberFormatting.INumberRounder;
+    NumeralSystem: string;
+    readonly ResolvedGeographicRegion: string;
+    readonly ResolvedLanguage: string;
+    SignificantDigits: number;
+  }
+
+  class SignificantDigitsNumberRounder implements Windows.Globalization.NumberFormatting.INumberRounder, Windows.Globalization.NumberFormatting.ISignificantDigitsNumberRounder {
+    constructor();
+    RoundDouble(value: number): number;
+    RoundInt32(value: number): number;
+    RoundInt64(value: number | bigint): number | bigint;
+    RoundSingle(value: number): number;
+    RoundUInt32(value: number): number;
+    RoundUInt64(value: number | bigint): number | bigint;
+    RoundingAlgorithm: number;
+    SignificantDigits: number;
+  }
+
+  enum CurrencyFormatterMode {
+    UseSymbol = 0,
+    UseCurrencyCode = 1,
+  }
+
+  enum RoundingAlgorithm {
+    None = 0,
+    RoundDown = 1,
+    RoundUp = 2,
+    RoundTowardsZero = 3,
+    RoundAwayFromZero = 4,
+    RoundHalfDown = 5,
+    RoundHalfUp = 6,
+    RoundHalfTowardsZero = 7,
+    RoundHalfAwayFromZero = 8,
+    RoundHalfToEven = 9,
+    RoundHalfToOdd = 10,
+  }
+
+  interface ICurrencyFormatter extends Windows.Globalization.NumberFormatting.INumberFormatter, Windows.Globalization.NumberFormatting.INumberFormatter2, Windows.Globalization.NumberFormatting.INumberFormatterOptions, Windows.Globalization.NumberFormatting.INumberParser {
+    Format(value: number | bigint): string;
+    FormatDouble(value: number): string;
+    FormatInt(value: number | bigint): string;
+    FormatUInt(value: number | bigint): string;
+    ParseDouble(text: string): number | null;
+    ParseInt(text: string): number | bigint | null;
+    ParseUInt(text: string): number | bigint | null;
+    Currency: string;
+  }
+  var ICurrencyFormatter: abstract new (...args: any[]) => ICurrencyFormatter;
+
+  interface ICurrencyFormatter2 {
+    ApplyRoundingForCurrency(roundingAlgorithm: number): void;
+    Mode: number;
+  }
+  var ICurrencyFormatter2: abstract new (...args: any[]) => ICurrencyFormatter2;
+
+  interface ICurrencyFormatterFactory {
+    CreateCurrencyFormatterCode(currencyCode: string): Windows.Globalization.NumberFormatting.CurrencyFormatter;
+    CreateCurrencyFormatterCodeContext(currencyCode: string, languages: Windows.Foundation.Collections.IIterable<string> | string[], geographicRegion: string): Windows.Globalization.NumberFormatting.CurrencyFormatter;
+  }
+  var ICurrencyFormatterFactory: abstract new (...args: any[]) => ICurrencyFormatterFactory;
+
+  interface IDecimalFormatterFactory {
+    CreateDecimalFormatter(languages: Windows.Foundation.Collections.IIterable<string> | string[], geographicRegion: string): Windows.Globalization.NumberFormatting.DecimalFormatter;
+  }
+  var IDecimalFormatterFactory: abstract new (...args: any[]) => IDecimalFormatterFactory;
+
+  interface IIncrementNumberRounder {
+    Increment: number;
+    RoundingAlgorithm: number;
+  }
+  var IIncrementNumberRounder: abstract new (...args: any[]) => IIncrementNumberRounder;
+
+  interface INumberFormatter {
+    Format(value: number | bigint): string;
+  }
+  var INumberFormatter: abstract new (...args: any[]) => INumberFormatter;
+
+  interface INumberFormatter2 {
+    FormatDouble(value: number): string;
+    FormatInt(value: number | bigint): string;
+    FormatUInt(value: number | bigint): string;
+  }
+  var INumberFormatter2: abstract new (...args: any[]) => INumberFormatter2;
+
+  interface INumberFormatterOptions {
+    FractionDigits: number;
+    readonly GeographicRegion: string;
+    IntegerDigits: number;
+    IsDecimalPointAlwaysDisplayed: boolean;
+    IsGrouped: boolean;
+    readonly Languages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    NumeralSystem: string;
+    readonly ResolvedGeographicRegion: string;
+    readonly ResolvedLanguage: string;
+  }
+  var INumberFormatterOptions: abstract new (...args: any[]) => INumberFormatterOptions;
+
+  interface INumberParser {
+    ParseDouble(text: string): number | null;
+    ParseInt(text: string): number | bigint | null;
+    ParseUInt(text: string): number | bigint | null;
+  }
+  var INumberParser: abstract new (...args: any[]) => INumberParser;
+
+  interface INumberRounder {
+    RoundDouble(value: number): number;
+    RoundInt32(value: number): number;
+    RoundInt64(value: number | bigint): number | bigint;
+    RoundSingle(value: number): number;
+    RoundUInt32(value: number): number;
+    RoundUInt64(value: number | bigint): number | bigint;
+  }
+  var INumberRounder: abstract new (...args: any[]) => INumberRounder;
+
+  interface INumberRounderOption {
+    NumberRounder: Windows.Globalization.NumberFormatting.INumberRounder;
+  }
+  var INumberRounderOption: abstract new (...args: any[]) => INumberRounderOption;
+
+  interface INumeralSystemTranslator {
+    TranslateNumerals(value: string): string;
+    readonly Languages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    NumeralSystem: string;
+    readonly ResolvedLanguage: string;
+  }
+  var INumeralSystemTranslator: abstract new (...args: any[]) => INumeralSystemTranslator;
+
+  interface INumeralSystemTranslatorFactory {
+    Create(languages: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Globalization.NumberFormatting.NumeralSystemTranslator;
+  }
+  var INumeralSystemTranslatorFactory: abstract new (...args: any[]) => INumeralSystemTranslatorFactory;
+
+  interface IPercentFormatterFactory {
+    CreatePercentFormatter(languages: Windows.Foundation.Collections.IIterable<string> | string[], geographicRegion: string): Windows.Globalization.NumberFormatting.PercentFormatter;
+  }
+  var IPercentFormatterFactory: abstract new (...args: any[]) => IPercentFormatterFactory;
+
+  interface IPermilleFormatterFactory {
+    CreatePermilleFormatter(languages: Windows.Foundation.Collections.IIterable<string> | string[], geographicRegion: string): Windows.Globalization.NumberFormatting.PermilleFormatter;
+  }
+  var IPermilleFormatterFactory: abstract new (...args: any[]) => IPermilleFormatterFactory;
+
+  interface ISignedZeroOption {
+    IsZeroSigned: boolean;
+  }
+  var ISignedZeroOption: abstract new (...args: any[]) => ISignedZeroOption;
+
+  interface ISignificantDigitsNumberRounder {
+    RoundingAlgorithm: number;
+    SignificantDigits: number;
+  }
+  var ISignificantDigitsNumberRounder: abstract new (...args: any[]) => ISignificantDigitsNumberRounder;
+
+  interface ISignificantDigitsOption {
+    SignificantDigits: number;
+  }
+  var ISignificantDigitsOption: abstract new (...args: any[]) => ISignificantDigitsOption;
+
+}
+
+declare namespace Windows.Globalization.PhoneNumberFormatting {
+  class PhoneNumberFormatter implements Windows.Globalization.PhoneNumberFormatting.IPhoneNumberFormatter {
+    constructor();
+    Format(number: Windows.Globalization.PhoneNumberFormatting.PhoneNumberInfo): string;
+    Format(number: Windows.Globalization.PhoneNumberFormatting.PhoneNumberInfo, numberFormat: number): string;
+    FormatPartialString(number: string): string;
+    FormatString(number: string): string;
+    FormatStringWithLeftToRightMarkers(number: string): string;
+    static GetCountryCodeForRegion(regionCode: string): number;
+    static GetNationalDirectDialingPrefixForRegion(regionCode: string, stripNonDigit: boolean): string;
+    static TryCreate(regionCode: string, phoneNumber: Windows.Globalization.PhoneNumberFormatting.PhoneNumberFormatter): void;
+    static WrapWithLeftToRightMarkers(number: string): string;
+  }
+
+  class PhoneNumberInfo implements Windows.Foundation.IStringable, Windows.Globalization.PhoneNumberFormatting.IPhoneNumberInfo {
+    constructor(number: string);
+    CheckNumberMatch(otherNumber: Windows.Globalization.PhoneNumberFormatting.PhoneNumberInfo): number;
+    GetGeographicRegionCode(): string;
+    GetLengthOfGeographicalAreaCode(): number;
+    GetLengthOfNationalDestinationCode(): number;
+    GetNationalSignificantNumber(): string;
+    PredictNumberKind(): number;
+    ToString(): string;
+    static TryParse(input: string, phoneNumber: Windows.Globalization.PhoneNumberFormatting.PhoneNumberInfo): number;
+    static TryParse(input: string, regionCode: string, phoneNumber: Windows.Globalization.PhoneNumberFormatting.PhoneNumberInfo): number;
+    readonly CountryCode: number;
+    readonly PhoneNumber: string;
+  }
+
+  enum PhoneNumberFormat {
+    E164 = 0,
+    International = 1,
+    National = 2,
+    Rfc3966 = 3,
+  }
+
+  enum PhoneNumberMatchResult {
+    NoMatch = 0,
+    ShortNationalSignificantNumberMatch = 1,
+    NationalSignificantNumberMatch = 2,
+    ExactMatch = 3,
+  }
+
+  enum PhoneNumberParseResult {
+    Valid = 0,
+    NotANumber = 1,
+    InvalidCountryCode = 2,
+    TooShort = 3,
+    TooLong = 4,
+  }
+
+  enum PredictedPhoneNumberKind {
+    FixedLine = 0,
+    Mobile = 1,
+    FixedLineOrMobile = 2,
+    TollFree = 3,
+    PremiumRate = 4,
+    SharedCost = 5,
+    Voip = 6,
+    PersonalNumber = 7,
+    Pager = 8,
+    UniversalAccountNumber = 9,
+    Voicemail = 10,
+    Unknown = 11,
+  }
+
+  interface IPhoneNumberFormatter {
+    Format(number: Windows.Globalization.PhoneNumberFormatting.PhoneNumberInfo): string;
+    Format(number: Windows.Globalization.PhoneNumberFormatting.PhoneNumberInfo, numberFormat: number): string;
+    FormatPartialString(number: string): string;
+    FormatString(number: string): string;
+    FormatStringWithLeftToRightMarkers(number: string): string;
+  }
+  var IPhoneNumberFormatter: abstract new (...args: any[]) => IPhoneNumberFormatter;
+
+  interface IPhoneNumberFormatterStatics {
+    GetCountryCodeForRegion(regionCode: string): number;
+    GetNationalDirectDialingPrefixForRegion(regionCode: string, stripNonDigit: boolean): string;
+    TryCreate(regionCode: string, phoneNumber: Windows.Globalization.PhoneNumberFormatting.PhoneNumberFormatter): void;
+    WrapWithLeftToRightMarkers(number: string): string;
+  }
+  var IPhoneNumberFormatterStatics: abstract new (...args: any[]) => IPhoneNumberFormatterStatics;
+
+  interface IPhoneNumberInfo {
+    CheckNumberMatch(otherNumber: Windows.Globalization.PhoneNumberFormatting.PhoneNumberInfo): number;
+    GetGeographicRegionCode(): string;
+    GetLengthOfGeographicalAreaCode(): number;
+    GetLengthOfNationalDestinationCode(): number;
+    GetNationalSignificantNumber(): string;
+    PredictNumberKind(): number;
+    readonly CountryCode: number;
+    readonly PhoneNumber: string;
+  }
+  var IPhoneNumberInfo: abstract new (...args: any[]) => IPhoneNumberInfo;
+
+  interface IPhoneNumberInfoFactory {
+    Create(number: string): Windows.Globalization.PhoneNumberFormatting.PhoneNumberInfo;
+  }
+  var IPhoneNumberInfoFactory: abstract new (...args: any[]) => IPhoneNumberInfoFactory;
+
+  interface IPhoneNumberInfoStatics {
+    TryParse(input: string, phoneNumber: Windows.Globalization.PhoneNumberFormatting.PhoneNumberInfo): number;
+    TryParse(input: string, regionCode: string, phoneNumber: Windows.Globalization.PhoneNumberFormatting.PhoneNumberInfo): number;
+  }
+  var IPhoneNumberInfoStatics: abstract new (...args: any[]) => IPhoneNumberInfoStatics;
+
+}
+
+declare namespace Windows.Graphics {
+  interface DisplayAdapterId {
+    LowPart: number;
+    HighPart: number;
+  }
+  var DisplayAdapterId: {
+    new(lowPart: number, highPart: number): DisplayAdapterId;
+    new(fields: { LowPart?: number; HighPart?: number }): DisplayAdapterId;
+  };
+
+  interface DisplayId {
+    Value: number | bigint;
+  }
+  var DisplayId: {
+    new(value: number | bigint): DisplayId;
+    new(fields: { Value?: number | bigint }): DisplayId;
+  };
+
+  interface IGeometrySource2D {
+  }
+  var IGeometrySource2D: abstract new (...args: any[]) => IGeometrySource2D;
+
+  interface PointInt32 {
+    X: number;
+    Y: number;
+  }
+  var PointInt32: {
+    new(x: number, y: number): PointInt32;
+    new(fields: { X?: number; Y?: number }): PointInt32;
+  };
+
+  interface RectInt32 {
+    X: number;
+    Y: number;
+    Width: number;
+    Height: number;
+  }
+  var RectInt32: {
+    new(x: number, y: number, width: number, height: number): RectInt32;
+    new(fields: { X?: number; Y?: number; Width?: number; Height?: number }): RectInt32;
+  };
+
+  interface SizeInt32 {
+    Width: number;
+    Height: number;
+  }
+  var SizeInt32: {
+    new(width: number, height: number): SizeInt32;
+    new(fields: { Width?: number; Height?: number }): SizeInt32;
+  };
+
+}
+
+declare namespace Windows.Graphics.Capture {
+  class Direct3D11CaptureFrame implements Windows.Foundation.IClosable, Windows.Graphics.Capture.IDirect3D11CaptureFrame, Windows.Graphics.Capture.IDirect3D11CaptureFrame2 {
+    Close(): void;
+    readonly ContentSize: Windows.Graphics.SizeInt32;
+    readonly DirtyRegionMode: number;
+    readonly DirtyRegions: Windows.Foundation.Collections.IVectorView<Windows.Graphics.RectInt32> | Windows.Graphics.RectInt32[];
+    readonly Surface: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface;
+    readonly SystemRelativeTime: Windows.Foundation.TimeSpan;
+  }
+
+  class Direct3D11CaptureFramePool implements Windows.Foundation.IClosable, Windows.Graphics.Capture.IDirect3D11CaptureFramePool {
+    Close(): void;
+    static Create(device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice, pixelFormat: number, numberOfBuffers: number, size: Windows.Graphics.SizeInt32): Windows.Graphics.Capture.Direct3D11CaptureFramePool;
+    CreateCaptureSession(item: Windows.Graphics.Capture.GraphicsCaptureItem): Windows.Graphics.Capture.GraphicsCaptureSession;
+    static CreateFreeThreaded(device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice, pixelFormat: number, numberOfBuffers: number, size: Windows.Graphics.SizeInt32): Windows.Graphics.Capture.Direct3D11CaptureFramePool;
+    Recreate(device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice, pixelFormat: number, numberOfBuffers: number, size: Windows.Graphics.SizeInt32): void;
+    TryGetNextFrame(): Windows.Graphics.Capture.Direct3D11CaptureFrame;
+    readonly DispatcherQueue: Windows.System.DispatcherQueue;
+    FrameArrived: Windows.Foundation.TypedEventHandler<Windows.Graphics.Capture.Direct3D11CaptureFramePool, Object> | null;
+  }
+
+  class GraphicsCaptureAccess {
+    static RequestAccessAsync(request: number): Windows.Foundation.IAsyncOperation<number>;
+  }
+
+  class GraphicsCaptureItem implements Windows.Graphics.Capture.IGraphicsCaptureItem {
+    static CreateFromVisual(visual: Windows.UI.Composition.Visual): Windows.Graphics.Capture.GraphicsCaptureItem;
+    static TryCreateFromDisplayId(displayId: Windows.Graphics.DisplayId): Windows.Graphics.Capture.GraphicsCaptureItem;
+    static TryCreateFromWindowId(windowId: Windows.UI.WindowId): Windows.Graphics.Capture.GraphicsCaptureItem;
+    readonly DisplayName: string;
+    readonly Size: Windows.Graphics.SizeInt32;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Graphics.Capture.GraphicsCaptureItem, Object> | null;
+  }
+
+  class GraphicsCapturePicker implements Windows.Graphics.Capture.IGraphicsCapturePicker {
+    constructor();
+    PickSingleItemAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Capture.GraphicsCaptureItem>;
+  }
+
+  class GraphicsCaptureSession implements Windows.Foundation.IClosable, Windows.Graphics.Capture.IGraphicsCaptureSession, Windows.Graphics.Capture.IGraphicsCaptureSession2, Windows.Graphics.Capture.IGraphicsCaptureSession3, Windows.Graphics.Capture.IGraphicsCaptureSession4, Windows.Graphics.Capture.IGraphicsCaptureSession5, Windows.Graphics.Capture.IGraphicsCaptureSession6 {
+    Close(): void;
+    static IsSupported(): boolean;
+    StartCapture(): void;
+    DirtyRegionMode: number;
+    IncludeSecondaryWindows: boolean;
+    IsBorderRequired: boolean;
+    IsCursorCaptureEnabled: boolean;
+    MinUpdateInterval: Windows.Foundation.TimeSpan;
+  }
+
+  enum GraphicsCaptureAccessKind {
+    Borderless = 0,
+    Programmatic = 1,
+  }
+
+  enum GraphicsCaptureDirtyRegionMode {
+    ReportOnly = 0,
+    ReportAndRender = 1,
+  }
+
+  interface IDirect3D11CaptureFrame {
+    readonly ContentSize: Windows.Graphics.SizeInt32;
+    readonly Surface: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface;
+    readonly SystemRelativeTime: Windows.Foundation.TimeSpan;
+  }
+  var IDirect3D11CaptureFrame: abstract new (...args: any[]) => IDirect3D11CaptureFrame;
+
+  interface IDirect3D11CaptureFrame2 {
+    readonly DirtyRegionMode: number;
+    readonly DirtyRegions: Windows.Foundation.Collections.IVectorView<Windows.Graphics.RectInt32> | Windows.Graphics.RectInt32[];
+  }
+  var IDirect3D11CaptureFrame2: abstract new (...args: any[]) => IDirect3D11CaptureFrame2;
+
+  interface IDirect3D11CaptureFramePool {
+    CreateCaptureSession(item: Windows.Graphics.Capture.GraphicsCaptureItem): Windows.Graphics.Capture.GraphicsCaptureSession;
+    Recreate(device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice, pixelFormat: number, numberOfBuffers: number, size: Windows.Graphics.SizeInt32): void;
+    TryGetNextFrame(): Windows.Graphics.Capture.Direct3D11CaptureFrame;
+    readonly DispatcherQueue: Windows.System.DispatcherQueue;
+    FrameArrived: Windows.Foundation.TypedEventHandler<Windows.Graphics.Capture.Direct3D11CaptureFramePool, Object> | null;
+  }
+  var IDirect3D11CaptureFramePool: abstract new (...args: any[]) => IDirect3D11CaptureFramePool;
+
+  interface IDirect3D11CaptureFramePoolStatics {
+    Create(device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice, pixelFormat: number, numberOfBuffers: number, size: Windows.Graphics.SizeInt32): Windows.Graphics.Capture.Direct3D11CaptureFramePool;
+  }
+  var IDirect3D11CaptureFramePoolStatics: abstract new (...args: any[]) => IDirect3D11CaptureFramePoolStatics;
+
+  interface IDirect3D11CaptureFramePoolStatics2 {
+    CreateFreeThreaded(device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice, pixelFormat: number, numberOfBuffers: number, size: Windows.Graphics.SizeInt32): Windows.Graphics.Capture.Direct3D11CaptureFramePool;
+  }
+  var IDirect3D11CaptureFramePoolStatics2: abstract new (...args: any[]) => IDirect3D11CaptureFramePoolStatics2;
+
+  interface IGraphicsCaptureAccessStatics {
+    RequestAccessAsync(request: number): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IGraphicsCaptureAccessStatics: abstract new (...args: any[]) => IGraphicsCaptureAccessStatics;
+
+  interface IGraphicsCaptureItem {
+    readonly DisplayName: string;
+    readonly Size: Windows.Graphics.SizeInt32;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Graphics.Capture.GraphicsCaptureItem, Object> | null;
+  }
+  var IGraphicsCaptureItem: abstract new (...args: any[]) => IGraphicsCaptureItem;
+
+  interface IGraphicsCaptureItemStatics {
+    CreateFromVisual(visual: Windows.UI.Composition.Visual): Windows.Graphics.Capture.GraphicsCaptureItem;
+  }
+  var IGraphicsCaptureItemStatics: abstract new (...args: any[]) => IGraphicsCaptureItemStatics;
+
+  interface IGraphicsCaptureItemStatics2 {
+    TryCreateFromDisplayId(displayId: Windows.Graphics.DisplayId): Windows.Graphics.Capture.GraphicsCaptureItem;
+    TryCreateFromWindowId(windowId: Windows.UI.WindowId): Windows.Graphics.Capture.GraphicsCaptureItem;
+  }
+  var IGraphicsCaptureItemStatics2: abstract new (...args: any[]) => IGraphicsCaptureItemStatics2;
+
+  interface IGraphicsCapturePicker {
+    PickSingleItemAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Capture.GraphicsCaptureItem>;
+  }
+  var IGraphicsCapturePicker: abstract new (...args: any[]) => IGraphicsCapturePicker;
+
+  interface IGraphicsCaptureSession {
+    StartCapture(): void;
+  }
+  var IGraphicsCaptureSession: abstract new (...args: any[]) => IGraphicsCaptureSession;
+
+  interface IGraphicsCaptureSession2 {
+    IsCursorCaptureEnabled: boolean;
+  }
+  var IGraphicsCaptureSession2: abstract new (...args: any[]) => IGraphicsCaptureSession2;
+
+  interface IGraphicsCaptureSession3 {
+    IsBorderRequired: boolean;
+  }
+  var IGraphicsCaptureSession3: abstract new (...args: any[]) => IGraphicsCaptureSession3;
+
+  interface IGraphicsCaptureSession4 {
+    DirtyRegionMode: number;
+  }
+  var IGraphicsCaptureSession4: abstract new (...args: any[]) => IGraphicsCaptureSession4;
+
+  interface IGraphicsCaptureSession5 {
+    MinUpdateInterval: Windows.Foundation.TimeSpan;
+  }
+  var IGraphicsCaptureSession5: abstract new (...args: any[]) => IGraphicsCaptureSession5;
+
+  interface IGraphicsCaptureSession6 {
+    IncludeSecondaryWindows: boolean;
+  }
+  var IGraphicsCaptureSession6: abstract new (...args: any[]) => IGraphicsCaptureSession6;
+
+  interface IGraphicsCaptureSessionStatics {
+    IsSupported(): boolean;
+  }
+  var IGraphicsCaptureSessionStatics: abstract new (...args: any[]) => IGraphicsCaptureSessionStatics;
+
+}
+
+declare namespace Windows.Graphics.DirectX {
+  enum DirectXAlphaMode {
+    Unspecified = 0,
+    Premultiplied = 1,
+    Straight = 2,
+    Ignore = 3,
+  }
+
+  enum DirectXColorSpace {
+    RgbFullG22NoneP709 = 0,
+    RgbFullG10NoneP709 = 1,
+    RgbStudioG22NoneP709 = 2,
+    RgbStudioG22NoneP2020 = 3,
+    Reserved = 4,
+    YccFullG22NoneP709X601 = 5,
+    YccStudioG22LeftP601 = 6,
+    YccFullG22LeftP601 = 7,
+    YccStudioG22LeftP709 = 8,
+    YccFullG22LeftP709 = 9,
+    YccStudioG22LeftP2020 = 10,
+    YccFullG22LeftP2020 = 11,
+    RgbFullG2084NoneP2020 = 12,
+    YccStudioG2084LeftP2020 = 13,
+    RgbStudioG2084NoneP2020 = 14,
+    YccStudioG22TopLeftP2020 = 15,
+    YccStudioG2084TopLeftP2020 = 16,
+    RgbFullG22NoneP2020 = 17,
+    YccStudioGHlgTopLeftP2020 = 18,
+    YccFullGHlgTopLeftP2020 = 19,
+    RgbStudioG24NoneP709 = 20,
+    RgbStudioG24NoneP2020 = 21,
+    YccStudioG24LeftP709 = 22,
+    YccStudioG24LeftP2020 = 23,
+    YccStudioG24TopLeftP2020 = 24,
+  }
+
+  enum DirectXPixelFormat {
+    Unknown = 0,
+    R32G32B32A32Typeless = 1,
+    R32G32B32A32Float = 2,
+    R32G32B32A32UInt = 3,
+    R32G32B32A32Int = 4,
+    R32G32B32Typeless = 5,
+    R32G32B32Float = 6,
+    R32G32B32UInt = 7,
+    R32G32B32Int = 8,
+    R16G16B16A16Typeless = 9,
+    R16G16B16A16Float = 10,
+    R16G16B16A16UIntNormalized = 11,
+    R16G16B16A16UInt = 12,
+    R16G16B16A16IntNormalized = 13,
+    R16G16B16A16Int = 14,
+    R32G32Typeless = 15,
+    R32G32Float = 16,
+    R32G32UInt = 17,
+    R32G32Int = 18,
+    R32G8X24Typeless = 19,
+    D32FloatS8X24UInt = 20,
+    R32FloatX8X24Typeless = 21,
+    X32TypelessG8X24UInt = 22,
+    R10G10B10A2Typeless = 23,
+    R10G10B10A2UIntNormalized = 24,
+    R10G10B10A2UInt = 25,
+    R11G11B10Float = 26,
+    R8G8B8A8Typeless = 27,
+    R8G8B8A8UIntNormalized = 28,
+    R8G8B8A8UIntNormalizedSrgb = 29,
+    R8G8B8A8UInt = 30,
+    R8G8B8A8IntNormalized = 31,
+    R8G8B8A8Int = 32,
+    R16G16Typeless = 33,
+    R16G16Float = 34,
+    R16G16UIntNormalized = 35,
+    R16G16UInt = 36,
+    R16G16IntNormalized = 37,
+    R16G16Int = 38,
+    R32Typeless = 39,
+    D32Float = 40,
+    R32Float = 41,
+    R32UInt = 42,
+    R32Int = 43,
+    R24G8Typeless = 44,
+    D24UIntNormalizedS8UInt = 45,
+    R24UIntNormalizedX8Typeless = 46,
+    X24TypelessG8UInt = 47,
+    R8G8Typeless = 48,
+    R8G8UIntNormalized = 49,
+    R8G8UInt = 50,
+    R8G8IntNormalized = 51,
+    R8G8Int = 52,
+    R16Typeless = 53,
+    R16Float = 54,
+    D16UIntNormalized = 55,
+    R16UIntNormalized = 56,
+    R16UInt = 57,
+    R16IntNormalized = 58,
+    R16Int = 59,
+    R8Typeless = 60,
+    R8UIntNormalized = 61,
+    R8UInt = 62,
+    R8IntNormalized = 63,
+    R8Int = 64,
+    A8UIntNormalized = 65,
+    R1UIntNormalized = 66,
+    R9G9B9E5SharedExponent = 67,
+    R8G8B8G8UIntNormalized = 68,
+    G8R8G8B8UIntNormalized = 69,
+    BC1Typeless = 70,
+    BC1UIntNormalized = 71,
+    BC1UIntNormalizedSrgb = 72,
+    BC2Typeless = 73,
+    BC2UIntNormalized = 74,
+    BC2UIntNormalizedSrgb = 75,
+    BC3Typeless = 76,
+    BC3UIntNormalized = 77,
+    BC3UIntNormalizedSrgb = 78,
+    BC4Typeless = 79,
+    BC4UIntNormalized = 80,
+    BC4IntNormalized = 81,
+    BC5Typeless = 82,
+    BC5UIntNormalized = 83,
+    BC5IntNormalized = 84,
+    B5G6R5UIntNormalized = 85,
+    B5G5R5A1UIntNormalized = 86,
+    B8G8R8A8UIntNormalized = 87,
+    B8G8R8X8UIntNormalized = 88,
+    R10G10B10XRBiasA2UIntNormalized = 89,
+    B8G8R8A8Typeless = 90,
+    B8G8R8A8UIntNormalizedSrgb = 91,
+    B8G8R8X8Typeless = 92,
+    B8G8R8X8UIntNormalizedSrgb = 93,
+    BC6HTypeless = 94,
+    BC6H16UnsignedFloat = 95,
+    BC6H16Float = 96,
+    BC7Typeless = 97,
+    BC7UIntNormalized = 98,
+    BC7UIntNormalizedSrgb = 99,
+    Ayuv = 100,
+    Y410 = 101,
+    Y416 = 102,
+    NV12 = 103,
+    P010 = 104,
+    P016 = 105,
+    Opaque420 = 106,
+    Yuy2 = 107,
+    Y210 = 108,
+    Y216 = 109,
+    NV11 = 110,
+    AI44 = 111,
+    IA44 = 112,
+    P8 = 113,
+    A8P8 = 114,
+    B4G4R4A4UIntNormalized = 115,
+    P208 = 130,
+    V208 = 131,
+    V408 = 132,
+    SamplerFeedbackMinMipOpaque = 189,
+    SamplerFeedbackMipRegionUsedOpaque = 190,
+    A4B4G4R4 = 191,
+  }
+
+  enum DirectXPrimitiveTopology {
+    Undefined = 0,
+    PointList = 1,
+    LineList = 2,
+    LineStrip = 3,
+    TriangleList = 4,
+    TriangleStrip = 5,
+  }
+
+}
+
+declare namespace Windows.Graphics.DirectX.Direct3D11 {
+  enum Direct3DBindings {
+    VertexBuffer = 1,
+    IndexBuffer = 2,
+    ConstantBuffer = 4,
+    ShaderResource = 8,
+    StreamOutput = 16,
+    RenderTarget = 32,
+    DepthStencil = 64,
+    UnorderedAccess = 128,
+    Decoder = 512,
+    VideoEncoder = 1024,
+  }
+
+  enum Direct3DUsage {
+    Default = 0,
+    Immutable = 1,
+    Dynamic = 2,
+    Staging = 3,
+  }
+
+  interface Direct3DMultisampleDescription {
+    Count: number;
+    Quality: number;
+  }
+  var Direct3DMultisampleDescription: {
+    new(count: number, quality: number): Direct3DMultisampleDescription;
+    new(fields: { Count?: number; Quality?: number }): Direct3DMultisampleDescription;
+  };
+
+  interface Direct3DSurfaceDescription {
+    Width: number;
+    Height: number;
+    Format: number;
+    MultisampleDescription: Windows.Graphics.DirectX.Direct3D11.Direct3DMultisampleDescription;
+  }
+  var Direct3DSurfaceDescription: {
+    new(width: number, height: number, format: number, multisampleDescription: Windows.Graphics.DirectX.Direct3D11.Direct3DMultisampleDescription): Direct3DSurfaceDescription;
+    new(fields: { Width?: number; Height?: number; Format?: number; MultisampleDescription?: Windows.Graphics.DirectX.Direct3D11.Direct3DMultisampleDescription }): Direct3DSurfaceDescription;
+  };
+
+  interface IDirect3DDevice extends Windows.Foundation.IClosable {
+    Close(): void;
+    Trim(): void;
+  }
+  var IDirect3DDevice: abstract new (...args: any[]) => IDirect3DDevice;
+
+  interface IDirect3DSurface extends Windows.Foundation.IClosable {
+    Close(): void;
+    readonly Description: Windows.Graphics.DirectX.Direct3D11.Direct3DSurfaceDescription;
+  }
+  var IDirect3DSurface: abstract new (...args: any[]) => IDirect3DSurface;
+
+}
+
+declare namespace Windows.Graphics.Display {
+  class AdvancedColorInfo implements Windows.Graphics.Display.IAdvancedColorInfo {
+    IsAdvancedColorKindAvailable(kind: number): boolean;
+    IsHdrMetadataFormatCurrentlySupported(format: number): boolean;
+    readonly BluePrimary: Windows.Foundation.Point;
+    readonly CurrentAdvancedColorKind: number;
+    readonly GreenPrimary: Windows.Foundation.Point;
+    readonly MaxAverageFullFrameLuminanceInNits: number;
+    readonly MaxLuminanceInNits: number;
+    readonly MinLuminanceInNits: number;
+    readonly RedPrimary: Windows.Foundation.Point;
+    readonly SdrWhiteLevelInNits: number;
+    readonly WhitePoint: Windows.Foundation.Point;
+  }
+
+  class BrightnessOverride implements Windows.Graphics.Display.IBrightnessOverride {
+    static GetDefaultForSystem(): Windows.Graphics.Display.BrightnessOverride;
+    static GetForCurrentView(): Windows.Graphics.Display.BrightnessOverride;
+    GetLevelForScenario(scenario: number): number;
+    static SaveForSystemAsync(value: Windows.Graphics.Display.BrightnessOverride): Windows.Foundation.IAsyncOperation<boolean>;
+    SetBrightnessLevel(brightnessLevel: number, options: number): void;
+    SetBrightnessScenario(scenario: number, options: number): void;
+    StartOverride(): void;
+    StopOverride(): void;
+    readonly BrightnessLevel: number;
+    readonly IsOverrideActive: boolean;
+    readonly IsSupported: boolean;
+    BrightnessLevelChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.BrightnessOverride, Object> | null;
+    IsOverrideActiveChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.BrightnessOverride, Object> | null;
+    IsSupportedChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.BrightnessOverride, Object> | null;
+  }
+
+  class BrightnessOverrideSettings implements Windows.Graphics.Display.IBrightnessOverrideSettings {
+    static CreateFromDisplayBrightnessOverrideScenario(overrideScenario: number): Windows.Graphics.Display.BrightnessOverrideSettings;
+    static CreateFromLevel(level: number): Windows.Graphics.Display.BrightnessOverrideSettings;
+    static CreateFromNits(nits: number): Windows.Graphics.Display.BrightnessOverrideSettings;
+    readonly DesiredLevel: number;
+    readonly DesiredNits: number;
+  }
+
+  class ColorOverrideSettings implements Windows.Graphics.Display.IColorOverrideSettings {
+    static CreateFromDisplayColorOverrideScenario(overrideScenario: number): Windows.Graphics.Display.ColorOverrideSettings;
+    readonly DesiredDisplayColorOverrideScenario: number;
+  }
+
+  class DisplayEnhancementOverride implements Windows.Graphics.Display.IDisplayEnhancementOverride {
+    GetCurrentDisplayEnhancementOverrideCapabilities(): Windows.Graphics.Display.DisplayEnhancementOverrideCapabilities;
+    static GetForCurrentView(): Windows.Graphics.Display.DisplayEnhancementOverride;
+    RequestOverride(): void;
+    StopOverride(): void;
+    BrightnessOverrideSettings: Windows.Graphics.Display.BrightnessOverrideSettings;
+    readonly CanOverride: boolean;
+    ColorOverrideSettings: Windows.Graphics.Display.ColorOverrideSettings;
+    readonly IsOverrideActive: boolean;
+    CanOverrideChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.DisplayEnhancementOverride, Object> | null;
+    DisplayEnhancementOverrideCapabilitiesChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.DisplayEnhancementOverride, Windows.Graphics.Display.DisplayEnhancementOverrideCapabilitiesChangedEventArgs> | null;
+    IsOverrideActiveChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.DisplayEnhancementOverride, Object> | null;
+  }
+
+  class DisplayEnhancementOverrideCapabilities implements Windows.Graphics.Display.IDisplayEnhancementOverrideCapabilities {
+    GetSupportedNitRanges(): Windows.Foundation.Collections.IVectorView<Windows.Graphics.Display.NitRange> | Windows.Graphics.Display.NitRange[];
+    readonly IsBrightnessControlSupported: boolean;
+    readonly IsBrightnessNitsControlSupported: boolean;
+  }
+
+  class DisplayEnhancementOverrideCapabilitiesChangedEventArgs implements Windows.Graphics.Display.IDisplayEnhancementOverrideCapabilitiesChangedEventArgs {
+    readonly Capabilities: Windows.Graphics.Display.DisplayEnhancementOverrideCapabilities;
+  }
+
+  class DisplayInformation implements Windows.Graphics.Display.IDisplayInformation, Windows.Graphics.Display.IDisplayInformation2, Windows.Graphics.Display.IDisplayInformation3, Windows.Graphics.Display.IDisplayInformation4, Windows.Graphics.Display.IDisplayInformation5 {
+    GetAdvancedColorInfo(): Windows.Graphics.Display.AdvancedColorInfo;
+    GetColorProfileAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    static GetForCurrentView(): Windows.Graphics.Display.DisplayInformation;
+    static AutoRotationPreferences: number;
+    readonly CurrentOrientation: number;
+    readonly DiagonalSizeInInches: number | null;
+    readonly LogicalDpi: number;
+    readonly NativeOrientation: number;
+    readonly RawDpiX: number;
+    readonly RawDpiY: number;
+    readonly RawPixelsPerViewPixel: number;
+    readonly ResolutionScale: number;
+    readonly ScreenHeightInRawPixels: number;
+    readonly ScreenWidthInRawPixels: number;
+    readonly StereoEnabled: boolean;
+    ColorProfileChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.DisplayInformation, Object> | null;
+    DpiChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.DisplayInformation, Object> | null;
+    OrientationChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.DisplayInformation, Object> | null;
+    StereoEnabledChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.DisplayInformation, Object> | null;
+    AdvancedColorInfoChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.DisplayInformation, Object> | null;
+    static DisplayContentsInvalidated: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.DisplayInformation, Object> | null;
+  }
+
+  class DisplayProperties {
+    static GetColorProfileAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    static AutoRotationPreferences: number;
+    static readonly CurrentOrientation: number;
+    static readonly LogicalDpi: number;
+    static readonly NativeOrientation: number;
+    static readonly ResolutionScale: number;
+    static readonly StereoEnabled: boolean;
+    static ColorProfileChanged: Windows.Graphics.Display.DisplayPropertiesEventHandler | null;
+    static DisplayContentsInvalidated: Windows.Graphics.Display.DisplayPropertiesEventHandler | null;
+    static LogicalDpiChanged: Windows.Graphics.Display.DisplayPropertiesEventHandler | null;
+    static OrientationChanged: Windows.Graphics.Display.DisplayPropertiesEventHandler | null;
+    static StereoEnabledChanged: Windows.Graphics.Display.DisplayPropertiesEventHandler | null;
+  }
+
+  class DisplayServices implements Windows.Graphics.Display.IDisplayServices {
+    static FindAll(): Windows.Graphics.DisplayId[];
+  }
+
+  enum AdvancedColorKind {
+    StandardDynamicRange = 0,
+    WideColorGamut = 1,
+    HighDynamicRange = 2,
+  }
+
+  enum DisplayBrightnessOverrideOptions {
+    None = 0,
+    UseDimmedPolicyWhenBatteryIsLow = 1,
+  }
+
+  enum DisplayBrightnessOverrideScenario {
+    IdleBrightness = 0,
+    BarcodeReadingBrightness = 1,
+    FullBrightness = 2,
+  }
+
+  enum DisplayBrightnessScenario {
+    DefaultBrightness = 0,
+    IdleBrightness = 1,
+    BarcodeReadingBrightness = 2,
+    FullBrightness = 3,
+  }
+
+  enum DisplayColorOverrideScenario {
+    Accurate = 0,
+  }
+
+  enum DisplayOrientations {
+    None = 0,
+    Landscape = 1,
+    Portrait = 2,
+    LandscapeFlipped = 4,
+    PortraitFlipped = 8,
+  }
+
+  enum HdrMetadataFormat {
+    Hdr10 = 0,
+    Hdr10Plus = 1,
+  }
+
+  enum ResolutionScale {
+    Invalid = 0,
+    Scale100Percent = 100,
+    Scale120Percent = 120,
+    Scale125Percent = 125,
+    Scale140Percent = 140,
+    Scale150Percent = 150,
+    Scale160Percent = 160,
+    Scale175Percent = 175,
+    Scale180Percent = 180,
+    Scale200Percent = 200,
+    Scale225Percent = 225,
+    Scale250Percent = 250,
+    Scale300Percent = 300,
+    Scale350Percent = 350,
+    Scale400Percent = 400,
+    Scale450Percent = 450,
+    Scale500Percent = 500,
+  }
+
+  interface DisplayPropertiesEventHandler {
+    (sender: Object): void;
+  }
+  var DisplayPropertiesEventHandler: {
+    new(callback: (sender: Object) => void): DisplayPropertiesEventHandler;
+  };
+
+  interface IAdvancedColorInfo {
+    IsAdvancedColorKindAvailable(kind: number): boolean;
+    IsHdrMetadataFormatCurrentlySupported(format: number): boolean;
+    readonly BluePrimary: Windows.Foundation.Point;
+    readonly CurrentAdvancedColorKind: number;
+    readonly GreenPrimary: Windows.Foundation.Point;
+    readonly MaxAverageFullFrameLuminanceInNits: number;
+    readonly MaxLuminanceInNits: number;
+    readonly MinLuminanceInNits: number;
+    readonly RedPrimary: Windows.Foundation.Point;
+    readonly SdrWhiteLevelInNits: number;
+    readonly WhitePoint: Windows.Foundation.Point;
+  }
+  var IAdvancedColorInfo: abstract new (...args: any[]) => IAdvancedColorInfo;
+
+  interface IBrightnessOverride {
+    GetLevelForScenario(scenario: number): number;
+    SetBrightnessLevel(brightnessLevel: number, options: number): void;
+    SetBrightnessScenario(scenario: number, options: number): void;
+    StartOverride(): void;
+    StopOverride(): void;
+    readonly BrightnessLevel: number;
+    readonly IsOverrideActive: boolean;
+    readonly IsSupported: boolean;
+    BrightnessLevelChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.BrightnessOverride, Object> | null;
+    IsOverrideActiveChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.BrightnessOverride, Object> | null;
+    IsSupportedChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.BrightnessOverride, Object> | null;
+  }
+  var IBrightnessOverride: abstract new (...args: any[]) => IBrightnessOverride;
+
+  interface IBrightnessOverrideSettings {
+    readonly DesiredLevel: number;
+    readonly DesiredNits: number;
+  }
+  var IBrightnessOverrideSettings: abstract new (...args: any[]) => IBrightnessOverrideSettings;
+
+  interface IBrightnessOverrideSettingsStatics {
+    CreateFromDisplayBrightnessOverrideScenario(overrideScenario: number): Windows.Graphics.Display.BrightnessOverrideSettings;
+    CreateFromLevel(level: number): Windows.Graphics.Display.BrightnessOverrideSettings;
+    CreateFromNits(nits: number): Windows.Graphics.Display.BrightnessOverrideSettings;
+  }
+  var IBrightnessOverrideSettingsStatics: abstract new (...args: any[]) => IBrightnessOverrideSettingsStatics;
+
+  interface IBrightnessOverrideStatics {
+    GetDefaultForSystem(): Windows.Graphics.Display.BrightnessOverride;
+    GetForCurrentView(): Windows.Graphics.Display.BrightnessOverride;
+    SaveForSystemAsync(value: Windows.Graphics.Display.BrightnessOverride): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IBrightnessOverrideStatics: abstract new (...args: any[]) => IBrightnessOverrideStatics;
+
+  interface IColorOverrideSettings {
+    readonly DesiredDisplayColorOverrideScenario: number;
+  }
+  var IColorOverrideSettings: abstract new (...args: any[]) => IColorOverrideSettings;
+
+  interface IColorOverrideSettingsStatics {
+    CreateFromDisplayColorOverrideScenario(overrideScenario: number): Windows.Graphics.Display.ColorOverrideSettings;
+  }
+  var IColorOverrideSettingsStatics: abstract new (...args: any[]) => IColorOverrideSettingsStatics;
+
+  interface IDisplayEnhancementOverride {
+    GetCurrentDisplayEnhancementOverrideCapabilities(): Windows.Graphics.Display.DisplayEnhancementOverrideCapabilities;
+    RequestOverride(): void;
+    StopOverride(): void;
+    BrightnessOverrideSettings: Windows.Graphics.Display.BrightnessOverrideSettings;
+    readonly CanOverride: boolean;
+    ColorOverrideSettings: Windows.Graphics.Display.ColorOverrideSettings;
+    readonly IsOverrideActive: boolean;
+    CanOverrideChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.DisplayEnhancementOverride, Object> | null;
+    DisplayEnhancementOverrideCapabilitiesChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.DisplayEnhancementOverride, Windows.Graphics.Display.DisplayEnhancementOverrideCapabilitiesChangedEventArgs> | null;
+    IsOverrideActiveChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.DisplayEnhancementOverride, Object> | null;
+  }
+  var IDisplayEnhancementOverride: abstract new (...args: any[]) => IDisplayEnhancementOverride;
+
+  interface IDisplayEnhancementOverrideCapabilities {
+    GetSupportedNitRanges(): Windows.Foundation.Collections.IVectorView<Windows.Graphics.Display.NitRange> | Windows.Graphics.Display.NitRange[];
+    readonly IsBrightnessControlSupported: boolean;
+    readonly IsBrightnessNitsControlSupported: boolean;
+  }
+  var IDisplayEnhancementOverrideCapabilities: abstract new (...args: any[]) => IDisplayEnhancementOverrideCapabilities;
+
+  interface IDisplayEnhancementOverrideCapabilitiesChangedEventArgs {
+    readonly Capabilities: Windows.Graphics.Display.DisplayEnhancementOverrideCapabilities;
+  }
+  var IDisplayEnhancementOverrideCapabilitiesChangedEventArgs: abstract new (...args: any[]) => IDisplayEnhancementOverrideCapabilitiesChangedEventArgs;
+
+  interface IDisplayEnhancementOverrideStatics {
+    GetForCurrentView(): Windows.Graphics.Display.DisplayEnhancementOverride;
+  }
+  var IDisplayEnhancementOverrideStatics: abstract new (...args: any[]) => IDisplayEnhancementOverrideStatics;
+
+  interface IDisplayInformation {
+    GetColorProfileAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    readonly CurrentOrientation: number;
+    readonly LogicalDpi: number;
+    readonly NativeOrientation: number;
+    readonly RawDpiX: number;
+    readonly RawDpiY: number;
+    readonly ResolutionScale: number;
+    readonly StereoEnabled: boolean;
+    ColorProfileChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.DisplayInformation, Object> | null;
+    DpiChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.DisplayInformation, Object> | null;
+    OrientationChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.DisplayInformation, Object> | null;
+    StereoEnabledChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.DisplayInformation, Object> | null;
+  }
+  var IDisplayInformation: abstract new (...args: any[]) => IDisplayInformation;
+
+  interface IDisplayInformation2 extends Windows.Graphics.Display.IDisplayInformation {
+    GetColorProfileAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    readonly RawPixelsPerViewPixel: number;
+  }
+  var IDisplayInformation2: abstract new (...args: any[]) => IDisplayInformation2;
+
+  interface IDisplayInformation3 {
+    readonly DiagonalSizeInInches: number | null;
+  }
+  var IDisplayInformation3: abstract new (...args: any[]) => IDisplayInformation3;
+
+  interface IDisplayInformation4 {
+    readonly ScreenHeightInRawPixels: number;
+    readonly ScreenWidthInRawPixels: number;
+  }
+  var IDisplayInformation4: abstract new (...args: any[]) => IDisplayInformation4;
+
+  interface IDisplayInformation5 {
+    GetAdvancedColorInfo(): Windows.Graphics.Display.AdvancedColorInfo;
+    AdvancedColorInfoChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.DisplayInformation, Object> | null;
+  }
+  var IDisplayInformation5: abstract new (...args: any[]) => IDisplayInformation5;
+
+  interface IDisplayInformationStatics {
+    GetForCurrentView(): Windows.Graphics.Display.DisplayInformation;
+    AutoRotationPreferences: number;
+    DisplayContentsInvalidated: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.DisplayInformation, Object> | null;
+  }
+  var IDisplayInformationStatics: abstract new (...args: any[]) => IDisplayInformationStatics;
+
+  interface IDisplayPropertiesStatics {
+    GetColorProfileAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    AutoRotationPreferences: number;
+    readonly CurrentOrientation: number;
+    readonly LogicalDpi: number;
+    readonly NativeOrientation: number;
+    readonly ResolutionScale: number;
+    readonly StereoEnabled: boolean;
+    ColorProfileChanged: Windows.Graphics.Display.DisplayPropertiesEventHandler | null;
+    DisplayContentsInvalidated: Windows.Graphics.Display.DisplayPropertiesEventHandler | null;
+    LogicalDpiChanged: Windows.Graphics.Display.DisplayPropertiesEventHandler | null;
+    OrientationChanged: Windows.Graphics.Display.DisplayPropertiesEventHandler | null;
+    StereoEnabledChanged: Windows.Graphics.Display.DisplayPropertiesEventHandler | null;
+  }
+  var IDisplayPropertiesStatics: abstract new (...args: any[]) => IDisplayPropertiesStatics;
+
+  interface IDisplayServices {
+  }
+  var IDisplayServices: abstract new (...args: any[]) => IDisplayServices;
+
+  interface IDisplayServicesStatics {
+    FindAll(): Windows.Graphics.DisplayId[];
+  }
+  var IDisplayServicesStatics: abstract new (...args: any[]) => IDisplayServicesStatics;
+
+  interface NitRange {
+    MinNits: number;
+    MaxNits: number;
+    StepSizeNits: number;
+  }
+  var NitRange: {
+    new(minNits: number, maxNits: number, stepSizeNits: number): NitRange;
+    new(fields: { MinNits?: number; MaxNits?: number; StepSizeNits?: number }): NitRange;
+  };
+
+}
+
+declare namespace Windows.Graphics.Display.Core {
+  class HdmiDisplayInformation implements Windows.Graphics.Display.Core.IHdmiDisplayInformation {
+    GetCurrentDisplayMode(): Windows.Graphics.Display.Core.HdmiDisplayMode;
+    static GetForCurrentView(): Windows.Graphics.Display.Core.HdmiDisplayInformation;
+    GetSupportedDisplayModes(): Windows.Foundation.Collections.IVectorView<Windows.Graphics.Display.Core.HdmiDisplayMode> | Windows.Graphics.Display.Core.HdmiDisplayMode[];
+    RequestSetCurrentDisplayModeAsync(mode: Windows.Graphics.Display.Core.HdmiDisplayMode): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestSetCurrentDisplayModeAsync(mode: Windows.Graphics.Display.Core.HdmiDisplayMode, hdrOption: number): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestSetCurrentDisplayModeAsync(mode: Windows.Graphics.Display.Core.HdmiDisplayMode, hdrOption: number, hdrMetadata: Windows.Graphics.Display.Core.HdmiDisplayHdr2086Metadata): Windows.Foundation.IAsyncOperation<boolean>;
+    SetDefaultDisplayModeAsync(): Windows.Foundation.IAsyncAction;
+    DisplayModesChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.Core.HdmiDisplayInformation, Object> | null;
+  }
+
+  class HdmiDisplayMode implements Windows.Graphics.Display.Core.IHdmiDisplayMode, Windows.Graphics.Display.Core.IHdmiDisplayMode2 {
+    IsEqual(mode: Windows.Graphics.Display.Core.HdmiDisplayMode): boolean;
+    readonly BitsPerPixel: number;
+    readonly ColorSpace: number;
+    readonly Is2086MetadataSupported: boolean;
+    readonly IsDolbyVisionLowLatencySupported: boolean;
+    readonly IsSdrLuminanceSupported: boolean;
+    readonly IsSmpte2084Supported: boolean;
+    readonly PixelEncoding: number;
+    readonly RefreshRate: number;
+    readonly ResolutionHeightInRawPixels: number;
+    readonly ResolutionWidthInRawPixels: number;
+    readonly StereoEnabled: boolean;
+  }
+
+  enum HdmiDisplayColorSpace {
+    RgbLimited = 0,
+    RgbFull = 1,
+    BT2020 = 2,
+    BT709 = 3,
+  }
+
+  enum HdmiDisplayHdrOption {
+    None = 0,
+    EotfSdr = 1,
+    Eotf2084 = 2,
+    DolbyVisionLowLatency = 3,
+  }
+
+  enum HdmiDisplayPixelEncoding {
+    Rgb444 = 0,
+    Ycc444 = 1,
+    Ycc422 = 2,
+    Ycc420 = 3,
+  }
+
+  interface HdmiDisplayHdr2086Metadata {
+    RedPrimaryX: number;
+    RedPrimaryY: number;
+    GreenPrimaryX: number;
+    GreenPrimaryY: number;
+    BluePrimaryX: number;
+    BluePrimaryY: number;
+    WhitePointX: number;
+    WhitePointY: number;
+    MaxMasteringLuminance: number;
+    MinMasteringLuminance: number;
+    MaxContentLightLevel: number;
+    MaxFrameAverageLightLevel: number;
+  }
+  var HdmiDisplayHdr2086Metadata: {
+    new(redPrimaryX: number, redPrimaryY: number, greenPrimaryX: number, greenPrimaryY: number, bluePrimaryX: number, bluePrimaryY: number, whitePointX: number, whitePointY: number, maxMasteringLuminance: number, minMasteringLuminance: number, maxContentLightLevel: number, maxFrameAverageLightLevel: number): HdmiDisplayHdr2086Metadata;
+    new(fields: { RedPrimaryX?: number; RedPrimaryY?: number; GreenPrimaryX?: number; GreenPrimaryY?: number; BluePrimaryX?: number; BluePrimaryY?: number; WhitePointX?: number; WhitePointY?: number; MaxMasteringLuminance?: number; MinMasteringLuminance?: number; MaxContentLightLevel?: number; MaxFrameAverageLightLevel?: number }): HdmiDisplayHdr2086Metadata;
+  };
+
+  interface IHdmiDisplayInformation {
+    GetCurrentDisplayMode(): Windows.Graphics.Display.Core.HdmiDisplayMode;
+    GetSupportedDisplayModes(): Windows.Foundation.Collections.IVectorView<Windows.Graphics.Display.Core.HdmiDisplayMode> | Windows.Graphics.Display.Core.HdmiDisplayMode[];
+    RequestSetCurrentDisplayModeAsync(mode: Windows.Graphics.Display.Core.HdmiDisplayMode): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestSetCurrentDisplayModeAsync(mode: Windows.Graphics.Display.Core.HdmiDisplayMode, hdrOption: number): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestSetCurrentDisplayModeAsync(mode: Windows.Graphics.Display.Core.HdmiDisplayMode, hdrOption: number, hdrMetadata: Windows.Graphics.Display.Core.HdmiDisplayHdr2086Metadata): Windows.Foundation.IAsyncOperation<boolean>;
+    SetDefaultDisplayModeAsync(): Windows.Foundation.IAsyncAction;
+    DisplayModesChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Display.Core.HdmiDisplayInformation, Object> | null;
+  }
+  var IHdmiDisplayInformation: abstract new (...args: any[]) => IHdmiDisplayInformation;
+
+  interface IHdmiDisplayInformationStatics {
+    GetForCurrentView(): Windows.Graphics.Display.Core.HdmiDisplayInformation;
+  }
+  var IHdmiDisplayInformationStatics: abstract new (...args: any[]) => IHdmiDisplayInformationStatics;
+
+  interface IHdmiDisplayMode {
+    IsEqual(mode: Windows.Graphics.Display.Core.HdmiDisplayMode): boolean;
+    readonly BitsPerPixel: number;
+    readonly ColorSpace: number;
+    readonly Is2086MetadataSupported: boolean;
+    readonly IsSdrLuminanceSupported: boolean;
+    readonly IsSmpte2084Supported: boolean;
+    readonly PixelEncoding: number;
+    readonly RefreshRate: number;
+    readonly ResolutionHeightInRawPixels: number;
+    readonly ResolutionWidthInRawPixels: number;
+    readonly StereoEnabled: boolean;
+  }
+  var IHdmiDisplayMode: abstract new (...args: any[]) => IHdmiDisplayMode;
+
+  interface IHdmiDisplayMode2 {
+    readonly IsDolbyVisionLowLatencySupported: boolean;
+  }
+  var IHdmiDisplayMode2: abstract new (...args: any[]) => IHdmiDisplayMode2;
+
+}
+
+declare namespace Windows.Graphics.Effects {
+  interface IGraphicsEffect extends Windows.Graphics.Effects.IGraphicsEffectSource {
+    Name: string;
+  }
+  var IGraphicsEffect: abstract new (...args: any[]) => IGraphicsEffect;
+
+  interface IGraphicsEffectSource {
+  }
+  var IGraphicsEffectSource: abstract new (...args: any[]) => IGraphicsEffectSource;
+
+}
+
+declare namespace Windows.Graphics.Holographic {
+  class HolographicCamera implements Windows.Graphics.Holographic.IHolographicCamera, Windows.Graphics.Holographic.IHolographicCamera2, Windows.Graphics.Holographic.IHolographicCamera3, Windows.Graphics.Holographic.IHolographicCamera4, Windows.Graphics.Holographic.IHolographicCamera5, Windows.Graphics.Holographic.IHolographicCamera6 {
+    SetFarPlaneDistance(value: number): void;
+    SetNearPlaneDistance(value: number): void;
+    readonly CanOverrideViewport: boolean;
+    readonly Display: Windows.Graphics.Holographic.HolographicDisplay;
+    readonly Id: number;
+    IsHardwareContentProtectionEnabled: boolean;
+    readonly IsHardwareContentProtectionSupported: boolean;
+    IsPrimaryLayerEnabled: boolean;
+    readonly IsStereo: boolean;
+    readonly LeftViewportParameters: Windows.Graphics.Holographic.HolographicCameraViewportParameters;
+    readonly MaxQuadLayerCount: number;
+    readonly QuadLayers: Windows.Foundation.Collections.IVector<Windows.Graphics.Holographic.HolographicQuadLayer> | Windows.Graphics.Holographic.HolographicQuadLayer[];
+    readonly RenderTargetSize: Windows.Foundation.Size;
+    readonly RightViewportParameters: Windows.Graphics.Holographic.HolographicCameraViewportParameters;
+    readonly ViewConfiguration: Windows.Graphics.Holographic.HolographicViewConfiguration;
+    ViewportScaleFactor: number;
+  }
+
+  class HolographicCameraPose implements Windows.Graphics.Holographic.IHolographicCameraPose, Windows.Graphics.Holographic.IHolographicCameraPose2 {
+    OverrideProjectionTransform(projectionTransform: Windows.Graphics.Holographic.HolographicStereoTransform): void;
+    OverrideViewTransform(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, coordinateSystemToViewTransform: Windows.Graphics.Holographic.HolographicStereoTransform): void;
+    OverrideViewport(leftViewport: Windows.Foundation.Rect, rightViewport: Windows.Foundation.Rect): void;
+    TryGetCullingFrustum(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Perception.Spatial.SpatialBoundingFrustum | null;
+    TryGetViewTransform(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Graphics.Holographic.HolographicStereoTransform | null;
+    TryGetVisibleFrustum(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Perception.Spatial.SpatialBoundingFrustum | null;
+    readonly FarPlaneDistance: number;
+    readonly HolographicCamera: Windows.Graphics.Holographic.HolographicCamera;
+    readonly NearPlaneDistance: number;
+    readonly ProjectionTransform: Windows.Graphics.Holographic.HolographicStereoTransform;
+    readonly Viewport: Windows.Foundation.Rect;
+  }
+
+  class HolographicCameraRenderingParameters implements Windows.Graphics.Holographic.IHolographicCameraRenderingParameters, Windows.Graphics.Holographic.IHolographicCameraRenderingParameters2, Windows.Graphics.Holographic.IHolographicCameraRenderingParameters3, Windows.Graphics.Holographic.IHolographicCameraRenderingParameters4 {
+    CommitDirect3D11DepthBuffer(value: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface): void;
+    SetFocusPoint(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, position: Windows.Foundation.Numerics.Vector3): void;
+    SetFocusPoint(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, position: Windows.Foundation.Numerics.Vector3, normal: Windows.Foundation.Numerics.Vector3): void;
+    SetFocusPoint(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, position: Windows.Foundation.Numerics.Vector3, normal: Windows.Foundation.Numerics.Vector3, linearVelocity: Windows.Foundation.Numerics.Vector3): void;
+    DepthReprojectionMethod: number;
+    readonly Direct3D11BackBuffer: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface;
+    readonly Direct3D11Device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice;
+    IsContentProtectionEnabled: boolean;
+    ReprojectionMode: number;
+  }
+
+  class HolographicCameraViewportParameters implements Windows.Graphics.Holographic.IHolographicCameraViewportParameters {
+    readonly HiddenAreaMesh: Windows.Foundation.Numerics.Vector2[];
+    readonly VisibleAreaMesh: Windows.Foundation.Numerics.Vector2[];
+  }
+
+  class HolographicDisplay implements Windows.Graphics.Holographic.IHolographicDisplay, Windows.Graphics.Holographic.IHolographicDisplay2, Windows.Graphics.Holographic.IHolographicDisplay3 {
+    static GetDefault(): Windows.Graphics.Holographic.HolographicDisplay;
+    TryGetViewConfiguration(kind: number): Windows.Graphics.Holographic.HolographicViewConfiguration;
+    readonly AdapterId: Windows.Graphics.Holographic.HolographicAdapterId;
+    readonly DisplayName: string;
+    readonly IsOpaque: boolean;
+    readonly IsStereo: boolean;
+    readonly MaxViewportSize: Windows.Foundation.Size;
+    readonly RefreshRate: number;
+    readonly SpatialLocator: Windows.Perception.Spatial.SpatialLocator;
+  }
+
+  class HolographicFrame implements Windows.Graphics.Holographic.IHolographicFrame, Windows.Graphics.Holographic.IHolographicFrame2, Windows.Graphics.Holographic.IHolographicFrame3 {
+    GetQuadLayerUpdateParameters(layer: Windows.Graphics.Holographic.HolographicQuadLayer): Windows.Graphics.Holographic.HolographicQuadLayerUpdateParameters;
+    GetRenderingParameters(cameraPose: Windows.Graphics.Holographic.HolographicCameraPose): Windows.Graphics.Holographic.HolographicCameraRenderingParameters;
+    PresentUsingCurrentPrediction(): number;
+    PresentUsingCurrentPrediction(waitBehavior: number): number;
+    UpdateCurrentPrediction(): void;
+    WaitForFrameToFinish(): void;
+    readonly AddedCameras: Windows.Foundation.Collections.IVectorView<Windows.Graphics.Holographic.HolographicCamera> | Windows.Graphics.Holographic.HolographicCamera[];
+    readonly CurrentPrediction: Windows.Graphics.Holographic.HolographicFramePrediction;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly Id: Windows.Graphics.Holographic.HolographicFrameId;
+    readonly RemovedCameras: Windows.Foundation.Collections.IVectorView<Windows.Graphics.Holographic.HolographicCamera> | Windows.Graphics.Holographic.HolographicCamera[];
+  }
+
+  class HolographicFramePrediction implements Windows.Graphics.Holographic.IHolographicFramePrediction {
+    readonly CameraPoses: Windows.Foundation.Collections.IVectorView<Windows.Graphics.Holographic.HolographicCameraPose> | Windows.Graphics.Holographic.HolographicCameraPose[];
+    readonly Timestamp: Windows.Perception.PerceptionTimestamp;
+  }
+
+  class HolographicFramePresentationMonitor implements Windows.Foundation.IClosable, Windows.Graphics.Holographic.IHolographicFramePresentationMonitor {
+    Close(): void;
+    ReadReports(): Windows.Foundation.Collections.IVectorView<Windows.Graphics.Holographic.HolographicFramePresentationReport> | Windows.Graphics.Holographic.HolographicFramePresentationReport[];
+  }
+
+  class HolographicFramePresentationReport implements Windows.Graphics.Holographic.IHolographicFramePresentationReport {
+    readonly AppGpuDuration: Windows.Foundation.TimeSpan;
+    readonly AppGpuOverrun: Windows.Foundation.TimeSpan;
+    readonly CompositorGpuDuration: Windows.Foundation.TimeSpan;
+    readonly MissedPresentationOpportunityCount: number;
+    readonly PresentationCount: number;
+  }
+
+  class HolographicFrameRenderingReport implements Windows.Graphics.Holographic.IHolographicFrameRenderingReport {
+    readonly FrameId: Windows.Graphics.Holographic.HolographicFrameId;
+    readonly MissedLatchCount: number;
+    readonly SystemRelativeActualGpuFinishTime: Windows.Foundation.TimeSpan;
+    readonly SystemRelativeFrameReadyTime: Windows.Foundation.TimeSpan;
+    readonly SystemRelativeTargetLatchTime: Windows.Foundation.TimeSpan;
+  }
+
+  class HolographicFrameScanoutMonitor implements Windows.Foundation.IClosable, Windows.Graphics.Holographic.IHolographicFrameScanoutMonitor {
+    Close(): void;
+    ReadReports(): Windows.Foundation.Collections.IVector<Windows.Graphics.Holographic.HolographicFrameScanoutReport> | Windows.Graphics.Holographic.HolographicFrameScanoutReport[];
+  }
+
+  class HolographicFrameScanoutReport implements Windows.Graphics.Holographic.IHolographicFrameScanoutReport {
+    readonly MissedScanoutCount: number;
+    readonly RenderingReport: Windows.Graphics.Holographic.HolographicFrameRenderingReport;
+    readonly SystemRelativeLatchTime: Windows.Foundation.TimeSpan;
+    readonly SystemRelativePhotonTime: Windows.Foundation.TimeSpan;
+    readonly SystemRelativeScanoutStartTime: Windows.Foundation.TimeSpan;
+  }
+
+  class HolographicQuadLayer implements Windows.Foundation.IClosable, Windows.Graphics.Holographic.IHolographicQuadLayer {
+    constructor(size: Windows.Foundation.Size);
+    constructor(size: Windows.Foundation.Size, pixelFormat: number);
+    Close(): void;
+    readonly PixelFormat: number;
+    readonly Size: Windows.Foundation.Size;
+  }
+
+  class HolographicQuadLayerUpdateParameters implements Windows.Graphics.Holographic.IHolographicQuadLayerUpdateParameters, Windows.Graphics.Holographic.IHolographicQuadLayerUpdateParameters2 {
+    AcquireBufferToUpdateContent(): Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface;
+    AcquireBufferToUpdateContentWithHardwareProtection(): Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface;
+    UpdateContentProtectionEnabled(value: boolean): void;
+    UpdateExtents(value: Windows.Foundation.Numerics.Vector2): void;
+    UpdateLocationWithDisplayRelativeMode(position: Windows.Foundation.Numerics.Vector3, orientation: Windows.Foundation.Numerics.Quaternion): void;
+    UpdateLocationWithStationaryMode(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, position: Windows.Foundation.Numerics.Vector3, orientation: Windows.Foundation.Numerics.Quaternion): void;
+    UpdateViewport(value: Windows.Foundation.Rect): void;
+    readonly CanAcquireWithHardwareProtection: boolean;
+  }
+
+  class HolographicSpace implements Windows.Graphics.Holographic.IHolographicSpace, Windows.Graphics.Holographic.IHolographicSpace2, Windows.Graphics.Holographic.IHolographicSpace3 {
+    static CreateForCoreWindow(window: Windows.UI.Core.CoreWindow): Windows.Graphics.Holographic.HolographicSpace;
+    CreateFramePresentationMonitor(maxQueuedReports: number): Windows.Graphics.Holographic.HolographicFramePresentationMonitor;
+    CreateFrameScanoutMonitor(maxQueuedReports: number): Windows.Graphics.Holographic.HolographicFrameScanoutMonitor;
+    CreateNextFrame(): Windows.Graphics.Holographic.HolographicFrame;
+    SetDirect3D11Device(value: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice): void;
+    WaitForNextFrameReady(): void;
+    WaitForNextFrameReadyWithHeadStart(requestedHeadStartDuration: Windows.Foundation.TimeSpan): void;
+    static readonly IsAvailable: boolean;
+    static readonly IsConfigured: boolean;
+    static readonly IsSupported: boolean;
+    readonly PrimaryAdapterId: Windows.Graphics.Holographic.HolographicAdapterId;
+    readonly UserPresence: number;
+    CameraAdded: Windows.Foundation.TypedEventHandler<Windows.Graphics.Holographic.HolographicSpace, Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs> | null;
+    CameraRemoved: Windows.Foundation.TypedEventHandler<Windows.Graphics.Holographic.HolographicSpace, Windows.Graphics.Holographic.HolographicSpaceCameraRemovedEventArgs> | null;
+    UserPresenceChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Holographic.HolographicSpace, Object> | null;
+    static IsAvailableChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class HolographicSpaceCameraAddedEventArgs implements Windows.Graphics.Holographic.IHolographicSpaceCameraAddedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Camera: Windows.Graphics.Holographic.HolographicCamera;
+  }
+
+  class HolographicSpaceCameraRemovedEventArgs implements Windows.Graphics.Holographic.IHolographicSpaceCameraRemovedEventArgs {
+    readonly Camera: Windows.Graphics.Holographic.HolographicCamera;
+  }
+
+  class HolographicViewConfiguration implements Windows.Graphics.Holographic.IHolographicViewConfiguration, Windows.Graphics.Holographic.IHolographicViewConfiguration2 {
+    RequestRenderTargetSize(size: Windows.Foundation.Size): Windows.Foundation.Size;
+    readonly Display: Windows.Graphics.Holographic.HolographicDisplay;
+    IsEnabled: boolean;
+    readonly IsStereo: boolean;
+    readonly Kind: number;
+    readonly NativeRenderTargetSize: Windows.Foundation.Size;
+    PixelFormat: number;
+    readonly RefreshRate: number;
+    readonly RenderTargetSize: Windows.Foundation.Size;
+    readonly SupportedDepthReprojectionMethods: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedPixelFormats: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  enum HolographicDepthReprojectionMethod {
+    DepthReprojection = 0,
+    AutoPlanar = 1,
+  }
+
+  enum HolographicFramePresentResult {
+    Success = 0,
+    DeviceRemoved = 1,
+  }
+
+  enum HolographicFramePresentWaitBehavior {
+    WaitForFrameToFinish = 0,
+    DoNotWaitForFrameToFinish = 1,
+  }
+
+  enum HolographicReprojectionMode {
+    PositionAndOrientation = 0,
+    OrientationOnly = 1,
+    Disabled = 2,
+  }
+
+  enum HolographicSpaceUserPresence {
+    Absent = 0,
+    PresentPassive = 1,
+    PresentActive = 2,
+  }
+
+  enum HolographicViewConfigurationKind {
+    Display = 0,
+    PhotoVideoCamera = 1,
+  }
+
+  interface HolographicAdapterId {
+    LowPart: number;
+    HighPart: number;
+  }
+  var HolographicAdapterId: {
+    new(lowPart: number, highPart: number): HolographicAdapterId;
+    new(fields: { LowPart?: number; HighPart?: number }): HolographicAdapterId;
+  };
+
+  interface HolographicFrameId {
+    Value: number | bigint;
+  }
+  var HolographicFrameId: {
+    new(value: number | bigint): HolographicFrameId;
+    new(fields: { Value?: number | bigint }): HolographicFrameId;
+  };
+
+  interface HolographicStereoTransform {
+    Left: Windows.Foundation.Numerics.Matrix4x4;
+    Right: Windows.Foundation.Numerics.Matrix4x4;
+  }
+  var HolographicStereoTransform: {
+    new(left: Windows.Foundation.Numerics.Matrix4x4, right: Windows.Foundation.Numerics.Matrix4x4): HolographicStereoTransform;
+    new(fields: { Left?: Windows.Foundation.Numerics.Matrix4x4; Right?: Windows.Foundation.Numerics.Matrix4x4 }): HolographicStereoTransform;
+  };
+
+  interface IHolographicCamera {
+    SetFarPlaneDistance(value: number): void;
+    SetNearPlaneDistance(value: number): void;
+    readonly Id: number;
+    readonly IsStereo: boolean;
+    readonly RenderTargetSize: Windows.Foundation.Size;
+    ViewportScaleFactor: number;
+  }
+  var IHolographicCamera: abstract new (...args: any[]) => IHolographicCamera;
+
+  interface IHolographicCamera2 extends Windows.Graphics.Holographic.IHolographicCamera {
+    SetFarPlaneDistance(value: number): void;
+    SetNearPlaneDistance(value: number): void;
+    readonly Display: Windows.Graphics.Holographic.HolographicDisplay;
+    readonly LeftViewportParameters: Windows.Graphics.Holographic.HolographicCameraViewportParameters;
+    readonly RightViewportParameters: Windows.Graphics.Holographic.HolographicCameraViewportParameters;
+  }
+  var IHolographicCamera2: abstract new (...args: any[]) => IHolographicCamera2;
+
+  interface IHolographicCamera3 extends Windows.Graphics.Holographic.IHolographicCamera, Windows.Graphics.Holographic.IHolographicCamera2 {
+    SetFarPlaneDistance(value: number): void;
+    SetNearPlaneDistance(value: number): void;
+    IsPrimaryLayerEnabled: boolean;
+    readonly MaxQuadLayerCount: number;
+    readonly QuadLayers: Windows.Foundation.Collections.IVector<Windows.Graphics.Holographic.HolographicQuadLayer> | Windows.Graphics.Holographic.HolographicQuadLayer[];
+  }
+  var IHolographicCamera3: abstract new (...args: any[]) => IHolographicCamera3;
+
+  interface IHolographicCamera4 {
+    readonly CanOverrideViewport: boolean;
+  }
+  var IHolographicCamera4: abstract new (...args: any[]) => IHolographicCamera4;
+
+  interface IHolographicCamera5 {
+    IsHardwareContentProtectionEnabled: boolean;
+    readonly IsHardwareContentProtectionSupported: boolean;
+  }
+  var IHolographicCamera5: abstract new (...args: any[]) => IHolographicCamera5;
+
+  interface IHolographicCamera6 {
+    readonly ViewConfiguration: Windows.Graphics.Holographic.HolographicViewConfiguration;
+  }
+  var IHolographicCamera6: abstract new (...args: any[]) => IHolographicCamera6;
+
+  interface IHolographicCameraPose {
+    TryGetCullingFrustum(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Perception.Spatial.SpatialBoundingFrustum | null;
+    TryGetViewTransform(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Graphics.Holographic.HolographicStereoTransform | null;
+    TryGetVisibleFrustum(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Perception.Spatial.SpatialBoundingFrustum | null;
+    readonly FarPlaneDistance: number;
+    readonly HolographicCamera: Windows.Graphics.Holographic.HolographicCamera;
+    readonly NearPlaneDistance: number;
+    readonly ProjectionTransform: Windows.Graphics.Holographic.HolographicStereoTransform;
+    readonly Viewport: Windows.Foundation.Rect;
+  }
+  var IHolographicCameraPose: abstract new (...args: any[]) => IHolographicCameraPose;
+
+  interface IHolographicCameraPose2 {
+    OverrideProjectionTransform(projectionTransform: Windows.Graphics.Holographic.HolographicStereoTransform): void;
+    OverrideViewTransform(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, coordinateSystemToViewTransform: Windows.Graphics.Holographic.HolographicStereoTransform): void;
+    OverrideViewport(leftViewport: Windows.Foundation.Rect, rightViewport: Windows.Foundation.Rect): void;
+  }
+  var IHolographicCameraPose2: abstract new (...args: any[]) => IHolographicCameraPose2;
+
+  interface IHolographicCameraRenderingParameters {
+    SetFocusPoint(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, position: Windows.Foundation.Numerics.Vector3): void;
+    SetFocusPoint(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, position: Windows.Foundation.Numerics.Vector3, normal: Windows.Foundation.Numerics.Vector3): void;
+    SetFocusPoint(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, position: Windows.Foundation.Numerics.Vector3, normal: Windows.Foundation.Numerics.Vector3, linearVelocity: Windows.Foundation.Numerics.Vector3): void;
+    readonly Direct3D11BackBuffer: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface;
+    readonly Direct3D11Device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice;
+  }
+  var IHolographicCameraRenderingParameters: abstract new (...args: any[]) => IHolographicCameraRenderingParameters;
+
+  interface IHolographicCameraRenderingParameters2 extends Windows.Graphics.Holographic.IHolographicCameraRenderingParameters {
+    CommitDirect3D11DepthBuffer(value: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface): void;
+    SetFocusPoint(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, position: Windows.Foundation.Numerics.Vector3): void;
+    SetFocusPoint(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, position: Windows.Foundation.Numerics.Vector3, normal: Windows.Foundation.Numerics.Vector3): void;
+    SetFocusPoint(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, position: Windows.Foundation.Numerics.Vector3, normal: Windows.Foundation.Numerics.Vector3, linearVelocity: Windows.Foundation.Numerics.Vector3): void;
+    ReprojectionMode: number;
+  }
+  var IHolographicCameraRenderingParameters2: abstract new (...args: any[]) => IHolographicCameraRenderingParameters2;
+
+  interface IHolographicCameraRenderingParameters3 extends Windows.Graphics.Holographic.IHolographicCameraRenderingParameters, Windows.Graphics.Holographic.IHolographicCameraRenderingParameters2 {
+    CommitDirect3D11DepthBuffer(value: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface): void;
+    SetFocusPoint(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, position: Windows.Foundation.Numerics.Vector3): void;
+    SetFocusPoint(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, position: Windows.Foundation.Numerics.Vector3, normal: Windows.Foundation.Numerics.Vector3): void;
+    SetFocusPoint(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, position: Windows.Foundation.Numerics.Vector3, normal: Windows.Foundation.Numerics.Vector3, linearVelocity: Windows.Foundation.Numerics.Vector3): void;
+    IsContentProtectionEnabled: boolean;
+  }
+  var IHolographicCameraRenderingParameters3: abstract new (...args: any[]) => IHolographicCameraRenderingParameters3;
+
+  interface IHolographicCameraRenderingParameters4 {
+    DepthReprojectionMethod: number;
+  }
+  var IHolographicCameraRenderingParameters4: abstract new (...args: any[]) => IHolographicCameraRenderingParameters4;
+
+  interface IHolographicCameraViewportParameters {
+    readonly HiddenAreaMesh: Windows.Foundation.Numerics.Vector2[];
+    readonly VisibleAreaMesh: Windows.Foundation.Numerics.Vector2[];
+  }
+  var IHolographicCameraViewportParameters: abstract new (...args: any[]) => IHolographicCameraViewportParameters;
+
+  interface IHolographicDisplay {
+    readonly AdapterId: Windows.Graphics.Holographic.HolographicAdapterId;
+    readonly DisplayName: string;
+    readonly IsOpaque: boolean;
+    readonly IsStereo: boolean;
+    readonly MaxViewportSize: Windows.Foundation.Size;
+    readonly SpatialLocator: Windows.Perception.Spatial.SpatialLocator;
+  }
+  var IHolographicDisplay: abstract new (...args: any[]) => IHolographicDisplay;
+
+  interface IHolographicDisplay2 {
+    readonly RefreshRate: number;
+  }
+  var IHolographicDisplay2: abstract new (...args: any[]) => IHolographicDisplay2;
+
+  interface IHolographicDisplay3 {
+    TryGetViewConfiguration(kind: number): Windows.Graphics.Holographic.HolographicViewConfiguration;
+  }
+  var IHolographicDisplay3: abstract new (...args: any[]) => IHolographicDisplay3;
+
+  interface IHolographicDisplayStatics {
+    GetDefault(): Windows.Graphics.Holographic.HolographicDisplay;
+  }
+  var IHolographicDisplayStatics: abstract new (...args: any[]) => IHolographicDisplayStatics;
+
+  interface IHolographicFrame {
+    GetRenderingParameters(cameraPose: Windows.Graphics.Holographic.HolographicCameraPose): Windows.Graphics.Holographic.HolographicCameraRenderingParameters;
+    PresentUsingCurrentPrediction(): number;
+    PresentUsingCurrentPrediction(waitBehavior: number): number;
+    UpdateCurrentPrediction(): void;
+    WaitForFrameToFinish(): void;
+    readonly AddedCameras: Windows.Foundation.Collections.IVectorView<Windows.Graphics.Holographic.HolographicCamera> | Windows.Graphics.Holographic.HolographicCamera[];
+    readonly CurrentPrediction: Windows.Graphics.Holographic.HolographicFramePrediction;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly RemovedCameras: Windows.Foundation.Collections.IVectorView<Windows.Graphics.Holographic.HolographicCamera> | Windows.Graphics.Holographic.HolographicCamera[];
+  }
+  var IHolographicFrame: abstract new (...args: any[]) => IHolographicFrame;
+
+  interface IHolographicFrame2 extends Windows.Graphics.Holographic.IHolographicFrame {
+    GetQuadLayerUpdateParameters(layer: Windows.Graphics.Holographic.HolographicQuadLayer): Windows.Graphics.Holographic.HolographicQuadLayerUpdateParameters;
+    GetRenderingParameters(cameraPose: Windows.Graphics.Holographic.HolographicCameraPose): Windows.Graphics.Holographic.HolographicCameraRenderingParameters;
+    PresentUsingCurrentPrediction(): number;
+    PresentUsingCurrentPrediction(waitBehavior: number): number;
+    UpdateCurrentPrediction(): void;
+    WaitForFrameToFinish(): void;
+  }
+  var IHolographicFrame2: abstract new (...args: any[]) => IHolographicFrame2;
+
+  interface IHolographicFrame3 {
+    readonly Id: Windows.Graphics.Holographic.HolographicFrameId;
+  }
+  var IHolographicFrame3: abstract new (...args: any[]) => IHolographicFrame3;
+
+  interface IHolographicFramePrediction {
+    readonly CameraPoses: Windows.Foundation.Collections.IVectorView<Windows.Graphics.Holographic.HolographicCameraPose> | Windows.Graphics.Holographic.HolographicCameraPose[];
+    readonly Timestamp: Windows.Perception.PerceptionTimestamp;
+  }
+  var IHolographicFramePrediction: abstract new (...args: any[]) => IHolographicFramePrediction;
+
+  interface IHolographicFramePresentationMonitor extends Windows.Foundation.IClosable {
+    Close(): void;
+    ReadReports(): Windows.Foundation.Collections.IVectorView<Windows.Graphics.Holographic.HolographicFramePresentationReport> | Windows.Graphics.Holographic.HolographicFramePresentationReport[];
+  }
+  var IHolographicFramePresentationMonitor: abstract new (...args: any[]) => IHolographicFramePresentationMonitor;
+
+  interface IHolographicFramePresentationReport {
+    readonly AppGpuDuration: Windows.Foundation.TimeSpan;
+    readonly AppGpuOverrun: Windows.Foundation.TimeSpan;
+    readonly CompositorGpuDuration: Windows.Foundation.TimeSpan;
+    readonly MissedPresentationOpportunityCount: number;
+    readonly PresentationCount: number;
+  }
+  var IHolographicFramePresentationReport: abstract new (...args: any[]) => IHolographicFramePresentationReport;
+
+  interface IHolographicFrameRenderingReport {
+    readonly FrameId: Windows.Graphics.Holographic.HolographicFrameId;
+    readonly MissedLatchCount: number;
+    readonly SystemRelativeActualGpuFinishTime: Windows.Foundation.TimeSpan;
+    readonly SystemRelativeFrameReadyTime: Windows.Foundation.TimeSpan;
+    readonly SystemRelativeTargetLatchTime: Windows.Foundation.TimeSpan;
+  }
+  var IHolographicFrameRenderingReport: abstract new (...args: any[]) => IHolographicFrameRenderingReport;
+
+  interface IHolographicFrameScanoutMonitor extends Windows.Foundation.IClosable {
+    Close(): void;
+    ReadReports(): Windows.Foundation.Collections.IVector<Windows.Graphics.Holographic.HolographicFrameScanoutReport> | Windows.Graphics.Holographic.HolographicFrameScanoutReport[];
+  }
+  var IHolographicFrameScanoutMonitor: abstract new (...args: any[]) => IHolographicFrameScanoutMonitor;
+
+  interface IHolographicFrameScanoutReport {
+    readonly MissedScanoutCount: number;
+    readonly RenderingReport: Windows.Graphics.Holographic.HolographicFrameRenderingReport;
+    readonly SystemRelativeLatchTime: Windows.Foundation.TimeSpan;
+    readonly SystemRelativePhotonTime: Windows.Foundation.TimeSpan;
+    readonly SystemRelativeScanoutStartTime: Windows.Foundation.TimeSpan;
+  }
+  var IHolographicFrameScanoutReport: abstract new (...args: any[]) => IHolographicFrameScanoutReport;
+
+  interface IHolographicQuadLayer {
+    readonly PixelFormat: number;
+    readonly Size: Windows.Foundation.Size;
+  }
+  var IHolographicQuadLayer: abstract new (...args: any[]) => IHolographicQuadLayer;
+
+  interface IHolographicQuadLayerFactory {
+    Create(size: Windows.Foundation.Size): Windows.Graphics.Holographic.HolographicQuadLayer;
+    CreateWithPixelFormat(size: Windows.Foundation.Size, pixelFormat: number): Windows.Graphics.Holographic.HolographicQuadLayer;
+  }
+  var IHolographicQuadLayerFactory: abstract new (...args: any[]) => IHolographicQuadLayerFactory;
+
+  interface IHolographicQuadLayerUpdateParameters {
+    AcquireBufferToUpdateContent(): Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface;
+    UpdateContentProtectionEnabled(value: boolean): void;
+    UpdateExtents(value: Windows.Foundation.Numerics.Vector2): void;
+    UpdateLocationWithDisplayRelativeMode(position: Windows.Foundation.Numerics.Vector3, orientation: Windows.Foundation.Numerics.Quaternion): void;
+    UpdateLocationWithStationaryMode(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, position: Windows.Foundation.Numerics.Vector3, orientation: Windows.Foundation.Numerics.Quaternion): void;
+    UpdateViewport(value: Windows.Foundation.Rect): void;
+  }
+  var IHolographicQuadLayerUpdateParameters: abstract new (...args: any[]) => IHolographicQuadLayerUpdateParameters;
+
+  interface IHolographicQuadLayerUpdateParameters2 {
+    AcquireBufferToUpdateContentWithHardwareProtection(): Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface;
+    readonly CanAcquireWithHardwareProtection: boolean;
+  }
+  var IHolographicQuadLayerUpdateParameters2: abstract new (...args: any[]) => IHolographicQuadLayerUpdateParameters2;
+
+  interface IHolographicSpace {
+    CreateNextFrame(): Windows.Graphics.Holographic.HolographicFrame;
+    SetDirect3D11Device(value: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice): void;
+    readonly PrimaryAdapterId: Windows.Graphics.Holographic.HolographicAdapterId;
+    CameraAdded: Windows.Foundation.TypedEventHandler<Windows.Graphics.Holographic.HolographicSpace, Windows.Graphics.Holographic.HolographicSpaceCameraAddedEventArgs> | null;
+    CameraRemoved: Windows.Foundation.TypedEventHandler<Windows.Graphics.Holographic.HolographicSpace, Windows.Graphics.Holographic.HolographicSpaceCameraRemovedEventArgs> | null;
+  }
+  var IHolographicSpace: abstract new (...args: any[]) => IHolographicSpace;
+
+  interface IHolographicSpace2 {
+    CreateFramePresentationMonitor(maxQueuedReports: number): Windows.Graphics.Holographic.HolographicFramePresentationMonitor;
+    WaitForNextFrameReady(): void;
+    WaitForNextFrameReadyWithHeadStart(requestedHeadStartDuration: Windows.Foundation.TimeSpan): void;
+    readonly UserPresence: number;
+    UserPresenceChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Holographic.HolographicSpace, Object> | null;
+  }
+  var IHolographicSpace2: abstract new (...args: any[]) => IHolographicSpace2;
+
+  interface IHolographicSpace3 {
+    CreateFrameScanoutMonitor(maxQueuedReports: number): Windows.Graphics.Holographic.HolographicFrameScanoutMonitor;
+  }
+  var IHolographicSpace3: abstract new (...args: any[]) => IHolographicSpace3;
+
+  interface IHolographicSpaceCameraAddedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Camera: Windows.Graphics.Holographic.HolographicCamera;
+  }
+  var IHolographicSpaceCameraAddedEventArgs: abstract new (...args: any[]) => IHolographicSpaceCameraAddedEventArgs;
+
+  interface IHolographicSpaceCameraRemovedEventArgs {
+    readonly Camera: Windows.Graphics.Holographic.HolographicCamera;
+  }
+  var IHolographicSpaceCameraRemovedEventArgs: abstract new (...args: any[]) => IHolographicSpaceCameraRemovedEventArgs;
+
+  interface IHolographicSpaceStatics {
+    CreateForCoreWindow(window: Windows.UI.Core.CoreWindow): Windows.Graphics.Holographic.HolographicSpace;
+  }
+  var IHolographicSpaceStatics: abstract new (...args: any[]) => IHolographicSpaceStatics;
+
+  interface IHolographicSpaceStatics2 {
+    readonly IsAvailable: boolean;
+    readonly IsSupported: boolean;
+    IsAvailableChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IHolographicSpaceStatics2: abstract new (...args: any[]) => IHolographicSpaceStatics2;
+
+  interface IHolographicSpaceStatics3 {
+    readonly IsConfigured: boolean;
+  }
+  var IHolographicSpaceStatics3: abstract new (...args: any[]) => IHolographicSpaceStatics3;
+
+  interface IHolographicViewConfiguration {
+    RequestRenderTargetSize(size: Windows.Foundation.Size): Windows.Foundation.Size;
+    readonly Display: Windows.Graphics.Holographic.HolographicDisplay;
+    IsEnabled: boolean;
+    readonly IsStereo: boolean;
+    readonly Kind: number;
+    readonly NativeRenderTargetSize: Windows.Foundation.Size;
+    PixelFormat: number;
+    readonly RefreshRate: number;
+    readonly RenderTargetSize: Windows.Foundation.Size;
+    readonly SupportedPixelFormats: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IHolographicViewConfiguration: abstract new (...args: any[]) => IHolographicViewConfiguration;
+
+  interface IHolographicViewConfiguration2 {
+    readonly SupportedDepthReprojectionMethods: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IHolographicViewConfiguration2: abstract new (...args: any[]) => IHolographicViewConfiguration2;
+
+}
+
+declare namespace Windows.Graphics.Imaging {
+  class BitmapBuffer implements Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer, Windows.Graphics.Imaging.IBitmapBuffer {
+    Close(): void;
+    CreateReference(): Windows.Foundation.IMemoryBufferReference;
+    GetPlaneCount(): number;
+    GetPlaneDescription(index: number): Windows.Graphics.Imaging.BitmapPlaneDescription;
+  }
+
+  class BitmapCodecInformation implements Windows.Graphics.Imaging.IBitmapCodecInformation {
+    readonly CodecId: Guid;
+    readonly FileExtensions: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly FriendlyName: string;
+    readonly MimeTypes: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+
+  class BitmapDecoder implements Windows.Graphics.Imaging.IBitmapDecoder, Windows.Graphics.Imaging.IBitmapFrame, Windows.Graphics.Imaging.IBitmapFrameWithSoftwareBitmap {
+    static CreateAsync(stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.BitmapDecoder>;
+    static CreateAsync(decoderId: Guid, stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.BitmapDecoder>;
+    static GetDecoderInformationEnumerator(): Windows.Foundation.Collections.IVectorView<Windows.Graphics.Imaging.BitmapCodecInformation> | Windows.Graphics.Imaging.BitmapCodecInformation[];
+    GetFrameAsync(frameIndex: number): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.BitmapFrame>;
+    GetPixelDataAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.PixelDataProvider>;
+    GetPixelDataAsync(pixelFormat: number, alphaMode: number, transform: Windows.Graphics.Imaging.BitmapTransform, exifOrientationMode: number, colorManagementMode: number): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.PixelDataProvider>;
+    GetPreviewAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.ImageStream>;
+    GetSoftwareBitmapAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.SoftwareBitmap>;
+    GetSoftwareBitmapAsync(pixelFormat: number, alphaMode: number): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.SoftwareBitmap>;
+    GetSoftwareBitmapAsync(pixelFormat: number, alphaMode: number, transform: Windows.Graphics.Imaging.BitmapTransform, exifOrientationMode: number, colorManagementMode: number): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.SoftwareBitmap>;
+    GetThumbnailAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.ImageStream>;
+    readonly BitmapAlphaMode: number;
+    readonly BitmapContainerProperties: Windows.Graphics.Imaging.BitmapPropertiesView;
+    readonly BitmapPixelFormat: number;
+    readonly BitmapProperties: Windows.Graphics.Imaging.BitmapPropertiesView;
+    static readonly BmpDecoderId: Guid;
+    readonly DecoderInformation: Windows.Graphics.Imaging.BitmapCodecInformation;
+    readonly DpiX: number;
+    readonly DpiY: number;
+    readonly FrameCount: number;
+    static readonly GifDecoderId: Guid;
+    static readonly HeifDecoderId: Guid;
+    static readonly IcoDecoderId: Guid;
+    static readonly JpegDecoderId: Guid;
+    static readonly JpegXRDecoderId: Guid;
+    readonly OrientedPixelHeight: number;
+    readonly OrientedPixelWidth: number;
+    readonly PixelHeight: number;
+    readonly PixelWidth: number;
+    static readonly PngDecoderId: Guid;
+    static readonly TiffDecoderId: Guid;
+    static readonly WebpDecoderId: Guid;
+  }
+
+  class BitmapEncoder implements Windows.Graphics.Imaging.IBitmapEncoder, Windows.Graphics.Imaging.IBitmapEncoderWithSoftwareBitmap {
+    static CreateAsync(encoderId: Guid, stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.BitmapEncoder>;
+    static CreateAsync(encoderId: Guid, stream: Windows.Storage.Streams.IRandomAccessStream, encodingOptions: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Graphics.Imaging.BitmapTypedValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Graphics.Imaging.BitmapTypedValue>[]): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.BitmapEncoder>;
+    static CreateForInPlacePropertyEncodingAsync(bitmapDecoder: Windows.Graphics.Imaging.BitmapDecoder): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.BitmapEncoder>;
+    static CreateForTranscodingAsync(stream: Windows.Storage.Streams.IRandomAccessStream, bitmapDecoder: Windows.Graphics.Imaging.BitmapDecoder): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.BitmapEncoder>;
+    FlushAsync(): Windows.Foundation.IAsyncAction;
+    static GetEncoderInformationEnumerator(): Windows.Foundation.Collections.IVectorView<Windows.Graphics.Imaging.BitmapCodecInformation> | Windows.Graphics.Imaging.BitmapCodecInformation[];
+    GoToNextFrameAsync(): Windows.Foundation.IAsyncAction;
+    GoToNextFrameAsync(encodingOptions: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Graphics.Imaging.BitmapTypedValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Graphics.Imaging.BitmapTypedValue>[]): Windows.Foundation.IAsyncAction;
+    SetPixelData(pixelFormat: number, alphaMode: number, width: number, height: number, dpiX: number, dpiY: number, pixels: number[]): void;
+    SetSoftwareBitmap(bitmap: Windows.Graphics.Imaging.SoftwareBitmap): void;
+    readonly BitmapContainerProperties: Windows.Graphics.Imaging.BitmapProperties;
+    readonly BitmapProperties: Windows.Graphics.Imaging.BitmapProperties;
+    readonly BitmapTransform: Windows.Graphics.Imaging.BitmapTransform;
+    static readonly BmpEncoderId: Guid;
+    readonly EncoderInformation: Windows.Graphics.Imaging.BitmapCodecInformation;
+    GeneratedThumbnailHeight: number;
+    GeneratedThumbnailWidth: number;
+    static readonly GifEncoderId: Guid;
+    static readonly HeifEncoderId: Guid;
+    IsThumbnailGenerated: boolean;
+    static readonly JpegEncoderId: Guid;
+    static readonly JpegXREncoderId: Guid;
+    static readonly PngEncoderId: Guid;
+    static readonly TiffEncoderId: Guid;
+  }
+
+  class BitmapFrame implements Windows.Graphics.Imaging.IBitmapFrame, Windows.Graphics.Imaging.IBitmapFrameWithSoftwareBitmap {
+    GetPixelDataAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.PixelDataProvider>;
+    GetPixelDataAsync(pixelFormat: number, alphaMode: number, transform: Windows.Graphics.Imaging.BitmapTransform, exifOrientationMode: number, colorManagementMode: number): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.PixelDataProvider>;
+    GetSoftwareBitmapAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.SoftwareBitmap>;
+    GetSoftwareBitmapAsync(pixelFormat: number, alphaMode: number): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.SoftwareBitmap>;
+    GetSoftwareBitmapAsync(pixelFormat: number, alphaMode: number, transform: Windows.Graphics.Imaging.BitmapTransform, exifOrientationMode: number, colorManagementMode: number): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.SoftwareBitmap>;
+    GetThumbnailAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.ImageStream>;
+    readonly BitmapAlphaMode: number;
+    readonly BitmapPixelFormat: number;
+    readonly BitmapProperties: Windows.Graphics.Imaging.BitmapPropertiesView;
+    readonly DpiX: number;
+    readonly DpiY: number;
+    readonly OrientedPixelHeight: number;
+    readonly OrientedPixelWidth: number;
+    readonly PixelHeight: number;
+    readonly PixelWidth: number;
+  }
+
+  class BitmapProperties implements Windows.Graphics.Imaging.IBitmapProperties, Windows.Graphics.Imaging.IBitmapPropertiesView {
+    GetPropertiesAsync(propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.BitmapPropertySet>;
+    SetPropertiesAsync(propertiesToSet: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Graphics.Imaging.BitmapTypedValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Graphics.Imaging.BitmapTypedValue>[]): Windows.Foundation.IAsyncAction;
+  }
+
+  class BitmapPropertiesView implements Windows.Graphics.Imaging.IBitmapPropertiesView {
+    GetPropertiesAsync(propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.BitmapPropertySet>;
+  }
+
+  class BitmapPropertySet {
+    constructor();
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Graphics.Imaging.BitmapTypedValue>>;
+    GetView(): Windows.Foundation.Collections.IMapView<string, Windows.Graphics.Imaging.BitmapTypedValue>;
+    HasKey(key: string): boolean;
+    Insert(key: string, value: Windows.Graphics.Imaging.BitmapTypedValue): boolean;
+    Lookup(key: string): Windows.Graphics.Imaging.BitmapTypedValue;
+    Remove(key: string): void;
+    readonly Size: number;
+  }
+
+  class BitmapTransform implements Windows.Graphics.Imaging.IBitmapTransform {
+    constructor();
+    Bounds: Windows.Graphics.Imaging.BitmapBounds;
+    Flip: number;
+    InterpolationMode: number;
+    Rotation: number;
+    ScaledHeight: number;
+    ScaledWidth: number;
+  }
+
+  class BitmapTypedValue implements Windows.Graphics.Imaging.IBitmapTypedValue {
+    constructor(value: Object, type: number);
+    readonly Type: number;
+    readonly Value: Object;
+  }
+
+  class ImageStream implements Windows.Foundation.IClosable, Windows.Storage.Streams.IContentTypeProvider, Windows.Storage.Streams.IInputStream, Windows.Storage.Streams.IOutputStream, Windows.Storage.Streams.IRandomAccessStream, Windows.Storage.Streams.IRandomAccessStreamWithContentType {
+    CloneStream(): Windows.Storage.Streams.IRandomAccessStream;
+    Close(): void;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    GetInputStreamAt(position: number | bigint): Windows.Storage.Streams.IInputStream;
+    GetOutputStreamAt(position: number | bigint): Windows.Storage.Streams.IOutputStream;
+    ReadAsync(buffer: Windows.Storage.Streams.IBuffer, count: number, options: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number>;
+    Seek(position: number | bigint): void;
+    WriteAsync(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    readonly CanRead: boolean;
+    readonly CanWrite: boolean;
+    readonly ContentType: string;
+    readonly Position: number | bigint;
+    Size: number | bigint;
+  }
+
+  class PixelDataProvider implements Windows.Graphics.Imaging.IPixelDataProvider {
+    DetachPixelData(): number[];
+  }
+
+  class SoftwareBitmap implements Windows.Foundation.IClosable, Windows.Graphics.Imaging.ISoftwareBitmap {
+    constructor(format: number, width: number, height: number);
+    constructor(format: number, width: number, height: number, alpha: number);
+    Close(): void;
+    static Convert(source: Windows.Graphics.Imaging.SoftwareBitmap, format: number): Windows.Graphics.Imaging.SoftwareBitmap;
+    static Convert(source: Windows.Graphics.Imaging.SoftwareBitmap, format: number, alpha: number): Windows.Graphics.Imaging.SoftwareBitmap;
+    static Copy(source: Windows.Graphics.Imaging.SoftwareBitmap): Windows.Graphics.Imaging.SoftwareBitmap;
+    CopyFromBuffer(buffer: Windows.Storage.Streams.IBuffer): void;
+    CopyTo(bitmap: Windows.Graphics.Imaging.SoftwareBitmap): void;
+    CopyToBuffer(buffer: Windows.Storage.Streams.IBuffer): void;
+    static CreateCopyFromBuffer(source: Windows.Storage.Streams.IBuffer, format: number, width: number, height: number): Windows.Graphics.Imaging.SoftwareBitmap;
+    static CreateCopyFromBuffer(source: Windows.Storage.Streams.IBuffer, format: number, width: number, height: number, alpha: number): Windows.Graphics.Imaging.SoftwareBitmap;
+    static CreateCopyFromSurfaceAsync(surface: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.SoftwareBitmap>;
+    static CreateCopyFromSurfaceAsync(surface: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface, alpha: number): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.SoftwareBitmap>;
+    GetReadOnlyView(): Windows.Graphics.Imaging.SoftwareBitmap;
+    LockBuffer(mode: number): Windows.Graphics.Imaging.BitmapBuffer;
+    readonly BitmapAlphaMode: number;
+    readonly BitmapPixelFormat: number;
+    DpiX: number;
+    DpiY: number;
+    readonly IsReadOnly: boolean;
+    readonly PixelHeight: number;
+    readonly PixelWidth: number;
+  }
+
+  enum BitmapAlphaMode {
+    Premultiplied = 0,
+    Straight = 1,
+    Ignore = 2,
+  }
+
+  enum BitmapBufferAccessMode {
+    Read = 0,
+    ReadWrite = 1,
+    Write = 2,
+  }
+
+  enum BitmapFlip {
+    None = 0,
+    Horizontal = 1,
+    Vertical = 2,
+  }
+
+  enum BitmapInterpolationMode {
+    NearestNeighbor = 0,
+    Linear = 1,
+    Cubic = 2,
+    Fant = 3,
+  }
+
+  enum BitmapPixelFormat {
+    Unknown = 0,
+    Rgba16 = 12,
+    Rgba8 = 30,
+    Gray16 = 57,
+    Gray8 = 62,
+    Bgra8 = 87,
+    Nv12 = 103,
+    P010 = 104,
+    Yuy2 = 107,
+  }
+
+  enum BitmapRotation {
+    None = 0,
+    Clockwise90Degrees = 1,
+    Clockwise180Degrees = 2,
+    Clockwise270Degrees = 3,
+  }
+
+  enum ColorManagementMode {
+    DoNotColorManage = 0,
+    ColorManageToSRgb = 1,
+  }
+
+  enum ExifOrientationMode {
+    IgnoreExifOrientation = 0,
+    RespectExifOrientation = 1,
+  }
+
+  enum JpegSubsamplingMode {
+    Default = 0,
+    Y4Cb2Cr0 = 1,
+    Y4Cb2Cr2 = 2,
+    Y4Cb4Cr4 = 3,
+  }
+
+  enum PngFilterMode {
+    Automatic = 0,
+    None = 1,
+    Sub = 2,
+    Up = 3,
+    Average = 4,
+    Paeth = 5,
+    Adaptive = 6,
+  }
+
+  enum TiffCompressionMode {
+    Automatic = 0,
+    None = 1,
+    Ccitt3 = 2,
+    Ccitt4 = 3,
+    Lzw = 4,
+    Rle = 5,
+    Zip = 6,
+    LzwhDifferencing = 7,
+  }
+
+  interface BitmapBounds {
+    X: number;
+    Y: number;
+    Width: number;
+    Height: number;
+  }
+  var BitmapBounds: {
+    new(x: number, y: number, width: number, height: number): BitmapBounds;
+    new(fields: { X?: number; Y?: number; Width?: number; Height?: number }): BitmapBounds;
+  };
+
+  interface BitmapPlaneDescription {
+    StartIndex: number;
+    Width: number;
+    Height: number;
+    Stride: number;
+  }
+  var BitmapPlaneDescription: {
+    new(startIndex: number, width: number, height: number, stride: number): BitmapPlaneDescription;
+    new(fields: { StartIndex?: number; Width?: number; Height?: number; Stride?: number }): BitmapPlaneDescription;
+  };
+
+  interface BitmapSize {
+    Width: number;
+    Height: number;
+  }
+  var BitmapSize: {
+    new(width: number, height: number): BitmapSize;
+    new(fields: { Width?: number; Height?: number }): BitmapSize;
+  };
+
+  interface IBitmapBuffer extends Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+    Close(): void;
+    CreateReference(): Windows.Foundation.IMemoryBufferReference;
+    GetPlaneCount(): number;
+    GetPlaneDescription(index: number): Windows.Graphics.Imaging.BitmapPlaneDescription;
+  }
+  var IBitmapBuffer: abstract new (...args: any[]) => IBitmapBuffer;
+
+  interface IBitmapCodecInformation {
+    readonly CodecId: Guid;
+    readonly FileExtensions: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly FriendlyName: string;
+    readonly MimeTypes: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var IBitmapCodecInformation: abstract new (...args: any[]) => IBitmapCodecInformation;
+
+  interface IBitmapDecoder {
+    GetFrameAsync(frameIndex: number): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.BitmapFrame>;
+    GetPreviewAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.ImageStream>;
+    readonly BitmapContainerProperties: Windows.Graphics.Imaging.BitmapPropertiesView;
+    readonly DecoderInformation: Windows.Graphics.Imaging.BitmapCodecInformation;
+    readonly FrameCount: number;
+  }
+  var IBitmapDecoder: abstract new (...args: any[]) => IBitmapDecoder;
+
+  interface IBitmapDecoderStatics {
+    CreateAsync(stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.BitmapDecoder>;
+    CreateAsync(decoderId: Guid, stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.BitmapDecoder>;
+    GetDecoderInformationEnumerator(): Windows.Foundation.Collections.IVectorView<Windows.Graphics.Imaging.BitmapCodecInformation> | Windows.Graphics.Imaging.BitmapCodecInformation[];
+    readonly BmpDecoderId: Guid;
+    readonly GifDecoderId: Guid;
+    readonly IcoDecoderId: Guid;
+    readonly JpegDecoderId: Guid;
+    readonly JpegXRDecoderId: Guid;
+    readonly PngDecoderId: Guid;
+    readonly TiffDecoderId: Guid;
+  }
+  var IBitmapDecoderStatics: abstract new (...args: any[]) => IBitmapDecoderStatics;
+
+  interface IBitmapDecoderStatics2 {
+    readonly HeifDecoderId: Guid;
+    readonly WebpDecoderId: Guid;
+  }
+  var IBitmapDecoderStatics2: abstract new (...args: any[]) => IBitmapDecoderStatics2;
+
+  interface IBitmapEncoder {
+    FlushAsync(): Windows.Foundation.IAsyncAction;
+    GoToNextFrameAsync(): Windows.Foundation.IAsyncAction;
+    GoToNextFrameAsync(encodingOptions: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Graphics.Imaging.BitmapTypedValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Graphics.Imaging.BitmapTypedValue>[]): Windows.Foundation.IAsyncAction;
+    SetPixelData(pixelFormat: number, alphaMode: number, width: number, height: number, dpiX: number, dpiY: number, pixels: number[]): void;
+    readonly BitmapContainerProperties: Windows.Graphics.Imaging.BitmapProperties;
+    readonly BitmapProperties: Windows.Graphics.Imaging.BitmapProperties;
+    readonly BitmapTransform: Windows.Graphics.Imaging.BitmapTransform;
+    readonly EncoderInformation: Windows.Graphics.Imaging.BitmapCodecInformation;
+    GeneratedThumbnailHeight: number;
+    GeneratedThumbnailWidth: number;
+    IsThumbnailGenerated: boolean;
+  }
+  var IBitmapEncoder: abstract new (...args: any[]) => IBitmapEncoder;
+
+  interface IBitmapEncoderStatics {
+    CreateAsync(encoderId: Guid, stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.BitmapEncoder>;
+    CreateAsync(encoderId: Guid, stream: Windows.Storage.Streams.IRandomAccessStream, encodingOptions: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Graphics.Imaging.BitmapTypedValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Graphics.Imaging.BitmapTypedValue>[]): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.BitmapEncoder>;
+    CreateForInPlacePropertyEncodingAsync(bitmapDecoder: Windows.Graphics.Imaging.BitmapDecoder): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.BitmapEncoder>;
+    CreateForTranscodingAsync(stream: Windows.Storage.Streams.IRandomAccessStream, bitmapDecoder: Windows.Graphics.Imaging.BitmapDecoder): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.BitmapEncoder>;
+    GetEncoderInformationEnumerator(): Windows.Foundation.Collections.IVectorView<Windows.Graphics.Imaging.BitmapCodecInformation> | Windows.Graphics.Imaging.BitmapCodecInformation[];
+    readonly BmpEncoderId: Guid;
+    readonly GifEncoderId: Guid;
+    readonly JpegEncoderId: Guid;
+    readonly JpegXREncoderId: Guid;
+    readonly PngEncoderId: Guid;
+    readonly TiffEncoderId: Guid;
+  }
+  var IBitmapEncoderStatics: abstract new (...args: any[]) => IBitmapEncoderStatics;
+
+  interface IBitmapEncoderStatics2 {
+    readonly HeifEncoderId: Guid;
+  }
+  var IBitmapEncoderStatics2: abstract new (...args: any[]) => IBitmapEncoderStatics2;
+
+  interface IBitmapEncoderWithSoftwareBitmap {
+    SetSoftwareBitmap(bitmap: Windows.Graphics.Imaging.SoftwareBitmap): void;
+  }
+  var IBitmapEncoderWithSoftwareBitmap: abstract new (...args: any[]) => IBitmapEncoderWithSoftwareBitmap;
+
+  interface IBitmapFrame {
+    GetPixelDataAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.PixelDataProvider>;
+    GetPixelDataAsync(pixelFormat: number, alphaMode: number, transform: Windows.Graphics.Imaging.BitmapTransform, exifOrientationMode: number, colorManagementMode: number): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.PixelDataProvider>;
+    GetThumbnailAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.ImageStream>;
+    readonly BitmapAlphaMode: number;
+    readonly BitmapPixelFormat: number;
+    readonly BitmapProperties: Windows.Graphics.Imaging.BitmapPropertiesView;
+    readonly DpiX: number;
+    readonly DpiY: number;
+    readonly OrientedPixelHeight: number;
+    readonly OrientedPixelWidth: number;
+    readonly PixelHeight: number;
+    readonly PixelWidth: number;
+  }
+  var IBitmapFrame: abstract new (...args: any[]) => IBitmapFrame;
+
+  interface IBitmapFrameWithSoftwareBitmap extends Windows.Graphics.Imaging.IBitmapFrame {
+    GetPixelDataAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.PixelDataProvider>;
+    GetPixelDataAsync(pixelFormat: number, alphaMode: number, transform: Windows.Graphics.Imaging.BitmapTransform, exifOrientationMode: number, colorManagementMode: number): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.PixelDataProvider>;
+    GetSoftwareBitmapAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.SoftwareBitmap>;
+    GetSoftwareBitmapAsync(pixelFormat: number, alphaMode: number): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.SoftwareBitmap>;
+    GetSoftwareBitmapAsync(pixelFormat: number, alphaMode: number, transform: Windows.Graphics.Imaging.BitmapTransform, exifOrientationMode: number, colorManagementMode: number): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.SoftwareBitmap>;
+    GetThumbnailAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.ImageStream>;
+  }
+  var IBitmapFrameWithSoftwareBitmap: abstract new (...args: any[]) => IBitmapFrameWithSoftwareBitmap;
+
+  interface IBitmapProperties extends Windows.Graphics.Imaging.IBitmapPropertiesView {
+    GetPropertiesAsync(propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.BitmapPropertySet>;
+    SetPropertiesAsync(propertiesToSet: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Graphics.Imaging.BitmapTypedValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Graphics.Imaging.BitmapTypedValue>[]): Windows.Foundation.IAsyncAction;
+  }
+  var IBitmapProperties: abstract new (...args: any[]) => IBitmapProperties;
+
+  interface IBitmapPropertiesView {
+    GetPropertiesAsync(propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.BitmapPropertySet>;
+  }
+  var IBitmapPropertiesView: abstract new (...args: any[]) => IBitmapPropertiesView;
+
+  interface IBitmapTransform {
+    Bounds: Windows.Graphics.Imaging.BitmapBounds;
+    Flip: number;
+    InterpolationMode: number;
+    Rotation: number;
+    ScaledHeight: number;
+    ScaledWidth: number;
+  }
+  var IBitmapTransform: abstract new (...args: any[]) => IBitmapTransform;
+
+  interface IBitmapTypedValue {
+    readonly Type: number;
+    readonly Value: Object;
+  }
+  var IBitmapTypedValue: abstract new (...args: any[]) => IBitmapTypedValue;
+
+  interface IBitmapTypedValueFactory {
+    Create(value: Object, type: number): Windows.Graphics.Imaging.BitmapTypedValue;
+  }
+  var IBitmapTypedValueFactory: abstract new (...args: any[]) => IBitmapTypedValueFactory;
+
+  interface IPixelDataProvider {
+    DetachPixelData(): number[];
+  }
+  var IPixelDataProvider: abstract new (...args: any[]) => IPixelDataProvider;
+
+  interface ISoftwareBitmap extends Windows.Foundation.IClosable {
+    Close(): void;
+    CopyFromBuffer(buffer: Windows.Storage.Streams.IBuffer): void;
+    CopyTo(bitmap: Windows.Graphics.Imaging.SoftwareBitmap): void;
+    CopyToBuffer(buffer: Windows.Storage.Streams.IBuffer): void;
+    GetReadOnlyView(): Windows.Graphics.Imaging.SoftwareBitmap;
+    LockBuffer(mode: number): Windows.Graphics.Imaging.BitmapBuffer;
+    readonly BitmapAlphaMode: number;
+    readonly BitmapPixelFormat: number;
+    DpiX: number;
+    DpiY: number;
+    readonly IsReadOnly: boolean;
+    readonly PixelHeight: number;
+    readonly PixelWidth: number;
+  }
+  var ISoftwareBitmap: abstract new (...args: any[]) => ISoftwareBitmap;
+
+  interface ISoftwareBitmapFactory {
+    Create(format: number, width: number, height: number): Windows.Graphics.Imaging.SoftwareBitmap;
+    CreateWithAlpha(format: number, width: number, height: number, alpha: number): Windows.Graphics.Imaging.SoftwareBitmap;
+  }
+  var ISoftwareBitmapFactory: abstract new (...args: any[]) => ISoftwareBitmapFactory;
+
+  interface ISoftwareBitmapStatics {
+    Convert(source: Windows.Graphics.Imaging.SoftwareBitmap, format: number): Windows.Graphics.Imaging.SoftwareBitmap;
+    Convert(source: Windows.Graphics.Imaging.SoftwareBitmap, format: number, alpha: number): Windows.Graphics.Imaging.SoftwareBitmap;
+    Copy(source: Windows.Graphics.Imaging.SoftwareBitmap): Windows.Graphics.Imaging.SoftwareBitmap;
+    CreateCopyFromBuffer(source: Windows.Storage.Streams.IBuffer, format: number, width: number, height: number): Windows.Graphics.Imaging.SoftwareBitmap;
+    CreateCopyFromBuffer(source: Windows.Storage.Streams.IBuffer, format: number, width: number, height: number, alpha: number): Windows.Graphics.Imaging.SoftwareBitmap;
+    CreateCopyFromSurfaceAsync(surface: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.SoftwareBitmap>;
+    CreateCopyFromSurfaceAsync(surface: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface, alpha: number): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.SoftwareBitmap>;
+  }
+  var ISoftwareBitmapStatics: abstract new (...args: any[]) => ISoftwareBitmapStatics;
+
+}
+
+declare namespace Windows.Graphics.Printing {
+  class PrintManager implements Windows.Graphics.Printing.IPrintManager {
+    static GetForCurrentView(): Windows.Graphics.Printing.PrintManager;
+    static IsSupported(): boolean;
+    static ShowPrintUIAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    PrintTaskRequested: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.PrintManager, Windows.Graphics.Printing.PrintTaskRequestedEventArgs> | null;
+  }
+
+  class PrintPageInfo implements Windows.Graphics.Printing.IPrintPageInfo {
+    constructor();
+    DpiX: number;
+    DpiY: number;
+    MediaSize: number;
+    Orientation: number;
+    PageSize: Windows.Foundation.Size;
+  }
+
+  class PrintPageRange implements Windows.Graphics.Printing.IPrintPageRange {
+    constructor(firstPage: number, lastPage: number);
+    constructor(page: number);
+    readonly FirstPageNumber: number;
+    readonly LastPageNumber: number;
+  }
+
+  class PrintPageRangeOptions implements Windows.Graphics.Printing.IPrintPageRangeOptions {
+    AllowAllPages: boolean;
+    AllowCurrentPage: boolean;
+    AllowCustomSetOfPages: boolean;
+  }
+
+  class PrintTask implements Windows.Graphics.Printing.IPrintTask, Windows.Graphics.Printing.IPrintTask2, Windows.Graphics.Printing.IPrintTaskTargetDeviceSupport {
+    Is3DManufacturingTargetEnabled: boolean;
+    IsPreviewEnabled: boolean;
+    IsPrinterTargetEnabled: boolean;
+    readonly Options: Windows.Graphics.Printing.PrintTaskOptions;
+    readonly Properties: Windows.ApplicationModel.DataTransfer.DataPackagePropertySet;
+    readonly Source: Windows.Graphics.Printing.IPrintDocumentSource;
+    Completed: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.PrintTask, Windows.Graphics.Printing.PrintTaskCompletedEventArgs> | null;
+    Previewing: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.PrintTask, Object> | null;
+    Progressing: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.PrintTask, Windows.Graphics.Printing.PrintTaskProgressingEventArgs> | null;
+    Submitting: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.PrintTask, Object> | null;
+  }
+
+  class PrintTaskCompletedEventArgs implements Windows.Graphics.Printing.IPrintTaskCompletedEventArgs {
+    readonly Completion: number;
+  }
+
+  class PrintTaskOptions implements Windows.Graphics.Printing.IPrintTaskOptions, Windows.Graphics.Printing.IPrintTaskOptions2, Windows.Graphics.Printing.IPrintTaskOptionsCore, Windows.Graphics.Printing.IPrintTaskOptionsCoreProperties, Windows.Graphics.Printing.IPrintTaskOptionsCoreUIConfiguration {
+    GetPageDescription(jobPageNumber: number): Windows.Graphics.Printing.PrintPageDescription;
+    GetPagePrintTicket(printPageInfo: Windows.Graphics.Printing.PrintPageInfo): Windows.Storage.Streams.IRandomAccessStream;
+    Binding: number;
+    Bordering: number;
+    Collation: number;
+    ColorMode: number;
+    readonly CustomPageRanges: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing.PrintPageRange> | Windows.Graphics.Printing.PrintPageRange[];
+    readonly DisplayedOptions: Windows.Foundation.Collections.IVector<string> | string[];
+    Duplex: number;
+    HolePunch: number;
+    readonly MaxCopies: number;
+    MediaSize: number;
+    MediaType: number;
+    readonly MinCopies: number;
+    NumberOfCopies: number;
+    Orientation: number;
+    readonly PageRangeOptions: Windows.Graphics.Printing.PrintPageRangeOptions;
+    PrintQuality: number;
+    Staple: number;
+  }
+
+  class PrintTaskProgressingEventArgs implements Windows.Graphics.Printing.IPrintTaskProgressingEventArgs {
+    readonly DocumentPageCount: number;
+  }
+
+  class PrintTaskRequest implements Windows.Graphics.Printing.IPrintTaskRequest {
+    CreatePrintTask(title: string, handler: Windows.Graphics.Printing.PrintTaskSourceRequestedHandler): Windows.Graphics.Printing.PrintTask;
+    GetDeferral(): Windows.Graphics.Printing.PrintTaskRequestedDeferral;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+
+  class PrintTaskRequestedDeferral implements Windows.Graphics.Printing.IPrintTaskRequestedDeferral {
+    Complete(): void;
+  }
+
+  class PrintTaskRequestedEventArgs implements Windows.Graphics.Printing.IPrintTaskRequestedEventArgs {
+    readonly Request: Windows.Graphics.Printing.PrintTaskRequest;
+  }
+
+  class PrintTaskSourceRequestedArgs implements Windows.Graphics.Printing.IPrintTaskSourceRequestedArgs {
+    GetDeferral(): Windows.Graphics.Printing.PrintTaskSourceRequestedDeferral;
+    SetSource(source: Windows.Graphics.Printing.IPrintDocumentSource): void;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+
+  class PrintTaskSourceRequestedDeferral implements Windows.Graphics.Printing.IPrintTaskSourceRequestedDeferral {
+    Complete(): void;
+  }
+
+  class StandardPrintTaskOptions {
+    static readonly Binding: string;
+    static readonly Bordering: string;
+    static readonly Collation: string;
+    static readonly ColorMode: string;
+    static readonly Copies: string;
+    static readonly CustomPageRanges: string;
+    static readonly Duplex: string;
+    static readonly HolePunch: string;
+    static readonly InputBin: string;
+    static readonly MediaSize: string;
+    static readonly MediaType: string;
+    static readonly NUp: string;
+    static readonly Orientation: string;
+    static readonly PrintQuality: string;
+    static readonly Staple: string;
+  }
+
+  enum PrintBinding {
+    Default = 0,
+    NotAvailable = 1,
+    PrinterCustom = 2,
+    None = 3,
+    Bale = 4,
+    BindBottom = 5,
+    BindLeft = 6,
+    BindRight = 7,
+    BindTop = 8,
+    Booklet = 9,
+    EdgeStitchBottom = 10,
+    EdgeStitchLeft = 11,
+    EdgeStitchRight = 12,
+    EdgeStitchTop = 13,
+    Fold = 14,
+    JogOffset = 15,
+    Trim = 16,
+  }
+
+  enum PrintBordering {
+    Default = 0,
+    NotAvailable = 1,
+    PrinterCustom = 2,
+    Bordered = 3,
+    Borderless = 4,
+  }
+
+  enum PrintCollation {
+    Default = 0,
+    NotAvailable = 1,
+    PrinterCustom = 2,
+    Collated = 3,
+    Uncollated = 4,
+  }
+
+  enum PrintColorMode {
+    Default = 0,
+    NotAvailable = 1,
+    PrinterCustom = 2,
+    Color = 3,
+    Grayscale = 4,
+    Monochrome = 5,
+    AutoSelect = 6,
+  }
+
+  enum PrintDuplex {
+    Default = 0,
+    NotAvailable = 1,
+    PrinterCustom = 2,
+    OneSided = 3,
+    TwoSidedShortEdge = 4,
+    TwoSidedLongEdge = 5,
+  }
+
+  enum PrintHolePunch {
+    Default = 0,
+    NotAvailable = 1,
+    PrinterCustom = 2,
+    None = 3,
+    LeftEdge = 4,
+    RightEdge = 5,
+    TopEdge = 6,
+    BottomEdge = 7,
+  }
+
+  enum PrintMediaSize {
+    Default = 0,
+    NotAvailable = 1,
+    PrinterCustom = 2,
+    BusinessCard = 3,
+    CreditCard = 4,
+    IsoA0 = 5,
+    IsoA1 = 6,
+    IsoA10 = 7,
+    IsoA2 = 8,
+    IsoA3 = 9,
+    IsoA3Extra = 10,
+    IsoA3Rotated = 11,
+    IsoA4 = 12,
+    IsoA4Extra = 13,
+    IsoA4Rotated = 14,
+    IsoA5 = 15,
+    IsoA5Extra = 16,
+    IsoA5Rotated = 17,
+    IsoA6 = 18,
+    IsoA6Rotated = 19,
+    IsoA7 = 20,
+    IsoA8 = 21,
+    IsoA9 = 22,
+    IsoB0 = 23,
+    IsoB1 = 24,
+    IsoB10 = 25,
+    IsoB2 = 26,
+    IsoB3 = 27,
+    IsoB4 = 28,
+    IsoB4Envelope = 29,
+    IsoB5Envelope = 30,
+    IsoB5Extra = 31,
+    IsoB7 = 32,
+    IsoB8 = 33,
+    IsoB9 = 34,
+    IsoC0 = 35,
+    IsoC1 = 36,
+    IsoC10 = 37,
+    IsoC2 = 38,
+    IsoC3 = 39,
+    IsoC3Envelope = 40,
+    IsoC4 = 41,
+    IsoC4Envelope = 42,
+    IsoC5 = 43,
+    IsoC5Envelope = 44,
+    IsoC6 = 45,
+    IsoC6C5Envelope = 46,
+    IsoC6Envelope = 47,
+    IsoC7 = 48,
+    IsoC8 = 49,
+    IsoC9 = 50,
+    IsoDLEnvelope = 51,
+    IsoDLEnvelopeRotated = 52,
+    IsoSRA3 = 53,
+    Japan2LPhoto = 54,
+    JapanChou3Envelope = 55,
+    JapanChou3EnvelopeRotated = 56,
+    JapanChou4Envelope = 57,
+    JapanChou4EnvelopeRotated = 58,
+    JapanDoubleHagakiPostcard = 59,
+    JapanDoubleHagakiPostcardRotated = 60,
+    JapanHagakiPostcard = 61,
+    JapanHagakiPostcardRotated = 62,
+    JapanKaku2Envelope = 63,
+    JapanKaku2EnvelopeRotated = 64,
+    JapanKaku3Envelope = 65,
+    JapanKaku3EnvelopeRotated = 66,
+    JapanLPhoto = 67,
+    JapanQuadrupleHagakiPostcard = 68,
+    JapanYou1Envelope = 69,
+    JapanYou2Envelope = 70,
+    JapanYou3Envelope = 71,
+    JapanYou4Envelope = 72,
+    JapanYou4EnvelopeRotated = 73,
+    JapanYou6Envelope = 74,
+    JapanYou6EnvelopeRotated = 75,
+    JisB0 = 76,
+    JisB1 = 77,
+    JisB10 = 78,
+    JisB2 = 79,
+    JisB3 = 80,
+    JisB4 = 81,
+    JisB4Rotated = 82,
+    JisB5 = 83,
+    JisB5Rotated = 84,
+    JisB6 = 85,
+    JisB6Rotated = 86,
+    JisB7 = 87,
+    JisB8 = 88,
+    JisB9 = 89,
+    NorthAmerica10x11 = 90,
+    NorthAmerica10x12 = 91,
+    NorthAmerica10x14 = 92,
+    NorthAmerica11x17 = 93,
+    NorthAmerica14x17 = 94,
+    NorthAmerica4x6 = 95,
+    NorthAmerica4x8 = 96,
+    NorthAmerica5x7 = 97,
+    NorthAmerica8x10 = 98,
+    NorthAmerica9x11 = 99,
+    NorthAmericaArchitectureASheet = 100,
+    NorthAmericaArchitectureBSheet = 101,
+    NorthAmericaArchitectureCSheet = 102,
+    NorthAmericaArchitectureDSheet = 103,
+    NorthAmericaArchitectureESheet = 104,
+    NorthAmericaCSheet = 105,
+    NorthAmericaDSheet = 106,
+    NorthAmericaESheet = 107,
+    NorthAmericaExecutive = 108,
+    NorthAmericaGermanLegalFanfold = 109,
+    NorthAmericaGermanStandardFanfold = 110,
+    NorthAmericaLegal = 111,
+    NorthAmericaLegalExtra = 112,
+    NorthAmericaLetter = 113,
+    NorthAmericaLetterExtra = 114,
+    NorthAmericaLetterPlus = 115,
+    NorthAmericaLetterRotated = 116,
+    NorthAmericaMonarchEnvelope = 117,
+    NorthAmericaNote = 118,
+    NorthAmericaNumber10Envelope = 119,
+    NorthAmericaNumber10EnvelopeRotated = 120,
+    NorthAmericaNumber11Envelope = 121,
+    NorthAmericaNumber12Envelope = 122,
+    NorthAmericaNumber14Envelope = 123,
+    NorthAmericaNumber9Envelope = 124,
+    NorthAmericaPersonalEnvelope = 125,
+    NorthAmericaQuarto = 126,
+    NorthAmericaStatement = 127,
+    NorthAmericaSuperA = 128,
+    NorthAmericaSuperB = 129,
+    NorthAmericaTabloid = 130,
+    NorthAmericaTabloidExtra = 131,
+    OtherMetricA3Plus = 132,
+    OtherMetricA4Plus = 133,
+    OtherMetricFolio = 134,
+    OtherMetricInviteEnvelope = 135,
+    OtherMetricItalianEnvelope = 136,
+    Prc10Envelope = 137,
+    Prc10EnvelopeRotated = 138,
+    Prc16K = 139,
+    Prc16KRotated = 140,
+    Prc1Envelope = 141,
+    Prc1EnvelopeRotated = 142,
+    Prc2Envelope = 143,
+    Prc2EnvelopeRotated = 144,
+    Prc32K = 145,
+    Prc32KBig = 146,
+    Prc32KRotated = 147,
+    Prc3Envelope = 148,
+    Prc3EnvelopeRotated = 149,
+    Prc4Envelope = 150,
+    Prc4EnvelopeRotated = 151,
+    Prc5Envelope = 152,
+    Prc5EnvelopeRotated = 153,
+    Prc6Envelope = 154,
+    Prc6EnvelopeRotated = 155,
+    Prc7Envelope = 156,
+    Prc7EnvelopeRotated = 157,
+    Prc8Envelope = 158,
+    Prc8EnvelopeRotated = 159,
+    Prc9Envelope = 160,
+    Prc9EnvelopeRotated = 161,
+    Roll04Inch = 162,
+    Roll06Inch = 163,
+    Roll08Inch = 164,
+    Roll12Inch = 165,
+    Roll15Inch = 166,
+    Roll18Inch = 167,
+    Roll22Inch = 168,
+    Roll24Inch = 169,
+    Roll30Inch = 170,
+    Roll36Inch = 171,
+    Roll54Inch = 172,
+  }
+
+  enum PrintMediaType {
+    Default = 0,
+    NotAvailable = 1,
+    PrinterCustom = 2,
+    AutoSelect = 3,
+    Archival = 4,
+    BackPrintFilm = 5,
+    Bond = 6,
+    CardStock = 7,
+    Continuous = 8,
+    EnvelopePlain = 9,
+    EnvelopeWindow = 10,
+    Fabric = 11,
+    HighResolution = 12,
+    Label = 13,
+    MultiLayerForm = 14,
+    MultiPartForm = 15,
+    Photographic = 16,
+    PhotographicFilm = 17,
+    PhotographicGlossy = 18,
+    PhotographicHighGloss = 19,
+    PhotographicMatte = 20,
+    PhotographicSatin = 21,
+    PhotographicSemiGloss = 22,
+    Plain = 23,
+    Screen = 24,
+    ScreenPaged = 25,
+    Stationery = 26,
+    TabStockFull = 27,
+    TabStockPreCut = 28,
+    Transparency = 29,
+    TShirtTransfer = 30,
+    None = 31,
+  }
+
+  enum PrintOrientation {
+    Default = 0,
+    NotAvailable = 1,
+    PrinterCustom = 2,
+    Portrait = 3,
+    PortraitFlipped = 4,
+    Landscape = 5,
+    LandscapeFlipped = 6,
+  }
+
+  enum PrintQuality {
+    Default = 0,
+    NotAvailable = 1,
+    PrinterCustom = 2,
+    Automatic = 3,
+    Draft = 4,
+    Fax = 5,
+    High = 6,
+    Normal = 7,
+    Photographic = 8,
+    Text = 9,
+  }
+
+  enum PrintStaple {
+    Default = 0,
+    NotAvailable = 1,
+    PrinterCustom = 2,
+    None = 3,
+    StapleTopLeft = 4,
+    StapleTopRight = 5,
+    StapleBottomLeft = 6,
+    StapleBottomRight = 7,
+    StapleDualLeft = 8,
+    StapleDualRight = 9,
+    StapleDualTop = 10,
+    StapleDualBottom = 11,
+    SaddleStitch = 12,
+  }
+
+  enum PrintTaskCompletion {
+    Abandoned = 0,
+    Canceled = 1,
+    Failed = 2,
+    Submitted = 3,
+  }
+
+  interface IPrintDocumentSource {
+  }
+  var IPrintDocumentSource: abstract new (...args: any[]) => IPrintDocumentSource;
+
+  interface IPrintManager {
+    PrintTaskRequested: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.PrintManager, Windows.Graphics.Printing.PrintTaskRequestedEventArgs> | null;
+  }
+  var IPrintManager: abstract new (...args: any[]) => IPrintManager;
+
+  interface IPrintManagerStatic {
+    GetForCurrentView(): Windows.Graphics.Printing.PrintManager;
+    ShowPrintUIAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IPrintManagerStatic: abstract new (...args: any[]) => IPrintManagerStatic;
+
+  interface IPrintManagerStatic2 {
+    IsSupported(): boolean;
+  }
+  var IPrintManagerStatic2: abstract new (...args: any[]) => IPrintManagerStatic2;
+
+  interface IPrintPageInfo {
+    DpiX: number;
+    DpiY: number;
+    MediaSize: number;
+    Orientation: number;
+    PageSize: Windows.Foundation.Size;
+  }
+  var IPrintPageInfo: abstract new (...args: any[]) => IPrintPageInfo;
+
+  interface IPrintPageRange {
+    readonly FirstPageNumber: number;
+    readonly LastPageNumber: number;
+  }
+  var IPrintPageRange: abstract new (...args: any[]) => IPrintPageRange;
+
+  interface IPrintPageRangeFactory {
+    Create(firstPage: number, lastPage: number): Windows.Graphics.Printing.PrintPageRange;
+    CreateWithSinglePage(page: number): Windows.Graphics.Printing.PrintPageRange;
+  }
+  var IPrintPageRangeFactory: abstract new (...args: any[]) => IPrintPageRangeFactory;
+
+  interface IPrintPageRangeOptions {
+    AllowAllPages: boolean;
+    AllowCurrentPage: boolean;
+    AllowCustomSetOfPages: boolean;
+  }
+  var IPrintPageRangeOptions: abstract new (...args: any[]) => IPrintPageRangeOptions;
+
+  interface IPrintTask {
+    readonly Options: Windows.Graphics.Printing.PrintTaskOptions;
+    readonly Properties: Windows.ApplicationModel.DataTransfer.DataPackagePropertySet;
+    readonly Source: Windows.Graphics.Printing.IPrintDocumentSource;
+    Completed: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.PrintTask, Windows.Graphics.Printing.PrintTaskCompletedEventArgs> | null;
+    Previewing: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.PrintTask, Object> | null;
+    Progressing: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.PrintTask, Windows.Graphics.Printing.PrintTaskProgressingEventArgs> | null;
+    Submitting: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.PrintTask, Object> | null;
+  }
+  var IPrintTask: abstract new (...args: any[]) => IPrintTask;
+
+  interface IPrintTask2 {
+    IsPreviewEnabled: boolean;
+  }
+  var IPrintTask2: abstract new (...args: any[]) => IPrintTask2;
+
+  interface IPrintTaskCompletedEventArgs {
+    readonly Completion: number;
+  }
+  var IPrintTaskCompletedEventArgs: abstract new (...args: any[]) => IPrintTaskCompletedEventArgs;
+
+  interface IPrintTaskOptions {
+    GetPagePrintTicket(printPageInfo: Windows.Graphics.Printing.PrintPageInfo): Windows.Storage.Streams.IRandomAccessStream;
+    Bordering: number;
+  }
+  var IPrintTaskOptions: abstract new (...args: any[]) => IPrintTaskOptions;
+
+  interface IPrintTaskOptions2 {
+    readonly CustomPageRanges: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing.PrintPageRange> | Windows.Graphics.Printing.PrintPageRange[];
+    readonly PageRangeOptions: Windows.Graphics.Printing.PrintPageRangeOptions;
+  }
+  var IPrintTaskOptions2: abstract new (...args: any[]) => IPrintTaskOptions2;
+
+  interface IPrintTaskOptionsCore {
+    GetPageDescription(jobPageNumber: number): Windows.Graphics.Printing.PrintPageDescription;
+  }
+  var IPrintTaskOptionsCore: abstract new (...args: any[]) => IPrintTaskOptionsCore;
+
+  interface IPrintTaskOptionsCoreProperties {
+    Binding: number;
+    Collation: number;
+    ColorMode: number;
+    Duplex: number;
+    HolePunch: number;
+    readonly MaxCopies: number;
+    MediaSize: number;
+    MediaType: number;
+    readonly MinCopies: number;
+    NumberOfCopies: number;
+    Orientation: number;
+    PrintQuality: number;
+    Staple: number;
+  }
+  var IPrintTaskOptionsCoreProperties: abstract new (...args: any[]) => IPrintTaskOptionsCoreProperties;
+
+  interface IPrintTaskOptionsCoreUIConfiguration {
+    readonly DisplayedOptions: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var IPrintTaskOptionsCoreUIConfiguration: abstract new (...args: any[]) => IPrintTaskOptionsCoreUIConfiguration;
+
+  interface IPrintTaskProgressingEventArgs {
+    readonly DocumentPageCount: number;
+  }
+  var IPrintTaskProgressingEventArgs: abstract new (...args: any[]) => IPrintTaskProgressingEventArgs;
+
+  interface IPrintTaskRequest {
+    CreatePrintTask(title: string, handler: Windows.Graphics.Printing.PrintTaskSourceRequestedHandler): Windows.Graphics.Printing.PrintTask;
+    GetDeferral(): Windows.Graphics.Printing.PrintTaskRequestedDeferral;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+  var IPrintTaskRequest: abstract new (...args: any[]) => IPrintTaskRequest;
+
+  interface IPrintTaskRequestedDeferral {
+    Complete(): void;
+  }
+  var IPrintTaskRequestedDeferral: abstract new (...args: any[]) => IPrintTaskRequestedDeferral;
+
+  interface IPrintTaskRequestedEventArgs {
+    readonly Request: Windows.Graphics.Printing.PrintTaskRequest;
+  }
+  var IPrintTaskRequestedEventArgs: abstract new (...args: any[]) => IPrintTaskRequestedEventArgs;
+
+  interface IPrintTaskSourceRequestedArgs {
+    GetDeferral(): Windows.Graphics.Printing.PrintTaskSourceRequestedDeferral;
+    SetSource(source: Windows.Graphics.Printing.IPrintDocumentSource): void;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+  var IPrintTaskSourceRequestedArgs: abstract new (...args: any[]) => IPrintTaskSourceRequestedArgs;
+
+  interface IPrintTaskSourceRequestedDeferral {
+    Complete(): void;
+  }
+  var IPrintTaskSourceRequestedDeferral: abstract new (...args: any[]) => IPrintTaskSourceRequestedDeferral;
+
+  interface IPrintTaskTargetDeviceSupport {
+    Is3DManufacturingTargetEnabled: boolean;
+    IsPrinterTargetEnabled: boolean;
+  }
+  var IPrintTaskTargetDeviceSupport: abstract new (...args: any[]) => IPrintTaskTargetDeviceSupport;
+
+  interface IStandardPrintTaskOptionsStatic {
+    readonly Binding: string;
+    readonly Collation: string;
+    readonly ColorMode: string;
+    readonly Copies: string;
+    readonly Duplex: string;
+    readonly HolePunch: string;
+    readonly InputBin: string;
+    readonly MediaSize: string;
+    readonly MediaType: string;
+    readonly NUp: string;
+    readonly Orientation: string;
+    readonly PrintQuality: string;
+    readonly Staple: string;
+  }
+  var IStandardPrintTaskOptionsStatic: abstract new (...args: any[]) => IStandardPrintTaskOptionsStatic;
+
+  interface IStandardPrintTaskOptionsStatic2 {
+    readonly Bordering: string;
+  }
+  var IStandardPrintTaskOptionsStatic2: abstract new (...args: any[]) => IStandardPrintTaskOptionsStatic2;
+
+  interface IStandardPrintTaskOptionsStatic3 {
+    readonly CustomPageRanges: string;
+  }
+  var IStandardPrintTaskOptionsStatic3: abstract new (...args: any[]) => IStandardPrintTaskOptionsStatic3;
+
+  interface PrintPageDescription {
+    PageSize: Windows.Foundation.Size;
+    ImageableRect: Windows.Foundation.Rect;
+    DpiX: number;
+    DpiY: number;
+  }
+  var PrintPageDescription: {
+    new(pageSize: Windows.Foundation.Size, imageableRect: Windows.Foundation.Rect, dpiX: number, dpiY: number): PrintPageDescription;
+    new(fields: { PageSize?: Windows.Foundation.Size; ImageableRect?: Windows.Foundation.Rect; DpiX?: number; DpiY?: number }): PrintPageDescription;
+  };
+
+  interface PrintTaskSourceRequestedHandler {
+    (args: Windows.Graphics.Printing.PrintTaskSourceRequestedArgs): void;
+  }
+  var PrintTaskSourceRequestedHandler: {
+    new(callback: (args: Windows.Graphics.Printing.PrintTaskSourceRequestedArgs) => void): PrintTaskSourceRequestedHandler;
+  };
+
+}
+
+declare namespace Windows.Graphics.Printing.OptionDetails {
+  class PrintBindingOptionDetails implements Windows.Graphics.Printing.OptionDetails.IPrintBindingOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintItemListOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails {
+    TrySetValue(value: Object): boolean;
+    Description: string;
+    ErrorText: string;
+    readonly Items: Windows.Foundation.Collections.IVectorView<Object> | Object[];
+    readonly OptionId: string;
+    readonly OptionType: number;
+    State: number;
+    readonly Value: Object;
+    WarningText: string;
+  }
+
+  class PrintBorderingOptionDetails implements Windows.Graphics.Printing.OptionDetails.IPrintBorderingOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintItemListOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails {
+    TrySetValue(value: Object): boolean;
+    Description: string;
+    ErrorText: string;
+    readonly Items: Windows.Foundation.Collections.IVectorView<Object> | Object[];
+    readonly OptionId: string;
+    readonly OptionType: number;
+    State: number;
+    readonly Value: Object;
+    WarningText: string;
+  }
+
+  class PrintCollationOptionDetails implements Windows.Graphics.Printing.OptionDetails.IPrintCollationOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintItemListOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails {
+    TrySetValue(value: Object): boolean;
+    Description: string;
+    ErrorText: string;
+    readonly Items: Windows.Foundation.Collections.IVectorView<Object> | Object[];
+    readonly OptionId: string;
+    readonly OptionType: number;
+    State: number;
+    readonly Value: Object;
+    WarningText: string;
+  }
+
+  class PrintColorModeOptionDetails implements Windows.Graphics.Printing.OptionDetails.IPrintColorModeOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintItemListOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails {
+    TrySetValue(value: Object): boolean;
+    Description: string;
+    ErrorText: string;
+    readonly Items: Windows.Foundation.Collections.IVectorView<Object> | Object[];
+    readonly OptionId: string;
+    readonly OptionType: number;
+    State: number;
+    readonly Value: Object;
+    WarningText: string;
+  }
+
+  class PrintCopiesOptionDetails implements Windows.Graphics.Printing.OptionDetails.IPrintCopiesOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintNumberOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails {
+    TrySetValue(value: Object): boolean;
+    Description: string;
+    ErrorText: string;
+    readonly MaxValue: number;
+    readonly MinValue: number;
+    readonly OptionId: string;
+    readonly OptionType: number;
+    State: number;
+    readonly Value: Object;
+    WarningText: string;
+  }
+
+  class PrintCustomItemDetails implements Windows.Graphics.Printing.OptionDetails.IPrintCustomItemDetails {
+    ItemDisplayName: string;
+    readonly ItemId: string;
+  }
+
+  class PrintCustomItemListOptionDetails implements Windows.Graphics.Printing.OptionDetails.IPrintCustomItemListOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintCustomItemListOptionDetails2, Windows.Graphics.Printing.OptionDetails.IPrintCustomItemListOptionDetails3, Windows.Graphics.Printing.OptionDetails.IPrintCustomOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintItemListOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails {
+    AddItem(itemId: string, displayName: string): void;
+    AddItem(itemId: string, displayName: string, description: string, icon: Windows.Storage.Streams.IRandomAccessStreamWithContentType): void;
+    TrySetValue(value: Object): boolean;
+    Description: string;
+    DisplayName: string;
+    ErrorText: string;
+    readonly Items: Windows.Foundation.Collections.IVectorView<Object> | Object[];
+    readonly OptionId: string;
+    readonly OptionType: number;
+    State: number;
+    readonly Value: Object;
+    WarningText: string;
+  }
+
+  class PrintCustomTextOptionDetails implements Windows.Graphics.Printing.OptionDetails.IPrintCustomOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintCustomTextOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintCustomTextOptionDetails2, Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails {
+    TrySetValue(value: Object): boolean;
+    Description: string;
+    DisplayName: string;
+    ErrorText: string;
+    MaxCharacters: number;
+    readonly OptionId: string;
+    readonly OptionType: number;
+    State: number;
+    readonly Value: Object;
+    WarningText: string;
+  }
+
+  class PrintCustomToggleOptionDetails implements Windows.Graphics.Printing.OptionDetails.IPrintCustomOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintCustomToggleOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails {
+    TrySetValue(value: Object): boolean;
+    Description: string;
+    DisplayName: string;
+    ErrorText: string;
+    readonly OptionId: string;
+    readonly OptionType: number;
+    State: number;
+    readonly Value: Object;
+    WarningText: string;
+  }
+
+  class PrintDuplexOptionDetails implements Windows.Graphics.Printing.OptionDetails.IPrintDuplexOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintItemListOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails {
+    TrySetValue(value: Object): boolean;
+    Description: string;
+    ErrorText: string;
+    readonly Items: Windows.Foundation.Collections.IVectorView<Object> | Object[];
+    readonly OptionId: string;
+    readonly OptionType: number;
+    State: number;
+    readonly Value: Object;
+    WarningText: string;
+  }
+
+  class PrintHolePunchOptionDetails implements Windows.Graphics.Printing.OptionDetails.IPrintHolePunchOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintItemListOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails {
+    TrySetValue(value: Object): boolean;
+    Description: string;
+    ErrorText: string;
+    readonly Items: Windows.Foundation.Collections.IVectorView<Object> | Object[];
+    readonly OptionId: string;
+    readonly OptionType: number;
+    State: number;
+    readonly Value: Object;
+    WarningText: string;
+  }
+
+  class PrintMediaSizeOptionDetails implements Windows.Graphics.Printing.OptionDetails.IPrintItemListOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintMediaSizeOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails {
+    TrySetValue(value: Object): boolean;
+    Description: string;
+    ErrorText: string;
+    readonly Items: Windows.Foundation.Collections.IVectorView<Object> | Object[];
+    readonly OptionId: string;
+    readonly OptionType: number;
+    State: number;
+    readonly Value: Object;
+    WarningText: string;
+  }
+
+  class PrintMediaTypeOptionDetails implements Windows.Graphics.Printing.OptionDetails.IPrintItemListOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintMediaTypeOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails {
+    TrySetValue(value: Object): boolean;
+    Description: string;
+    ErrorText: string;
+    readonly Items: Windows.Foundation.Collections.IVectorView<Object> | Object[];
+    readonly OptionId: string;
+    readonly OptionType: number;
+    State: number;
+    readonly Value: Object;
+    WarningText: string;
+  }
+
+  class PrintOrientationOptionDetails implements Windows.Graphics.Printing.OptionDetails.IPrintItemListOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintOrientationOptionDetails {
+    TrySetValue(value: Object): boolean;
+    Description: string;
+    ErrorText: string;
+    readonly Items: Windows.Foundation.Collections.IVectorView<Object> | Object[];
+    readonly OptionId: string;
+    readonly OptionType: number;
+    State: number;
+    readonly Value: Object;
+    WarningText: string;
+  }
+
+  class PrintPageRangeOptionDetails implements Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintPageRangeOptionDetails {
+    TrySetValue(value: Object): boolean;
+    Description: string;
+    ErrorText: string;
+    readonly OptionId: string;
+    readonly OptionType: number;
+    State: number;
+    readonly Value: Object;
+    WarningText: string;
+  }
+
+  class PrintQualityOptionDetails implements Windows.Graphics.Printing.OptionDetails.IPrintItemListOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintQualityOptionDetails {
+    TrySetValue(value: Object): boolean;
+    Description: string;
+    ErrorText: string;
+    readonly Items: Windows.Foundation.Collections.IVectorView<Object> | Object[];
+    readonly OptionId: string;
+    readonly OptionType: number;
+    State: number;
+    readonly Value: Object;
+    WarningText: string;
+  }
+
+  class PrintStapleOptionDetails implements Windows.Graphics.Printing.OptionDetails.IPrintItemListOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintStapleOptionDetails {
+    TrySetValue(value: Object): boolean;
+    Description: string;
+    ErrorText: string;
+    readonly Items: Windows.Foundation.Collections.IVectorView<Object> | Object[];
+    readonly OptionId: string;
+    readonly OptionType: number;
+    State: number;
+    readonly Value: Object;
+    WarningText: string;
+  }
+
+  class PrintTaskOptionChangedEventArgs implements Windows.Graphics.Printing.OptionDetails.IPrintTaskOptionChangedEventArgs {
+    readonly OptionId: Object;
+  }
+
+  class PrintTaskOptionDetails implements Windows.Graphics.Printing.IPrintTaskOptionsCore, Windows.Graphics.Printing.IPrintTaskOptionsCoreUIConfiguration, Windows.Graphics.Printing.OptionDetails.IPrintTaskOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintTaskOptionDetails2 {
+    CreateItemListOption(optionId: string, displayName: string): Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails;
+    CreateTextOption(optionId: string, displayName: string): Windows.Graphics.Printing.OptionDetails.PrintCustomTextOptionDetails;
+    CreateToggleOption(optionId: string, displayName: string): Windows.Graphics.Printing.OptionDetails.PrintCustomToggleOptionDetails;
+    static GetFromPrintTaskOptions(printTaskOptions: Windows.Graphics.Printing.PrintTaskOptions): Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails;
+    GetPageDescription(jobPageNumber: number): Windows.Graphics.Printing.PrintPageDescription;
+    readonly DisplayedOptions: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Options: Windows.Foundation.Collections.IMapView<string, Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails>;
+    BeginValidation: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails, Object> | null;
+    OptionChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails, Windows.Graphics.Printing.OptionDetails.PrintTaskOptionChangedEventArgs> | null;
+  }
+
+  enum PrintOptionStates {
+    None = 0,
+    Enabled = 1,
+    Constrained = 2,
+  }
+
+  enum PrintOptionType {
+    Unknown = 0,
+    Number = 1,
+    Text = 2,
+    ItemList = 3,
+    Toggle = 4,
+  }
+
+  interface IPrintBindingOptionDetails {
+    Description: string;
+    WarningText: string;
+  }
+  var IPrintBindingOptionDetails: abstract new (...args: any[]) => IPrintBindingOptionDetails;
+
+  interface IPrintBorderingOptionDetails {
+    Description: string;
+    WarningText: string;
+  }
+  var IPrintBorderingOptionDetails: abstract new (...args: any[]) => IPrintBorderingOptionDetails;
+
+  interface IPrintCollationOptionDetails {
+    Description: string;
+    WarningText: string;
+  }
+  var IPrintCollationOptionDetails: abstract new (...args: any[]) => IPrintCollationOptionDetails;
+
+  interface IPrintColorModeOptionDetails {
+    Description: string;
+    WarningText: string;
+  }
+  var IPrintColorModeOptionDetails: abstract new (...args: any[]) => IPrintColorModeOptionDetails;
+
+  interface IPrintCopiesOptionDetails {
+    Description: string;
+    WarningText: string;
+  }
+  var IPrintCopiesOptionDetails: abstract new (...args: any[]) => IPrintCopiesOptionDetails;
+
+  interface IPrintCustomItemDetails {
+    ItemDisplayName: string;
+    readonly ItemId: string;
+  }
+  var IPrintCustomItemDetails: abstract new (...args: any[]) => IPrintCustomItemDetails;
+
+  interface IPrintCustomItemListOptionDetails extends Windows.Graphics.Printing.OptionDetails.IPrintCustomOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintItemListOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails {
+    AddItem(itemId: string, displayName: string): void;
+    TrySetValue(value: Object): boolean;
+  }
+  var IPrintCustomItemListOptionDetails: abstract new (...args: any[]) => IPrintCustomItemListOptionDetails;
+
+  interface IPrintCustomItemListOptionDetails2 {
+    AddItem(itemId: string, displayName: string, description: string, icon: Windows.Storage.Streams.IRandomAccessStreamWithContentType): void;
+  }
+  var IPrintCustomItemListOptionDetails2: abstract new (...args: any[]) => IPrintCustomItemListOptionDetails2;
+
+  interface IPrintCustomItemListOptionDetails3 {
+    Description: string;
+    WarningText: string;
+  }
+  var IPrintCustomItemListOptionDetails3: abstract new (...args: any[]) => IPrintCustomItemListOptionDetails3;
+
+  interface IPrintCustomOptionDetails extends Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails {
+    TrySetValue(value: Object): boolean;
+    DisplayName: string;
+  }
+  var IPrintCustomOptionDetails: abstract new (...args: any[]) => IPrintCustomOptionDetails;
+
+  interface IPrintCustomTextOptionDetails extends Windows.Graphics.Printing.OptionDetails.IPrintCustomOptionDetails, Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails {
+    TrySetValue(value: Object): boolean;
+    MaxCharacters: number;
+  }
+  var IPrintCustomTextOptionDetails: abstract new (...args: any[]) => IPrintCustomTextOptionDetails;
+
+  interface IPrintCustomTextOptionDetails2 {
+    Description: string;
+    WarningText: string;
+  }
+  var IPrintCustomTextOptionDetails2: abstract new (...args: any[]) => IPrintCustomTextOptionDetails2;
+
+  interface IPrintCustomToggleOptionDetails {
+    Description: string;
+    WarningText: string;
+  }
+  var IPrintCustomToggleOptionDetails: abstract new (...args: any[]) => IPrintCustomToggleOptionDetails;
+
+  interface IPrintDuplexOptionDetails {
+    Description: string;
+    WarningText: string;
+  }
+  var IPrintDuplexOptionDetails: abstract new (...args: any[]) => IPrintDuplexOptionDetails;
+
+  interface IPrintHolePunchOptionDetails {
+    Description: string;
+    WarningText: string;
+  }
+  var IPrintHolePunchOptionDetails: abstract new (...args: any[]) => IPrintHolePunchOptionDetails;
+
+  interface IPrintItemListOptionDetails extends Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails {
+    TrySetValue(value: Object): boolean;
+    readonly Items: Windows.Foundation.Collections.IVectorView<Object> | Object[];
+  }
+  var IPrintItemListOptionDetails: abstract new (...args: any[]) => IPrintItemListOptionDetails;
+
+  interface IPrintMediaSizeOptionDetails {
+    Description: string;
+    WarningText: string;
+  }
+  var IPrintMediaSizeOptionDetails: abstract new (...args: any[]) => IPrintMediaSizeOptionDetails;
+
+  interface IPrintMediaTypeOptionDetails {
+    Description: string;
+    WarningText: string;
+  }
+  var IPrintMediaTypeOptionDetails: abstract new (...args: any[]) => IPrintMediaTypeOptionDetails;
+
+  interface IPrintNumberOptionDetails extends Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails {
+    TrySetValue(value: Object): boolean;
+    readonly MaxValue: number;
+    readonly MinValue: number;
+  }
+  var IPrintNumberOptionDetails: abstract new (...args: any[]) => IPrintNumberOptionDetails;
+
+  interface IPrintOptionDetails {
+    TrySetValue(value: Object): boolean;
+    ErrorText: string;
+    readonly OptionId: string;
+    readonly OptionType: number;
+    State: number;
+    readonly Value: Object;
+  }
+  var IPrintOptionDetails: abstract new (...args: any[]) => IPrintOptionDetails;
+
+  interface IPrintOrientationOptionDetails {
+    Description: string;
+    WarningText: string;
+  }
+  var IPrintOrientationOptionDetails: abstract new (...args: any[]) => IPrintOrientationOptionDetails;
+
+  interface IPrintPageRangeOptionDetails {
+    Description: string;
+    WarningText: string;
+  }
+  var IPrintPageRangeOptionDetails: abstract new (...args: any[]) => IPrintPageRangeOptionDetails;
+
+  interface IPrintQualityOptionDetails {
+    Description: string;
+    WarningText: string;
+  }
+  var IPrintQualityOptionDetails: abstract new (...args: any[]) => IPrintQualityOptionDetails;
+
+  interface IPrintStapleOptionDetails {
+    Description: string;
+    WarningText: string;
+  }
+  var IPrintStapleOptionDetails: abstract new (...args: any[]) => IPrintStapleOptionDetails;
+
+  interface IPrintTaskOptionChangedEventArgs {
+    readonly OptionId: Object;
+  }
+  var IPrintTaskOptionChangedEventArgs: abstract new (...args: any[]) => IPrintTaskOptionChangedEventArgs;
+
+  interface IPrintTaskOptionDetails {
+    CreateItemListOption(optionId: string, displayName: string): Windows.Graphics.Printing.OptionDetails.PrintCustomItemListOptionDetails;
+    CreateTextOption(optionId: string, displayName: string): Windows.Graphics.Printing.OptionDetails.PrintCustomTextOptionDetails;
+    readonly Options: Windows.Foundation.Collections.IMapView<string, Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails>;
+    BeginValidation: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails, Object> | null;
+    OptionChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails, Windows.Graphics.Printing.OptionDetails.PrintTaskOptionChangedEventArgs> | null;
+  }
+  var IPrintTaskOptionDetails: abstract new (...args: any[]) => IPrintTaskOptionDetails;
+
+  interface IPrintTaskOptionDetails2 {
+    CreateToggleOption(optionId: string, displayName: string): Windows.Graphics.Printing.OptionDetails.PrintCustomToggleOptionDetails;
+  }
+  var IPrintTaskOptionDetails2: abstract new (...args: any[]) => IPrintTaskOptionDetails2;
+
+  interface IPrintTaskOptionDetailsStatic {
+    GetFromPrintTaskOptions(printTaskOptions: Windows.Graphics.Printing.PrintTaskOptions): Windows.Graphics.Printing.OptionDetails.PrintTaskOptionDetails;
+  }
+  var IPrintTaskOptionDetailsStatic: abstract new (...args: any[]) => IPrintTaskOptionDetailsStatic;
+
+  interface IPrintTextOptionDetails extends Windows.Graphics.Printing.OptionDetails.IPrintOptionDetails {
+    TrySetValue(value: Object): boolean;
+    readonly MaxCharacters: number;
+  }
+  var IPrintTextOptionDetails: abstract new (...args: any[]) => IPrintTextOptionDetails;
+
+}
+
+declare namespace Windows.Graphics.Printing.PrintSupport {
+  class PrintSupportCommunicationErrorDetectedEventArgs implements Windows.Graphics.Printing.PrintSupport.IPrintSupportCommunicationErrorDetectedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly CommunicationConfiguration: Windows.Graphics.Printing.PrintSupport.PrintSupportIppCommunicationConfiguration;
+    readonly ErrorKind: number;
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+
+  class PrintSupportExtensionSession implements Windows.Graphics.Printing.PrintSupport.IPrintSupportExtensionSession, Windows.Graphics.Printing.PrintSupport.IPrintSupportExtensionSession2, Windows.Graphics.Printing.PrintSupport.IPrintSupportExtensionSession3 {
+    Start(): void;
+    readonly Printer: Windows.Devices.Printers.IppPrintDevice;
+    PrintDeviceCapabilitiesChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.PrintSupport.PrintSupportExtensionSession, Windows.Graphics.Printing.PrintSupport.PrintSupportPrintDeviceCapabilitiesChangedEventArgs> | null;
+    PrintTicketValidationRequested: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.PrintSupport.PrintSupportExtensionSession, Windows.Graphics.Printing.PrintSupport.PrintSupportPrintTicketValidationRequestedEventArgs> | null;
+    PrinterSelected: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.PrintSupport.PrintSupportExtensionSession, Windows.Graphics.Printing.PrintSupport.PrintSupportPrinterSelectedEventArgs> | null;
+    CommunicationErrorDetected: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.PrintSupport.PrintSupportExtensionSession, Windows.Graphics.Printing.PrintSupport.PrintSupportCommunicationErrorDetectedEventArgs> | null;
+  }
+
+  class PrintSupportExtensionTriggerDetails implements Windows.Graphics.Printing.PrintSupport.IPrintSupportExtensionTriggerDetails {
+    readonly Session: Windows.Graphics.Printing.PrintSupport.PrintSupportExtensionSession;
+  }
+
+  class PrintSupportIppCommunicationConfiguration implements Windows.Graphics.Printing.PrintSupport.IPrintSupportIppCommunicationConfiguration {
+    readonly CanModifyTimeouts: boolean;
+    readonly CommunicationKind: number;
+    readonly IppAttributeTimeouts: Windows.Graphics.Printing.PrintSupport.PrintSupportIppCommunicationTimeouts;
+    readonly IppJobTimeouts: Windows.Graphics.Printing.PrintSupport.PrintSupportIppCommunicationTimeouts;
+  }
+
+  class PrintSupportIppCommunicationTimeouts implements Windows.Graphics.Printing.PrintSupport.IPrintSupportIppCommunicationTimeouts {
+    ConnectTimeout: Windows.Foundation.TimeSpan;
+    ReceiveTimeout: Windows.Foundation.TimeSpan;
+    SendTimeout: Windows.Foundation.TimeSpan;
+  }
+
+  class PrintSupportMxdcImageQualityConfiguration implements Windows.Graphics.Printing.PrintSupport.IPrintSupportMxdcImageQualityConfiguration {
+    AutomaticOutputQuality: number;
+    DraftOutputQuality: number;
+    FaxOutputQuality: number;
+    HighOutputQuality: number;
+    NormalOutputQuality: number;
+    PhotographicOutputQuality: number;
+    TextOutputQuality: number;
+  }
+
+  class PrintSupportPrintDeviceCapabilitiesChangedEventArgs implements Windows.Graphics.Printing.PrintSupport.IPrintSupportPrintDeviceCapabilitiesChangedEventArgs, Windows.Graphics.Printing.PrintSupport.IPrintSupportPrintDeviceCapabilitiesChangedEventArgs2, Windows.Graphics.Printing.PrintSupport.IPrintSupportPrintDeviceCapabilitiesChangedEventArgs3, Windows.Graphics.Printing.PrintSupport.IPrintSupportPrintDeviceCapabilitiesChangedEventArgs4 {
+    GetCurrentPrintDeviceCapabilities(): Windows.Data.Xml.Dom.XmlDocument;
+    GetCurrentPrintDeviceResources(): Windows.Data.Xml.Dom.XmlDocument;
+    GetDeferral(): Windows.Foundation.Deferral;
+    SetPrintDeviceCapabilitiesUpdatePolicy(updatePolicy: Windows.Graphics.Printing.PrintSupport.PrintSupportPrintDeviceCapabilitiesUpdatePolicy): void;
+    SetSupportedPdlPassthroughContentTypes(supportedPdlContentTypes: Windows.Foundation.Collections.IIterable<string> | string[]): void;
+    UpdatePrintDeviceCapabilities(updatedPdc: Windows.Data.Xml.Dom.XmlDocument): void;
+    UpdatePrintDeviceResources(updatedPdr: Windows.Data.Xml.Dom.XmlDocument): void;
+    readonly CommunicationConfiguration: Windows.Graphics.Printing.PrintSupport.PrintSupportIppCommunicationConfiguration;
+    readonly MxdcImageQualityConfiguration: Windows.Graphics.Printing.PrintSupport.PrintSupportMxdcImageQualityConfiguration;
+    readonly ResourceLanguage: string;
+  }
+
+  class PrintSupportPrintDeviceCapabilitiesUpdatePolicy implements Windows.Graphics.Printing.PrintSupport.IPrintSupportPrintDeviceCapabilitiesUpdatePolicy {
+    static CreatePeriodicRefresh(updatePeriod: Windows.Foundation.TimeSpan): Windows.Graphics.Printing.PrintSupport.PrintSupportPrintDeviceCapabilitiesUpdatePolicy;
+    static CreatePrintJobRefresh(numberOfJobs: number): Windows.Graphics.Printing.PrintSupport.PrintSupportPrintDeviceCapabilitiesUpdatePolicy;
+  }
+
+  class PrintSupportPrintTicketElement implements Windows.Graphics.Printing.PrintSupport.IPrintSupportPrintTicketElement {
+    constructor();
+    LocalName: string;
+    NamespaceUri: string;
+  }
+
+  class PrintSupportPrintTicketValidationRequestedEventArgs implements Windows.Graphics.Printing.PrintSupport.IPrintSupportPrintTicketValidationRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    SetPrintTicketValidationStatus(status: number): void;
+    readonly PrintTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket;
+  }
+
+  class PrintSupportPrinterSelectedEventArgs implements Windows.Graphics.Printing.PrintSupport.IPrintSupportPrinterSelectedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    SetAdaptiveCard(adaptiveCard: Windows.UI.Shell.IAdaptiveCard): void;
+    SetAdditionalFeatures(features: Windows.Foundation.Collections.IIterable<Windows.Graphics.Printing.PrintSupport.PrintSupportPrintTicketElement> | Windows.Graphics.Printing.PrintSupport.PrintSupportPrintTicketElement[]): void;
+    SetAdditionalParameters(parameters: Windows.Foundation.Collections.IIterable<Windows.Graphics.Printing.PrintSupport.PrintSupportPrintTicketElement> | Windows.Graphics.Printing.PrintSupport.PrintSupportPrintTicketElement[]): void;
+    readonly AllowedAdditionalFeaturesAndParametersCount: number;
+    PrintTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket;
+    readonly SourceAppInfo: Windows.ApplicationModel.AppInfo;
+  }
+
+  class PrintSupportSessionInfo implements Windows.Graphics.Printing.PrintSupport.IPrintSupportSessionInfo {
+    readonly Printer: Windows.Devices.Printers.IppPrintDevice;
+    readonly SourceAppInfo: Windows.ApplicationModel.AppInfo;
+  }
+
+  class PrintSupportSettingsActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.Graphics.Printing.PrintSupport.IPrintSupportSettingsActivatedEventArgs, Windows.Graphics.Printing.PrintSupport.IPrintSupportSettingsActivatedEventArgs2 {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Kind: number;
+    readonly OwnerWindowId: Windows.UI.WindowId;
+    readonly PreviousExecutionState: number;
+    readonly Session: Windows.Graphics.Printing.PrintSupport.PrintSupportSettingsUISession;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class PrintSupportSettingsUISession implements Windows.Graphics.Printing.PrintSupport.IPrintSupportSettingsUISession {
+    UpdatePrintTicket(printTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket): void;
+    readonly DocumentTitle: string;
+    readonly LaunchKind: number;
+    readonly SessionInfo: Windows.Graphics.Printing.PrintSupport.PrintSupportSessionInfo;
+    readonly SessionPrintTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket;
+  }
+
+  enum IppCommunicationErrorKind {
+    Other = 0,
+    Timeout = 1,
+    ConnectionError = 2,
+    AccessDenied = 3,
+  }
+
+  enum IppPrinterCommunicationKind {
+    Network = 0,
+    Usb = 1,
+    PrinterConnection = 2,
+    UniversalPrint = 3,
+    VirtualPrinter = 4,
+  }
+
+  enum SettingsLaunchKind {
+    JobPrintTicket = 0,
+    UserDefaultPrintTicket = 1,
+  }
+
+  enum WorkflowPrintTicketValidationStatus {
+    Resolved = 0,
+    Conflicting = 1,
+    Invalid = 2,
+  }
+
+  enum XpsImageQuality {
+    JpegHighCompression = 0,
+    JpegMediumCompression = 1,
+    JpegLowCompression = 2,
+    Png = 3,
+  }
+
+  interface IPrintSupportCommunicationErrorDetectedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly CommunicationConfiguration: Windows.Graphics.Printing.PrintSupport.PrintSupportIppCommunicationConfiguration;
+    readonly ErrorKind: number;
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+  var IPrintSupportCommunicationErrorDetectedEventArgs: abstract new (...args: any[]) => IPrintSupportCommunicationErrorDetectedEventArgs;
+
+  interface IPrintSupportExtensionSession {
+    Start(): void;
+    readonly Printer: Windows.Devices.Printers.IppPrintDevice;
+    PrintDeviceCapabilitiesChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.PrintSupport.PrintSupportExtensionSession, Windows.Graphics.Printing.PrintSupport.PrintSupportPrintDeviceCapabilitiesChangedEventArgs> | null;
+    PrintTicketValidationRequested: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.PrintSupport.PrintSupportExtensionSession, Windows.Graphics.Printing.PrintSupport.PrintSupportPrintTicketValidationRequestedEventArgs> | null;
+  }
+  var IPrintSupportExtensionSession: abstract new (...args: any[]) => IPrintSupportExtensionSession;
+
+  interface IPrintSupportExtensionSession2 {
+    PrinterSelected: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.PrintSupport.PrintSupportExtensionSession, Windows.Graphics.Printing.PrintSupport.PrintSupportPrinterSelectedEventArgs> | null;
+  }
+  var IPrintSupportExtensionSession2: abstract new (...args: any[]) => IPrintSupportExtensionSession2;
+
+  interface IPrintSupportExtensionSession3 {
+    CommunicationErrorDetected: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.PrintSupport.PrintSupportExtensionSession, Windows.Graphics.Printing.PrintSupport.PrintSupportCommunicationErrorDetectedEventArgs> | null;
+  }
+  var IPrintSupportExtensionSession3: abstract new (...args: any[]) => IPrintSupportExtensionSession3;
+
+  interface IPrintSupportExtensionTriggerDetails {
+    readonly Session: Windows.Graphics.Printing.PrintSupport.PrintSupportExtensionSession;
+  }
+  var IPrintSupportExtensionTriggerDetails: abstract new (...args: any[]) => IPrintSupportExtensionTriggerDetails;
+
+  interface IPrintSupportIppCommunicationConfiguration {
+    readonly CanModifyTimeouts: boolean;
+    readonly CommunicationKind: number;
+    readonly IppAttributeTimeouts: Windows.Graphics.Printing.PrintSupport.PrintSupportIppCommunicationTimeouts;
+    readonly IppJobTimeouts: Windows.Graphics.Printing.PrintSupport.PrintSupportIppCommunicationTimeouts;
+  }
+  var IPrintSupportIppCommunicationConfiguration: abstract new (...args: any[]) => IPrintSupportIppCommunicationConfiguration;
+
+  interface IPrintSupportIppCommunicationTimeouts {
+    ConnectTimeout: Windows.Foundation.TimeSpan;
+    ReceiveTimeout: Windows.Foundation.TimeSpan;
+    SendTimeout: Windows.Foundation.TimeSpan;
+  }
+  var IPrintSupportIppCommunicationTimeouts: abstract new (...args: any[]) => IPrintSupportIppCommunicationTimeouts;
+
+  interface IPrintSupportMxdcImageQualityConfiguration {
+    AutomaticOutputQuality: number;
+    DraftOutputQuality: number;
+    FaxOutputQuality: number;
+    HighOutputQuality: number;
+    NormalOutputQuality: number;
+    PhotographicOutputQuality: number;
+    TextOutputQuality: number;
+  }
+  var IPrintSupportMxdcImageQualityConfiguration: abstract new (...args: any[]) => IPrintSupportMxdcImageQualityConfiguration;
+
+  interface IPrintSupportPrintDeviceCapabilitiesChangedEventArgs {
+    GetCurrentPrintDeviceCapabilities(): Windows.Data.Xml.Dom.XmlDocument;
+    GetDeferral(): Windows.Foundation.Deferral;
+    UpdatePrintDeviceCapabilities(updatedPdc: Windows.Data.Xml.Dom.XmlDocument): void;
+  }
+  var IPrintSupportPrintDeviceCapabilitiesChangedEventArgs: abstract new (...args: any[]) => IPrintSupportPrintDeviceCapabilitiesChangedEventArgs;
+
+  interface IPrintSupportPrintDeviceCapabilitiesChangedEventArgs2 {
+    GetCurrentPrintDeviceResources(): Windows.Data.Xml.Dom.XmlDocument;
+    SetPrintDeviceCapabilitiesUpdatePolicy(updatePolicy: Windows.Graphics.Printing.PrintSupport.PrintSupportPrintDeviceCapabilitiesUpdatePolicy): void;
+    SetSupportedPdlPassthroughContentTypes(supportedPdlContentTypes: Windows.Foundation.Collections.IIterable<string> | string[]): void;
+    UpdatePrintDeviceResources(updatedPdr: Windows.Data.Xml.Dom.XmlDocument): void;
+    readonly ResourceLanguage: string;
+  }
+  var IPrintSupportPrintDeviceCapabilitiesChangedEventArgs2: abstract new (...args: any[]) => IPrintSupportPrintDeviceCapabilitiesChangedEventArgs2;
+
+  interface IPrintSupportPrintDeviceCapabilitiesChangedEventArgs3 {
+    readonly CommunicationConfiguration: Windows.Graphics.Printing.PrintSupport.PrintSupportIppCommunicationConfiguration;
+  }
+  var IPrintSupportPrintDeviceCapabilitiesChangedEventArgs3: abstract new (...args: any[]) => IPrintSupportPrintDeviceCapabilitiesChangedEventArgs3;
+
+  interface IPrintSupportPrintDeviceCapabilitiesChangedEventArgs4 {
+    readonly MxdcImageQualityConfiguration: Windows.Graphics.Printing.PrintSupport.PrintSupportMxdcImageQualityConfiguration;
+  }
+  var IPrintSupportPrintDeviceCapabilitiesChangedEventArgs4: abstract new (...args: any[]) => IPrintSupportPrintDeviceCapabilitiesChangedEventArgs4;
+
+  interface IPrintSupportPrintDeviceCapabilitiesUpdatePolicy {
+  }
+  var IPrintSupportPrintDeviceCapabilitiesUpdatePolicy: abstract new (...args: any[]) => IPrintSupportPrintDeviceCapabilitiesUpdatePolicy;
+
+  interface IPrintSupportPrintDeviceCapabilitiesUpdatePolicyStatics {
+    CreatePeriodicRefresh(updatePeriod: Windows.Foundation.TimeSpan): Windows.Graphics.Printing.PrintSupport.PrintSupportPrintDeviceCapabilitiesUpdatePolicy;
+    CreatePrintJobRefresh(numberOfJobs: number): Windows.Graphics.Printing.PrintSupport.PrintSupportPrintDeviceCapabilitiesUpdatePolicy;
+  }
+  var IPrintSupportPrintDeviceCapabilitiesUpdatePolicyStatics: abstract new (...args: any[]) => IPrintSupportPrintDeviceCapabilitiesUpdatePolicyStatics;
+
+  interface IPrintSupportPrintTicketElement {
+    LocalName: string;
+    NamespaceUri: string;
+  }
+  var IPrintSupportPrintTicketElement: abstract new (...args: any[]) => IPrintSupportPrintTicketElement;
+
+  interface IPrintSupportPrintTicketValidationRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    SetPrintTicketValidationStatus(status: number): void;
+    readonly PrintTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket;
+  }
+  var IPrintSupportPrintTicketValidationRequestedEventArgs: abstract new (...args: any[]) => IPrintSupportPrintTicketValidationRequestedEventArgs;
+
+  interface IPrintSupportPrinterSelectedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    SetAdaptiveCard(adaptiveCard: Windows.UI.Shell.IAdaptiveCard): void;
+    SetAdditionalFeatures(features: Windows.Foundation.Collections.IIterable<Windows.Graphics.Printing.PrintSupport.PrintSupportPrintTicketElement> | Windows.Graphics.Printing.PrintSupport.PrintSupportPrintTicketElement[]): void;
+    SetAdditionalParameters(parameters: Windows.Foundation.Collections.IIterable<Windows.Graphics.Printing.PrintSupport.PrintSupportPrintTicketElement> | Windows.Graphics.Printing.PrintSupport.PrintSupportPrintTicketElement[]): void;
+    readonly AllowedAdditionalFeaturesAndParametersCount: number;
+    PrintTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket;
+    readonly SourceAppInfo: Windows.ApplicationModel.AppInfo;
+  }
+  var IPrintSupportPrinterSelectedEventArgs: abstract new (...args: any[]) => IPrintSupportPrinterSelectedEventArgs;
+
+  interface IPrintSupportSessionInfo {
+    readonly Printer: Windows.Devices.Printers.IppPrintDevice;
+    readonly SourceAppInfo: Windows.ApplicationModel.AppInfo;
+  }
+  var IPrintSupportSessionInfo: abstract new (...args: any[]) => IPrintSupportSessionInfo;
+
+  interface IPrintSupportSettingsActivatedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Session: Windows.Graphics.Printing.PrintSupport.PrintSupportSettingsUISession;
+  }
+  var IPrintSupportSettingsActivatedEventArgs: abstract new (...args: any[]) => IPrintSupportSettingsActivatedEventArgs;
+
+  interface IPrintSupportSettingsActivatedEventArgs2 {
+    readonly OwnerWindowId: Windows.UI.WindowId;
+  }
+  var IPrintSupportSettingsActivatedEventArgs2: abstract new (...args: any[]) => IPrintSupportSettingsActivatedEventArgs2;
+
+  interface IPrintSupportSettingsUISession {
+    UpdatePrintTicket(printTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket): void;
+    readonly DocumentTitle: string;
+    readonly LaunchKind: number;
+    readonly SessionInfo: Windows.Graphics.Printing.PrintSupport.PrintSupportSessionInfo;
+    readonly SessionPrintTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket;
+  }
+  var IPrintSupportSettingsUISession: abstract new (...args: any[]) => IPrintSupportSettingsUISession;
+
+}
+
+declare namespace Windows.Graphics.Printing.PrintTicket {
+  class PrintTicketCapabilities implements Windows.Graphics.Printing.PrintTicket.IPrintTicketCapabilities {
+    GetFeature(name: string, xmlNamespace: string): Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    GetParameterDefinition(name: string, xmlNamespace: string): Windows.Graphics.Printing.PrintTicket.PrintTicketParameterDefinition;
+    readonly DocumentBindingFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentCollateFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentDuplexFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentHolePunchFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentInputBinFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentNUpFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentStapleFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly JobPasscodeFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly Name: string;
+    readonly PageBorderlessFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageMediaSizeFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageMediaTypeFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageOrientationFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageOutputColorFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageOutputQualityFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageResolutionFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly XmlNamespace: string;
+    readonly XmlNode: Windows.Data.Xml.Dom.IXmlNode;
+  }
+
+  class PrintTicketFeature implements Windows.Graphics.Printing.PrintTicket.IPrintTicketFeature {
+    GetOption(name: string, xmlNamespace: string): Windows.Graphics.Printing.PrintTicket.PrintTicketOption;
+    GetSelectedOption(): Windows.Graphics.Printing.PrintTicket.PrintTicketOption;
+    SetSelectedOption(value: Windows.Graphics.Printing.PrintTicket.PrintTicketOption): void;
+    readonly DisplayName: string;
+    readonly Name: string;
+    readonly Options: Windows.Foundation.Collections.IVectorView<Windows.Graphics.Printing.PrintTicket.PrintTicketOption> | Windows.Graphics.Printing.PrintTicket.PrintTicketOption[];
+    readonly SelectionType: number;
+    readonly XmlNamespace: string;
+    readonly XmlNode: Windows.Data.Xml.Dom.IXmlNode;
+  }
+
+  class PrintTicketOption implements Windows.Graphics.Printing.PrintTicket.IPrintTicketOption {
+    GetPropertyNode(name: string, xmlNamespace: string): Windows.Data.Xml.Dom.IXmlNode;
+    GetPropertyValue(name: string, xmlNamespace: string): Windows.Graphics.Printing.PrintTicket.PrintTicketValue;
+    GetScoredPropertyNode(name: string, xmlNamespace: string): Windows.Data.Xml.Dom.IXmlNode;
+    GetScoredPropertyValue(name: string, xmlNamespace: string): Windows.Graphics.Printing.PrintTicket.PrintTicketValue;
+    readonly DisplayName: string;
+    readonly Name: string;
+    readonly XmlNamespace: string;
+    readonly XmlNode: Windows.Data.Xml.Dom.IXmlNode;
+  }
+
+  class PrintTicketParameterDefinition implements Windows.Graphics.Printing.PrintTicket.IPrintTicketParameterDefinition {
+    readonly DataType: number;
+    readonly Name: string;
+    readonly RangeMax: number;
+    readonly RangeMin: number;
+    readonly UnitType: string;
+    readonly XmlNamespace: string;
+    readonly XmlNode: Windows.Data.Xml.Dom.IXmlNode;
+  }
+
+  class PrintTicketParameterInitializer implements Windows.Graphics.Printing.PrintTicket.IPrintTicketParameterInitializer {
+    readonly Name: string;
+    Value: Windows.Graphics.Printing.PrintTicket.PrintTicketValue;
+    readonly XmlNamespace: string;
+    readonly XmlNode: Windows.Data.Xml.Dom.IXmlNode;
+  }
+
+  class PrintTicketValue implements Windows.Graphics.Printing.PrintTicket.IPrintTicketValue {
+    GetValueAsInteger(): number;
+    GetValueAsString(): string;
+    readonly Type: number;
+  }
+
+  class WorkflowPrintTicket implements Windows.Graphics.Printing.PrintTicket.IWorkflowPrintTicket {
+    GetCapabilities(): Windows.Graphics.Printing.PrintTicket.PrintTicketCapabilities;
+    GetFeature(name: string, xmlNamespace: string): Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    GetParameterInitializer(name: string, xmlNamespace: string): Windows.Graphics.Printing.PrintTicket.PrintTicketParameterInitializer;
+    MergeAndValidateTicket(deltaShemaTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket): Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket;
+    NotifyXmlChangedAsync(): Windows.Foundation.IAsyncAction;
+    SetParameterInitializerAsInteger(name: string, xmlNamespace: string, integerValue: number): Windows.Graphics.Printing.PrintTicket.PrintTicketParameterInitializer;
+    SetParameterInitializerAsString(name: string, xmlNamespace: string, stringValue: string): Windows.Graphics.Printing.PrintTicket.PrintTicketParameterInitializer;
+    ValidateAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicketValidationResult>;
+    readonly DocumentBindingFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentCollateFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentDuplexFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentHolePunchFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentInputBinFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentNUpFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentStapleFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly JobPasscodeFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly Name: string;
+    readonly PageBorderlessFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageMediaSizeFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageMediaTypeFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageOrientationFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageOutputColorFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageOutputQualityFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageResolutionFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly XmlNamespace: string;
+    readonly XmlNode: Windows.Data.Xml.Dom.IXmlNode;
+  }
+
+  class WorkflowPrintTicketValidationResult implements Windows.Graphics.Printing.PrintTicket.IWorkflowPrintTicketValidationResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Validated: boolean;
+  }
+
+  enum PrintTicketFeatureSelectionType {
+    PickOne = 0,
+    PickMany = 1,
+  }
+
+  enum PrintTicketParameterDataType {
+    Integer = 0,
+    NumericString = 1,
+    String = 2,
+  }
+
+  enum PrintTicketValueType {
+    Integer = 0,
+    String = 1,
+    Unknown = 2,
+  }
+
+  interface IPrintTicketCapabilities {
+    GetFeature(name: string, xmlNamespace: string): Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    GetParameterDefinition(name: string, xmlNamespace: string): Windows.Graphics.Printing.PrintTicket.PrintTicketParameterDefinition;
+    readonly DocumentBindingFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentCollateFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentDuplexFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentHolePunchFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentInputBinFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentNUpFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentStapleFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly JobPasscodeFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly Name: string;
+    readonly PageBorderlessFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageMediaSizeFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageMediaTypeFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageOrientationFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageOutputColorFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageOutputQualityFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageResolutionFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly XmlNamespace: string;
+    readonly XmlNode: Windows.Data.Xml.Dom.IXmlNode;
+  }
+  var IPrintTicketCapabilities: abstract new (...args: any[]) => IPrintTicketCapabilities;
+
+  interface IPrintTicketFeature {
+    GetOption(name: string, xmlNamespace: string): Windows.Graphics.Printing.PrintTicket.PrintTicketOption;
+    GetSelectedOption(): Windows.Graphics.Printing.PrintTicket.PrintTicketOption;
+    SetSelectedOption(value: Windows.Graphics.Printing.PrintTicket.PrintTicketOption): void;
+    readonly DisplayName: string;
+    readonly Name: string;
+    readonly Options: Windows.Foundation.Collections.IVectorView<Windows.Graphics.Printing.PrintTicket.PrintTicketOption> | Windows.Graphics.Printing.PrintTicket.PrintTicketOption[];
+    readonly SelectionType: number;
+    readonly XmlNamespace: string;
+    readonly XmlNode: Windows.Data.Xml.Dom.IXmlNode;
+  }
+  var IPrintTicketFeature: abstract new (...args: any[]) => IPrintTicketFeature;
+
+  interface IPrintTicketOption {
+    GetPropertyNode(name: string, xmlNamespace: string): Windows.Data.Xml.Dom.IXmlNode;
+    GetPropertyValue(name: string, xmlNamespace: string): Windows.Graphics.Printing.PrintTicket.PrintTicketValue;
+    GetScoredPropertyNode(name: string, xmlNamespace: string): Windows.Data.Xml.Dom.IXmlNode;
+    GetScoredPropertyValue(name: string, xmlNamespace: string): Windows.Graphics.Printing.PrintTicket.PrintTicketValue;
+    readonly DisplayName: string;
+    readonly Name: string;
+    readonly XmlNamespace: string;
+    readonly XmlNode: Windows.Data.Xml.Dom.IXmlNode;
+  }
+  var IPrintTicketOption: abstract new (...args: any[]) => IPrintTicketOption;
+
+  interface IPrintTicketParameterDefinition {
+    readonly DataType: number;
+    readonly Name: string;
+    readonly RangeMax: number;
+    readonly RangeMin: number;
+    readonly UnitType: string;
+    readonly XmlNamespace: string;
+    readonly XmlNode: Windows.Data.Xml.Dom.IXmlNode;
+  }
+  var IPrintTicketParameterDefinition: abstract new (...args: any[]) => IPrintTicketParameterDefinition;
+
+  interface IPrintTicketParameterInitializer {
+    readonly Name: string;
+    Value: Windows.Graphics.Printing.PrintTicket.PrintTicketValue;
+    readonly XmlNamespace: string;
+    readonly XmlNode: Windows.Data.Xml.Dom.IXmlNode;
+  }
+  var IPrintTicketParameterInitializer: abstract new (...args: any[]) => IPrintTicketParameterInitializer;
+
+  interface IPrintTicketValue {
+    GetValueAsInteger(): number;
+    GetValueAsString(): string;
+    readonly Type: number;
+  }
+  var IPrintTicketValue: abstract new (...args: any[]) => IPrintTicketValue;
+
+  interface IWorkflowPrintTicket {
+    GetCapabilities(): Windows.Graphics.Printing.PrintTicket.PrintTicketCapabilities;
+    GetFeature(name: string, xmlNamespace: string): Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    GetParameterInitializer(name: string, xmlNamespace: string): Windows.Graphics.Printing.PrintTicket.PrintTicketParameterInitializer;
+    MergeAndValidateTicket(deltaShemaTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket): Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket;
+    NotifyXmlChangedAsync(): Windows.Foundation.IAsyncAction;
+    SetParameterInitializerAsInteger(name: string, xmlNamespace: string, integerValue: number): Windows.Graphics.Printing.PrintTicket.PrintTicketParameterInitializer;
+    SetParameterInitializerAsString(name: string, xmlNamespace: string, stringValue: string): Windows.Graphics.Printing.PrintTicket.PrintTicketParameterInitializer;
+    ValidateAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicketValidationResult>;
+    readonly DocumentBindingFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentCollateFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentDuplexFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentHolePunchFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentInputBinFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentNUpFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly DocumentStapleFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly JobPasscodeFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly Name: string;
+    readonly PageBorderlessFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageMediaSizeFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageMediaTypeFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageOrientationFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageOutputColorFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageOutputQualityFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly PageResolutionFeature: Windows.Graphics.Printing.PrintTicket.PrintTicketFeature;
+    readonly XmlNamespace: string;
+    readonly XmlNode: Windows.Data.Xml.Dom.IXmlNode;
+  }
+  var IWorkflowPrintTicket: abstract new (...args: any[]) => IWorkflowPrintTicket;
+
+  interface IWorkflowPrintTicketValidationResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Validated: boolean;
+  }
+  var IWorkflowPrintTicketValidationResult: abstract new (...args: any[]) => IWorkflowPrintTicketValidationResult;
+
+}
+
+declare namespace Windows.Graphics.Printing.ProtectedPrint {
+  class WindowsProtectedPrintInfo {
+    static readonly IsProtectedPrintEnabled: boolean;
+  }
+
+  interface IWindowsProtectedPrintInfoStatics {
+    readonly IsProtectedPrintEnabled: boolean;
+  }
+  var IWindowsProtectedPrintInfoStatics: abstract new (...args: any[]) => IWindowsProtectedPrintInfoStatics;
+
+}
+
+declare namespace Windows.Graphics.Printing.Workflow {
+  class PrintWorkflowBackgroundSession implements Windows.Graphics.Printing.Workflow.IPrintWorkflowBackgroundSession {
+    Start(): void;
+    readonly Status: number;
+    SetupRequested: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession, Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSetupRequestedEventArgs> | null;
+    Submitted: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession, Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedEventArgs> | null;
+  }
+
+  class PrintWorkflowBackgroundSetupRequestedEventArgs implements Windows.Graphics.Printing.Workflow.IPrintWorkflowBackgroundSetupRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    GetUserPrintTicketAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket>;
+    SetRequiresUI(): void;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+  }
+
+  class PrintWorkflowConfiguration implements Windows.Graphics.Printing.Workflow.IPrintWorkflowConfiguration, Windows.Graphics.Printing.Workflow.IPrintWorkflowConfiguration2 {
+    AbortPrintFlow(reason: number): void;
+    readonly JobTitle: string;
+    readonly SessionId: string;
+    readonly SourceAppDisplayName: string;
+  }
+
+  class PrintWorkflowForegroundSession implements Windows.Graphics.Printing.Workflow.IPrintWorkflowForegroundSession {
+    Start(): void;
+    readonly Status: number;
+    SetupRequested: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession, Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSetupRequestedEventArgs> | null;
+    XpsDataAvailable: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession, Windows.Graphics.Printing.Workflow.PrintWorkflowXpsDataAvailableEventArgs> | null;
+  }
+
+  class PrintWorkflowForegroundSetupRequestedEventArgs implements Windows.Graphics.Printing.Workflow.IPrintWorkflowForegroundSetupRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    GetUserPrintTicketAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket>;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+  }
+
+  class PrintWorkflowJobActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.Graphics.Printing.Workflow.IPrintWorkflowJobActivatedEventArgs {
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly Session: Windows.Graphics.Printing.Workflow.PrintWorkflowJobUISession;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class PrintWorkflowJobBackgroundSession implements Windows.Graphics.Printing.Workflow.IPrintWorkflowJobBackgroundSession, Windows.Graphics.Printing.Workflow.IPrintWorkflowJobBackgroundSession2 {
+    Start(): void;
+    readonly Status: number;
+    JobStarting: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowJobBackgroundSession, Windows.Graphics.Printing.Workflow.PrintWorkflowJobStartingEventArgs> | null;
+    PdlModificationRequested: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowJobBackgroundSession, Windows.Graphics.Printing.Workflow.PrintWorkflowPdlModificationRequestedEventArgs> | null;
+    JobIssueDetected: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowJobBackgroundSession, Windows.Graphics.Printing.Workflow.PrintWorkflowJobIssueDetectedEventArgs> | null;
+  }
+
+  class PrintWorkflowJobIssueDetectedEventArgs implements Windows.Graphics.Printing.Workflow.IPrintWorkflowJobIssueDetectedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly JobIssueKind: number;
+    readonly PrinterJob: Windows.Graphics.Printing.Workflow.PrintWorkflowPrinterJob;
+    SkipSystemErrorToast: boolean;
+    readonly UILauncher: Windows.Graphics.Printing.Workflow.PrintWorkflowUILauncher;
+  }
+
+  class PrintWorkflowJobNotificationEventArgs implements Windows.Graphics.Printing.Workflow.IPrintWorkflowJobNotificationEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+    readonly PrinterJob: Windows.Graphics.Printing.Workflow.PrintWorkflowPrinterJob;
+  }
+
+  class PrintWorkflowJobStartingEventArgs implements Windows.Graphics.Printing.Workflow.IPrintWorkflowJobStartingEventArgs, Windows.Graphics.Printing.Workflow.IPrintWorkflowJobStartingEventArgs2 {
+    DisableIppCompressionForJob(): void;
+    GetDeferral(): Windows.Foundation.Deferral;
+    SetSkipSystemRendering(): void;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+    readonly IsIppCompressionEnabled: boolean;
+    readonly Printer: Windows.Devices.Printers.IppPrintDevice;
+    SkipSystemFaxUI: boolean;
+  }
+
+  class PrintWorkflowJobTriggerDetails implements Windows.Graphics.Printing.Workflow.IPrintWorkflowJobTriggerDetails {
+    readonly PrintWorkflowJobSession: Windows.Graphics.Printing.Workflow.PrintWorkflowJobBackgroundSession;
+  }
+
+  class PrintWorkflowJobUISession implements Windows.Graphics.Printing.Workflow.IPrintWorkflowJobUISession, Windows.Graphics.Printing.Workflow.IPrintWorkflowJobUISession2 {
+    Start(): void;
+    readonly Status: number;
+    JobNotification: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowJobUISession, Windows.Graphics.Printing.Workflow.PrintWorkflowJobNotificationEventArgs> | null;
+    PdlDataAvailable: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowJobUISession, Windows.Graphics.Printing.Workflow.PrintWorkflowPdlDataAvailableEventArgs> | null;
+    VirtualPrinterUIDataAvailable: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowJobUISession, Windows.Graphics.Printing.Workflow.PrintWorkflowVirtualPrinterUIEventArgs> | null;
+  }
+
+  class PrintWorkflowObjectModelSourceFileContent implements Windows.Graphics.Printing.Workflow.IPrintWorkflowObjectModelSourceFileContent {
+    constructor(xpsStream: Windows.Storage.Streams.IInputStream);
+  }
+
+  class PrintWorkflowObjectModelTargetPackage implements Windows.Graphics.Printing.Workflow.IPrintWorkflowObjectModelTargetPackage {
+  }
+
+  class PrintWorkflowPdlConverter implements Windows.Graphics.Printing.Workflow.IPrintWorkflowPdlConverter, Windows.Graphics.Printing.Workflow.IPrintWorkflowPdlConverter2 {
+    ConvertPdlAsync(printTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket, inputStream: Windows.Storage.Streams.IInputStream, outputStream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncAction;
+    ConvertPdlAsync(printTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket, inputStream: Windows.Storage.Streams.IInputStream, outputStream: Windows.Storage.Streams.IOutputStream, hostBasedProcessingOperations: number): Windows.Foundation.IAsyncAction;
+  }
+
+  class PrintWorkflowPdlDataAvailableEventArgs implements Windows.Graphics.Printing.Workflow.IPrintWorkflowPdlDataAvailableEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+    readonly PrinterJob: Windows.Graphics.Printing.Workflow.PrintWorkflowPrinterJob;
+    readonly SourceContent: Windows.Graphics.Printing.Workflow.PrintWorkflowPdlSourceContent;
+  }
+
+  class PrintWorkflowPdlModificationRequestedEventArgs implements Windows.Graphics.Printing.Workflow.IPrintWorkflowPdlModificationRequestedEventArgs, Windows.Graphics.Printing.Workflow.IPrintWorkflowPdlModificationRequestedEventArgs2 {
+    CreateJobOnPrinter(targetContentType: string): Windows.Graphics.Printing.Workflow.PrintWorkflowPdlTargetStream;
+    CreateJobOnPrinterWithAttributes(jobAttributes: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>[], targetContentType: string): Windows.Graphics.Printing.Workflow.PrintWorkflowPdlTargetStream;
+    CreateJobOnPrinterWithAttributes(jobAttributes: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>[], targetContentType: string, operationAttributes: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>[], jobAttributesMergePolicy: number, operationAttributesMergePolicy: number): Windows.Graphics.Printing.Workflow.PrintWorkflowPdlTargetStream;
+    CreateJobOnPrinterWithAttributesBuffer(jobAttributesBuffer: Windows.Storage.Streams.IBuffer, targetContentType: string): Windows.Graphics.Printing.Workflow.PrintWorkflowPdlTargetStream;
+    CreateJobOnPrinterWithAttributesBuffer(jobAttributesBuffer: Windows.Storage.Streams.IBuffer, targetContentType: string, operationAttributesBuffer: Windows.Storage.Streams.IBuffer, jobAttributesMergePolicy: number, operationAttributesMergePolicy: number): Windows.Graphics.Printing.Workflow.PrintWorkflowPdlTargetStream;
+    GetDeferral(): Windows.Foundation.Deferral;
+    GetPdlConverter(conversionType: number): Windows.Graphics.Printing.Workflow.PrintWorkflowPdlConverter;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+    readonly PrinterJob: Windows.Graphics.Printing.Workflow.PrintWorkflowPrinterJob;
+    readonly SourceContent: Windows.Graphics.Printing.Workflow.PrintWorkflowPdlSourceContent;
+    readonly UILauncher: Windows.Graphics.Printing.Workflow.PrintWorkflowUILauncher;
+  }
+
+  class PrintWorkflowPdlSourceContent implements Windows.Graphics.Printing.Workflow.IPrintWorkflowPdlSourceContent {
+    GetContentFileAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    GetInputStream(): Windows.Storage.Streams.IInputStream;
+    readonly ContentType: string;
+  }
+
+  class PrintWorkflowPdlTargetStream implements Windows.Graphics.Printing.Workflow.IPrintWorkflowPdlTargetStream {
+    CompleteStreamSubmission(status: number): void;
+    GetOutputStream(): Windows.Storage.Streams.IOutputStream;
+  }
+
+  class PrintWorkflowPrinterJob implements Windows.Graphics.Printing.Workflow.IPrintWorkflowPrinterJob, Windows.Graphics.Printing.Workflow.IPrintWorkflowPrinterJob2 {
+    ConvertPrintTicketToJobAttributes(printTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket, targetPdlFormat: string): Windows.Foundation.Collections.IMap<string, Windows.Devices.Printers.IppAttributeValue> | Record<string, Windows.Devices.Printers.IppAttributeValue>;
+    GetJobAttributes(attributeNames: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.Collections.IMap<string, Windows.Devices.Printers.IppAttributeValue> | Record<string, Windows.Devices.Printers.IppAttributeValue>;
+    GetJobAttributesAsBuffer(attributeNames: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Storage.Streams.IBuffer;
+    GetJobPrintTicket(): Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket;
+    GetJobStatus(): number;
+    SetJobAttributes(jobAttributes: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>[]): Windows.Devices.Printers.IppSetAttributesResult;
+    SetJobAttributesFromBuffer(jobAttributesBuffer: Windows.Storage.Streams.IBuffer): Windows.Devices.Printers.IppSetAttributesResult;
+    readonly JobId: number;
+    readonly Printer: Windows.Devices.Printers.IppPrintDevice;
+  }
+
+  class PrintWorkflowSourceContent implements Windows.Graphics.Printing.Workflow.IPrintWorkflowSourceContent {
+    GetJobPrintTicketAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket>;
+    GetSourceSpoolDataAsStreamContent(): Windows.Graphics.Printing.Workflow.PrintWorkflowSpoolStreamContent;
+    GetSourceSpoolDataAsXpsObjectModel(): Windows.Graphics.Printing.Workflow.PrintWorkflowObjectModelSourceFileContent;
+  }
+
+  class PrintWorkflowSpoolStreamContent implements Windows.Graphics.Printing.Workflow.IPrintWorkflowSpoolStreamContent {
+    GetInputStream(): Windows.Storage.Streams.IInputStream;
+  }
+
+  class PrintWorkflowStreamTarget implements Windows.Graphics.Printing.Workflow.IPrintWorkflowStreamTarget {
+    GetOutputStream(): Windows.Storage.Streams.IOutputStream;
+  }
+
+  class PrintWorkflowSubmittedEventArgs implements Windows.Graphics.Printing.Workflow.IPrintWorkflowSubmittedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    GetTarget(jobPrintTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket): Windows.Graphics.Printing.Workflow.PrintWorkflowTarget;
+    readonly Operation: Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedOperation;
+  }
+
+  class PrintWorkflowSubmittedOperation implements Windows.Graphics.Printing.Workflow.IPrintWorkflowSubmittedOperation {
+    Complete(status: number): void;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+    readonly XpsContent: Windows.Graphics.Printing.Workflow.PrintWorkflowSourceContent;
+  }
+
+  class PrintWorkflowTarget implements Windows.Graphics.Printing.Workflow.IPrintWorkflowTarget {
+    readonly TargetAsStream: Windows.Graphics.Printing.Workflow.PrintWorkflowStreamTarget;
+    readonly TargetAsXpsObjectModelPackage: Windows.Graphics.Printing.Workflow.PrintWorkflowObjectModelTargetPackage;
+  }
+
+  class PrintWorkflowTriggerDetails implements Windows.Graphics.Printing.Workflow.IPrintWorkflowTriggerDetails {
+    readonly PrintWorkflowSession: Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession;
+  }
+
+  class PrintWorkflowUIActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.Graphics.Printing.Workflow.IPrintWorkflowUIActivatedEventArgs {
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly PrintWorkflowSession: Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class PrintWorkflowUILauncher implements Windows.Graphics.Printing.Workflow.IPrintWorkflowUILauncher {
+    IsUILaunchEnabled(): boolean;
+    LaunchAndCompleteUIAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+
+  class PrintWorkflowVirtualPrinterDataAvailableEventArgs implements Windows.Graphics.Printing.Workflow.IPrintWorkflowVirtualPrinterDataAvailableEventArgs {
+    CompleteJob(status: number): void;
+    GetJobPrintTicket(): Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket;
+    GetPdlConverter(conversionType: number): Windows.Graphics.Printing.Workflow.PrintWorkflowPdlConverter;
+    GetTargetFileAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+    readonly SourceContent: Windows.Graphics.Printing.Workflow.PrintWorkflowPdlSourceContent;
+    readonly UILauncher: Windows.Graphics.Printing.Workflow.PrintWorkflowUILauncher;
+  }
+
+  class PrintWorkflowVirtualPrinterSession implements Windows.Graphics.Printing.Workflow.IPrintWorkflowVirtualPrinterSession {
+    Start(): void;
+    readonly Printer: Windows.Devices.Printers.IppPrintDevice;
+    readonly Status: number;
+    VirtualPrinterDataAvailable: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowVirtualPrinterSession, Windows.Graphics.Printing.Workflow.PrintWorkflowVirtualPrinterDataAvailableEventArgs> | null;
+  }
+
+  class PrintWorkflowVirtualPrinterTriggerDetails implements Windows.Graphics.Printing.Workflow.IPrintWorkflowVirtualPrinterTriggerDetails {
+    readonly VirtualPrinterSession: Windows.Graphics.Printing.Workflow.PrintWorkflowVirtualPrinterSession;
+  }
+
+  class PrintWorkflowVirtualPrinterUIEventArgs implements Windows.Graphics.Printing.Workflow.IPrintWorkflowVirtualPrinterUIEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    GetJobPrintTicket(): Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+    readonly Printer: Windows.Devices.Printers.IppPrintDevice;
+    readonly SourceContent: Windows.Graphics.Printing.Workflow.PrintWorkflowPdlSourceContent;
+  }
+
+  class PrintWorkflowXpsDataAvailableEventArgs implements Windows.Graphics.Printing.Workflow.IPrintWorkflowXpsDataAvailableEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Operation: Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedOperation;
+  }
+
+  enum PdlConversionHostBasedProcessingOperations {
+    None = 0,
+    PageRotation = 1,
+    PageOrdering = 2,
+    Copies = 4,
+    BlankPageInsertion = 8,
+    All = 4294967295,
+  }
+
+  enum PrintWorkflowAttributesMergePolicy {
+    MergePreferPrintTicketOnConflict = 0,
+    MergePreferPsaOnConflict = 1,
+    DoNotMergeWithPrintTicket = 2,
+  }
+
+  enum PrintWorkflowJobAbortReason {
+    JobFailed = 0,
+    UserCanceled = 1,
+  }
+
+  enum PrintWorkflowJobIssueKind {
+    Other = 0,
+    AttentionRequired = 1,
+    DoorOpen = 2,
+    MarkerSupplyLow = 3,
+    MarkerSupplyEmpty = 4,
+    MediaJam = 5,
+    MediaEmpty = 6,
+    MediaLow = 7,
+    OutputAreaAlmostFull = 8,
+    OutputAreaFull = 9,
+    JobPrintingError = 10,
+  }
+
+  enum PrintWorkflowPdlConversionType {
+    XpsToPdf = 0,
+    XpsToPwgr = 1,
+    XpsToPclm = 2,
+    XpsToTiff = 3,
+  }
+
+  enum PrintWorkflowPrinterJobStatus {
+    Error = 0,
+    Aborted = 1,
+    InProgress = 2,
+    Completed = 3,
+  }
+
+  enum PrintWorkflowSessionStatus {
+    Started = 0,
+    Completed = 1,
+    Aborted = 2,
+    Closed = 3,
+    PdlDataAvailableForModification = 4,
+  }
+
+  enum PrintWorkflowSubmittedStatus {
+    Succeeded = 0,
+    Canceled = 1,
+    Failed = 2,
+  }
+
+  enum PrintWorkflowUICompletionStatus {
+    Completed = 0,
+    LaunchFailed = 1,
+    JobFailed = 2,
+    UserCanceled = 3,
+  }
+
+  interface IPrintWorkflowBackgroundSession {
+    Start(): void;
+    readonly Status: number;
+    SetupRequested: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession, Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSetupRequestedEventArgs> | null;
+    Submitted: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession, Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedEventArgs> | null;
+  }
+  var IPrintWorkflowBackgroundSession: abstract new (...args: any[]) => IPrintWorkflowBackgroundSession;
+
+  interface IPrintWorkflowBackgroundSetupRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    GetUserPrintTicketAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket>;
+    SetRequiresUI(): void;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+  }
+  var IPrintWorkflowBackgroundSetupRequestedEventArgs: abstract new (...args: any[]) => IPrintWorkflowBackgroundSetupRequestedEventArgs;
+
+  interface IPrintWorkflowConfiguration {
+    readonly JobTitle: string;
+    readonly SessionId: string;
+    readonly SourceAppDisplayName: string;
+  }
+  var IPrintWorkflowConfiguration: abstract new (...args: any[]) => IPrintWorkflowConfiguration;
+
+  interface IPrintWorkflowConfiguration2 {
+    AbortPrintFlow(reason: number): void;
+  }
+  var IPrintWorkflowConfiguration2: abstract new (...args: any[]) => IPrintWorkflowConfiguration2;
+
+  interface IPrintWorkflowForegroundSession {
+    Start(): void;
+    readonly Status: number;
+    SetupRequested: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession, Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSetupRequestedEventArgs> | null;
+    XpsDataAvailable: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession, Windows.Graphics.Printing.Workflow.PrintWorkflowXpsDataAvailableEventArgs> | null;
+  }
+  var IPrintWorkflowForegroundSession: abstract new (...args: any[]) => IPrintWorkflowForegroundSession;
+
+  interface IPrintWorkflowForegroundSetupRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    GetUserPrintTicketAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket>;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+  }
+  var IPrintWorkflowForegroundSetupRequestedEventArgs: abstract new (...args: any[]) => IPrintWorkflowForegroundSetupRequestedEventArgs;
+
+  interface IPrintWorkflowJobActivatedEventArgs {
+    readonly Session: Windows.Graphics.Printing.Workflow.PrintWorkflowJobUISession;
+  }
+  var IPrintWorkflowJobActivatedEventArgs: abstract new (...args: any[]) => IPrintWorkflowJobActivatedEventArgs;
+
+  interface IPrintWorkflowJobBackgroundSession {
+    Start(): void;
+    readonly Status: number;
+    JobStarting: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowJobBackgroundSession, Windows.Graphics.Printing.Workflow.PrintWorkflowJobStartingEventArgs> | null;
+    PdlModificationRequested: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowJobBackgroundSession, Windows.Graphics.Printing.Workflow.PrintWorkflowPdlModificationRequestedEventArgs> | null;
+  }
+  var IPrintWorkflowJobBackgroundSession: abstract new (...args: any[]) => IPrintWorkflowJobBackgroundSession;
+
+  interface IPrintWorkflowJobBackgroundSession2 {
+    JobIssueDetected: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowJobBackgroundSession, Windows.Graphics.Printing.Workflow.PrintWorkflowJobIssueDetectedEventArgs> | null;
+  }
+  var IPrintWorkflowJobBackgroundSession2: abstract new (...args: any[]) => IPrintWorkflowJobBackgroundSession2;
+
+  interface IPrintWorkflowJobIssueDetectedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly JobIssueKind: number;
+    readonly PrinterJob: Windows.Graphics.Printing.Workflow.PrintWorkflowPrinterJob;
+    SkipSystemErrorToast: boolean;
+    readonly UILauncher: Windows.Graphics.Printing.Workflow.PrintWorkflowUILauncher;
+  }
+  var IPrintWorkflowJobIssueDetectedEventArgs: abstract new (...args: any[]) => IPrintWorkflowJobIssueDetectedEventArgs;
+
+  interface IPrintWorkflowJobNotificationEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+    readonly PrinterJob: Windows.Graphics.Printing.Workflow.PrintWorkflowPrinterJob;
+  }
+  var IPrintWorkflowJobNotificationEventArgs: abstract new (...args: any[]) => IPrintWorkflowJobNotificationEventArgs;
+
+  interface IPrintWorkflowJobStartingEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    SetSkipSystemRendering(): void;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+    readonly Printer: Windows.Devices.Printers.IppPrintDevice;
+  }
+  var IPrintWorkflowJobStartingEventArgs: abstract new (...args: any[]) => IPrintWorkflowJobStartingEventArgs;
+
+  interface IPrintWorkflowJobStartingEventArgs2 {
+    DisableIppCompressionForJob(): void;
+    readonly IsIppCompressionEnabled: boolean;
+    SkipSystemFaxUI: boolean;
+  }
+  var IPrintWorkflowJobStartingEventArgs2: abstract new (...args: any[]) => IPrintWorkflowJobStartingEventArgs2;
+
+  interface IPrintWorkflowJobTriggerDetails {
+    readonly PrintWorkflowJobSession: Windows.Graphics.Printing.Workflow.PrintWorkflowJobBackgroundSession;
+  }
+  var IPrintWorkflowJobTriggerDetails: abstract new (...args: any[]) => IPrintWorkflowJobTriggerDetails;
+
+  interface IPrintWorkflowJobUISession {
+    Start(): void;
+    readonly Status: number;
+    JobNotification: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowJobUISession, Windows.Graphics.Printing.Workflow.PrintWorkflowJobNotificationEventArgs> | null;
+    PdlDataAvailable: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowJobUISession, Windows.Graphics.Printing.Workflow.PrintWorkflowPdlDataAvailableEventArgs> | null;
+  }
+  var IPrintWorkflowJobUISession: abstract new (...args: any[]) => IPrintWorkflowJobUISession;
+
+  interface IPrintWorkflowJobUISession2 {
+    VirtualPrinterUIDataAvailable: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowJobUISession, Windows.Graphics.Printing.Workflow.PrintWorkflowVirtualPrinterUIEventArgs> | null;
+  }
+  var IPrintWorkflowJobUISession2: abstract new (...args: any[]) => IPrintWorkflowJobUISession2;
+
+  interface IPrintWorkflowObjectModelSourceFileContent {
+  }
+  var IPrintWorkflowObjectModelSourceFileContent: abstract new (...args: any[]) => IPrintWorkflowObjectModelSourceFileContent;
+
+  interface IPrintWorkflowObjectModelSourceFileContentFactory {
+    CreateInstance(xpsStream: Windows.Storage.Streams.IInputStream): Windows.Graphics.Printing.Workflow.PrintWorkflowObjectModelSourceFileContent;
+  }
+  var IPrintWorkflowObjectModelSourceFileContentFactory: abstract new (...args: any[]) => IPrintWorkflowObjectModelSourceFileContentFactory;
+
+  interface IPrintWorkflowObjectModelTargetPackage {
+  }
+  var IPrintWorkflowObjectModelTargetPackage: abstract new (...args: any[]) => IPrintWorkflowObjectModelTargetPackage;
+
+  interface IPrintWorkflowPdlConverter {
+    ConvertPdlAsync(printTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket, inputStream: Windows.Storage.Streams.IInputStream, outputStream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncAction;
+  }
+  var IPrintWorkflowPdlConverter: abstract new (...args: any[]) => IPrintWorkflowPdlConverter;
+
+  interface IPrintWorkflowPdlConverter2 {
+    ConvertPdlAsync(printTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket, inputStream: Windows.Storage.Streams.IInputStream, outputStream: Windows.Storage.Streams.IOutputStream, hostBasedProcessingOperations: number): Windows.Foundation.IAsyncAction;
+  }
+  var IPrintWorkflowPdlConverter2: abstract new (...args: any[]) => IPrintWorkflowPdlConverter2;
+
+  interface IPrintWorkflowPdlDataAvailableEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+    readonly PrinterJob: Windows.Graphics.Printing.Workflow.PrintWorkflowPrinterJob;
+    readonly SourceContent: Windows.Graphics.Printing.Workflow.PrintWorkflowPdlSourceContent;
+  }
+  var IPrintWorkflowPdlDataAvailableEventArgs: abstract new (...args: any[]) => IPrintWorkflowPdlDataAvailableEventArgs;
+
+  interface IPrintWorkflowPdlModificationRequestedEventArgs {
+    CreateJobOnPrinter(targetContentType: string): Windows.Graphics.Printing.Workflow.PrintWorkflowPdlTargetStream;
+    CreateJobOnPrinterWithAttributes(jobAttributes: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>[], targetContentType: string): Windows.Graphics.Printing.Workflow.PrintWorkflowPdlTargetStream;
+    CreateJobOnPrinterWithAttributesBuffer(jobAttributesBuffer: Windows.Storage.Streams.IBuffer, targetContentType: string): Windows.Graphics.Printing.Workflow.PrintWorkflowPdlTargetStream;
+    GetDeferral(): Windows.Foundation.Deferral;
+    GetPdlConverter(conversionType: number): Windows.Graphics.Printing.Workflow.PrintWorkflowPdlConverter;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+    readonly PrinterJob: Windows.Graphics.Printing.Workflow.PrintWorkflowPrinterJob;
+    readonly SourceContent: Windows.Graphics.Printing.Workflow.PrintWorkflowPdlSourceContent;
+    readonly UILauncher: Windows.Graphics.Printing.Workflow.PrintWorkflowUILauncher;
+  }
+  var IPrintWorkflowPdlModificationRequestedEventArgs: abstract new (...args: any[]) => IPrintWorkflowPdlModificationRequestedEventArgs;
+
+  interface IPrintWorkflowPdlModificationRequestedEventArgs2 {
+    CreateJobOnPrinterWithAttributes(jobAttributes: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>[], targetContentType: string, operationAttributes: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>[], jobAttributesMergePolicy: number, operationAttributesMergePolicy: number): Windows.Graphics.Printing.Workflow.PrintWorkflowPdlTargetStream;
+    CreateJobOnPrinterWithAttributesBuffer(jobAttributesBuffer: Windows.Storage.Streams.IBuffer, targetContentType: string, operationAttributesBuffer: Windows.Storage.Streams.IBuffer, jobAttributesMergePolicy: number, operationAttributesMergePolicy: number): Windows.Graphics.Printing.Workflow.PrintWorkflowPdlTargetStream;
+  }
+  var IPrintWorkflowPdlModificationRequestedEventArgs2: abstract new (...args: any[]) => IPrintWorkflowPdlModificationRequestedEventArgs2;
+
+  interface IPrintWorkflowPdlSourceContent {
+    GetContentFileAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    GetInputStream(): Windows.Storage.Streams.IInputStream;
+    readonly ContentType: string;
+  }
+  var IPrintWorkflowPdlSourceContent: abstract new (...args: any[]) => IPrintWorkflowPdlSourceContent;
+
+  interface IPrintWorkflowPdlTargetStream {
+    CompleteStreamSubmission(status: number): void;
+    GetOutputStream(): Windows.Storage.Streams.IOutputStream;
+  }
+  var IPrintWorkflowPdlTargetStream: abstract new (...args: any[]) => IPrintWorkflowPdlTargetStream;
+
+  interface IPrintWorkflowPrinterJob {
+    GetJobAttributes(attributeNames: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.Collections.IMap<string, Windows.Devices.Printers.IppAttributeValue> | Record<string, Windows.Devices.Printers.IppAttributeValue>;
+    GetJobAttributesAsBuffer(attributeNames: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Storage.Streams.IBuffer;
+    GetJobPrintTicket(): Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket;
+    GetJobStatus(): number;
+    SetJobAttributes(jobAttributes: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Devices.Printers.IppAttributeValue>[]): Windows.Devices.Printers.IppSetAttributesResult;
+    SetJobAttributesFromBuffer(jobAttributesBuffer: Windows.Storage.Streams.IBuffer): Windows.Devices.Printers.IppSetAttributesResult;
+    readonly JobId: number;
+    readonly Printer: Windows.Devices.Printers.IppPrintDevice;
+  }
+  var IPrintWorkflowPrinterJob: abstract new (...args: any[]) => IPrintWorkflowPrinterJob;
+
+  interface IPrintWorkflowPrinterJob2 {
+    ConvertPrintTicketToJobAttributes(printTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket, targetPdlFormat: string): Windows.Foundation.Collections.IMap<string, Windows.Devices.Printers.IppAttributeValue> | Record<string, Windows.Devices.Printers.IppAttributeValue>;
+  }
+  var IPrintWorkflowPrinterJob2: abstract new (...args: any[]) => IPrintWorkflowPrinterJob2;
+
+  interface IPrintWorkflowSourceContent {
+    GetJobPrintTicketAsync(): Windows.Foundation.IAsyncOperation<Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket>;
+    GetSourceSpoolDataAsStreamContent(): Windows.Graphics.Printing.Workflow.PrintWorkflowSpoolStreamContent;
+    GetSourceSpoolDataAsXpsObjectModel(): Windows.Graphics.Printing.Workflow.PrintWorkflowObjectModelSourceFileContent;
+  }
+  var IPrintWorkflowSourceContent: abstract new (...args: any[]) => IPrintWorkflowSourceContent;
+
+  interface IPrintWorkflowSpoolStreamContent {
+    GetInputStream(): Windows.Storage.Streams.IInputStream;
+  }
+  var IPrintWorkflowSpoolStreamContent: abstract new (...args: any[]) => IPrintWorkflowSpoolStreamContent;
+
+  interface IPrintWorkflowStreamTarget {
+    GetOutputStream(): Windows.Storage.Streams.IOutputStream;
+  }
+  var IPrintWorkflowStreamTarget: abstract new (...args: any[]) => IPrintWorkflowStreamTarget;
+
+  interface IPrintWorkflowSubmittedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    GetTarget(jobPrintTicket: Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket): Windows.Graphics.Printing.Workflow.PrintWorkflowTarget;
+    readonly Operation: Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedOperation;
+  }
+  var IPrintWorkflowSubmittedEventArgs: abstract new (...args: any[]) => IPrintWorkflowSubmittedEventArgs;
+
+  interface IPrintWorkflowSubmittedOperation {
+    Complete(status: number): void;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+    readonly XpsContent: Windows.Graphics.Printing.Workflow.PrintWorkflowSourceContent;
+  }
+  var IPrintWorkflowSubmittedOperation: abstract new (...args: any[]) => IPrintWorkflowSubmittedOperation;
+
+  interface IPrintWorkflowTarget {
+    readonly TargetAsStream: Windows.Graphics.Printing.Workflow.PrintWorkflowStreamTarget;
+    readonly TargetAsXpsObjectModelPackage: Windows.Graphics.Printing.Workflow.PrintWorkflowObjectModelTargetPackage;
+  }
+  var IPrintWorkflowTarget: abstract new (...args: any[]) => IPrintWorkflowTarget;
+
+  interface IPrintWorkflowTriggerDetails {
+    readonly PrintWorkflowSession: Windows.Graphics.Printing.Workflow.PrintWorkflowBackgroundSession;
+  }
+  var IPrintWorkflowTriggerDetails: abstract new (...args: any[]) => IPrintWorkflowTriggerDetails;
+
+  interface IPrintWorkflowUIActivatedEventArgs extends Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser {
+    readonly PrintWorkflowSession: Windows.Graphics.Printing.Workflow.PrintWorkflowForegroundSession;
+  }
+  var IPrintWorkflowUIActivatedEventArgs: abstract new (...args: any[]) => IPrintWorkflowUIActivatedEventArgs;
+
+  interface IPrintWorkflowUILauncher {
+    IsUILaunchEnabled(): boolean;
+    LaunchAndCompleteUIAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IPrintWorkflowUILauncher: abstract new (...args: any[]) => IPrintWorkflowUILauncher;
+
+  interface IPrintWorkflowVirtualPrinterDataAvailableEventArgs {
+    CompleteJob(status: number): void;
+    GetJobPrintTicket(): Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket;
+    GetPdlConverter(conversionType: number): Windows.Graphics.Printing.Workflow.PrintWorkflowPdlConverter;
+    GetTargetFileAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+    readonly SourceContent: Windows.Graphics.Printing.Workflow.PrintWorkflowPdlSourceContent;
+    readonly UILauncher: Windows.Graphics.Printing.Workflow.PrintWorkflowUILauncher;
+  }
+  var IPrintWorkflowVirtualPrinterDataAvailableEventArgs: abstract new (...args: any[]) => IPrintWorkflowVirtualPrinterDataAvailableEventArgs;
+
+  interface IPrintWorkflowVirtualPrinterSession {
+    Start(): void;
+    readonly Printer: Windows.Devices.Printers.IppPrintDevice;
+    readonly Status: number;
+    VirtualPrinterDataAvailable: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing.Workflow.PrintWorkflowVirtualPrinterSession, Windows.Graphics.Printing.Workflow.PrintWorkflowVirtualPrinterDataAvailableEventArgs> | null;
+  }
+  var IPrintWorkflowVirtualPrinterSession: abstract new (...args: any[]) => IPrintWorkflowVirtualPrinterSession;
+
+  interface IPrintWorkflowVirtualPrinterTriggerDetails {
+    readonly VirtualPrinterSession: Windows.Graphics.Printing.Workflow.PrintWorkflowVirtualPrinterSession;
+  }
+  var IPrintWorkflowVirtualPrinterTriggerDetails: abstract new (...args: any[]) => IPrintWorkflowVirtualPrinterTriggerDetails;
+
+  interface IPrintWorkflowVirtualPrinterUIEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    GetJobPrintTicket(): Windows.Graphics.Printing.PrintTicket.WorkflowPrintTicket;
+    readonly Configuration: Windows.Graphics.Printing.Workflow.PrintWorkflowConfiguration;
+    readonly Printer: Windows.Devices.Printers.IppPrintDevice;
+    readonly SourceContent: Windows.Graphics.Printing.Workflow.PrintWorkflowPdlSourceContent;
+  }
+  var IPrintWorkflowVirtualPrinterUIEventArgs: abstract new (...args: any[]) => IPrintWorkflowVirtualPrinterUIEventArgs;
+
+  interface IPrintWorkflowXpsDataAvailableEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Operation: Windows.Graphics.Printing.Workflow.PrintWorkflowSubmittedOperation;
+  }
+  var IPrintWorkflowXpsDataAvailableEventArgs: abstract new (...args: any[]) => IPrintWorkflowXpsDataAvailableEventArgs;
+
+}
+
+declare namespace Windows.Graphics.Printing3D {
+  class Print3DManager implements Windows.Graphics.Printing3D.IPrint3DManager {
+    static GetForCurrentView(): Windows.Graphics.Printing3D.Print3DManager;
+    static ShowPrintUIAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TaskRequested: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing3D.Print3DManager, Windows.Graphics.Printing3D.Print3DTaskRequestedEventArgs> | null;
+  }
+
+  class Print3DTask implements Windows.Graphics.Printing3D.IPrint3DTask {
+    readonly Source: Windows.Graphics.Printing3D.Printing3D3MFPackage;
+    Completed: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing3D.Print3DTask, Windows.Graphics.Printing3D.Print3DTaskCompletedEventArgs> | null;
+    SourceChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing3D.Print3DTask, Windows.Graphics.Printing3D.Print3DTaskSourceChangedEventArgs> | null;
+    Submitting: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing3D.Print3DTask, Object> | null;
+  }
+
+  class Print3DTaskCompletedEventArgs implements Windows.Graphics.Printing3D.IPrint3DTaskCompletedEventArgs {
+    readonly Completion: number;
+    readonly ExtendedStatus: number;
+  }
+
+  class Print3DTaskRequest implements Windows.Graphics.Printing3D.IPrint3DTaskRequest {
+    CreateTask(title: string, printerId: string, handler: Windows.Graphics.Printing3D.Print3DTaskSourceRequestedHandler): Windows.Graphics.Printing3D.Print3DTask;
+  }
+
+  class Print3DTaskRequestedEventArgs implements Windows.Graphics.Printing3D.IPrint3DTaskRequestedEventArgs {
+    readonly Request: Windows.Graphics.Printing3D.Print3DTaskRequest;
+  }
+
+  class Print3DTaskSourceChangedEventArgs implements Windows.Graphics.Printing3D.IPrint3DTaskSourceChangedEventArgs {
+    readonly Source: Windows.Graphics.Printing3D.Printing3D3MFPackage;
+  }
+
+  class Print3DTaskSourceRequestedArgs implements Windows.Graphics.Printing3D.IPrint3DTaskSourceRequestedArgs {
+    SetSource(source: Windows.Graphics.Printing3D.Printing3D3MFPackage): void;
+  }
+
+  class Printing3D3MFPackage implements Windows.Graphics.Printing3D.IPrinting3D3MFPackage, Windows.Graphics.Printing3D.IPrinting3D3MFPackage2 {
+    constructor();
+    static LoadAsync(value: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<Windows.Graphics.Printing3D.Printing3D3MFPackage>;
+    LoadModelFromPackageAsync(value: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<Windows.Graphics.Printing3D.Printing3DModel>;
+    SaveAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    SaveModelToPackageAsync(value: Windows.Graphics.Printing3D.Printing3DModel): Windows.Foundation.IAsyncAction;
+    Compression: number;
+    ModelPart: Windows.Storage.Streams.IRandomAccessStream;
+    PrintTicket: Windows.Storage.Streams.IRandomAccessStream;
+    readonly Textures: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DTextureResource> | Windows.Graphics.Printing3D.Printing3DTextureResource[];
+    Thumbnail: Windows.Graphics.Printing3D.Printing3DTextureResource;
+  }
+
+  class Printing3DBaseMaterial implements Windows.Graphics.Printing3D.IPrinting3DBaseMaterial {
+    constructor();
+    static readonly Abs: string;
+    Color: Windows.Graphics.Printing3D.Printing3DColorMaterial;
+    Name: string;
+    static readonly Pla: string;
+  }
+
+  class Printing3DBaseMaterialGroup implements Windows.Graphics.Printing3D.IPrinting3DBaseMaterialGroup {
+    constructor(MaterialGroupId: number);
+    readonly Bases: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DBaseMaterial> | Windows.Graphics.Printing3D.Printing3DBaseMaterial[];
+    readonly MaterialGroupId: number;
+  }
+
+  class Printing3DColorMaterial implements Windows.Graphics.Printing3D.IPrinting3DColorMaterial, Windows.Graphics.Printing3D.IPrinting3DColorMaterial2 {
+    constructor();
+    Color: Windows.UI.Color;
+    Value: number;
+  }
+
+  class Printing3DColorMaterialGroup implements Windows.Graphics.Printing3D.IPrinting3DColorMaterialGroup {
+    constructor(MaterialGroupId: number);
+    readonly Colors: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DColorMaterial> | Windows.Graphics.Printing3D.Printing3DColorMaterial[];
+    readonly MaterialGroupId: number;
+  }
+
+  class Printing3DComponent implements Windows.Graphics.Printing3D.IPrinting3DComponent {
+    constructor();
+    readonly Components: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DComponentWithMatrix> | Windows.Graphics.Printing3D.Printing3DComponentWithMatrix[];
+    Mesh: Windows.Graphics.Printing3D.Printing3DMesh;
+    Name: string;
+    PartNumber: string;
+    Thumbnail: Windows.Graphics.Printing3D.Printing3DTextureResource;
+    Type: number;
+  }
+
+  class Printing3DComponentWithMatrix implements Windows.Graphics.Printing3D.IPrinting3DComponentWithMatrix {
+    constructor();
+    Component: Windows.Graphics.Printing3D.Printing3DComponent;
+    Matrix: Windows.Foundation.Numerics.Matrix4x4;
+  }
+
+  class Printing3DCompositeMaterial implements Windows.Graphics.Printing3D.IPrinting3DCompositeMaterial {
+    constructor();
+    readonly Values: Windows.Foundation.Collections.IVector<number> | number[];
+  }
+
+  class Printing3DCompositeMaterialGroup implements Windows.Graphics.Printing3D.IPrinting3DCompositeMaterialGroup, Windows.Graphics.Printing3D.IPrinting3DCompositeMaterialGroup2 {
+    constructor(MaterialGroupId: number);
+    BaseMaterialGroup: Windows.Graphics.Printing3D.Printing3DBaseMaterialGroup;
+    readonly Composites: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DCompositeMaterial> | Windows.Graphics.Printing3D.Printing3DCompositeMaterial[];
+    readonly MaterialGroupId: number;
+    readonly MaterialIndices: Windows.Foundation.Collections.IVector<number> | number[];
+  }
+
+  class Printing3DFaceReductionOptions implements Windows.Graphics.Printing3D.IPrinting3DFaceReductionOptions {
+    constructor();
+    MaxEdgeLength: number;
+    MaxReductionArea: number;
+    TargetTriangleCount: number;
+  }
+
+  class Printing3DMaterial implements Windows.Graphics.Printing3D.IPrinting3DMaterial {
+    constructor();
+    readonly BaseGroups: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DBaseMaterialGroup> | Windows.Graphics.Printing3D.Printing3DBaseMaterialGroup[];
+    readonly ColorGroups: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DColorMaterialGroup> | Windows.Graphics.Printing3D.Printing3DColorMaterialGroup[];
+    readonly CompositeGroups: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DCompositeMaterialGroup> | Windows.Graphics.Printing3D.Printing3DCompositeMaterialGroup[];
+    readonly MultiplePropertyGroups: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DMultiplePropertyMaterialGroup> | Windows.Graphics.Printing3D.Printing3DMultiplePropertyMaterialGroup[];
+    readonly Texture2CoordGroups: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DTexture2CoordMaterialGroup> | Windows.Graphics.Printing3D.Printing3DTexture2CoordMaterialGroup[];
+  }
+
+  class Printing3DMesh implements Windows.Graphics.Printing3D.IPrinting3DMesh {
+    constructor();
+    CreateTriangleIndices(value: number): void;
+    CreateTriangleMaterialIndices(value: number): void;
+    CreateVertexNormals(value: number): void;
+    CreateVertexPositions(value: number): void;
+    GetTriangleIndices(): Windows.Storage.Streams.IBuffer;
+    GetTriangleMaterialIndices(): Windows.Storage.Streams.IBuffer;
+    GetVertexNormals(): Windows.Storage.Streams.IBuffer;
+    GetVertexPositions(): Windows.Storage.Streams.IBuffer;
+    VerifyAsync(value: number): Windows.Foundation.IAsyncOperation<Windows.Graphics.Printing3D.Printing3DMeshVerificationResult>;
+    readonly BufferDescriptionSet: Windows.Foundation.Collections.IPropertySet;
+    readonly BufferSet: Windows.Foundation.Collections.IPropertySet;
+    IndexCount: number;
+    TriangleIndicesDescription: Windows.Graphics.Printing3D.Printing3DBufferDescription;
+    TriangleMaterialIndicesDescription: Windows.Graphics.Printing3D.Printing3DBufferDescription;
+    VertexCount: number;
+    VertexNormalsDescription: Windows.Graphics.Printing3D.Printing3DBufferDescription;
+    VertexPositionsDescription: Windows.Graphics.Printing3D.Printing3DBufferDescription;
+  }
+
+  class Printing3DMeshVerificationResult implements Windows.Graphics.Printing3D.IPrinting3DMeshVerificationResult {
+    readonly IsValid: boolean;
+    readonly NonmanifoldTriangles: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly ReversedNormalTriangles: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class Printing3DModel implements Windows.Graphics.Printing3D.IPrinting3DModel, Windows.Graphics.Printing3D.IPrinting3DModel2 {
+    constructor();
+    Clone(): Windows.Graphics.Printing3D.Printing3DModel;
+    RepairAsync(): Windows.Foundation.IAsyncAction;
+    RepairWithProgressAsync(): Windows.Foundation.IAsyncOperationWithProgress<boolean, number>;
+    TryPartialRepairAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryPartialRepairAsync(maxWaitTime: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<boolean>;
+    TryReduceFacesAsync(): Windows.Foundation.IAsyncOperationWithProgress<boolean, number>;
+    TryReduceFacesAsync(printing3DFaceReductionOptions: Windows.Graphics.Printing3D.Printing3DFaceReductionOptions): Windows.Foundation.IAsyncOperationWithProgress<boolean, number>;
+    TryReduceFacesAsync(printing3DFaceReductionOptions: Windows.Graphics.Printing3D.Printing3DFaceReductionOptions, maxWait: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperationWithProgress<boolean, number>;
+    Build: Windows.Graphics.Printing3D.Printing3DComponent;
+    readonly Components: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DComponent> | Windows.Graphics.Printing3D.Printing3DComponent[];
+    Material: Windows.Graphics.Printing3D.Printing3DMaterial;
+    readonly Meshes: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DMesh> | Windows.Graphics.Printing3D.Printing3DMesh[];
+    readonly Metadata: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    readonly RequiredExtensions: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Textures: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DModelTexture> | Windows.Graphics.Printing3D.Printing3DModelTexture[];
+    Unit: number;
+    Version: string;
+  }
+
+  class Printing3DModelTexture implements Windows.Graphics.Printing3D.IPrinting3DModelTexture {
+    constructor();
+    TextureResource: Windows.Graphics.Printing3D.Printing3DTextureResource;
+    TileStyleU: number;
+    TileStyleV: number;
+  }
+
+  class Printing3DMultiplePropertyMaterial implements Windows.Graphics.Printing3D.IPrinting3DMultiplePropertyMaterial {
+    constructor();
+    readonly MaterialIndices: Windows.Foundation.Collections.IVector<number> | number[];
+  }
+
+  class Printing3DMultiplePropertyMaterialGroup implements Windows.Graphics.Printing3D.IPrinting3DMultiplePropertyMaterialGroup {
+    constructor(MaterialGroupId: number);
+    readonly MaterialGroupId: number;
+    readonly MaterialGroupIndices: Windows.Foundation.Collections.IVector<number> | number[];
+    readonly MultipleProperties: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DMultiplePropertyMaterial> | Windows.Graphics.Printing3D.Printing3DMultiplePropertyMaterial[];
+  }
+
+  class Printing3DTexture2CoordMaterial implements Windows.Graphics.Printing3D.IPrinting3DTexture2CoordMaterial {
+    constructor();
+    Texture: Windows.Graphics.Printing3D.Printing3DModelTexture;
+    U: number;
+    V: number;
+  }
+
+  class Printing3DTexture2CoordMaterialGroup implements Windows.Graphics.Printing3D.IPrinting3DTexture2CoordMaterialGroup, Windows.Graphics.Printing3D.IPrinting3DTexture2CoordMaterialGroup2 {
+    constructor(MaterialGroupId: number);
+    readonly MaterialGroupId: number;
+    Texture: Windows.Graphics.Printing3D.Printing3DModelTexture;
+    readonly Texture2Coords: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DTexture2CoordMaterial> | Windows.Graphics.Printing3D.Printing3DTexture2CoordMaterial[];
+  }
+
+  class Printing3DTextureResource implements Windows.Graphics.Printing3D.IPrinting3DTextureResource {
+    constructor();
+    Name: string;
+    TextureData: Windows.Storage.Streams.IRandomAccessStreamWithContentType;
+  }
+
+  enum Print3DTaskCompletion {
+    Abandoned = 0,
+    Canceled = 1,
+    Failed = 2,
+    Slicing = 3,
+    Submitted = 4,
+  }
+
+  enum Print3DTaskDetail {
+    Unknown = 0,
+    ModelExceedsPrintBed = 1,
+    UploadFailed = 2,
+    InvalidMaterialSelection = 3,
+    InvalidModel = 4,
+    ModelNotManifold = 5,
+    InvalidPrintTicket = 6,
+  }
+
+  enum Printing3DBufferFormat {
+    Unknown = 0,
+    R32G32B32A32Float = 2,
+    R32G32B32A32UInt = 3,
+    R32G32B32Float = 6,
+    R32G32B32UInt = 7,
+    Printing3DDouble = 500,
+    Printing3DUInt = 501,
+  }
+
+  enum Printing3DMeshVerificationMode {
+    FindFirstError = 0,
+    FindAllErrors = 1,
+  }
+
+  enum Printing3DModelUnit {
+    Meter = 0,
+    Micron = 1,
+    Millimeter = 2,
+    Centimeter = 3,
+    Inch = 4,
+    Foot = 5,
+  }
+
+  enum Printing3DObjectType {
+    Model = 0,
+    Support = 1,
+    Others = 2,
+  }
+
+  enum Printing3DPackageCompression {
+    Low = 0,
+    Medium = 1,
+    High = 2,
+  }
+
+  enum Printing3DTextureEdgeBehavior {
+    None = 0,
+    Wrap = 1,
+    Mirror = 2,
+    Clamp = 3,
+  }
+
+  interface IPrint3DManager {
+    TaskRequested: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing3D.Print3DManager, Windows.Graphics.Printing3D.Print3DTaskRequestedEventArgs> | null;
+  }
+  var IPrint3DManager: abstract new (...args: any[]) => IPrint3DManager;
+
+  interface IPrint3DManagerStatics {
+    GetForCurrentView(): Windows.Graphics.Printing3D.Print3DManager;
+    ShowPrintUIAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IPrint3DManagerStatics: abstract new (...args: any[]) => IPrint3DManagerStatics;
+
+  interface IPrint3DTask {
+    readonly Source: Windows.Graphics.Printing3D.Printing3D3MFPackage;
+    Completed: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing3D.Print3DTask, Windows.Graphics.Printing3D.Print3DTaskCompletedEventArgs> | null;
+    SourceChanged: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing3D.Print3DTask, Windows.Graphics.Printing3D.Print3DTaskSourceChangedEventArgs> | null;
+    Submitting: Windows.Foundation.TypedEventHandler<Windows.Graphics.Printing3D.Print3DTask, Object> | null;
+  }
+  var IPrint3DTask: abstract new (...args: any[]) => IPrint3DTask;
+
+  interface IPrint3DTaskCompletedEventArgs {
+    readonly Completion: number;
+    readonly ExtendedStatus: number;
+  }
+  var IPrint3DTaskCompletedEventArgs: abstract new (...args: any[]) => IPrint3DTaskCompletedEventArgs;
+
+  interface IPrint3DTaskRequest {
+    CreateTask(title: string, printerId: string, handler: Windows.Graphics.Printing3D.Print3DTaskSourceRequestedHandler): Windows.Graphics.Printing3D.Print3DTask;
+  }
+  var IPrint3DTaskRequest: abstract new (...args: any[]) => IPrint3DTaskRequest;
+
+  interface IPrint3DTaskRequestedEventArgs {
+    readonly Request: Windows.Graphics.Printing3D.Print3DTaskRequest;
+  }
+  var IPrint3DTaskRequestedEventArgs: abstract new (...args: any[]) => IPrint3DTaskRequestedEventArgs;
+
+  interface IPrint3DTaskSourceChangedEventArgs {
+    readonly Source: Windows.Graphics.Printing3D.Printing3D3MFPackage;
+  }
+  var IPrint3DTaskSourceChangedEventArgs: abstract new (...args: any[]) => IPrint3DTaskSourceChangedEventArgs;
+
+  interface IPrint3DTaskSourceRequestedArgs {
+    SetSource(source: Windows.Graphics.Printing3D.Printing3D3MFPackage): void;
+  }
+  var IPrint3DTaskSourceRequestedArgs: abstract new (...args: any[]) => IPrint3DTaskSourceRequestedArgs;
+
+  interface IPrinting3D3MFPackage {
+    LoadModelFromPackageAsync(value: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<Windows.Graphics.Printing3D.Printing3DModel>;
+    SaveAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    SaveModelToPackageAsync(value: Windows.Graphics.Printing3D.Printing3DModel): Windows.Foundation.IAsyncAction;
+    ModelPart: Windows.Storage.Streams.IRandomAccessStream;
+    PrintTicket: Windows.Storage.Streams.IRandomAccessStream;
+    readonly Textures: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DTextureResource> | Windows.Graphics.Printing3D.Printing3DTextureResource[];
+    Thumbnail: Windows.Graphics.Printing3D.Printing3DTextureResource;
+  }
+  var IPrinting3D3MFPackage: abstract new (...args: any[]) => IPrinting3D3MFPackage;
+
+  interface IPrinting3D3MFPackage2 {
+    Compression: number;
+  }
+  var IPrinting3D3MFPackage2: abstract new (...args: any[]) => IPrinting3D3MFPackage2;
+
+  interface IPrinting3D3MFPackageStatics {
+    LoadAsync(value: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<Windows.Graphics.Printing3D.Printing3D3MFPackage>;
+  }
+  var IPrinting3D3MFPackageStatics: abstract new (...args: any[]) => IPrinting3D3MFPackageStatics;
+
+  interface IPrinting3DBaseMaterial {
+    Color: Windows.Graphics.Printing3D.Printing3DColorMaterial;
+    Name: string;
+  }
+  var IPrinting3DBaseMaterial: abstract new (...args: any[]) => IPrinting3DBaseMaterial;
+
+  interface IPrinting3DBaseMaterialGroup {
+    readonly Bases: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DBaseMaterial> | Windows.Graphics.Printing3D.Printing3DBaseMaterial[];
+    readonly MaterialGroupId: number;
+  }
+  var IPrinting3DBaseMaterialGroup: abstract new (...args: any[]) => IPrinting3DBaseMaterialGroup;
+
+  interface IPrinting3DBaseMaterialGroupFactory {
+    Create(MaterialGroupId: number): Windows.Graphics.Printing3D.Printing3DBaseMaterialGroup;
+  }
+  var IPrinting3DBaseMaterialGroupFactory: abstract new (...args: any[]) => IPrinting3DBaseMaterialGroupFactory;
+
+  interface IPrinting3DBaseMaterialStatics {
+    readonly Abs: string;
+    readonly Pla: string;
+  }
+  var IPrinting3DBaseMaterialStatics: abstract new (...args: any[]) => IPrinting3DBaseMaterialStatics;
+
+  interface IPrinting3DColorMaterial {
+    Value: number;
+  }
+  var IPrinting3DColorMaterial: abstract new (...args: any[]) => IPrinting3DColorMaterial;
+
+  interface IPrinting3DColorMaterial2 {
+    Color: Windows.UI.Color;
+  }
+  var IPrinting3DColorMaterial2: abstract new (...args: any[]) => IPrinting3DColorMaterial2;
+
+  interface IPrinting3DColorMaterialGroup {
+    readonly Colors: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DColorMaterial> | Windows.Graphics.Printing3D.Printing3DColorMaterial[];
+    readonly MaterialGroupId: number;
+  }
+  var IPrinting3DColorMaterialGroup: abstract new (...args: any[]) => IPrinting3DColorMaterialGroup;
+
+  interface IPrinting3DColorMaterialGroupFactory {
+    Create(MaterialGroupId: number): Windows.Graphics.Printing3D.Printing3DColorMaterialGroup;
+  }
+  var IPrinting3DColorMaterialGroupFactory: abstract new (...args: any[]) => IPrinting3DColorMaterialGroupFactory;
+
+  interface IPrinting3DComponent {
+    readonly Components: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DComponentWithMatrix> | Windows.Graphics.Printing3D.Printing3DComponentWithMatrix[];
+    Mesh: Windows.Graphics.Printing3D.Printing3DMesh;
+    Name: string;
+    PartNumber: string;
+    Thumbnail: Windows.Graphics.Printing3D.Printing3DTextureResource;
+    Type: number;
+  }
+  var IPrinting3DComponent: abstract new (...args: any[]) => IPrinting3DComponent;
+
+  interface IPrinting3DComponentWithMatrix {
+    Component: Windows.Graphics.Printing3D.Printing3DComponent;
+    Matrix: Windows.Foundation.Numerics.Matrix4x4;
+  }
+  var IPrinting3DComponentWithMatrix: abstract new (...args: any[]) => IPrinting3DComponentWithMatrix;
+
+  interface IPrinting3DCompositeMaterial {
+    readonly Values: Windows.Foundation.Collections.IVector<number> | number[];
+  }
+  var IPrinting3DCompositeMaterial: abstract new (...args: any[]) => IPrinting3DCompositeMaterial;
+
+  interface IPrinting3DCompositeMaterialGroup {
+    readonly Composites: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DCompositeMaterial> | Windows.Graphics.Printing3D.Printing3DCompositeMaterial[];
+    readonly MaterialGroupId: number;
+    readonly MaterialIndices: Windows.Foundation.Collections.IVector<number> | number[];
+  }
+  var IPrinting3DCompositeMaterialGroup: abstract new (...args: any[]) => IPrinting3DCompositeMaterialGroup;
+
+  interface IPrinting3DCompositeMaterialGroup2 {
+    BaseMaterialGroup: Windows.Graphics.Printing3D.Printing3DBaseMaterialGroup;
+  }
+  var IPrinting3DCompositeMaterialGroup2: abstract new (...args: any[]) => IPrinting3DCompositeMaterialGroup2;
+
+  interface IPrinting3DCompositeMaterialGroupFactory {
+    Create(MaterialGroupId: number): Windows.Graphics.Printing3D.Printing3DCompositeMaterialGroup;
+  }
+  var IPrinting3DCompositeMaterialGroupFactory: abstract new (...args: any[]) => IPrinting3DCompositeMaterialGroupFactory;
+
+  interface IPrinting3DFaceReductionOptions {
+    MaxEdgeLength: number;
+    MaxReductionArea: number;
+    TargetTriangleCount: number;
+  }
+  var IPrinting3DFaceReductionOptions: abstract new (...args: any[]) => IPrinting3DFaceReductionOptions;
+
+  interface IPrinting3DMaterial {
+    readonly BaseGroups: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DBaseMaterialGroup> | Windows.Graphics.Printing3D.Printing3DBaseMaterialGroup[];
+    readonly ColorGroups: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DColorMaterialGroup> | Windows.Graphics.Printing3D.Printing3DColorMaterialGroup[];
+    readonly CompositeGroups: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DCompositeMaterialGroup> | Windows.Graphics.Printing3D.Printing3DCompositeMaterialGroup[];
+    readonly MultiplePropertyGroups: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DMultiplePropertyMaterialGroup> | Windows.Graphics.Printing3D.Printing3DMultiplePropertyMaterialGroup[];
+    readonly Texture2CoordGroups: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DTexture2CoordMaterialGroup> | Windows.Graphics.Printing3D.Printing3DTexture2CoordMaterialGroup[];
+  }
+  var IPrinting3DMaterial: abstract new (...args: any[]) => IPrinting3DMaterial;
+
+  interface IPrinting3DMesh {
+    CreateTriangleIndices(value: number): void;
+    CreateTriangleMaterialIndices(value: number): void;
+    CreateVertexNormals(value: number): void;
+    CreateVertexPositions(value: number): void;
+    GetTriangleIndices(): Windows.Storage.Streams.IBuffer;
+    GetTriangleMaterialIndices(): Windows.Storage.Streams.IBuffer;
+    GetVertexNormals(): Windows.Storage.Streams.IBuffer;
+    GetVertexPositions(): Windows.Storage.Streams.IBuffer;
+    VerifyAsync(value: number): Windows.Foundation.IAsyncOperation<Windows.Graphics.Printing3D.Printing3DMeshVerificationResult>;
+    readonly BufferDescriptionSet: Windows.Foundation.Collections.IPropertySet;
+    readonly BufferSet: Windows.Foundation.Collections.IPropertySet;
+    IndexCount: number;
+    TriangleIndicesDescription: Windows.Graphics.Printing3D.Printing3DBufferDescription;
+    TriangleMaterialIndicesDescription: Windows.Graphics.Printing3D.Printing3DBufferDescription;
+    VertexCount: number;
+    VertexNormalsDescription: Windows.Graphics.Printing3D.Printing3DBufferDescription;
+    VertexPositionsDescription: Windows.Graphics.Printing3D.Printing3DBufferDescription;
+  }
+  var IPrinting3DMesh: abstract new (...args: any[]) => IPrinting3DMesh;
+
+  interface IPrinting3DMeshVerificationResult {
+    readonly IsValid: boolean;
+    readonly NonmanifoldTriangles: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly ReversedNormalTriangles: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IPrinting3DMeshVerificationResult: abstract new (...args: any[]) => IPrinting3DMeshVerificationResult;
+
+  interface IPrinting3DModel {
+    Clone(): Windows.Graphics.Printing3D.Printing3DModel;
+    RepairAsync(): Windows.Foundation.IAsyncAction;
+    Build: Windows.Graphics.Printing3D.Printing3DComponent;
+    readonly Components: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DComponent> | Windows.Graphics.Printing3D.Printing3DComponent[];
+    Material: Windows.Graphics.Printing3D.Printing3DMaterial;
+    readonly Meshes: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DMesh> | Windows.Graphics.Printing3D.Printing3DMesh[];
+    readonly Metadata: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    readonly RequiredExtensions: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Textures: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DModelTexture> | Windows.Graphics.Printing3D.Printing3DModelTexture[];
+    Unit: number;
+    Version: string;
+  }
+  var IPrinting3DModel: abstract new (...args: any[]) => IPrinting3DModel;
+
+  interface IPrinting3DModel2 {
+    RepairWithProgressAsync(): Windows.Foundation.IAsyncOperationWithProgress<boolean, number>;
+    TryPartialRepairAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryPartialRepairAsync(maxWaitTime: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<boolean>;
+    TryReduceFacesAsync(): Windows.Foundation.IAsyncOperationWithProgress<boolean, number>;
+    TryReduceFacesAsync(printing3DFaceReductionOptions: Windows.Graphics.Printing3D.Printing3DFaceReductionOptions): Windows.Foundation.IAsyncOperationWithProgress<boolean, number>;
+    TryReduceFacesAsync(printing3DFaceReductionOptions: Windows.Graphics.Printing3D.Printing3DFaceReductionOptions, maxWait: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperationWithProgress<boolean, number>;
+  }
+  var IPrinting3DModel2: abstract new (...args: any[]) => IPrinting3DModel2;
+
+  interface IPrinting3DModelTexture {
+    TextureResource: Windows.Graphics.Printing3D.Printing3DTextureResource;
+    TileStyleU: number;
+    TileStyleV: number;
+  }
+  var IPrinting3DModelTexture: abstract new (...args: any[]) => IPrinting3DModelTexture;
+
+  interface IPrinting3DMultiplePropertyMaterial {
+    readonly MaterialIndices: Windows.Foundation.Collections.IVector<number> | number[];
+  }
+  var IPrinting3DMultiplePropertyMaterial: abstract new (...args: any[]) => IPrinting3DMultiplePropertyMaterial;
+
+  interface IPrinting3DMultiplePropertyMaterialGroup {
+    readonly MaterialGroupId: number;
+    readonly MaterialGroupIndices: Windows.Foundation.Collections.IVector<number> | number[];
+    readonly MultipleProperties: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DMultiplePropertyMaterial> | Windows.Graphics.Printing3D.Printing3DMultiplePropertyMaterial[];
+  }
+  var IPrinting3DMultiplePropertyMaterialGroup: abstract new (...args: any[]) => IPrinting3DMultiplePropertyMaterialGroup;
+
+  interface IPrinting3DMultiplePropertyMaterialGroupFactory {
+    Create(MaterialGroupId: number): Windows.Graphics.Printing3D.Printing3DMultiplePropertyMaterialGroup;
+  }
+  var IPrinting3DMultiplePropertyMaterialGroupFactory: abstract new (...args: any[]) => IPrinting3DMultiplePropertyMaterialGroupFactory;
+
+  interface IPrinting3DTexture2CoordMaterial {
+    Texture: Windows.Graphics.Printing3D.Printing3DModelTexture;
+    U: number;
+    V: number;
+  }
+  var IPrinting3DTexture2CoordMaterial: abstract new (...args: any[]) => IPrinting3DTexture2CoordMaterial;
+
+  interface IPrinting3DTexture2CoordMaterialGroup {
+    readonly MaterialGroupId: number;
+    readonly Texture2Coords: Windows.Foundation.Collections.IVector<Windows.Graphics.Printing3D.Printing3DTexture2CoordMaterial> | Windows.Graphics.Printing3D.Printing3DTexture2CoordMaterial[];
+  }
+  var IPrinting3DTexture2CoordMaterialGroup: abstract new (...args: any[]) => IPrinting3DTexture2CoordMaterialGroup;
+
+  interface IPrinting3DTexture2CoordMaterialGroup2 {
+    Texture: Windows.Graphics.Printing3D.Printing3DModelTexture;
+  }
+  var IPrinting3DTexture2CoordMaterialGroup2: abstract new (...args: any[]) => IPrinting3DTexture2CoordMaterialGroup2;
+
+  interface IPrinting3DTexture2CoordMaterialGroupFactory {
+    Create(MaterialGroupId: number): Windows.Graphics.Printing3D.Printing3DTexture2CoordMaterialGroup;
+  }
+  var IPrinting3DTexture2CoordMaterialGroupFactory: abstract new (...args: any[]) => IPrinting3DTexture2CoordMaterialGroupFactory;
+
+  interface IPrinting3DTextureResource {
+    Name: string;
+    TextureData: Windows.Storage.Streams.IRandomAccessStreamWithContentType;
+  }
+  var IPrinting3DTextureResource: abstract new (...args: any[]) => IPrinting3DTextureResource;
+
+  interface Print3DTaskSourceRequestedHandler {
+    (args: Windows.Graphics.Printing3D.Print3DTaskSourceRequestedArgs): void;
+  }
+  var Print3DTaskSourceRequestedHandler: {
+    new(callback: (args: Windows.Graphics.Printing3D.Print3DTaskSourceRequestedArgs) => void): Print3DTaskSourceRequestedHandler;
+  };
+
+  interface Printing3DBufferDescription {
+    Format: number;
+    Stride: number;
+  }
+  var Printing3DBufferDescription: {
+    new(format: number, stride: number): Printing3DBufferDescription;
+    new(fields: { Format?: number; Stride?: number }): Printing3DBufferDescription;
+  };
+
+  interface Printing3DContract {
+  }
+  var Printing3DContract: {
+    new(fields: {  }): Printing3DContract;
+  };
+
+}
+
+declare namespace Windows.Management {
+  class MdmAlert implements Windows.Management.IMdmAlert {
+    constructor();
+    Data: string;
+    Format: number;
+    Mark: number;
+    Source: string;
+    readonly Status: number;
+    Target: string;
+    Type: string;
+  }
+
+  class MdmSession implements Windows.Management.IMdmSession {
+    AttachAsync(): Windows.Foundation.IAsyncAction;
+    Delete(): void;
+    StartAsync(): Windows.Foundation.IAsyncAction;
+    StartAsync(alerts: Windows.Foundation.Collections.IIterable<Windows.Management.MdmAlert> | Windows.Management.MdmAlert[]): Windows.Foundation.IAsyncAction;
+    readonly Alerts: Windows.Foundation.Collections.IVectorView<Windows.Management.MdmAlert> | Windows.Management.MdmAlert[];
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Id: string;
+    readonly State: number;
+  }
+
+  class MdmSessionManager {
+    static DeleteSessionById(sessionId: string): void;
+    static GetSessionById(sessionId: string): Windows.Management.MdmSession;
+    static TryCreateSession(): Windows.Management.MdmSession;
+    static readonly SessionIds: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+
+  enum MdmAlertDataType {
+    String = 0,
+    Base64 = 1,
+    Boolean = 2,
+    Integer = 3,
+  }
+
+  enum MdmAlertMark {
+    None = 0,
+    Fatal = 1,
+    Critical = 2,
+    Warning = 3,
+    Informational = 4,
+  }
+
+  enum MdmSessionState {
+    NotStarted = 0,
+    Starting = 1,
+    Connecting = 2,
+    Communicating = 3,
+    AlertStatusAvailable = 4,
+    Retrying = 5,
+    Completed = 6,
+  }
+
+  interface IMdmAlert {
+    Data: string;
+    Format: number;
+    Mark: number;
+    Source: string;
+    readonly Status: number;
+    Target: string;
+    Type: string;
+  }
+  var IMdmAlert: abstract new (...args: any[]) => IMdmAlert;
+
+  interface IMdmSession {
+    AttachAsync(): Windows.Foundation.IAsyncAction;
+    Delete(): void;
+    StartAsync(): Windows.Foundation.IAsyncAction;
+    StartAsync(alerts: Windows.Foundation.Collections.IIterable<Windows.Management.MdmAlert> | Windows.Management.MdmAlert[]): Windows.Foundation.IAsyncAction;
+    readonly Alerts: Windows.Foundation.Collections.IVectorView<Windows.Management.MdmAlert> | Windows.Management.MdmAlert[];
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Id: string;
+    readonly State: number;
+  }
+  var IMdmSession: abstract new (...args: any[]) => IMdmSession;
+
+  interface IMdmSessionManagerStatics {
+    DeleteSessionById(sessionId: string): void;
+    GetSessionById(sessionId: string): Windows.Management.MdmSession;
+    TryCreateSession(): Windows.Management.MdmSession;
+    readonly SessionIds: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var IMdmSessionManagerStatics: abstract new (...args: any[]) => IMdmSessionManagerStatics;
+
+}
+
+declare namespace Windows.Management.Core {
+  class ApplicationDataManager implements Windows.Management.Core.IApplicationDataManager {
+    static CreateForPackageFamily(packageFamilyName: string): Windows.Storage.ApplicationData;
+  }
+
+  interface IApplicationDataManager {
+  }
+  var IApplicationDataManager: abstract new (...args: any[]) => IApplicationDataManager;
+
+  interface IApplicationDataManagerStatics {
+    CreateForPackageFamily(packageFamilyName: string): Windows.Storage.ApplicationData;
+  }
+  var IApplicationDataManagerStatics: abstract new (...args: any[]) => IApplicationDataManagerStatics;
+
+}
+
+declare namespace Windows.Management.Deployment {
+  class AddPackageOptions implements Windows.Management.Deployment.IAddPackageOptions, Windows.Management.Deployment.IAddPackageOptions2 {
+    constructor();
+    AllowUnsigned: boolean;
+    DeferRegistrationWhenPackagesAreInUse: boolean;
+    readonly DependencyPackageUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    DeveloperMode: boolean;
+    readonly ExpectedDigests: Windows.Foundation.Collections.IMap<Windows.Foundation.Uri, string>;
+    ExternalLocationUri: Windows.Foundation.Uri;
+    ForceAppShutdown: boolean;
+    ForceTargetAppShutdown: boolean;
+    ForceUpdateFromAnyVersion: boolean;
+    InstallAllResources: boolean;
+    LimitToExistingPackages: boolean;
+    readonly OptionalPackageFamilyNames: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly OptionalPackageUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly RelatedPackageUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    RequiredContentGroupOnly: boolean;
+    RetainFilesOnFailure: boolean;
+    StageInPlace: boolean;
+    StubPackageOption: number;
+    TargetVolume: Windows.Management.Deployment.PackageVolume;
+  }
+
+  class AppInstallerManager implements Windows.Management.Deployment.IAppInstallerManager {
+    ClearAutoUpdateSettings(packageFamilyName: string): void;
+    static GetDefault(): Windows.Management.Deployment.AppInstallerManager;
+    static GetForSystem(): Windows.Management.Deployment.AppInstallerManager;
+    PauseAutoUpdatesUntil(packageFamilyName: string, dateTime: Windows.Foundation.DateTime): void;
+    SetAutoUpdateSettings(packageFamilyName: string, appInstallerInfo: Windows.Management.Deployment.AutoUpdateSettingsOptions): void;
+  }
+
+  class AutoUpdateSettingsOptions implements Windows.Management.Deployment.IAutoUpdateSettingsOptions {
+    constructor();
+    static CreateFromAppInstallerInfo(appInstallerInfo: Windows.ApplicationModel.AppInstallerInfo): Windows.Management.Deployment.AutoUpdateSettingsOptions;
+    AppInstallerUri: Windows.Foundation.Uri;
+    AutomaticBackgroundTask: boolean;
+    readonly DependencyPackageUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    ForceUpdateFromAnyVersion: boolean;
+    HoursBetweenUpdateChecks: number;
+    IsAutoRepairEnabled: boolean;
+    OnLaunch: boolean;
+    readonly OptionalPackageUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly RepairUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    ShowPrompt: boolean;
+    UpdateBlocksActivation: boolean;
+    readonly UpdateUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    Version: Windows.ApplicationModel.PackageVersion;
+  }
+
+  class CreateSharedPackageContainerOptions implements Windows.Management.Deployment.ICreateSharedPackageContainerOptions {
+    constructor();
+    CreateCollisionOption: number;
+    ForceAppShutdown: boolean;
+    readonly Members: Windows.Foundation.Collections.IVector<Windows.Management.Deployment.SharedPackageContainerMember> | Windows.Management.Deployment.SharedPackageContainerMember[];
+  }
+
+  class CreateSharedPackageContainerResult implements Windows.Management.Deployment.ICreateSharedPackageContainerResult {
+    readonly Container: Windows.Management.Deployment.SharedPackageContainer;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+
+  class DeleteSharedPackageContainerOptions implements Windows.Management.Deployment.IDeleteSharedPackageContainerOptions {
+    constructor();
+    AllUsers: boolean;
+    ForceAppShutdown: boolean;
+  }
+
+  class DeleteSharedPackageContainerResult implements Windows.Management.Deployment.IDeleteSharedPackageContainerResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+
+  class DeploymentResult implements Windows.Management.Deployment.IDeploymentResult, Windows.Management.Deployment.IDeploymentResult2 {
+    readonly ActivityId: Guid;
+    readonly ErrorText: string;
+    readonly ExtendedErrorCode: Windows.Foundation.HResult;
+    readonly IsRegistered: boolean;
+  }
+
+  class FindSharedPackageContainerOptions implements Windows.Management.Deployment.IFindSharedPackageContainerOptions {
+    constructor();
+    Name: string;
+    PackageFamilyName: string;
+  }
+
+  class PackageAllUserProvisioningOptions implements Windows.Management.Deployment.IPackageAllUserProvisioningOptions, Windows.Management.Deployment.IPackageAllUserProvisioningOptions2 {
+    constructor();
+    DeferAutomaticRegistration: boolean;
+    readonly OptionalPackageFamilyNames: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly ProjectionOrderPackageFamilyNames: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+
+  class PackageManager implements Windows.Management.Deployment.IPackageManager, Windows.Management.Deployment.IPackageManager10, Windows.Management.Deployment.IPackageManager11, Windows.Management.Deployment.IPackageManager12, Windows.Management.Deployment.IPackageManager2, Windows.Management.Deployment.IPackageManager3, Windows.Management.Deployment.IPackageManager4, Windows.Management.Deployment.IPackageManager5, Windows.Management.Deployment.IPackageManager6, Windows.Management.Deployment.IPackageManager7, Windows.Management.Deployment.IPackageManager8, Windows.Management.Deployment.IPackageManager9 {
+    constructor();
+    AddPackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    AddPackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number, targetVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    AddPackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number, targetVolume: Windows.Management.Deployment.PackageVolume, optionalPackageFamilyNames: Windows.Foundation.Collections.IIterable<string> | string[], externalPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    AddPackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], options: number, targetVolume: Windows.Management.Deployment.PackageVolume, optionalPackageFamilyNames: Windows.Foundation.Collections.IIterable<string> | string[], packageUrisToInstall: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], relatedPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    AddPackageByAppInstallerFileAsync(appInstallerFileUri: Windows.Foundation.Uri, options: number, targetVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    AddPackageByUriAsync(packageUri: Windows.Foundation.Uri, options: Windows.Management.Deployment.AddPackageOptions): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    AddPackageVolumeAsync(packageStorePath: string): Windows.Foundation.IAsyncOperation<Windows.Management.Deployment.PackageVolume>;
+    CleanupPackageForUserAsync(packageName: string, userSecurityId: string): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    ClearPackageStatus(packageFullName: string, status: number): void;
+    DeprovisionPackageForAllUsersAsync(packageFamilyName: string): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    FindPackage(packageFullName: string): Windows.ApplicationModel.Package;
+    FindPackageForUser(userSecurityId: string, packageFullName: string): Windows.ApplicationModel.Package;
+    FindPackageVolume(volumeName: string): Windows.Management.Deployment.PackageVolume;
+    FindPackageVolumes(): Windows.Foundation.Collections.IIterable<Windows.Management.Deployment.PackageVolume> | Windows.Management.Deployment.PackageVolume[];
+    FindPackages(): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackages(packageName: string, packagePublisher: string): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackages(packageFamilyName: string): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUser(userSecurityId: string): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUser(userSecurityId: string, packageName: string, packagePublisher: string): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUser(userSecurityId: string, packageFamilyName: string): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUserWithPackageTypes(userSecurityId: string, packageTypes: number): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUserWithPackageTypes(userSecurityId: string, packageName: string, packagePublisher: string, packageTypes: number): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUserWithPackageTypes(userSecurityId: string, packageFamilyName: string, packageTypes: number): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesWithPackageTypes(packageTypes: number): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesWithPackageTypes(packageName: string, packagePublisher: string, packageTypes: number): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesWithPackageTypes(packageFamilyName: string, packageTypes: number): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindProvisionedPackages(): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindUsers(packageFullName: string): Windows.Foundation.Collections.IIterable<Windows.Management.Deployment.PackageUserInformation> | Windows.Management.Deployment.PackageUserInformation[];
+    GetDefaultPackageVolume(): Windows.Management.Deployment.PackageVolume;
+    GetPackageStubPreference(packageFamilyName: string): number;
+    GetPackageVolumesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Management.Deployment.PackageVolume> | Windows.Management.Deployment.PackageVolume[]>;
+    IsPackageRemovalPending(packageFullName: string): boolean;
+    IsPackageRemovalPendingByUri(packageUri: Windows.Foundation.Uri): boolean;
+    IsPackageRemovalPendingByUriForUser(packageUri: Windows.Foundation.Uri, userSecurityId: string): boolean;
+    IsPackageRemovalPendingForUser(packageFullName: string, userSecurityId: string): boolean;
+    MovePackageToVolumeAsync(packageFullName: string, deploymentOptions: number, targetVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    ProvisionPackageForAllUsersAsync(packageFamilyName: string): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    ProvisionPackageForAllUsersAsync(mainPackageFamilyName: string, options: Windows.Management.Deployment.PackageAllUserProvisioningOptions): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RegisterPackageAsync(manifestUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RegisterPackageAsync(manifestUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number, appDataVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RegisterPackageByFamilyNameAsync(mainPackageFamilyName: string, dependencyPackageFamilyNames: Windows.Foundation.Collections.IIterable<string> | string[], deploymentOptions: number, appDataVolume: Windows.Management.Deployment.PackageVolume, optionalPackageFamilyNames: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RegisterPackageByFullNameAsync(mainPackageFullName: string, dependencyPackageFullNames: Windows.Foundation.Collections.IIterable<string> | string[], deploymentOptions: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RegisterPackageByUriAsync(manifestUri: Windows.Foundation.Uri, options: Windows.Management.Deployment.RegisterPackageOptions): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RegisterPackagesByFullNameAsync(packageFullNames: Windows.Foundation.Collections.IIterable<string> | string[], options: Windows.Management.Deployment.RegisterPackageOptions): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RemovePackageAsync(packageFullName: string): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RemovePackageAsync(packageFullName: string, removalOptions: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RemovePackageByUriAsync(packageUri: Windows.Foundation.Uri, options: Windows.Management.Deployment.RemovePackageOptions): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RemovePackageVolumeAsync(volume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RequestAddPackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number, targetVolume: Windows.Management.Deployment.PackageVolume, optionalPackageFamilyNames: Windows.Foundation.Collections.IIterable<string> | string[], relatedPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RequestAddPackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number, targetVolume: Windows.Management.Deployment.PackageVolume, optionalPackageFamilyNames: Windows.Foundation.Collections.IIterable<string> | string[], relatedPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], packageUrisToInstall: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RequestAddPackageByAppInstallerFileAsync(appInstallerFileUri: Windows.Foundation.Uri, options: number, targetVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    SetDefaultPackageVolume(volume: Windows.Management.Deployment.PackageVolume): void;
+    SetPackageState(packageFullName: string, packageState: number): void;
+    SetPackageStatus(packageFullName: string, status: number): void;
+    SetPackageStubPreference(packageFamilyName: string, useStub: number): void;
+    SetPackageVolumeOfflineAsync(packageVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    SetPackageVolumeOnlineAsync(packageVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    StagePackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    StagePackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    StagePackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number, targetVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    StagePackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number, targetVolume: Windows.Management.Deployment.PackageVolume, optionalPackageFamilyNames: Windows.Foundation.Collections.IIterable<string> | string[], externalPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    StagePackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], options: number, targetVolume: Windows.Management.Deployment.PackageVolume, optionalPackageFamilyNames: Windows.Foundation.Collections.IIterable<string> | string[], packageUrisToInstall: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], relatedPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    StagePackageByUriAsync(packageUri: Windows.Foundation.Uri, options: Windows.Management.Deployment.StagePackageOptions): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    StageUserDataAsync(packageFullName: string): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    StageUserDataAsync(packageFullName: string, deploymentOptions: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    UpdatePackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    readonly DebugSettings: Windows.Management.Deployment.PackageManagerDebugSettings;
+  }
+
+  class PackageManagerDebugSettings implements Windows.Management.Deployment.IPackageManagerDebugSettings {
+    SetContentGroupStateAsync(package_: Windows.ApplicationModel.Package, contentGroupName: string, state: number): Windows.Foundation.IAsyncAction;
+    SetContentGroupStateAsync(package_: Windows.ApplicationModel.Package, contentGroupName: string, state: number, completionPercentage: number): Windows.Foundation.IAsyncAction;
+  }
+
+  class PackageUserInformation implements Windows.Management.Deployment.IPackageUserInformation {
+    readonly InstallState: number;
+    readonly UserSecurityId: string;
+  }
+
+  class PackageVolume implements Windows.Management.Deployment.IPackageVolume, Windows.Management.Deployment.IPackageVolume2 {
+    FindPackage(packageFullName: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackageForUser(userSecurityId: string, packageFullName: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackages(): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackages(packageName: string, packagePublisher: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackages(packageFamilyName: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUser(userSecurityId: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUser(userSecurityId: string, packageName: string, packagePublisher: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUser(userSecurityId: string, packageFamilyName: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUserWithPackageTypes(userSecurityId: string, packageTypes: number): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUserWithPackageTypes(userSecurityId: string, packageTypes: number, packageName: string, packagePublisher: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUserWithPackageTypes(userSecurityId: string, packageTypes: number, packageFamilyName: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesWithPackageTypes(packageTypes: number): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesWithPackageTypes(packageTypes: number, packageName: string, packagePublisher: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesWithPackageTypes(packageTypes: number, packageFamilyName: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    GetAvailableSpaceAsync(): Windows.Foundation.IAsyncOperation<number | bigint>;
+    readonly IsAppxInstallSupported: boolean;
+    readonly IsFullTrustPackageSupported: boolean;
+    readonly IsOffline: boolean;
+    readonly IsSystemVolume: boolean;
+    readonly MountPoint: string;
+    readonly Name: string;
+    readonly PackageStorePath: string;
+    readonly SupportsHardLinks: boolean;
+  }
+
+  class RegisterPackageOptions implements Windows.Management.Deployment.IRegisterPackageOptions, Windows.Management.Deployment.IRegisterPackageOptions2 {
+    constructor();
+    AllowUnsigned: boolean;
+    AppDataVolume: Windows.Management.Deployment.PackageVolume;
+    DeferRegistrationWhenPackagesAreInUse: boolean;
+    readonly DependencyPackageUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    DeveloperMode: boolean;
+    readonly ExpectedDigests: Windows.Foundation.Collections.IMap<Windows.Foundation.Uri, string>;
+    ExternalLocationUri: Windows.Foundation.Uri;
+    ForceAppShutdown: boolean;
+    ForceTargetAppShutdown: boolean;
+    ForceUpdateFromAnyVersion: boolean;
+    InstallAllResources: boolean;
+    readonly OptionalPackageFamilyNames: Windows.Foundation.Collections.IVector<string> | string[];
+    StageInPlace: boolean;
+  }
+
+  class RemovePackageOptions implements Windows.Management.Deployment.IRemovePackageOptions, Windows.Management.Deployment.IRemovePackageOptions2 {
+    constructor();
+    DeferRemovalWhenPackagesAreInUse: boolean;
+    PreserveApplicationData: boolean;
+    PreserveRoamableApplicationData: boolean;
+    RemoveForAllUsers: boolean;
+  }
+
+  class SharedPackageContainer implements Windows.Management.Deployment.ISharedPackageContainer {
+    GetMembers(): Windows.Foundation.Collections.IVector<Windows.Management.Deployment.SharedPackageContainerMember> | Windows.Management.Deployment.SharedPackageContainerMember[];
+    RemovePackageFamily(packageFamilyName: string, options: Windows.Management.Deployment.UpdateSharedPackageContainerOptions): Windows.Management.Deployment.UpdateSharedPackageContainerResult;
+    ResetData(): Windows.Management.Deployment.UpdateSharedPackageContainerResult;
+    readonly Id: string;
+    readonly Name: string;
+  }
+
+  class SharedPackageContainerManager implements Windows.Management.Deployment.ISharedPackageContainerManager {
+    CreateContainer(name: string, options: Windows.Management.Deployment.CreateSharedPackageContainerOptions): Windows.Management.Deployment.CreateSharedPackageContainerResult;
+    DeleteContainer(id: string, options: Windows.Management.Deployment.DeleteSharedPackageContainerOptions): Windows.Management.Deployment.DeleteSharedPackageContainerResult;
+    FindContainers(): Windows.Foundation.Collections.IVector<Windows.Management.Deployment.SharedPackageContainer> | Windows.Management.Deployment.SharedPackageContainer[];
+    FindContainers(options: Windows.Management.Deployment.FindSharedPackageContainerOptions): Windows.Foundation.Collections.IVector<Windows.Management.Deployment.SharedPackageContainer> | Windows.Management.Deployment.SharedPackageContainer[];
+    GetContainer(id: string): Windows.Management.Deployment.SharedPackageContainer;
+    static GetDefault(): Windows.Management.Deployment.SharedPackageContainerManager;
+    static GetForProvisioning(): Windows.Management.Deployment.SharedPackageContainerManager;
+    static GetForUser(userSid: string): Windows.Management.Deployment.SharedPackageContainerManager;
+  }
+
+  class SharedPackageContainerMember implements Windows.Management.Deployment.ISharedPackageContainerMember {
+    constructor(packageFamilyName: string);
+    readonly PackageFamilyName: string;
+  }
+
+  class StagePackageOptions implements Windows.Management.Deployment.IStagePackageOptions, Windows.Management.Deployment.IStagePackageOptions2 {
+    constructor();
+    AllowUnsigned: boolean;
+    readonly DependencyPackageUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    DeveloperMode: boolean;
+    readonly ExpectedDigests: Windows.Foundation.Collections.IMap<Windows.Foundation.Uri, string>;
+    ExternalLocationUri: Windows.Foundation.Uri;
+    ForceUpdateFromAnyVersion: boolean;
+    InstallAllResources: boolean;
+    readonly OptionalPackageFamilyNames: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly OptionalPackageUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly RelatedPackageUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    RequiredContentGroupOnly: boolean;
+    StageInPlace: boolean;
+    StubPackageOption: number;
+    TargetVolume: Windows.Management.Deployment.PackageVolume;
+  }
+
+  class UpdateSharedPackageContainerOptions implements Windows.Management.Deployment.IUpdateSharedPackageContainerOptions {
+    constructor();
+    ForceAppShutdown: boolean;
+    RequirePackagesPresent: boolean;
+  }
+
+  class UpdateSharedPackageContainerResult implements Windows.Management.Deployment.IUpdateSharedPackageContainerResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+
+  enum AddPackageByAppInstallerOptions {
+    None = 0,
+    InstallAllResources = 32,
+    ForceTargetAppShutdown = 64,
+    RequiredContentGroupOnly = 256,
+    LimitToExistingPackages = 512,
+  }
+
+  enum DeploymentOptions {
+    None = 0,
+    ForceApplicationShutdown = 1,
+    DevelopmentMode = 2,
+    InstallAllResources = 32,
+    ForceTargetApplicationShutdown = 64,
+    RequiredContentGroupOnly = 256,
+    ForceUpdateFromAnyVersion = 262144,
+    RetainFilesOnFailure = 2097152,
+    StageInPlace = 4194304,
+  }
+
+  enum DeploymentProgressState {
+    Queued = 0,
+    Processing = 1,
+  }
+
+  enum PackageInstallState {
+    NotInstalled = 0,
+    Staged = 1,
+    Installed = 2,
+    Paused = 6,
+  }
+
+  enum PackageState {
+    Normal = 0,
+    LicenseInvalid = 1,
+    Modified = 2,
+    Tampered = 3,
+  }
+
+  enum PackageStatus {
+    OK = 0,
+    LicenseIssue = 1,
+    Modified = 2,
+    Tampered = 4,
+    Disabled = 8,
+  }
+
+  enum PackageStubPreference {
+    Full = 0,
+    Stub = 1,
+  }
+
+  enum PackageTypes {
+    None = 0,
+    Main = 1,
+    Framework = 2,
+    Resource = 4,
+    Bundle = 8,
+    Xap = 16,
+    Optional = 32,
+    All = 4294967295,
+  }
+
+  enum RemovalOptions {
+    None = 0,
+    PreserveApplicationData = 4096,
+    PreserveRoamableApplicationData = 128,
+    DeferRemovalWhenPackagesAreInUse = 8192,
+    RemoveForAllUsers = 524288,
+  }
+
+  enum SharedPackageContainerCreationCollisionOptions {
+    FailIfExists = 0,
+    MergeWithExisting = 1,
+    ReplaceExisting = 2,
+  }
+
+  enum SharedPackageContainerOperationStatus {
+    Success = 0,
+    BlockedByPolicy = 1,
+    AlreadyExists = 2,
+    PackageFamilyExistsInAnotherContainer = 3,
+    NotFound = 4,
+    UnknownFailure = 5,
+  }
+
+  enum StubPackageOption {
+    Default = 0,
+    InstallFull = 1,
+    InstallStub = 2,
+    UsePreference = 3,
+  }
+
+  interface DeploymentProgress {
+    state: number;
+    percentage: number;
+  }
+  var DeploymentProgress: {
+    new(state: number, percentage: number): DeploymentProgress;
+    new(fields: { state?: number; percentage?: number }): DeploymentProgress;
+  };
+
+  interface IAddPackageOptions {
+    AllowUnsigned: boolean;
+    DeferRegistrationWhenPackagesAreInUse: boolean;
+    readonly DependencyPackageUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    DeveloperMode: boolean;
+    ExternalLocationUri: Windows.Foundation.Uri;
+    ForceAppShutdown: boolean;
+    ForceTargetAppShutdown: boolean;
+    ForceUpdateFromAnyVersion: boolean;
+    InstallAllResources: boolean;
+    readonly OptionalPackageFamilyNames: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly OptionalPackageUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly RelatedPackageUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    RequiredContentGroupOnly: boolean;
+    RetainFilesOnFailure: boolean;
+    StageInPlace: boolean;
+    StubPackageOption: number;
+    TargetVolume: Windows.Management.Deployment.PackageVolume;
+  }
+  var IAddPackageOptions: abstract new (...args: any[]) => IAddPackageOptions;
+
+  interface IAddPackageOptions2 {
+    readonly ExpectedDigests: Windows.Foundation.Collections.IMap<Windows.Foundation.Uri, string>;
+    LimitToExistingPackages: boolean;
+  }
+  var IAddPackageOptions2: abstract new (...args: any[]) => IAddPackageOptions2;
+
+  interface IAppInstallerManager {
+    ClearAutoUpdateSettings(packageFamilyName: string): void;
+    PauseAutoUpdatesUntil(packageFamilyName: string, dateTime: Windows.Foundation.DateTime): void;
+    SetAutoUpdateSettings(packageFamilyName: string, appInstallerInfo: Windows.Management.Deployment.AutoUpdateSettingsOptions): void;
+  }
+  var IAppInstallerManager: abstract new (...args: any[]) => IAppInstallerManager;
+
+  interface IAppInstallerManagerStatics {
+    GetDefault(): Windows.Management.Deployment.AppInstallerManager;
+    GetForSystem(): Windows.Management.Deployment.AppInstallerManager;
+  }
+  var IAppInstallerManagerStatics: abstract new (...args: any[]) => IAppInstallerManagerStatics;
+
+  interface IAutoUpdateSettingsOptions {
+    AppInstallerUri: Windows.Foundation.Uri;
+    AutomaticBackgroundTask: boolean;
+    readonly DependencyPackageUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    ForceUpdateFromAnyVersion: boolean;
+    HoursBetweenUpdateChecks: number;
+    IsAutoRepairEnabled: boolean;
+    OnLaunch: boolean;
+    readonly OptionalPackageUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly RepairUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    ShowPrompt: boolean;
+    UpdateBlocksActivation: boolean;
+    readonly UpdateUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    Version: Windows.ApplicationModel.PackageVersion;
+  }
+  var IAutoUpdateSettingsOptions: abstract new (...args: any[]) => IAutoUpdateSettingsOptions;
+
+  interface IAutoUpdateSettingsOptionsStatics {
+    CreateFromAppInstallerInfo(appInstallerInfo: Windows.ApplicationModel.AppInstallerInfo): Windows.Management.Deployment.AutoUpdateSettingsOptions;
+  }
+  var IAutoUpdateSettingsOptionsStatics: abstract new (...args: any[]) => IAutoUpdateSettingsOptionsStatics;
+
+  interface ICreateSharedPackageContainerOptions {
+    CreateCollisionOption: number;
+    ForceAppShutdown: boolean;
+    readonly Members: Windows.Foundation.Collections.IVector<Windows.Management.Deployment.SharedPackageContainerMember> | Windows.Management.Deployment.SharedPackageContainerMember[];
+  }
+  var ICreateSharedPackageContainerOptions: abstract new (...args: any[]) => ICreateSharedPackageContainerOptions;
+
+  interface ICreateSharedPackageContainerResult {
+    readonly Container: Windows.Management.Deployment.SharedPackageContainer;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+  var ICreateSharedPackageContainerResult: abstract new (...args: any[]) => ICreateSharedPackageContainerResult;
+
+  interface IDeleteSharedPackageContainerOptions {
+    AllUsers: boolean;
+    ForceAppShutdown: boolean;
+  }
+  var IDeleteSharedPackageContainerOptions: abstract new (...args: any[]) => IDeleteSharedPackageContainerOptions;
+
+  interface IDeleteSharedPackageContainerResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+  var IDeleteSharedPackageContainerResult: abstract new (...args: any[]) => IDeleteSharedPackageContainerResult;
+
+  interface IDeploymentResult {
+    readonly ActivityId: Guid;
+    readonly ErrorText: string;
+    readonly ExtendedErrorCode: Windows.Foundation.HResult;
+  }
+  var IDeploymentResult: abstract new (...args: any[]) => IDeploymentResult;
+
+  interface IDeploymentResult2 {
+    readonly IsRegistered: boolean;
+  }
+  var IDeploymentResult2: abstract new (...args: any[]) => IDeploymentResult2;
+
+  interface IFindSharedPackageContainerOptions {
+    Name: string;
+    PackageFamilyName: string;
+  }
+  var IFindSharedPackageContainerOptions: abstract new (...args: any[]) => IFindSharedPackageContainerOptions;
+
+  interface IPackageAllUserProvisioningOptions {
+    readonly OptionalPackageFamilyNames: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly ProjectionOrderPackageFamilyNames: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var IPackageAllUserProvisioningOptions: abstract new (...args: any[]) => IPackageAllUserProvisioningOptions;
+
+  interface IPackageAllUserProvisioningOptions2 {
+    DeferAutomaticRegistration: boolean;
+  }
+  var IPackageAllUserProvisioningOptions2: abstract new (...args: any[]) => IPackageAllUserProvisioningOptions2;
+
+  interface IPackageManager {
+    AddPackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    CleanupPackageForUserAsync(packageName: string, userSecurityId: string): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    FindPackage(packageFullName: string): Windows.ApplicationModel.Package;
+    FindPackageForUser(userSecurityId: string, packageFullName: string): Windows.ApplicationModel.Package;
+    FindPackages(): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackages(packageName: string, packagePublisher: string): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackages(packageFamilyName: string): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUser(userSecurityId: string): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUser(userSecurityId: string, packageName: string, packagePublisher: string): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUser(userSecurityId: string, packageFamilyName: string): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindUsers(packageFullName: string): Windows.Foundation.Collections.IIterable<Windows.Management.Deployment.PackageUserInformation> | Windows.Management.Deployment.PackageUserInformation[];
+    RegisterPackageAsync(manifestUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RemovePackageAsync(packageFullName: string): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    SetPackageState(packageFullName: string, packageState: number): void;
+    StagePackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    UpdatePackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+  }
+  var IPackageManager: abstract new (...args: any[]) => IPackageManager;
+
+  interface IPackageManager10 {
+    ProvisionPackageForAllUsersAsync(mainPackageFamilyName: string, options: Windows.Management.Deployment.PackageAllUserProvisioningOptions): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+  }
+  var IPackageManager10: abstract new (...args: any[]) => IPackageManager10;
+
+  interface IPackageManager11 {
+    RemovePackageByUriAsync(packageUri: Windows.Foundation.Uri, options: Windows.Management.Deployment.RemovePackageOptions): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+  }
+  var IPackageManager11: abstract new (...args: any[]) => IPackageManager11;
+
+  interface IPackageManager12 {
+    IsPackageRemovalPending(packageFullName: string): boolean;
+    IsPackageRemovalPendingByUri(packageUri: Windows.Foundation.Uri): boolean;
+    IsPackageRemovalPendingByUriForUser(packageUri: Windows.Foundation.Uri, userSecurityId: string): boolean;
+    IsPackageRemovalPendingForUser(packageFullName: string, userSecurityId: string): boolean;
+  }
+  var IPackageManager12: abstract new (...args: any[]) => IPackageManager12;
+
+  interface IPackageManager2 {
+    FindPackagesForUserWithPackageTypes(userSecurityId: string, packageTypes: number): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUserWithPackageTypes(userSecurityId: string, packageName: string, packagePublisher: string, packageTypes: number): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUserWithPackageTypes(userSecurityId: string, packageFamilyName: string, packageTypes: number): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesWithPackageTypes(packageTypes: number): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesWithPackageTypes(packageName: string, packagePublisher: string, packageTypes: number): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesWithPackageTypes(packageFamilyName: string, packageTypes: number): Windows.Foundation.Collections.IIterable<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    RegisterPackageByFullNameAsync(mainPackageFullName: string, dependencyPackageFullNames: Windows.Foundation.Collections.IIterable<string> | string[], deploymentOptions: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RemovePackageAsync(packageFullName: string, removalOptions: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    StagePackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    StageUserDataAsync(packageFullName: string): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+  }
+  var IPackageManager2: abstract new (...args: any[]) => IPackageManager2;
+
+  interface IPackageManager3 {
+    AddPackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number, targetVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    AddPackageVolumeAsync(packageStorePath: string): Windows.Foundation.IAsyncOperation<Windows.Management.Deployment.PackageVolume>;
+    ClearPackageStatus(packageFullName: string, status: number): void;
+    FindPackageVolume(volumeName: string): Windows.Management.Deployment.PackageVolume;
+    FindPackageVolumes(): Windows.Foundation.Collections.IIterable<Windows.Management.Deployment.PackageVolume> | Windows.Management.Deployment.PackageVolume[];
+    GetDefaultPackageVolume(): Windows.Management.Deployment.PackageVolume;
+    MovePackageToVolumeAsync(packageFullName: string, deploymentOptions: number, targetVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RegisterPackageAsync(manifestUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number, appDataVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RemovePackageVolumeAsync(volume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    SetDefaultPackageVolume(volume: Windows.Management.Deployment.PackageVolume): void;
+    SetPackageStatus(packageFullName: string, status: number): void;
+    SetPackageVolumeOfflineAsync(packageVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    SetPackageVolumeOnlineAsync(packageVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    StagePackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number, targetVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    StageUserDataAsync(packageFullName: string, deploymentOptions: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+  }
+  var IPackageManager3: abstract new (...args: any[]) => IPackageManager3;
+
+  interface IPackageManager4 {
+    GetPackageVolumesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Management.Deployment.PackageVolume> | Windows.Management.Deployment.PackageVolume[]>;
+  }
+  var IPackageManager4: abstract new (...args: any[]) => IPackageManager4;
+
+  interface IPackageManager5 {
+    AddPackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number, targetVolume: Windows.Management.Deployment.PackageVolume, optionalPackageFamilyNames: Windows.Foundation.Collections.IIterable<string> | string[], externalPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RegisterPackageByFamilyNameAsync(mainPackageFamilyName: string, dependencyPackageFamilyNames: Windows.Foundation.Collections.IIterable<string> | string[], deploymentOptions: number, appDataVolume: Windows.Management.Deployment.PackageVolume, optionalPackageFamilyNames: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    StagePackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number, targetVolume: Windows.Management.Deployment.PackageVolume, optionalPackageFamilyNames: Windows.Foundation.Collections.IIterable<string> | string[], externalPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    readonly DebugSettings: Windows.Management.Deployment.PackageManagerDebugSettings;
+  }
+  var IPackageManager5: abstract new (...args: any[]) => IPackageManager5;
+
+  interface IPackageManager6 {
+    AddPackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], options: number, targetVolume: Windows.Management.Deployment.PackageVolume, optionalPackageFamilyNames: Windows.Foundation.Collections.IIterable<string> | string[], packageUrisToInstall: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], relatedPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    AddPackageByAppInstallerFileAsync(appInstallerFileUri: Windows.Foundation.Uri, options: number, targetVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    ProvisionPackageForAllUsersAsync(packageFamilyName: string): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RequestAddPackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number, targetVolume: Windows.Management.Deployment.PackageVolume, optionalPackageFamilyNames: Windows.Foundation.Collections.IIterable<string> | string[], relatedPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RequestAddPackageByAppInstallerFileAsync(appInstallerFileUri: Windows.Foundation.Uri, options: number, targetVolume: Windows.Management.Deployment.PackageVolume): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    StagePackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], options: number, targetVolume: Windows.Management.Deployment.PackageVolume, optionalPackageFamilyNames: Windows.Foundation.Collections.IIterable<string> | string[], packageUrisToInstall: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], relatedPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+  }
+  var IPackageManager6: abstract new (...args: any[]) => IPackageManager6;
+
+  interface IPackageManager7 {
+    RequestAddPackageAsync(packageUri: Windows.Foundation.Uri, dependencyPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], deploymentOptions: number, targetVolume: Windows.Management.Deployment.PackageVolume, optionalPackageFamilyNames: Windows.Foundation.Collections.IIterable<string> | string[], relatedPackageUris: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], packageUrisToInstall: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+  }
+  var IPackageManager7: abstract new (...args: any[]) => IPackageManager7;
+
+  interface IPackageManager8 {
+    DeprovisionPackageForAllUsersAsync(packageFamilyName: string): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+  }
+  var IPackageManager8: abstract new (...args: any[]) => IPackageManager8;
+
+  interface IPackageManager9 {
+    AddPackageByUriAsync(packageUri: Windows.Foundation.Uri, options: Windows.Management.Deployment.AddPackageOptions): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    FindProvisionedPackages(): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    GetPackageStubPreference(packageFamilyName: string): number;
+    RegisterPackageByUriAsync(manifestUri: Windows.Foundation.Uri, options: Windows.Management.Deployment.RegisterPackageOptions): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    RegisterPackagesByFullNameAsync(packageFullNames: Windows.Foundation.Collections.IIterable<string> | string[], options: Windows.Management.Deployment.RegisterPackageOptions): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+    SetPackageStubPreference(packageFamilyName: string, useStub: number): void;
+    StagePackageByUriAsync(packageUri: Windows.Foundation.Uri, options: Windows.Management.Deployment.StagePackageOptions): Windows.Foundation.IAsyncOperationWithProgress<Windows.Management.Deployment.DeploymentResult, Windows.Management.Deployment.DeploymentProgress>;
+  }
+  var IPackageManager9: abstract new (...args: any[]) => IPackageManager9;
+
+  interface IPackageManagerDebugSettings {
+    SetContentGroupStateAsync(package_: Windows.ApplicationModel.Package, contentGroupName: string, state: number): Windows.Foundation.IAsyncAction;
+    SetContentGroupStateAsync(package_: Windows.ApplicationModel.Package, contentGroupName: string, state: number, completionPercentage: number): Windows.Foundation.IAsyncAction;
+  }
+  var IPackageManagerDebugSettings: abstract new (...args: any[]) => IPackageManagerDebugSettings;
+
+  interface IPackageUserInformation {
+    readonly InstallState: number;
+    readonly UserSecurityId: string;
+  }
+  var IPackageUserInformation: abstract new (...args: any[]) => IPackageUserInformation;
+
+  interface IPackageVolume {
+    FindPackage(packageFullName: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackageForUser(userSecurityId: string, packageFullName: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackages(): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackages(packageName: string, packagePublisher: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackages(packageFamilyName: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUser(userSecurityId: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUser(userSecurityId: string, packageName: string, packagePublisher: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUser(userSecurityId: string, packageFamilyName: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUserWithPackageTypes(userSecurityId: string, packageTypes: number): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUserWithPackageTypes(userSecurityId: string, packageTypes: number, packageName: string, packagePublisher: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesForUserWithPackageTypes(userSecurityId: string, packageTypes: number, packageFamilyName: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesWithPackageTypes(packageTypes: number): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesWithPackageTypes(packageTypes: number, packageName: string, packagePublisher: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    FindPackagesWithPackageTypes(packageTypes: number, packageFamilyName: string): Windows.Foundation.Collections.IVector<Windows.ApplicationModel.Package> | Windows.ApplicationModel.Package[];
+    readonly IsOffline: boolean;
+    readonly IsSystemVolume: boolean;
+    readonly MountPoint: string;
+    readonly Name: string;
+    readonly PackageStorePath: string;
+    readonly SupportsHardLinks: boolean;
+  }
+  var IPackageVolume: abstract new (...args: any[]) => IPackageVolume;
+
+  interface IPackageVolume2 {
+    GetAvailableSpaceAsync(): Windows.Foundation.IAsyncOperation<number | bigint>;
+    readonly IsAppxInstallSupported: boolean;
+    readonly IsFullTrustPackageSupported: boolean;
+  }
+  var IPackageVolume2: abstract new (...args: any[]) => IPackageVolume2;
+
+  interface IRegisterPackageOptions {
+    AllowUnsigned: boolean;
+    AppDataVolume: Windows.Management.Deployment.PackageVolume;
+    DeferRegistrationWhenPackagesAreInUse: boolean;
+    readonly DependencyPackageUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    DeveloperMode: boolean;
+    ExternalLocationUri: Windows.Foundation.Uri;
+    ForceAppShutdown: boolean;
+    ForceTargetAppShutdown: boolean;
+    ForceUpdateFromAnyVersion: boolean;
+    InstallAllResources: boolean;
+    readonly OptionalPackageFamilyNames: Windows.Foundation.Collections.IVector<string> | string[];
+    StageInPlace: boolean;
+  }
+  var IRegisterPackageOptions: abstract new (...args: any[]) => IRegisterPackageOptions;
+
+  interface IRegisterPackageOptions2 {
+    readonly ExpectedDigests: Windows.Foundation.Collections.IMap<Windows.Foundation.Uri, string>;
+  }
+  var IRegisterPackageOptions2: abstract new (...args: any[]) => IRegisterPackageOptions2;
+
+  interface IRemovePackageOptions {
+    PreserveApplicationData: boolean;
+    PreserveRoamableApplicationData: boolean;
+    RemoveForAllUsers: boolean;
+  }
+  var IRemovePackageOptions: abstract new (...args: any[]) => IRemovePackageOptions;
+
+  interface IRemovePackageOptions2 {
+    DeferRemovalWhenPackagesAreInUse: boolean;
+  }
+  var IRemovePackageOptions2: abstract new (...args: any[]) => IRemovePackageOptions2;
+
+  interface ISharedPackageContainer {
+    GetMembers(): Windows.Foundation.Collections.IVector<Windows.Management.Deployment.SharedPackageContainerMember> | Windows.Management.Deployment.SharedPackageContainerMember[];
+    RemovePackageFamily(packageFamilyName: string, options: Windows.Management.Deployment.UpdateSharedPackageContainerOptions): Windows.Management.Deployment.UpdateSharedPackageContainerResult;
+    ResetData(): Windows.Management.Deployment.UpdateSharedPackageContainerResult;
+    readonly Id: string;
+    readonly Name: string;
+  }
+  var ISharedPackageContainer: abstract new (...args: any[]) => ISharedPackageContainer;
+
+  interface ISharedPackageContainerManager {
+    CreateContainer(name: string, options: Windows.Management.Deployment.CreateSharedPackageContainerOptions): Windows.Management.Deployment.CreateSharedPackageContainerResult;
+    DeleteContainer(id: string, options: Windows.Management.Deployment.DeleteSharedPackageContainerOptions): Windows.Management.Deployment.DeleteSharedPackageContainerResult;
+    FindContainers(): Windows.Foundation.Collections.IVector<Windows.Management.Deployment.SharedPackageContainer> | Windows.Management.Deployment.SharedPackageContainer[];
+    FindContainers(options: Windows.Management.Deployment.FindSharedPackageContainerOptions): Windows.Foundation.Collections.IVector<Windows.Management.Deployment.SharedPackageContainer> | Windows.Management.Deployment.SharedPackageContainer[];
+    GetContainer(id: string): Windows.Management.Deployment.SharedPackageContainer;
+  }
+  var ISharedPackageContainerManager: abstract new (...args: any[]) => ISharedPackageContainerManager;
+
+  interface ISharedPackageContainerManagerStatics {
+    GetDefault(): Windows.Management.Deployment.SharedPackageContainerManager;
+    GetForProvisioning(): Windows.Management.Deployment.SharedPackageContainerManager;
+    GetForUser(userSid: string): Windows.Management.Deployment.SharedPackageContainerManager;
+  }
+  var ISharedPackageContainerManagerStatics: abstract new (...args: any[]) => ISharedPackageContainerManagerStatics;
+
+  interface ISharedPackageContainerMember {
+    readonly PackageFamilyName: string;
+  }
+  var ISharedPackageContainerMember: abstract new (...args: any[]) => ISharedPackageContainerMember;
+
+  interface ISharedPackageContainerMemberFactory {
+    CreateInstance(packageFamilyName: string): Windows.Management.Deployment.SharedPackageContainerMember;
+  }
+  var ISharedPackageContainerMemberFactory: abstract new (...args: any[]) => ISharedPackageContainerMemberFactory;
+
+  interface IStagePackageOptions {
+    AllowUnsigned: boolean;
+    readonly DependencyPackageUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    DeveloperMode: boolean;
+    ExternalLocationUri: Windows.Foundation.Uri;
+    ForceUpdateFromAnyVersion: boolean;
+    InstallAllResources: boolean;
+    readonly OptionalPackageFamilyNames: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly OptionalPackageUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly RelatedPackageUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    RequiredContentGroupOnly: boolean;
+    StageInPlace: boolean;
+    StubPackageOption: number;
+    TargetVolume: Windows.Management.Deployment.PackageVolume;
+  }
+  var IStagePackageOptions: abstract new (...args: any[]) => IStagePackageOptions;
+
+  interface IStagePackageOptions2 {
+    readonly ExpectedDigests: Windows.Foundation.Collections.IMap<Windows.Foundation.Uri, string>;
+  }
+  var IStagePackageOptions2: abstract new (...args: any[]) => IStagePackageOptions2;
+
+  interface IUpdateSharedPackageContainerOptions {
+    ForceAppShutdown: boolean;
+    RequirePackagesPresent: boolean;
+  }
+  var IUpdateSharedPackageContainerOptions: abstract new (...args: any[]) => IUpdateSharedPackageContainerOptions;
+
+  interface IUpdateSharedPackageContainerResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+  var IUpdateSharedPackageContainerResult: abstract new (...args: any[]) => IUpdateSharedPackageContainerResult;
+
+  interface SharedPackageContainerContract {
+  }
+  var SharedPackageContainerContract: {
+    new(fields: {  }): SharedPackageContainerContract;
+  };
+
+}
+
+declare namespace Windows.Management.Deployment.Preview {
+  class ClassicAppManager {
+    static FindInstalledApp(appUninstallKey: string): Windows.Management.Deployment.Preview.InstalledClassicAppInfo;
+  }
+
+  class InstalledClassicAppInfo implements Windows.Management.Deployment.Preview.IInstalledClassicAppInfo {
+    readonly DisplayName: string;
+    readonly DisplayVersion: string;
+  }
+
+  interface DeploymentPreviewContract {
+  }
+  var DeploymentPreviewContract: {
+    new(fields: {  }): DeploymentPreviewContract;
+  };
+
+  interface IClassicAppManagerStatics {
+    FindInstalledApp(appUninstallKey: string): Windows.Management.Deployment.Preview.InstalledClassicAppInfo;
+  }
+  var IClassicAppManagerStatics: abstract new (...args: any[]) => IClassicAppManagerStatics;
+
+  interface IInstalledClassicAppInfo {
+    readonly DisplayName: string;
+    readonly DisplayVersion: string;
+  }
+  var IInstalledClassicAppInfo: abstract new (...args: any[]) => IInstalledClassicAppInfo;
+
+}
+
+declare namespace Windows.Management.Policies {
+  class NamedPolicy {
+    static GetPolicyFromPath(area: string, name: string): Windows.Management.Policies.NamedPolicyData;
+    static GetPolicyFromPathForUser(user: Windows.System.User, area: string, name: string): Windows.Management.Policies.NamedPolicyData;
+  }
+
+  class NamedPolicyData implements Windows.Management.Policies.INamedPolicyData {
+    GetBinary(): Windows.Storage.Streams.IBuffer;
+    GetBoolean(): boolean;
+    GetInt32(): number;
+    GetInt64(): number | bigint;
+    GetString(): string;
+    readonly Area: string;
+    readonly IsManaged: boolean;
+    readonly IsUserPolicy: boolean;
+    readonly Kind: number;
+    readonly Name: string;
+    readonly User: Windows.System.User;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.Management.Policies.NamedPolicyData, Object> | null;
+  }
+
+  enum NamedPolicyKind {
+    Invalid = 0,
+    Binary = 1,
+    Boolean = 2,
+    Int32 = 3,
+    Int64 = 4,
+    String = 5,
+  }
+
+  interface INamedPolicyData {
+    GetBinary(): Windows.Storage.Streams.IBuffer;
+    GetBoolean(): boolean;
+    GetInt32(): number;
+    GetInt64(): number | bigint;
+    GetString(): string;
+    readonly Area: string;
+    readonly IsManaged: boolean;
+    readonly IsUserPolicy: boolean;
+    readonly Kind: number;
+    readonly Name: string;
+    readonly User: Windows.System.User;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.Management.Policies.NamedPolicyData, Object> | null;
+  }
+  var INamedPolicyData: abstract new (...args: any[]) => INamedPolicyData;
+
+  interface INamedPolicyStatics {
+    GetPolicyFromPath(area: string, name: string): Windows.Management.Policies.NamedPolicyData;
+    GetPolicyFromPathForUser(user: Windows.System.User, area: string, name: string): Windows.Management.Policies.NamedPolicyData;
+  }
+  var INamedPolicyStatics: abstract new (...args: any[]) => INamedPolicyStatics;
+
+}
+
+declare namespace Windows.Management.Setup {
+  class AgentProvisioningProgressReport implements Windows.Management.Setup.IAgentProvisioningProgressReport {
+    constructor();
+    readonly Batches: Windows.Foundation.Collections.IVector<Windows.Management.Setup.DeploymentWorkloadBatch> | Windows.Management.Setup.DeploymentWorkloadBatch[];
+    CurrentBatchIndex: number;
+    DisplayProgress: string;
+    DisplayProgressSecondary: string;
+    EstimatedTimeRemaining: Windows.Foundation.TimeSpan;
+    ProgressPercentage: number;
+    State: number;
+  }
+
+  class DeploymentSessionConnectionChangedEventArgs implements Windows.Management.Setup.IDeploymentSessionConnectionChangedEventArgs {
+    readonly Change: number;
+    readonly SessionId: string;
+  }
+
+  class DeploymentSessionHeartbeatRequestedEventArgs implements Windows.Management.Setup.IDeploymentSessionHeartbeatRequestedEventArgs {
+    Handled: boolean;
+  }
+
+  class DeploymentSessionStateChangedEventArgs implements Windows.Management.Setup.IDeploymentSessionStateChangedEventArgs {
+    readonly Change: number;
+    readonly SessionId: string;
+  }
+
+  class DeploymentWorkload implements Windows.Management.Setup.IDeploymentWorkload {
+    constructor(id: string);
+    DisplayFriendlyName: string;
+    EndTime: Windows.Foundation.DateTime | null;
+    ErrorCode: number;
+    ErrorMessage: string;
+    readonly Id: string;
+    PossibleCause: string;
+    PossibleResolution: string;
+    StartTime: Windows.Foundation.DateTime | null;
+    State: number;
+    StateDetails: string;
+  }
+
+  class DeploymentWorkloadBatch implements Windows.Management.Setup.IDeploymentWorkloadBatch {
+    constructor(id: number);
+    readonly BatchWorkloads: Windows.Foundation.Collections.IVector<Windows.Management.Setup.DeploymentWorkload> | Windows.Management.Setup.DeploymentWorkload[];
+    DisplayCategoryTitle: string;
+    readonly Id: number;
+  }
+
+  class DevicePreparationExecutionContext implements Windows.Management.Setup.IDevicePreparationExecutionContext {
+    readonly Context: string;
+  }
+
+  class MachineProvisioningProgressReporter implements Windows.Management.Setup.IMachineProvisioningProgressReporter {
+    GetDevicePreparationExecutionContextAsync(): Windows.Foundation.IAsyncOperation<Windows.Management.Setup.DevicePreparationExecutionContext>;
+    static GetForLaunchUri(launchUri: Windows.Foundation.Uri, heartbeatHandler: Windows.Management.Setup.DeploymentSessionHeartbeatRequested): Windows.Management.Setup.MachineProvisioningProgressReporter;
+    ReportProgress(updateReport: Windows.Management.Setup.AgentProvisioningProgressReport): void;
+    readonly SessionConnection: number;
+    readonly SessionId: Guid;
+    readonly SessionState: number;
+    SessionConnectionChanged: Windows.Foundation.TypedEventHandler<Windows.Management.Setup.MachineProvisioningProgressReporter, Windows.Management.Setup.DeploymentSessionConnectionChangedEventArgs> | null;
+    SessionStateChanged: Windows.Foundation.TypedEventHandler<Windows.Management.Setup.MachineProvisioningProgressReporter, Windows.Management.Setup.DeploymentSessionStateChangedEventArgs> | null;
+  }
+
+  enum DeploymentAgentProgressState {
+    NotStarted = 0,
+    Initializing = 1,
+    InProgress = 2,
+    Completed = 3,
+    ErrorOccurred = 4,
+    RebootRequired = 5,
+    Canceled = 6,
+  }
+
+  enum DeploymentSessionConnectionChange {
+    NoChange = 0,
+    HostConnectionLost = 1,
+    HostConnectionRestored = 2,
+    AgentConnectionLost = 3,
+    AgentConnectionRestored = 4,
+    InternetConnectionLost = 5,
+    InternetConnectionRestored = 6,
+  }
+
+  enum DeploymentSessionStateChange {
+    NoChange = 0,
+    CancelRequestedByUser = 1,
+    RetryRequestedByUser = 2,
+  }
+
+  enum DeploymentWorkloadState {
+    NotStarted = 0,
+    InProgress = 1,
+    Completed = 2,
+    Failed = 3,
+    Canceled = 4,
+    Skipped = 5,
+    Uninstalled = 6,
+    RebootRequired = 7,
+  }
+
+  interface DeploymentSessionHeartbeatRequested {
+    (eventArgs: Windows.Management.Setup.DeploymentSessionHeartbeatRequestedEventArgs): void;
+  }
+  var DeploymentSessionHeartbeatRequested: {
+    new(callback: (eventArgs: Windows.Management.Setup.DeploymentSessionHeartbeatRequestedEventArgs) => void): DeploymentSessionHeartbeatRequested;
+  };
+
+  interface IAgentProvisioningProgressReport {
+    readonly Batches: Windows.Foundation.Collections.IVector<Windows.Management.Setup.DeploymentWorkloadBatch> | Windows.Management.Setup.DeploymentWorkloadBatch[];
+    CurrentBatchIndex: number;
+    DisplayProgress: string;
+    DisplayProgressSecondary: string;
+    EstimatedTimeRemaining: Windows.Foundation.TimeSpan;
+    ProgressPercentage: number;
+    State: number;
+  }
+  var IAgentProvisioningProgressReport: abstract new (...args: any[]) => IAgentProvisioningProgressReport;
+
+  interface IDeploymentSessionConnectionChangedEventArgs {
+    readonly Change: number;
+    readonly SessionId: string;
+  }
+  var IDeploymentSessionConnectionChangedEventArgs: abstract new (...args: any[]) => IDeploymentSessionConnectionChangedEventArgs;
+
+  interface IDeploymentSessionHeartbeatRequestedEventArgs {
+    Handled: boolean;
+  }
+  var IDeploymentSessionHeartbeatRequestedEventArgs: abstract new (...args: any[]) => IDeploymentSessionHeartbeatRequestedEventArgs;
+
+  interface IDeploymentSessionStateChangedEventArgs {
+    readonly Change: number;
+    readonly SessionId: string;
+  }
+  var IDeploymentSessionStateChangedEventArgs: abstract new (...args: any[]) => IDeploymentSessionStateChangedEventArgs;
+
+  interface IDeploymentWorkload {
+    DisplayFriendlyName: string;
+    EndTime: Windows.Foundation.DateTime | null;
+    ErrorCode: number;
+    ErrorMessage: string;
+    readonly Id: string;
+    PossibleCause: string;
+    PossibleResolution: string;
+    StartTime: Windows.Foundation.DateTime | null;
+    State: number;
+    StateDetails: string;
+  }
+  var IDeploymentWorkload: abstract new (...args: any[]) => IDeploymentWorkload;
+
+  interface IDeploymentWorkloadBatch {
+    readonly BatchWorkloads: Windows.Foundation.Collections.IVector<Windows.Management.Setup.DeploymentWorkload> | Windows.Management.Setup.DeploymentWorkload[];
+    DisplayCategoryTitle: string;
+    readonly Id: number;
+  }
+  var IDeploymentWorkloadBatch: abstract new (...args: any[]) => IDeploymentWorkloadBatch;
+
+  interface IDeploymentWorkloadBatchFactory {
+    CreateInstance(id: number): Windows.Management.Setup.DeploymentWorkloadBatch;
+  }
+  var IDeploymentWorkloadBatchFactory: abstract new (...args: any[]) => IDeploymentWorkloadBatchFactory;
+
+  interface IDeploymentWorkloadFactory {
+    CreateInstance(id: string): Windows.Management.Setup.DeploymentWorkload;
+  }
+  var IDeploymentWorkloadFactory: abstract new (...args: any[]) => IDeploymentWorkloadFactory;
+
+  interface IDevicePreparationExecutionContext {
+    readonly Context: string;
+  }
+  var IDevicePreparationExecutionContext: abstract new (...args: any[]) => IDevicePreparationExecutionContext;
+
+  interface IMachineProvisioningProgressReporter {
+    GetDevicePreparationExecutionContextAsync(): Windows.Foundation.IAsyncOperation<Windows.Management.Setup.DevicePreparationExecutionContext>;
+    ReportProgress(updateReport: Windows.Management.Setup.AgentProvisioningProgressReport): void;
+    readonly SessionConnection: number;
+    readonly SessionId: Guid;
+    readonly SessionState: number;
+    SessionConnectionChanged: Windows.Foundation.TypedEventHandler<Windows.Management.Setup.MachineProvisioningProgressReporter, Windows.Management.Setup.DeploymentSessionConnectionChangedEventArgs> | null;
+    SessionStateChanged: Windows.Foundation.TypedEventHandler<Windows.Management.Setup.MachineProvisioningProgressReporter, Windows.Management.Setup.DeploymentSessionStateChangedEventArgs> | null;
+  }
+  var IMachineProvisioningProgressReporter: abstract new (...args: any[]) => IMachineProvisioningProgressReporter;
+
+  interface IMachineProvisioningProgressReporterStatics {
+    GetForLaunchUri(launchUri: Windows.Foundation.Uri, heartbeatHandler: Windows.Management.Setup.DeploymentSessionHeartbeatRequested): Windows.Management.Setup.MachineProvisioningProgressReporter;
+  }
+  var IMachineProvisioningProgressReporterStatics: abstract new (...args: any[]) => IMachineProvisioningProgressReporterStatics;
+
+}
+
+declare namespace Windows.Management.Update {
+  class PreviewBuildsManager implements Windows.Management.Update.IPreviewBuildsManager {
+    GetCurrentState(): Windows.Management.Update.PreviewBuildsState;
+    static GetDefault(): Windows.Management.Update.PreviewBuildsManager;
+    static IsSupported(): boolean;
+    SyncAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    ArePreviewBuildsAllowed: boolean;
+  }
+
+  class PreviewBuildsState implements Windows.Management.Update.IPreviewBuildsState {
+    readonly Properties: Windows.Foundation.Collections.ValueSet;
+  }
+
+  class WindowsUpdate implements Windows.Management.Update.IWindowsUpdate {
+    AcceptEula(): void;
+    GetPropertyValue(propertyName: string): Object;
+    readonly ActionProgress: Windows.Management.Update.WindowsUpdateActionProgress;
+    readonly ActionResult: Windows.Management.Update.WindowsUpdateActionResult;
+    readonly AttentionRequiredInfo: Windows.Management.Update.WindowsUpdateAttentionRequiredInfo;
+    readonly CurrentAction: string;
+    readonly Deadline: Windows.Foundation.DateTime | null;
+    readonly Description: string;
+    readonly EulaText: string;
+    readonly IsCritical: boolean;
+    readonly IsDriver: boolean;
+    readonly IsEulaAccepted: boolean;
+    readonly IsFeatureUpdate: boolean;
+    readonly IsForOS: boolean;
+    readonly IsMandatory: boolean;
+    readonly IsMinorImpact: boolean;
+    readonly IsSecurity: boolean;
+    readonly IsSeeker: boolean;
+    readonly IsUrgent: boolean;
+    readonly MoreInfoUrl: Windows.Foundation.Uri;
+    readonly ProviderId: string;
+    readonly SupportUrl: Windows.Foundation.Uri;
+    readonly Title: string;
+    readonly UpdateId: string;
+  }
+
+  class WindowsUpdateActionCompletedEventArgs implements Windows.Management.Update.IWindowsUpdateActionCompletedEventArgs {
+    readonly Action: string;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Succeeded: boolean;
+    readonly Update: Windows.Management.Update.WindowsUpdate;
+  }
+
+  class WindowsUpdateActionProgress implements Windows.Management.Update.IWindowsUpdateActionProgress {
+    readonly Action: string;
+    readonly Progress: number;
+  }
+
+  class WindowsUpdateActionResult implements Windows.Management.Update.IWindowsUpdateActionResult {
+    readonly Action: string;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Succeeded: boolean;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class WindowsUpdateAdministrator implements Windows.Management.Update.IWindowsUpdateAdministrator {
+    ApproveWindowsUpdate(updateId: string, approvalData: Windows.Management.Update.WindowsUpdateApprovalData): void;
+    ApproveWindowsUpdateAction(updateId: string, action: string): void;
+    static CancelRestartRequest(requestRestartToken: string): void;
+    static GetRegisteredAdministrator(organizationName: string): Windows.Management.Update.WindowsUpdateGetAdministratorResult;
+    static GetRegisteredAdministratorName(): string;
+    GetUpdates(): Windows.Foundation.Collections.IVectorView<Windows.Management.Update.WindowsUpdate> | Windows.Management.Update.WindowsUpdate[];
+    static RegisterForAdministration(organizationName: string, options: number): number;
+    static RequestRestart(restartOptions: Windows.Management.Update.WindowsUpdateRestartRequestOptions): string;
+    RevokeWindowsUpdateActionApproval(updateId: string, action: string): void;
+    RevokeWindowsUpdateApproval(updateId: string): void;
+    StartAdministratorScan(): void;
+    static UnregisterForAdministration(organizationName: string): number;
+  }
+
+  class WindowsUpdateApprovalData implements Windows.Management.Update.IWindowsUpdateApprovalData {
+    constructor();
+    AllowDownloadOnMetered: boolean | null;
+    ComplianceDeadlineInDays: number | null;
+    ComplianceGracePeriodInDays: number | null;
+    OptOutOfAutoReboot: boolean | null;
+    Seeker: boolean | null;
+  }
+
+  class WindowsUpdateAttentionRequiredInfo implements Windows.Management.Update.IWindowsUpdateAttentionRequiredInfo {
+    readonly Reason: number;
+    readonly Timestamp: Windows.Foundation.DateTime | null;
+  }
+
+  class WindowsUpdateAttentionRequiredReasonChangedEventArgs implements Windows.Management.Update.IWindowsUpdateAttentionRequiredReasonChangedEventArgs {
+    readonly Reason: number;
+    readonly Update: Windows.Management.Update.WindowsUpdate;
+  }
+
+  class WindowsUpdateGetAdministratorResult implements Windows.Management.Update.IWindowsUpdateGetAdministratorResult {
+    readonly Administrator: Windows.Management.Update.WindowsUpdateAdministrator;
+    readonly Status: number;
+  }
+
+  class WindowsUpdateItem implements Windows.Management.Update.IWindowsUpdateItem {
+    readonly Category: string;
+    readonly Description: string;
+    readonly MoreInfoUrl: Windows.Foundation.Uri;
+    readonly Operation: string;
+    readonly ProviderId: string;
+    readonly Timestamp: Windows.Foundation.DateTime;
+    readonly Title: string;
+    readonly UpdateId: string;
+  }
+
+  class WindowsUpdateManager implements Windows.Management.Update.IWindowsUpdateManager {
+    constructor(clientId: string);
+    GetApplicableUpdates(): Windows.Foundation.Collections.IVectorView<Windows.Management.Update.WindowsUpdate> | Windows.Management.Update.WindowsUpdate[];
+    GetMostRecentCompletedUpdates(count: number): Windows.Foundation.Collections.IVectorView<Windows.Management.Update.WindowsUpdateItem> | Windows.Management.Update.WindowsUpdateItem[];
+    GetMostRecentCompletedUpdatesAsync(count: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Management.Update.WindowsUpdateItem> | Windows.Management.Update.WindowsUpdateItem[]>;
+    StartScan(userInitiated: boolean): void;
+    readonly IsScanning: boolean;
+    readonly IsWorking: boolean;
+    readonly LastSuccessfulScanTimestamp: Windows.Foundation.DateTime | null;
+    ActionCompleted: Windows.Foundation.TypedEventHandler<Windows.Management.Update.WindowsUpdateManager, Windows.Management.Update.WindowsUpdateActionCompletedEventArgs> | null;
+    AttentionRequiredReasonChanged: Windows.Foundation.TypedEventHandler<Windows.Management.Update.WindowsUpdateManager, Windows.Management.Update.WindowsUpdateAttentionRequiredReasonChangedEventArgs> | null;
+    ProgressChanged: Windows.Foundation.TypedEventHandler<Windows.Management.Update.WindowsUpdateManager, Windows.Management.Update.WindowsUpdateProgressChangedEventArgs> | null;
+    ScanCompleted: Windows.Foundation.TypedEventHandler<Windows.Management.Update.WindowsUpdateManager, Windows.Management.Update.WindowsUpdateScanCompletedEventArgs> | null;
+    ScanningStateChanged: Windows.Foundation.TypedEventHandler<Windows.Management.Update.WindowsUpdateManager, Object> | null;
+    WorkingStateChanged: Windows.Foundation.TypedEventHandler<Windows.Management.Update.WindowsUpdateManager, Object> | null;
+  }
+
+  class WindowsUpdateProgressChangedEventArgs implements Windows.Management.Update.IWindowsUpdateProgressChangedEventArgs {
+    readonly ActionProgress: Windows.Management.Update.WindowsUpdateActionProgress;
+    readonly Update: Windows.Management.Update.WindowsUpdate;
+  }
+
+  class WindowsUpdateRestartRequestOptions implements Windows.Management.Update.IWindowsUpdateRestartRequestOptions {
+    constructor(title: string, description: string, moreInfoUrl: Windows.Foundation.Uri, complianceDeadlineInDays: number, complianceGracePeriodInDays: number);
+    constructor();
+    ComplianceDeadlineInDays: number;
+    ComplianceGracePeriodInDays: number;
+    Description: string;
+    MoreInfoUrl: Windows.Foundation.Uri;
+    OptOutOfAutoReboot: boolean;
+    OrganizationName: string;
+    Title: string;
+  }
+
+  class WindowsUpdateScanCompletedEventArgs implements Windows.Management.Update.IWindowsUpdateScanCompletedEventArgs {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly ProviderId: string;
+    readonly Succeeded: boolean;
+    readonly Updates: Windows.Foundation.Collections.IVectorView<Windows.Management.Update.WindowsUpdate> | Windows.Management.Update.WindowsUpdate[];
+  }
+
+  enum WindowsUpdateAdministratorOptions {
+    None = 0,
+    RequireAdministratorApprovalForScans = 1,
+    RequireAdministratorApprovalForUpdates = 2,
+    RequireAdministratorApprovalForActions = 4,
+  }
+
+  enum WindowsUpdateAdministratorStatus {
+    Succeeded = 0,
+    NoAdministratorRegistered = 1,
+    OtherAdministratorIsRegistered = 2,
+  }
+
+  enum WindowsUpdateAttentionRequiredReason {
+    None = 0,
+    SeekerUpdate = 1,
+    ReadyToReboot = 2,
+    NeedNonMeteredNetwork = 3,
+    NeedUserAgreementForMeteredNetwork = 4,
+    NeedNetwork = 5,
+    NeedMoreSpace = 6,
+    BatterySaverEnabled = 7,
+    NeedUserInteraction = 8,
+    NeedUserAgreementForPolicy = 9,
+    CompatibilityError = 10,
+    NeedUserInteractionForEula = 11,
+    NeedUserInteractionForCta = 12,
+    Regulated = 13,
+    ExternalReboot = 14,
+    OtherUpdate = 15,
+    BlockedByProvider = 16,
+    BlockedByPostRebootFailure = 17,
+    UserEngaged = 18,
+    BlockedByBattery = 19,
+    Exclusivity = 20,
+    BlockedBySerialization = 21,
+    ConflictClass = 22,
+    BlockedByAdminApproval = 23,
+    BlockedByTooManyAttempts = 24,
+    BlockedByFailure = 25,
+    Demotion = 26,
+    BlockedByActiveHours = 27,
+    ScheduledForMaintenance = 28,
+    PolicyScheduledInstallTime = 29,
+    BlockedByOobe = 30,
+    DeferredDuringOobe = 31,
+    DeferredForSustainableTime = 32,
+  }
+
+  interface IPreviewBuildsManager {
+    GetCurrentState(): Windows.Management.Update.PreviewBuildsState;
+    SyncAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    ArePreviewBuildsAllowed: boolean;
+  }
+  var IPreviewBuildsManager: abstract new (...args: any[]) => IPreviewBuildsManager;
+
+  interface IPreviewBuildsManagerStatics {
+    GetDefault(): Windows.Management.Update.PreviewBuildsManager;
+    IsSupported(): boolean;
+  }
+  var IPreviewBuildsManagerStatics: abstract new (...args: any[]) => IPreviewBuildsManagerStatics;
+
+  interface IPreviewBuildsState {
+    readonly Properties: Windows.Foundation.Collections.ValueSet;
+  }
+  var IPreviewBuildsState: abstract new (...args: any[]) => IPreviewBuildsState;
+
+  interface IWindowsUpdate {
+    AcceptEula(): void;
+    GetPropertyValue(propertyName: string): Object;
+    readonly ActionProgress: Windows.Management.Update.WindowsUpdateActionProgress;
+    readonly ActionResult: Windows.Management.Update.WindowsUpdateActionResult;
+    readonly AttentionRequiredInfo: Windows.Management.Update.WindowsUpdateAttentionRequiredInfo;
+    readonly CurrentAction: string;
+    readonly Deadline: Windows.Foundation.DateTime | null;
+    readonly Description: string;
+    readonly EulaText: string;
+    readonly IsCritical: boolean;
+    readonly IsDriver: boolean;
+    readonly IsEulaAccepted: boolean;
+    readonly IsFeatureUpdate: boolean;
+    readonly IsForOS: boolean;
+    readonly IsMandatory: boolean;
+    readonly IsMinorImpact: boolean;
+    readonly IsSecurity: boolean;
+    readonly IsSeeker: boolean;
+    readonly IsUrgent: boolean;
+    readonly MoreInfoUrl: Windows.Foundation.Uri;
+    readonly ProviderId: string;
+    readonly SupportUrl: Windows.Foundation.Uri;
+    readonly Title: string;
+    readonly UpdateId: string;
+  }
+  var IWindowsUpdate: abstract new (...args: any[]) => IWindowsUpdate;
+
+  interface IWindowsUpdateActionCompletedEventArgs {
+    readonly Action: string;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Succeeded: boolean;
+    readonly Update: Windows.Management.Update.WindowsUpdate;
+  }
+  var IWindowsUpdateActionCompletedEventArgs: abstract new (...args: any[]) => IWindowsUpdateActionCompletedEventArgs;
+
+  interface IWindowsUpdateActionProgress {
+    readonly Action: string;
+    readonly Progress: number;
+  }
+  var IWindowsUpdateActionProgress: abstract new (...args: any[]) => IWindowsUpdateActionProgress;
+
+  interface IWindowsUpdateActionResult {
+    readonly Action: string;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Succeeded: boolean;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IWindowsUpdateActionResult: abstract new (...args: any[]) => IWindowsUpdateActionResult;
+
+  interface IWindowsUpdateAdministrator {
+    ApproveWindowsUpdate(updateId: string, approvalData: Windows.Management.Update.WindowsUpdateApprovalData): void;
+    ApproveWindowsUpdateAction(updateId: string, action: string): void;
+    GetUpdates(): Windows.Foundation.Collections.IVectorView<Windows.Management.Update.WindowsUpdate> | Windows.Management.Update.WindowsUpdate[];
+    RevokeWindowsUpdateActionApproval(updateId: string, action: string): void;
+    RevokeWindowsUpdateApproval(updateId: string): void;
+    StartAdministratorScan(): void;
+  }
+  var IWindowsUpdateAdministrator: abstract new (...args: any[]) => IWindowsUpdateAdministrator;
+
+  interface IWindowsUpdateAdministratorStatics {
+    CancelRestartRequest(requestRestartToken: string): void;
+    GetRegisteredAdministrator(organizationName: string): Windows.Management.Update.WindowsUpdateGetAdministratorResult;
+    GetRegisteredAdministratorName(): string;
+    RegisterForAdministration(organizationName: string, options: number): number;
+    RequestRestart(restartOptions: Windows.Management.Update.WindowsUpdateRestartRequestOptions): string;
+    UnregisterForAdministration(organizationName: string): number;
+  }
+  var IWindowsUpdateAdministratorStatics: abstract new (...args: any[]) => IWindowsUpdateAdministratorStatics;
+
+  interface IWindowsUpdateApprovalData {
+    AllowDownloadOnMetered: boolean | null;
+    ComplianceDeadlineInDays: number | null;
+    ComplianceGracePeriodInDays: number | null;
+    OptOutOfAutoReboot: boolean | null;
+    Seeker: boolean | null;
+  }
+  var IWindowsUpdateApprovalData: abstract new (...args: any[]) => IWindowsUpdateApprovalData;
+
+  interface IWindowsUpdateAttentionRequiredInfo {
+    readonly Reason: number;
+    readonly Timestamp: Windows.Foundation.DateTime | null;
+  }
+  var IWindowsUpdateAttentionRequiredInfo: abstract new (...args: any[]) => IWindowsUpdateAttentionRequiredInfo;
+
+  interface IWindowsUpdateAttentionRequiredReasonChangedEventArgs {
+    readonly Reason: number;
+    readonly Update: Windows.Management.Update.WindowsUpdate;
+  }
+  var IWindowsUpdateAttentionRequiredReasonChangedEventArgs: abstract new (...args: any[]) => IWindowsUpdateAttentionRequiredReasonChangedEventArgs;
+
+  interface IWindowsUpdateGetAdministratorResult {
+    readonly Administrator: Windows.Management.Update.WindowsUpdateAdministrator;
+    readonly Status: number;
+  }
+  var IWindowsUpdateGetAdministratorResult: abstract new (...args: any[]) => IWindowsUpdateGetAdministratorResult;
+
+  interface IWindowsUpdateItem {
+    readonly Category: string;
+    readonly Description: string;
+    readonly MoreInfoUrl: Windows.Foundation.Uri;
+    readonly Operation: string;
+    readonly ProviderId: string;
+    readonly Timestamp: Windows.Foundation.DateTime;
+    readonly Title: string;
+    readonly UpdateId: string;
+  }
+  var IWindowsUpdateItem: abstract new (...args: any[]) => IWindowsUpdateItem;
+
+  interface IWindowsUpdateManager {
+    GetApplicableUpdates(): Windows.Foundation.Collections.IVectorView<Windows.Management.Update.WindowsUpdate> | Windows.Management.Update.WindowsUpdate[];
+    GetMostRecentCompletedUpdates(count: number): Windows.Foundation.Collections.IVectorView<Windows.Management.Update.WindowsUpdateItem> | Windows.Management.Update.WindowsUpdateItem[];
+    GetMostRecentCompletedUpdatesAsync(count: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Management.Update.WindowsUpdateItem> | Windows.Management.Update.WindowsUpdateItem[]>;
+    StartScan(userInitiated: boolean): void;
+    readonly IsScanning: boolean;
+    readonly IsWorking: boolean;
+    readonly LastSuccessfulScanTimestamp: Windows.Foundation.DateTime | null;
+    ActionCompleted: Windows.Foundation.TypedEventHandler<Windows.Management.Update.WindowsUpdateManager, Windows.Management.Update.WindowsUpdateActionCompletedEventArgs> | null;
+    AttentionRequiredReasonChanged: Windows.Foundation.TypedEventHandler<Windows.Management.Update.WindowsUpdateManager, Windows.Management.Update.WindowsUpdateAttentionRequiredReasonChangedEventArgs> | null;
+    ProgressChanged: Windows.Foundation.TypedEventHandler<Windows.Management.Update.WindowsUpdateManager, Windows.Management.Update.WindowsUpdateProgressChangedEventArgs> | null;
+    ScanCompleted: Windows.Foundation.TypedEventHandler<Windows.Management.Update.WindowsUpdateManager, Windows.Management.Update.WindowsUpdateScanCompletedEventArgs> | null;
+    ScanningStateChanged: Windows.Foundation.TypedEventHandler<Windows.Management.Update.WindowsUpdateManager, Object> | null;
+    WorkingStateChanged: Windows.Foundation.TypedEventHandler<Windows.Management.Update.WindowsUpdateManager, Object> | null;
+  }
+  var IWindowsUpdateManager: abstract new (...args: any[]) => IWindowsUpdateManager;
+
+  interface IWindowsUpdateManagerFactory {
+    CreateInstance(clientId: string): Windows.Management.Update.WindowsUpdateManager;
+  }
+  var IWindowsUpdateManagerFactory: abstract new (...args: any[]) => IWindowsUpdateManagerFactory;
+
+  interface IWindowsUpdateProgressChangedEventArgs {
+    readonly ActionProgress: Windows.Management.Update.WindowsUpdateActionProgress;
+    readonly Update: Windows.Management.Update.WindowsUpdate;
+  }
+  var IWindowsUpdateProgressChangedEventArgs: abstract new (...args: any[]) => IWindowsUpdateProgressChangedEventArgs;
+
+  interface IWindowsUpdateRestartRequestOptions {
+    ComplianceDeadlineInDays: number;
+    ComplianceGracePeriodInDays: number;
+    Description: string;
+    MoreInfoUrl: Windows.Foundation.Uri;
+    OptOutOfAutoReboot: boolean;
+    OrganizationName: string;
+    Title: string;
+  }
+  var IWindowsUpdateRestartRequestOptions: abstract new (...args: any[]) => IWindowsUpdateRestartRequestOptions;
+
+  interface IWindowsUpdateRestartRequestOptionsFactory {
+    CreateInstance(title: string, description: string, moreInfoUrl: Windows.Foundation.Uri, complianceDeadlineInDays: number, complianceGracePeriodInDays: number): Windows.Management.Update.WindowsUpdateRestartRequestOptions;
+  }
+  var IWindowsUpdateRestartRequestOptionsFactory: abstract new (...args: any[]) => IWindowsUpdateRestartRequestOptionsFactory;
+
+  interface IWindowsUpdateScanCompletedEventArgs {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly ProviderId: string;
+    readonly Succeeded: boolean;
+    readonly Updates: Windows.Foundation.Collections.IVectorView<Windows.Management.Update.WindowsUpdate> | Windows.Management.Update.WindowsUpdate[];
+  }
+  var IWindowsUpdateScanCompletedEventArgs: abstract new (...args: any[]) => IWindowsUpdateScanCompletedEventArgs;
+
+  interface WindowsUpdateContract {
+  }
+  var WindowsUpdateContract: {
+    new(fields: {  }): WindowsUpdateContract;
+  };
+
+}
+
+declare namespace Windows.Management.Workplace {
+  class MdmPolicy {
+    static GetMessagingSyncPolicy(): number;
+    static IsBrowserAllowed(): boolean;
+    static IsCameraAllowed(): boolean;
+    static IsMicrosoftAccountAllowed(): boolean;
+    static IsStoreAllowed(): boolean;
+  }
+
+  class WorkplaceSettings {
+    static readonly IsMicrosoftAccountOptional: boolean;
+  }
+
+  enum MessagingSyncPolicy {
+    Disallowed = 0,
+    Allowed = 1,
+    Required = 2,
+  }
+
+  interface IMdmAllowPolicyStatics {
+    IsBrowserAllowed(): boolean;
+    IsCameraAllowed(): boolean;
+    IsMicrosoftAccountAllowed(): boolean;
+    IsStoreAllowed(): boolean;
+  }
+  var IMdmAllowPolicyStatics: abstract new (...args: any[]) => IMdmAllowPolicyStatics;
+
+  interface IMdmPolicyStatics2 {
+    GetMessagingSyncPolicy(): number;
+  }
+  var IMdmPolicyStatics2: abstract new (...args: any[]) => IMdmPolicyStatics2;
+
+  interface IWorkplaceSettingsStatics {
+    readonly IsMicrosoftAccountOptional: boolean;
+  }
+  var IWorkplaceSettingsStatics: abstract new (...args: any[]) => IWorkplaceSettingsStatics;
+
+  interface WorkplaceSettingsContract {
+  }
+  var WorkplaceSettingsContract: {
+    new(fields: {  }): WorkplaceSettingsContract;
+  };
+
+}
+
+declare namespace Windows.Media {
+  class AudioBuffer implements Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer, Windows.Media.IAudioBuffer {
+    Close(): void;
+    CreateReference(): Windows.Foundation.IMemoryBufferReference;
+    readonly Capacity: number;
+    Length: number;
+  }
+
+  class AudioFrame implements Windows.Foundation.IClosable, Windows.Media.IAudioFrame, Windows.Media.IMediaFrame {
+    constructor(capacity: number);
+    Close(): void;
+    LockBuffer(mode: number): Windows.Media.AudioBuffer;
+    Duration: Windows.Foundation.TimeSpan | null;
+    readonly ExtendedProperties: Windows.Foundation.Collections.IPropertySet;
+    IsDiscontinuous: boolean;
+    readonly IsReadOnly: boolean;
+    RelativeTime: Windows.Foundation.TimeSpan | null;
+    SystemRelativeTime: Windows.Foundation.TimeSpan | null;
+    readonly Type: string;
+  }
+
+  class AutoRepeatModeChangeRequestedEventArgs implements Windows.Media.IAutoRepeatModeChangeRequestedEventArgs {
+    readonly RequestedAutoRepeatMode: number;
+  }
+
+  class ImageDisplayProperties implements Windows.Media.IImageDisplayProperties {
+    Subtitle: string;
+    Title: string;
+  }
+
+  class MediaControl {
+    static AlbumArt: Windows.Foundation.Uri;
+    static ArtistName: string;
+    static IsPlaying: boolean;
+    static readonly SoundLevel: number;
+    static TrackName: string;
+    static ChannelDownPressed: Windows.Foundation.EventHandler<Object> | null;
+    static ChannelUpPressed: Windows.Foundation.EventHandler<Object> | null;
+    static FastForwardPressed: Windows.Foundation.EventHandler<Object> | null;
+    static NextTrackPressed: Windows.Foundation.EventHandler<Object> | null;
+    static PausePressed: Windows.Foundation.EventHandler<Object> | null;
+    static PlayPauseTogglePressed: Windows.Foundation.EventHandler<Object> | null;
+    static PlayPressed: Windows.Foundation.EventHandler<Object> | null;
+    static PreviousTrackPressed: Windows.Foundation.EventHandler<Object> | null;
+    static RecordPressed: Windows.Foundation.EventHandler<Object> | null;
+    static RewindPressed: Windows.Foundation.EventHandler<Object> | null;
+    static SoundLevelChanged: Windows.Foundation.EventHandler<Object> | null;
+    static StopPressed: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class MediaExtensionManager implements Windows.Media.IMediaExtensionManager, Windows.Media.IMediaExtensionManager2 {
+    constructor();
+    RegisterAudioDecoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid): void;
+    RegisterAudioDecoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    RegisterAudioEncoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid): void;
+    RegisterAudioEncoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    RegisterByteStreamHandler(activatableClassId: string, fileExtension: string, mimeType: string): void;
+    RegisterByteStreamHandler(activatableClassId: string, fileExtension: string, mimeType: string, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    RegisterMediaExtensionForAppService(extension: Windows.Media.IMediaExtension, connection: Windows.ApplicationModel.AppService.AppServiceConnection): void;
+    RegisterSchemeHandler(activatableClassId: string, scheme: string): void;
+    RegisterSchemeHandler(activatableClassId: string, scheme: string, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    RegisterVideoDecoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid): void;
+    RegisterVideoDecoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    RegisterVideoEncoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid): void;
+    RegisterVideoEncoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid, configuration: Windows.Foundation.Collections.IPropertySet): void;
+  }
+
+  class MediaMarkerTypes {
+    static readonly Bookmark: string;
+  }
+
+  class MediaProcessingTriggerDetails implements Windows.Media.IMediaProcessingTriggerDetails {
+    readonly Arguments: Windows.Foundation.Collections.ValueSet;
+  }
+
+  class MediaTimelineController implements Windows.Media.IMediaTimelineController, Windows.Media.IMediaTimelineController2 {
+    constructor();
+    Pause(): void;
+    Resume(): void;
+    Start(): void;
+    ClockRate: number;
+    Duration: Windows.Foundation.TimeSpan | null;
+    IsLoopingEnabled: boolean;
+    Position: Windows.Foundation.TimeSpan;
+    readonly State: number;
+    PositionChanged: Windows.Foundation.TypedEventHandler<Windows.Media.MediaTimelineController, Object> | null;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.MediaTimelineController, Object> | null;
+    Ended: Windows.Foundation.TypedEventHandler<Windows.Media.MediaTimelineController, Object> | null;
+    Failed: Windows.Foundation.TypedEventHandler<Windows.Media.MediaTimelineController, Windows.Media.MediaTimelineControllerFailedEventArgs> | null;
+  }
+
+  class MediaTimelineControllerFailedEventArgs implements Windows.Media.IMediaTimelineControllerFailedEventArgs {
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+
+  class MusicDisplayProperties implements Windows.Media.IMusicDisplayProperties, Windows.Media.IMusicDisplayProperties2, Windows.Media.IMusicDisplayProperties3 {
+    AlbumArtist: string;
+    AlbumTitle: string;
+    AlbumTrackCount: number;
+    Artist: string;
+    readonly Genres: Windows.Foundation.Collections.IVector<string> | string[];
+    Title: string;
+    TrackNumber: number;
+  }
+
+  class PlaybackPositionChangeRequestedEventArgs implements Windows.Media.IPlaybackPositionChangeRequestedEventArgs {
+    readonly RequestedPlaybackPosition: Windows.Foundation.TimeSpan;
+  }
+
+  class PlaybackRateChangeRequestedEventArgs implements Windows.Media.IPlaybackRateChangeRequestedEventArgs {
+    readonly RequestedPlaybackRate: number;
+  }
+
+  class ShuffleEnabledChangeRequestedEventArgs implements Windows.Media.IShuffleEnabledChangeRequestedEventArgs {
+    readonly RequestedShuffleEnabled: boolean;
+  }
+
+  class SystemMediaTransportControls implements Windows.Media.ISystemMediaTransportControls, Windows.Media.ISystemMediaTransportControls2 {
+    static GetForCurrentView(): Windows.Media.SystemMediaTransportControls;
+    UpdateTimelineProperties(timelineProperties: Windows.Media.SystemMediaTransportControlsTimelineProperties): void;
+    AutoRepeatMode: number;
+    readonly DisplayUpdater: Windows.Media.SystemMediaTransportControlsDisplayUpdater;
+    IsChannelDownEnabled: boolean;
+    IsChannelUpEnabled: boolean;
+    IsEnabled: boolean;
+    IsFastForwardEnabled: boolean;
+    IsNextEnabled: boolean;
+    IsPauseEnabled: boolean;
+    IsPlayEnabled: boolean;
+    IsPreviousEnabled: boolean;
+    IsRecordEnabled: boolean;
+    IsRewindEnabled: boolean;
+    IsStopEnabled: boolean;
+    PlaybackRate: number;
+    PlaybackStatus: number;
+    ShuffleEnabled: boolean;
+    readonly SoundLevel: number;
+    ButtonPressed: Windows.Foundation.TypedEventHandler<Windows.Media.SystemMediaTransportControls, Windows.Media.SystemMediaTransportControlsButtonPressedEventArgs> | null;
+    PropertyChanged: Windows.Foundation.TypedEventHandler<Windows.Media.SystemMediaTransportControls, Windows.Media.SystemMediaTransportControlsPropertyChangedEventArgs> | null;
+    AutoRepeatModeChangeRequested: Windows.Foundation.TypedEventHandler<Windows.Media.SystemMediaTransportControls, Windows.Media.AutoRepeatModeChangeRequestedEventArgs> | null;
+    PlaybackPositionChangeRequested: Windows.Foundation.TypedEventHandler<Windows.Media.SystemMediaTransportControls, Windows.Media.PlaybackPositionChangeRequestedEventArgs> | null;
+    PlaybackRateChangeRequested: Windows.Foundation.TypedEventHandler<Windows.Media.SystemMediaTransportControls, Windows.Media.PlaybackRateChangeRequestedEventArgs> | null;
+    ShuffleEnabledChangeRequested: Windows.Foundation.TypedEventHandler<Windows.Media.SystemMediaTransportControls, Windows.Media.ShuffleEnabledChangeRequestedEventArgs> | null;
+  }
+
+  class SystemMediaTransportControlsButtonPressedEventArgs implements Windows.Media.ISystemMediaTransportControlsButtonPressedEventArgs {
+    readonly Button: number;
+  }
+
+  class SystemMediaTransportControlsDisplayUpdater implements Windows.Media.ISystemMediaTransportControlsDisplayUpdater {
+    ClearAll(): void;
+    CopyFromFileAsync(type: number, source: Windows.Storage.StorageFile): Windows.Foundation.IAsyncOperation<boolean>;
+    Update(): void;
+    AppMediaId: string;
+    readonly ImageProperties: Windows.Media.ImageDisplayProperties;
+    readonly MusicProperties: Windows.Media.MusicDisplayProperties;
+    Thumbnail: Windows.Storage.Streams.RandomAccessStreamReference;
+    Type: number;
+    readonly VideoProperties: Windows.Media.VideoDisplayProperties;
+  }
+
+  class SystemMediaTransportControlsPropertyChangedEventArgs implements Windows.Media.ISystemMediaTransportControlsPropertyChangedEventArgs {
+    readonly Property: number;
+  }
+
+  class SystemMediaTransportControlsTimelineProperties implements Windows.Media.ISystemMediaTransportControlsTimelineProperties {
+    constructor();
+    EndTime: Windows.Foundation.TimeSpan;
+    MaxSeekTime: Windows.Foundation.TimeSpan;
+    MinSeekTime: Windows.Foundation.TimeSpan;
+    Position: Windows.Foundation.TimeSpan;
+    StartTime: Windows.Foundation.TimeSpan;
+  }
+
+  class VideoDisplayProperties implements Windows.Media.IVideoDisplayProperties, Windows.Media.IVideoDisplayProperties2 {
+    readonly Genres: Windows.Foundation.Collections.IVector<string> | string[];
+    Subtitle: string;
+    Title: string;
+  }
+
+  class VideoEffects {
+    static readonly VideoStabilization: string;
+  }
+
+  class VideoFrame implements Windows.Foundation.IClosable, Windows.Media.IMediaFrame, Windows.Media.IVideoFrame, Windows.Media.IVideoFrame2 {
+    constructor(format: number, width: number, height: number);
+    constructor(format: number, width: number, height: number, alpha: number);
+    Close(): void;
+    CopyToAsync(frame: Windows.Media.VideoFrame): Windows.Foundation.IAsyncAction;
+    CopyToAsync(frame: Windows.Media.VideoFrame, sourceBounds: Windows.Graphics.Imaging.BitmapBounds | null, destinationBounds: Windows.Graphics.Imaging.BitmapBounds | null): Windows.Foundation.IAsyncAction;
+    static CreateAsDirect3D11SurfaceBacked(format: number, width: number, height: number): Windows.Media.VideoFrame;
+    static CreateAsDirect3D11SurfaceBacked(format: number, width: number, height: number, device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice): Windows.Media.VideoFrame;
+    static CreateWithDirect3D11Surface(surface: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface): Windows.Media.VideoFrame;
+    static CreateWithSoftwareBitmap(bitmap: Windows.Graphics.Imaging.SoftwareBitmap): Windows.Media.VideoFrame;
+    readonly Direct3DSurface: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface;
+    Duration: Windows.Foundation.TimeSpan | null;
+    readonly ExtendedProperties: Windows.Foundation.Collections.IPropertySet;
+    IsDiscontinuous: boolean;
+    readonly IsReadOnly: boolean;
+    RelativeTime: Windows.Foundation.TimeSpan | null;
+    readonly SoftwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap;
+    SystemRelativeTime: Windows.Foundation.TimeSpan | null;
+    readonly Type: string;
+  }
+
+  enum AudioBufferAccessMode {
+    Read = 0,
+    ReadWrite = 1,
+    Write = 2,
+  }
+
+  enum AudioProcessing {
+    Default = 0,
+    Raw = 1,
+  }
+
+  enum MediaPlaybackAutoRepeatMode {
+    None = 0,
+    Track = 1,
+    List = 2,
+  }
+
+  enum MediaPlaybackStatus {
+    Closed = 0,
+    Changing = 1,
+    Stopped = 2,
+    Playing = 3,
+    Paused = 4,
+  }
+
+  enum MediaPlaybackType {
+    Unknown = 0,
+    Music = 1,
+    Video = 2,
+    Image = 3,
+  }
+
+  enum MediaTimelineControllerState {
+    Paused = 0,
+    Running = 1,
+    Stalled = 2,
+    Error = 3,
+  }
+
+  enum SoundLevel {
+    Muted = 0,
+    Low = 1,
+    Full = 2,
+  }
+
+  enum SystemMediaTransportControlsButton {
+    Play = 0,
+    Pause = 1,
+    Stop = 2,
+    Record = 3,
+    FastForward = 4,
+    Rewind = 5,
+    Next = 6,
+    Previous = 7,
+    ChannelUp = 8,
+    ChannelDown = 9,
+  }
+
+  enum SystemMediaTransportControlsProperty {
+    SoundLevel = 0,
+  }
+
+  interface IAudioBuffer extends Windows.Foundation.IClosable, Windows.Foundation.IMemoryBuffer {
+    Close(): void;
+    CreateReference(): Windows.Foundation.IMemoryBufferReference;
+    readonly Capacity: number;
+    Length: number;
+  }
+  var IAudioBuffer: abstract new (...args: any[]) => IAudioBuffer;
+
+  interface IAudioFrame extends Windows.Foundation.IClosable, Windows.Media.IMediaFrame {
+    Close(): void;
+    LockBuffer(mode: number): Windows.Media.AudioBuffer;
+  }
+  var IAudioFrame: abstract new (...args: any[]) => IAudioFrame;
+
+  interface IAudioFrameFactory {
+    Create(capacity: number): Windows.Media.AudioFrame;
+  }
+  var IAudioFrameFactory: abstract new (...args: any[]) => IAudioFrameFactory;
+
+  interface IAutoRepeatModeChangeRequestedEventArgs {
+    readonly RequestedAutoRepeatMode: number;
+  }
+  var IAutoRepeatModeChangeRequestedEventArgs: abstract new (...args: any[]) => IAutoRepeatModeChangeRequestedEventArgs;
+
+  interface IImageDisplayProperties {
+    Subtitle: string;
+    Title: string;
+  }
+  var IImageDisplayProperties: abstract new (...args: any[]) => IImageDisplayProperties;
+
+  interface IMediaControl {
+    AlbumArt: Windows.Foundation.Uri;
+    ArtistName: string;
+    IsPlaying: boolean;
+    readonly SoundLevel: number;
+    TrackName: string;
+    ChannelDownPressed: Windows.Foundation.EventHandler<Object> | null;
+    ChannelUpPressed: Windows.Foundation.EventHandler<Object> | null;
+    FastForwardPressed: Windows.Foundation.EventHandler<Object> | null;
+    NextTrackPressed: Windows.Foundation.EventHandler<Object> | null;
+    PausePressed: Windows.Foundation.EventHandler<Object> | null;
+    PlayPauseTogglePressed: Windows.Foundation.EventHandler<Object> | null;
+    PlayPressed: Windows.Foundation.EventHandler<Object> | null;
+    PreviousTrackPressed: Windows.Foundation.EventHandler<Object> | null;
+    RecordPressed: Windows.Foundation.EventHandler<Object> | null;
+    RewindPressed: Windows.Foundation.EventHandler<Object> | null;
+    SoundLevelChanged: Windows.Foundation.EventHandler<Object> | null;
+    StopPressed: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IMediaControl: abstract new (...args: any[]) => IMediaControl;
+
+  interface IMediaExtension {
+    SetProperties(configuration: Windows.Foundation.Collections.IPropertySet): void;
+  }
+  var IMediaExtension: abstract new (...args: any[]) => IMediaExtension;
+
+  interface IMediaExtensionManager {
+    RegisterAudioDecoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid): void;
+    RegisterAudioDecoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    RegisterAudioEncoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid): void;
+    RegisterAudioEncoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    RegisterByteStreamHandler(activatableClassId: string, fileExtension: string, mimeType: string): void;
+    RegisterByteStreamHandler(activatableClassId: string, fileExtension: string, mimeType: string, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    RegisterSchemeHandler(activatableClassId: string, scheme: string): void;
+    RegisterSchemeHandler(activatableClassId: string, scheme: string, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    RegisterVideoDecoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid): void;
+    RegisterVideoDecoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    RegisterVideoEncoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid): void;
+    RegisterVideoEncoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid, configuration: Windows.Foundation.Collections.IPropertySet): void;
+  }
+  var IMediaExtensionManager: abstract new (...args: any[]) => IMediaExtensionManager;
+
+  interface IMediaExtensionManager2 extends Windows.Media.IMediaExtensionManager {
+    RegisterAudioDecoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid): void;
+    RegisterAudioDecoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    RegisterAudioEncoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid): void;
+    RegisterAudioEncoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    RegisterByteStreamHandler(activatableClassId: string, fileExtension: string, mimeType: string): void;
+    RegisterByteStreamHandler(activatableClassId: string, fileExtension: string, mimeType: string, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    RegisterMediaExtensionForAppService(extension: Windows.Media.IMediaExtension, connection: Windows.ApplicationModel.AppService.AppServiceConnection): void;
+    RegisterSchemeHandler(activatableClassId: string, scheme: string): void;
+    RegisterSchemeHandler(activatableClassId: string, scheme: string, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    RegisterVideoDecoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid): void;
+    RegisterVideoDecoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    RegisterVideoEncoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid): void;
+    RegisterVideoEncoder(activatableClassId: string, inputSubtype: Guid, outputSubtype: Guid, configuration: Windows.Foundation.Collections.IPropertySet): void;
+  }
+  var IMediaExtensionManager2: abstract new (...args: any[]) => IMediaExtensionManager2;
+
+  interface IMediaFrame extends Windows.Foundation.IClosable {
+    Close(): void;
+    Duration: Windows.Foundation.TimeSpan | null;
+    readonly ExtendedProperties: Windows.Foundation.Collections.IPropertySet;
+    IsDiscontinuous: boolean;
+    readonly IsReadOnly: boolean;
+    RelativeTime: Windows.Foundation.TimeSpan | null;
+    SystemRelativeTime: Windows.Foundation.TimeSpan | null;
+    readonly Type: string;
+  }
+  var IMediaFrame: abstract new (...args: any[]) => IMediaFrame;
+
+  interface IMediaMarker {
+    readonly MediaMarkerType: string;
+    readonly Text: string;
+    readonly Time: Windows.Foundation.TimeSpan;
+  }
+  var IMediaMarker: abstract new (...args: any[]) => IMediaMarker;
+
+  interface IMediaMarkerTypesStatics {
+    readonly Bookmark: string;
+  }
+  var IMediaMarkerTypesStatics: abstract new (...args: any[]) => IMediaMarkerTypesStatics;
+
+  interface IMediaMarkers {
+    readonly Markers: Windows.Foundation.Collections.IVectorView<Windows.Media.IMediaMarker> | Windows.Media.IMediaMarker[];
+  }
+  var IMediaMarkers: abstract new (...args: any[]) => IMediaMarkers;
+
+  interface IMediaProcessingTriggerDetails {
+    readonly Arguments: Windows.Foundation.Collections.ValueSet;
+  }
+  var IMediaProcessingTriggerDetails: abstract new (...args: any[]) => IMediaProcessingTriggerDetails;
+
+  interface IMediaTimelineController {
+    Pause(): void;
+    Resume(): void;
+    Start(): void;
+    ClockRate: number;
+    Position: Windows.Foundation.TimeSpan;
+    readonly State: number;
+    PositionChanged: Windows.Foundation.TypedEventHandler<Windows.Media.MediaTimelineController, Object> | null;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.MediaTimelineController, Object> | null;
+  }
+  var IMediaTimelineController: abstract new (...args: any[]) => IMediaTimelineController;
+
+  interface IMediaTimelineController2 {
+    Duration: Windows.Foundation.TimeSpan | null;
+    IsLoopingEnabled: boolean;
+    Ended: Windows.Foundation.TypedEventHandler<Windows.Media.MediaTimelineController, Object> | null;
+    Failed: Windows.Foundation.TypedEventHandler<Windows.Media.MediaTimelineController, Windows.Media.MediaTimelineControllerFailedEventArgs> | null;
+  }
+  var IMediaTimelineController2: abstract new (...args: any[]) => IMediaTimelineController2;
+
+  interface IMediaTimelineControllerFailedEventArgs {
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+  var IMediaTimelineControllerFailedEventArgs: abstract new (...args: any[]) => IMediaTimelineControllerFailedEventArgs;
+
+  interface IMusicDisplayProperties {
+    AlbumArtist: string;
+    Artist: string;
+    Title: string;
+  }
+  var IMusicDisplayProperties: abstract new (...args: any[]) => IMusicDisplayProperties;
+
+  interface IMusicDisplayProperties2 {
+    AlbumTitle: string;
+    readonly Genres: Windows.Foundation.Collections.IVector<string> | string[];
+    TrackNumber: number;
+  }
+  var IMusicDisplayProperties2: abstract new (...args: any[]) => IMusicDisplayProperties2;
+
+  interface IMusicDisplayProperties3 {
+    AlbumTrackCount: number;
+  }
+  var IMusicDisplayProperties3: abstract new (...args: any[]) => IMusicDisplayProperties3;
+
+  interface IPlaybackPositionChangeRequestedEventArgs {
+    readonly RequestedPlaybackPosition: Windows.Foundation.TimeSpan;
+  }
+  var IPlaybackPositionChangeRequestedEventArgs: abstract new (...args: any[]) => IPlaybackPositionChangeRequestedEventArgs;
+
+  interface IPlaybackRateChangeRequestedEventArgs {
+    readonly RequestedPlaybackRate: number;
+  }
+  var IPlaybackRateChangeRequestedEventArgs: abstract new (...args: any[]) => IPlaybackRateChangeRequestedEventArgs;
+
+  interface IShuffleEnabledChangeRequestedEventArgs {
+    readonly RequestedShuffleEnabled: boolean;
+  }
+  var IShuffleEnabledChangeRequestedEventArgs: abstract new (...args: any[]) => IShuffleEnabledChangeRequestedEventArgs;
+
+  interface ISystemMediaTransportControls {
+    readonly DisplayUpdater: Windows.Media.SystemMediaTransportControlsDisplayUpdater;
+    IsChannelDownEnabled: boolean;
+    IsChannelUpEnabled: boolean;
+    IsEnabled: boolean;
+    IsFastForwardEnabled: boolean;
+    IsNextEnabled: boolean;
+    IsPauseEnabled: boolean;
+    IsPlayEnabled: boolean;
+    IsPreviousEnabled: boolean;
+    IsRecordEnabled: boolean;
+    IsRewindEnabled: boolean;
+    IsStopEnabled: boolean;
+    PlaybackStatus: number;
+    readonly SoundLevel: number;
+    ButtonPressed: Windows.Foundation.TypedEventHandler<Windows.Media.SystemMediaTransportControls, Windows.Media.SystemMediaTransportControlsButtonPressedEventArgs> | null;
+    PropertyChanged: Windows.Foundation.TypedEventHandler<Windows.Media.SystemMediaTransportControls, Windows.Media.SystemMediaTransportControlsPropertyChangedEventArgs> | null;
+  }
+  var ISystemMediaTransportControls: abstract new (...args: any[]) => ISystemMediaTransportControls;
+
+  interface ISystemMediaTransportControls2 {
+    UpdateTimelineProperties(timelineProperties: Windows.Media.SystemMediaTransportControlsTimelineProperties): void;
+    AutoRepeatMode: number;
+    PlaybackRate: number;
+    ShuffleEnabled: boolean;
+    AutoRepeatModeChangeRequested: Windows.Foundation.TypedEventHandler<Windows.Media.SystemMediaTransportControls, Windows.Media.AutoRepeatModeChangeRequestedEventArgs> | null;
+    PlaybackPositionChangeRequested: Windows.Foundation.TypedEventHandler<Windows.Media.SystemMediaTransportControls, Windows.Media.PlaybackPositionChangeRequestedEventArgs> | null;
+    PlaybackRateChangeRequested: Windows.Foundation.TypedEventHandler<Windows.Media.SystemMediaTransportControls, Windows.Media.PlaybackRateChangeRequestedEventArgs> | null;
+    ShuffleEnabledChangeRequested: Windows.Foundation.TypedEventHandler<Windows.Media.SystemMediaTransportControls, Windows.Media.ShuffleEnabledChangeRequestedEventArgs> | null;
+  }
+  var ISystemMediaTransportControls2: abstract new (...args: any[]) => ISystemMediaTransportControls2;
+
+  interface ISystemMediaTransportControlsButtonPressedEventArgs {
+    readonly Button: number;
+  }
+  var ISystemMediaTransportControlsButtonPressedEventArgs: abstract new (...args: any[]) => ISystemMediaTransportControlsButtonPressedEventArgs;
+
+  interface ISystemMediaTransportControlsDisplayUpdater {
+    ClearAll(): void;
+    CopyFromFileAsync(type: number, source: Windows.Storage.StorageFile): Windows.Foundation.IAsyncOperation<boolean>;
+    Update(): void;
+    AppMediaId: string;
+    readonly ImageProperties: Windows.Media.ImageDisplayProperties;
+    readonly MusicProperties: Windows.Media.MusicDisplayProperties;
+    Thumbnail: Windows.Storage.Streams.RandomAccessStreamReference;
+    Type: number;
+    readonly VideoProperties: Windows.Media.VideoDisplayProperties;
+  }
+  var ISystemMediaTransportControlsDisplayUpdater: abstract new (...args: any[]) => ISystemMediaTransportControlsDisplayUpdater;
+
+  interface ISystemMediaTransportControlsPropertyChangedEventArgs {
+    readonly Property: number;
+  }
+  var ISystemMediaTransportControlsPropertyChangedEventArgs: abstract new (...args: any[]) => ISystemMediaTransportControlsPropertyChangedEventArgs;
+
+  interface ISystemMediaTransportControlsStatics {
+    GetForCurrentView(): Windows.Media.SystemMediaTransportControls;
+  }
+  var ISystemMediaTransportControlsStatics: abstract new (...args: any[]) => ISystemMediaTransportControlsStatics;
+
+  interface ISystemMediaTransportControlsTimelineProperties {
+    EndTime: Windows.Foundation.TimeSpan;
+    MaxSeekTime: Windows.Foundation.TimeSpan;
+    MinSeekTime: Windows.Foundation.TimeSpan;
+    Position: Windows.Foundation.TimeSpan;
+    StartTime: Windows.Foundation.TimeSpan;
+  }
+  var ISystemMediaTransportControlsTimelineProperties: abstract new (...args: any[]) => ISystemMediaTransportControlsTimelineProperties;
+
+  interface IVideoDisplayProperties {
+    Subtitle: string;
+    Title: string;
+  }
+  var IVideoDisplayProperties: abstract new (...args: any[]) => IVideoDisplayProperties;
+
+  interface IVideoDisplayProperties2 {
+    readonly Genres: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var IVideoDisplayProperties2: abstract new (...args: any[]) => IVideoDisplayProperties2;
+
+  interface IVideoEffectsStatics {
+    readonly VideoStabilization: string;
+  }
+  var IVideoEffectsStatics: abstract new (...args: any[]) => IVideoEffectsStatics;
+
+  interface IVideoFrame extends Windows.Foundation.IClosable, Windows.Media.IMediaFrame {
+    Close(): void;
+    CopyToAsync(frame: Windows.Media.VideoFrame): Windows.Foundation.IAsyncAction;
+    readonly Direct3DSurface: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface;
+    readonly SoftwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap;
+  }
+  var IVideoFrame: abstract new (...args: any[]) => IVideoFrame;
+
+  interface IVideoFrame2 {
+    CopyToAsync(frame: Windows.Media.VideoFrame, sourceBounds: Windows.Graphics.Imaging.BitmapBounds | null, destinationBounds: Windows.Graphics.Imaging.BitmapBounds | null): Windows.Foundation.IAsyncAction;
+  }
+  var IVideoFrame2: abstract new (...args: any[]) => IVideoFrame2;
+
+  interface IVideoFrameFactory {
+    Create(format: number, width: number, height: number): Windows.Media.VideoFrame;
+    CreateWithAlpha(format: number, width: number, height: number, alpha: number): Windows.Media.VideoFrame;
+  }
+  var IVideoFrameFactory: abstract new (...args: any[]) => IVideoFrameFactory;
+
+  interface IVideoFrameStatics {
+    CreateAsDirect3D11SurfaceBacked(format: number, width: number, height: number): Windows.Media.VideoFrame;
+    CreateAsDirect3D11SurfaceBacked(format: number, width: number, height: number, device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice): Windows.Media.VideoFrame;
+    CreateWithDirect3D11Surface(surface: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface): Windows.Media.VideoFrame;
+    CreateWithSoftwareBitmap(bitmap: Windows.Graphics.Imaging.SoftwareBitmap): Windows.Media.VideoFrame;
+  }
+  var IVideoFrameStatics: abstract new (...args: any[]) => IVideoFrameStatics;
+
+  interface MediaControlContract {
+  }
+  var MediaControlContract: {
+    new(fields: {  }): MediaControlContract;
+  };
+
+  interface MediaTimeRange {
+    Start: Windows.Foundation.TimeSpan;
+    End: Windows.Foundation.TimeSpan;
+  }
+  var MediaTimeRange: {
+    new(start: Windows.Foundation.TimeSpan, end: Windows.Foundation.TimeSpan): MediaTimeRange;
+    new(fields: { Start?: Windows.Foundation.TimeSpan; End?: Windows.Foundation.TimeSpan }): MediaTimeRange;
+  };
+
+}
+
+declare namespace Windows.Media.AppBroadcasting {
+  class AppBroadcastingMonitor implements Windows.Media.AppBroadcasting.IAppBroadcastingMonitor {
+    constructor();
+    readonly IsCurrentAppBroadcasting: boolean;
+    IsCurrentAppBroadcastingChanged: Windows.Foundation.TypedEventHandler<Windows.Media.AppBroadcasting.AppBroadcastingMonitor, Object> | null;
+  }
+
+  class AppBroadcastingStatus implements Windows.Media.AppBroadcasting.IAppBroadcastingStatus {
+    readonly CanStartBroadcast: boolean;
+    readonly Details: Windows.Media.AppBroadcasting.AppBroadcastingStatusDetails;
+  }
+
+  class AppBroadcastingStatusDetails implements Windows.Media.AppBroadcasting.IAppBroadcastingStatusDetails {
+    readonly IsAnyAppBroadcasting: boolean;
+    readonly IsAppInactive: boolean;
+    readonly IsBlockedForApp: boolean;
+    readonly IsCaptureResourceUnavailable: boolean;
+    readonly IsDisabledBySystem: boolean;
+    readonly IsDisabledByUser: boolean;
+    readonly IsGameStreamInProgress: boolean;
+    readonly IsGpuConstrained: boolean;
+  }
+
+  class AppBroadcastingUI implements Windows.Media.AppBroadcasting.IAppBroadcastingUI {
+    static GetDefault(): Windows.Media.AppBroadcasting.AppBroadcastingUI;
+    static GetForUser(user: Windows.System.User): Windows.Media.AppBroadcasting.AppBroadcastingUI;
+    GetStatus(): Windows.Media.AppBroadcasting.AppBroadcastingStatus;
+    ShowBroadcastUI(): void;
+  }
+
+  interface AppBroadcastingContract {
+  }
+  var AppBroadcastingContract: {
+    new(fields: {  }): AppBroadcastingContract;
+  };
+
+  interface IAppBroadcastingMonitor {
+    readonly IsCurrentAppBroadcasting: boolean;
+    IsCurrentAppBroadcastingChanged: Windows.Foundation.TypedEventHandler<Windows.Media.AppBroadcasting.AppBroadcastingMonitor, Object> | null;
+  }
+  var IAppBroadcastingMonitor: abstract new (...args: any[]) => IAppBroadcastingMonitor;
+
+  interface IAppBroadcastingStatus {
+    readonly CanStartBroadcast: boolean;
+    readonly Details: Windows.Media.AppBroadcasting.AppBroadcastingStatusDetails;
+  }
+  var IAppBroadcastingStatus: abstract new (...args: any[]) => IAppBroadcastingStatus;
+
+  interface IAppBroadcastingStatusDetails {
+    readonly IsAnyAppBroadcasting: boolean;
+    readonly IsAppInactive: boolean;
+    readonly IsBlockedForApp: boolean;
+    readonly IsCaptureResourceUnavailable: boolean;
+    readonly IsDisabledBySystem: boolean;
+    readonly IsDisabledByUser: boolean;
+    readonly IsGameStreamInProgress: boolean;
+    readonly IsGpuConstrained: boolean;
+  }
+  var IAppBroadcastingStatusDetails: abstract new (...args: any[]) => IAppBroadcastingStatusDetails;
+
+  interface IAppBroadcastingUI {
+    GetStatus(): Windows.Media.AppBroadcasting.AppBroadcastingStatus;
+    ShowBroadcastUI(): void;
+  }
+  var IAppBroadcastingUI: abstract new (...args: any[]) => IAppBroadcastingUI;
+
+  interface IAppBroadcastingUIStatics {
+    GetDefault(): Windows.Media.AppBroadcasting.AppBroadcastingUI;
+    GetForUser(user: Windows.System.User): Windows.Media.AppBroadcasting.AppBroadcastingUI;
+  }
+  var IAppBroadcastingUIStatics: abstract new (...args: any[]) => IAppBroadcastingUIStatics;
+
+}
+
+declare namespace Windows.Media.AppRecording {
+  class AppRecordingManager implements Windows.Media.AppRecording.IAppRecordingManager {
+    static GetDefault(): Windows.Media.AppRecording.AppRecordingManager;
+    GetStatus(): Windows.Media.AppRecording.AppRecordingStatus;
+    RecordTimeSpanToFileAsync(startTime: Windows.Foundation.DateTime, duration: Windows.Foundation.TimeSpan, file: Windows.Storage.StorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.AppRecording.AppRecordingResult>;
+    SaveScreenshotToFilesAsync(folder: Windows.Storage.StorageFolder, filenamePrefix: string, option: number, requestedFormats: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Media.AppRecording.AppRecordingSaveScreenshotResult>;
+    StartRecordingToFileAsync(file: Windows.Storage.StorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.AppRecording.AppRecordingResult>;
+    readonly SupportedScreenshotMediaEncodingSubtypes: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+
+  class AppRecordingResult implements Windows.Media.AppRecording.IAppRecordingResult {
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly IsFileTruncated: boolean;
+    readonly Succeeded: boolean;
+  }
+
+  class AppRecordingSaveScreenshotResult implements Windows.Media.AppRecording.IAppRecordingSaveScreenshotResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly SavedScreenshotInfos: Windows.Foundation.Collections.IVectorView<Windows.Media.AppRecording.AppRecordingSavedScreenshotInfo> | Windows.Media.AppRecording.AppRecordingSavedScreenshotInfo[];
+    readonly Succeeded: boolean;
+  }
+
+  class AppRecordingSavedScreenshotInfo implements Windows.Media.AppRecording.IAppRecordingSavedScreenshotInfo {
+    readonly File: Windows.Storage.StorageFile;
+    readonly MediaEncodingSubtype: string;
+  }
+
+  class AppRecordingStatus implements Windows.Media.AppRecording.IAppRecordingStatus {
+    readonly CanRecord: boolean;
+    readonly CanRecordTimeSpan: boolean;
+    readonly Details: Windows.Media.AppRecording.AppRecordingStatusDetails;
+    readonly HistoricalBufferDuration: Windows.Foundation.TimeSpan;
+  }
+
+  class AppRecordingStatusDetails implements Windows.Media.AppRecording.IAppRecordingStatusDetails {
+    readonly IsAnyAppBroadcasting: boolean;
+    readonly IsAppInactive: boolean;
+    readonly IsBlockedForApp: boolean;
+    readonly IsCaptureResourceUnavailable: boolean;
+    readonly IsDisabledBySystem: boolean;
+    readonly IsDisabledByUser: boolean;
+    readonly IsGameStreamInProgress: boolean;
+    readonly IsGpuConstrained: boolean;
+    readonly IsTimeSpanRecordingDisabled: boolean;
+  }
+
+  enum AppRecordingSaveScreenshotOption {
+    None = 0,
+    HdrContentVisible = 1,
+  }
+
+  interface AppRecordingContract {
+  }
+  var AppRecordingContract: {
+    new(fields: {  }): AppRecordingContract;
+  };
+
+  interface IAppRecordingManager {
+    GetStatus(): Windows.Media.AppRecording.AppRecordingStatus;
+    RecordTimeSpanToFileAsync(startTime: Windows.Foundation.DateTime, duration: Windows.Foundation.TimeSpan, file: Windows.Storage.StorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.AppRecording.AppRecordingResult>;
+    SaveScreenshotToFilesAsync(folder: Windows.Storage.StorageFolder, filenamePrefix: string, option: number, requestedFormats: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Media.AppRecording.AppRecordingSaveScreenshotResult>;
+    StartRecordingToFileAsync(file: Windows.Storage.StorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.AppRecording.AppRecordingResult>;
+    readonly SupportedScreenshotMediaEncodingSubtypes: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var IAppRecordingManager: abstract new (...args: any[]) => IAppRecordingManager;
+
+  interface IAppRecordingManagerStatics {
+    GetDefault(): Windows.Media.AppRecording.AppRecordingManager;
+  }
+  var IAppRecordingManagerStatics: abstract new (...args: any[]) => IAppRecordingManagerStatics;
+
+  interface IAppRecordingResult {
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly IsFileTruncated: boolean;
+    readonly Succeeded: boolean;
+  }
+  var IAppRecordingResult: abstract new (...args: any[]) => IAppRecordingResult;
+
+  interface IAppRecordingSaveScreenshotResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly SavedScreenshotInfos: Windows.Foundation.Collections.IVectorView<Windows.Media.AppRecording.AppRecordingSavedScreenshotInfo> | Windows.Media.AppRecording.AppRecordingSavedScreenshotInfo[];
+    readonly Succeeded: boolean;
+  }
+  var IAppRecordingSaveScreenshotResult: abstract new (...args: any[]) => IAppRecordingSaveScreenshotResult;
+
+  interface IAppRecordingSavedScreenshotInfo {
+    readonly File: Windows.Storage.StorageFile;
+    readonly MediaEncodingSubtype: string;
+  }
+  var IAppRecordingSavedScreenshotInfo: abstract new (...args: any[]) => IAppRecordingSavedScreenshotInfo;
+
+  interface IAppRecordingStatus {
+    readonly CanRecord: boolean;
+    readonly CanRecordTimeSpan: boolean;
+    readonly Details: Windows.Media.AppRecording.AppRecordingStatusDetails;
+    readonly HistoricalBufferDuration: Windows.Foundation.TimeSpan;
+  }
+  var IAppRecordingStatus: abstract new (...args: any[]) => IAppRecordingStatus;
+
+  interface IAppRecordingStatusDetails {
+    readonly IsAnyAppBroadcasting: boolean;
+    readonly IsAppInactive: boolean;
+    readonly IsBlockedForApp: boolean;
+    readonly IsCaptureResourceUnavailable: boolean;
+    readonly IsDisabledBySystem: boolean;
+    readonly IsDisabledByUser: boolean;
+    readonly IsGameStreamInProgress: boolean;
+    readonly IsGpuConstrained: boolean;
+    readonly IsTimeSpanRecordingDisabled: boolean;
+  }
+  var IAppRecordingStatusDetails: abstract new (...args: any[]) => IAppRecordingStatusDetails;
+
+}
+
+declare namespace Windows.Media.Audio {
+  class AudioDeviceInputNode implements Windows.Foundation.IClosable, Windows.Media.Audio.IAudioDeviceInputNode, Windows.Media.Audio.IAudioInputNode, Windows.Media.Audio.IAudioInputNode2, Windows.Media.Audio.IAudioNode {
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode, gain: number): void;
+    Close(): void;
+    DisableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    EnableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    RemoveOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    Reset(): void;
+    Start(): void;
+    Stop(): void;
+    ConsumeInput: boolean;
+    readonly Device: Windows.Devices.Enumeration.DeviceInformation;
+    readonly EffectDefinitions: Windows.Foundation.Collections.IVector<Windows.Media.Effects.IAudioEffectDefinition> | Windows.Media.Effects.IAudioEffectDefinition[];
+    readonly Emitter: Windows.Media.Audio.AudioNodeEmitter;
+    readonly EncodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties;
+    readonly OutgoingConnections: Windows.Foundation.Collections.IVectorView<Windows.Media.Audio.AudioGraphConnection> | Windows.Media.Audio.AudioGraphConnection[];
+    OutgoingGain: number;
+  }
+
+  class AudioDeviceOutputNode implements Windows.Foundation.IClosable, Windows.Media.Audio.IAudioDeviceOutputNode, Windows.Media.Audio.IAudioNode, Windows.Media.Audio.IAudioNodeWithListener {
+    Close(): void;
+    DisableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    EnableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    Reset(): void;
+    Start(): void;
+    Stop(): void;
+    ConsumeInput: boolean;
+    readonly Device: Windows.Devices.Enumeration.DeviceInformation;
+    readonly EffectDefinitions: Windows.Foundation.Collections.IVector<Windows.Media.Effects.IAudioEffectDefinition> | Windows.Media.Effects.IAudioEffectDefinition[];
+    readonly EncodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties;
+    Listener: Windows.Media.Audio.AudioNodeListener;
+    OutgoingGain: number;
+  }
+
+  class AudioEffectsPackConfiguration implements Windows.Media.Audio.IAudioEffectsPackConfiguration {
+    static GetForDeviceId(effectsPackId: string, deviceId: string): Windows.Media.Audio.AudioEffectsPackConfiguration;
+    static IsDeviceIdSupported(effectsPackId: string, deviceId: string): boolean;
+    readonly DeviceId: string;
+    readonly EffectsPackId: string;
+    readonly Status: number;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.AudioEffectsPackConfiguration, Object> | null;
+  }
+
+  class AudioFileInputNode implements Windows.Foundation.IClosable, Windows.Media.Audio.IAudioFileInputNode, Windows.Media.Audio.IAudioInputNode, Windows.Media.Audio.IAudioInputNode2, Windows.Media.Audio.IAudioNode {
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode, gain: number): void;
+    Close(): void;
+    DisableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    EnableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    RemoveOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    Reset(): void;
+    Seek(position: Windows.Foundation.TimeSpan): void;
+    Start(): void;
+    Stop(): void;
+    ConsumeInput: boolean;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly EffectDefinitions: Windows.Foundation.Collections.IVector<Windows.Media.Effects.IAudioEffectDefinition> | Windows.Media.Effects.IAudioEffectDefinition[];
+    readonly Emitter: Windows.Media.Audio.AudioNodeEmitter;
+    readonly EncodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties;
+    EndTime: Windows.Foundation.TimeSpan | null;
+    LoopCount: number | null;
+    readonly OutgoingConnections: Windows.Foundation.Collections.IVectorView<Windows.Media.Audio.AudioGraphConnection> | Windows.Media.Audio.AudioGraphConnection[];
+    OutgoingGain: number;
+    PlaybackSpeedFactor: number;
+    readonly Position: Windows.Foundation.TimeSpan;
+    readonly SourceFile: Windows.Storage.StorageFile;
+    StartTime: Windows.Foundation.TimeSpan | null;
+    FileCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.AudioFileInputNode, Object> | null;
+  }
+
+  class AudioFileOutputNode implements Windows.Foundation.IClosable, Windows.Media.Audio.IAudioFileOutputNode, Windows.Media.Audio.IAudioNode {
+    Close(): void;
+    DisableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    EnableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    FinalizeAsync(): Windows.Foundation.IAsyncOperation<number>;
+    Reset(): void;
+    Start(): void;
+    Stop(): void;
+    ConsumeInput: boolean;
+    readonly EffectDefinitions: Windows.Foundation.Collections.IVector<Windows.Media.Effects.IAudioEffectDefinition> | Windows.Media.Effects.IAudioEffectDefinition[];
+    readonly EncodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties;
+    readonly File: Windows.Storage.IStorageFile;
+    readonly FileEncodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile;
+    OutgoingGain: number;
+  }
+
+  class AudioFrameCompletedEventArgs implements Windows.Media.Audio.IAudioFrameCompletedEventArgs {
+    readonly Frame: Windows.Media.AudioFrame;
+  }
+
+  class AudioFrameInputNode implements Windows.Foundation.IClosable, Windows.Media.Audio.IAudioFrameInputNode, Windows.Media.Audio.IAudioInputNode, Windows.Media.Audio.IAudioInputNode2, Windows.Media.Audio.IAudioNode {
+    AddFrame(frame: Windows.Media.AudioFrame): void;
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode, gain: number): void;
+    Close(): void;
+    DisableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    DiscardQueuedFrames(): void;
+    EnableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    RemoveOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    Reset(): void;
+    Start(): void;
+    Stop(): void;
+    ConsumeInput: boolean;
+    readonly EffectDefinitions: Windows.Foundation.Collections.IVector<Windows.Media.Effects.IAudioEffectDefinition> | Windows.Media.Effects.IAudioEffectDefinition[];
+    readonly Emitter: Windows.Media.Audio.AudioNodeEmitter;
+    readonly EncodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties;
+    readonly OutgoingConnections: Windows.Foundation.Collections.IVectorView<Windows.Media.Audio.AudioGraphConnection> | Windows.Media.Audio.AudioGraphConnection[];
+    OutgoingGain: number;
+    PlaybackSpeedFactor: number;
+    readonly QueuedSampleCount: number | bigint;
+    AudioFrameCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.AudioFrameInputNode, Windows.Media.Audio.AudioFrameCompletedEventArgs> | null;
+    QuantumStarted: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.AudioFrameInputNode, Windows.Media.Audio.FrameInputNodeQuantumStartedEventArgs> | null;
+  }
+
+  class AudioFrameOutputNode implements Windows.Foundation.IClosable, Windows.Media.Audio.IAudioFrameOutputNode, Windows.Media.Audio.IAudioNode {
+    Close(): void;
+    DisableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    EnableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    GetFrame(): Windows.Media.AudioFrame;
+    Reset(): void;
+    Start(): void;
+    Stop(): void;
+    ConsumeInput: boolean;
+    readonly EffectDefinitions: Windows.Foundation.Collections.IVector<Windows.Media.Effects.IAudioEffectDefinition> | Windows.Media.Effects.IAudioEffectDefinition[];
+    readonly EncodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties;
+    OutgoingGain: number;
+  }
+
+  class AudioGraph implements Windows.Foundation.IClosable, Windows.Media.Audio.IAudioGraph, Windows.Media.Audio.IAudioGraph2, Windows.Media.Audio.IAudioGraph3 {
+    Close(): void;
+    static CreateAsync(settings: Windows.Media.Audio.AudioGraphSettings): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioGraphResult>;
+    CreateBatchUpdater(): Windows.Media.Audio.AudioGraphBatchUpdater;
+    CreateDeviceInputNodeAsync(category: number): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioDeviceInputNodeResult>;
+    CreateDeviceInputNodeAsync(category: number, encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioDeviceInputNodeResult>;
+    CreateDeviceInputNodeAsync(category: number, encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties, device: Windows.Devices.Enumeration.DeviceInformation): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioDeviceInputNodeResult>;
+    CreateDeviceInputNodeAsync(category: number, encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties, device: Windows.Devices.Enumeration.DeviceInformation, emitter: Windows.Media.Audio.AudioNodeEmitter): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioDeviceInputNodeResult>;
+    CreateDeviceOutputNodeAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioDeviceOutputNodeResult>;
+    CreateFileInputNodeAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioFileInputNodeResult>;
+    CreateFileInputNodeAsync(file: Windows.Storage.IStorageFile, emitter: Windows.Media.Audio.AudioNodeEmitter): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioFileInputNodeResult>;
+    CreateFileOutputNodeAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioFileOutputNodeResult>;
+    CreateFileOutputNodeAsync(file: Windows.Storage.IStorageFile, fileEncodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioFileOutputNodeResult>;
+    CreateFrameInputNode(): Windows.Media.Audio.AudioFrameInputNode;
+    CreateFrameInputNode(encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties): Windows.Media.Audio.AudioFrameInputNode;
+    CreateFrameInputNode(encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties, emitter: Windows.Media.Audio.AudioNodeEmitter): Windows.Media.Audio.AudioFrameInputNode;
+    CreateFrameOutputNode(): Windows.Media.Audio.AudioFrameOutputNode;
+    CreateFrameOutputNode(encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties): Windows.Media.Audio.AudioFrameOutputNode;
+    CreateMediaSourceAudioInputNodeAsync(mediaSource: Windows.Media.Core.MediaSource): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateMediaSourceAudioInputNodeResult>;
+    CreateMediaSourceAudioInputNodeAsync(mediaSource: Windows.Media.Core.MediaSource, emitter: Windows.Media.Audio.AudioNodeEmitter): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateMediaSourceAudioInputNodeResult>;
+    CreateSubmixNode(): Windows.Media.Audio.AudioSubmixNode;
+    CreateSubmixNode(encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties): Windows.Media.Audio.AudioSubmixNode;
+    CreateSubmixNode(encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties, emitter: Windows.Media.Audio.AudioNodeEmitter): Windows.Media.Audio.AudioSubmixNode;
+    ResetAllNodes(): void;
+    Start(): void;
+    Stop(): void;
+    readonly CompletedQuantumCount: number | bigint;
+    readonly EncodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties;
+    readonly LatencyInSamples: number;
+    readonly PrimaryRenderDevice: Windows.Devices.Enumeration.DeviceInformation;
+    readonly RenderDeviceAudioProcessing: number;
+    readonly SamplesPerQuantum: number;
+    QuantumProcessed: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.AudioGraph, Object> | null;
+    QuantumStarted: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.AudioGraph, Object> | null;
+    UnrecoverableErrorOccurred: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.AudioGraph, Windows.Media.Audio.AudioGraphUnrecoverableErrorOccurredEventArgs> | null;
+  }
+
+  class AudioGraphBatchUpdater implements Windows.Foundation.IClosable {
+    Close(): void;
+  }
+
+  class AudioGraphConnection implements Windows.Media.Audio.IAudioGraphConnection {
+    readonly Destination: Windows.Media.Audio.IAudioNode;
+    Gain: number;
+  }
+
+  class AudioGraphSettings implements Windows.Media.Audio.IAudioGraphSettings, Windows.Media.Audio.IAudioGraphSettings2 {
+    constructor(audioRenderCategory: number);
+    AudioRenderCategory: number;
+    DesiredRenderDeviceAudioProcessing: number;
+    DesiredSamplesPerQuantum: number;
+    EncodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties;
+    MaxPlaybackSpeedFactor: number;
+    PrimaryRenderDevice: Windows.Devices.Enumeration.DeviceInformation;
+    QuantumSizeSelectionMode: number;
+  }
+
+  class AudioGraphUnrecoverableErrorOccurredEventArgs implements Windows.Media.Audio.IAudioGraphUnrecoverableErrorOccurredEventArgs {
+    readonly Error: number;
+  }
+
+  class AudioNodeEmitter implements Windows.Media.Audio.IAudioNodeEmitter, Windows.Media.Audio.IAudioNodeEmitter2 {
+    constructor(shape: Windows.Media.Audio.AudioNodeEmitterShape, decayModel: Windows.Media.Audio.AudioNodeEmitterDecayModel, settings: number);
+    constructor();
+    readonly DecayModel: Windows.Media.Audio.AudioNodeEmitterDecayModel;
+    Direction: Windows.Foundation.Numerics.Vector3;
+    DistanceScale: number;
+    DopplerScale: number;
+    DopplerVelocity: Windows.Foundation.Numerics.Vector3;
+    Gain: number;
+    readonly IsDopplerDisabled: boolean;
+    Position: Windows.Foundation.Numerics.Vector3;
+    readonly Shape: Windows.Media.Audio.AudioNodeEmitterShape;
+    SpatialAudioModel: number;
+  }
+
+  class AudioNodeEmitterConeProperties implements Windows.Media.Audio.IAudioNodeEmitterConeProperties {
+    readonly InnerAngle: number;
+    readonly OuterAngle: number;
+    readonly OuterAngleGain: number;
+  }
+
+  class AudioNodeEmitterDecayModel implements Windows.Media.Audio.IAudioNodeEmitterDecayModel {
+    static CreateCustom(minGain: number, maxGain: number): Windows.Media.Audio.AudioNodeEmitterDecayModel;
+    static CreateNatural(minGain: number, maxGain: number, unityGainDistance: number, cutoffDistance: number): Windows.Media.Audio.AudioNodeEmitterDecayModel;
+    readonly Kind: number;
+    readonly MaxGain: number;
+    readonly MinGain: number;
+    readonly NaturalProperties: Windows.Media.Audio.AudioNodeEmitterNaturalDecayModelProperties;
+  }
+
+  class AudioNodeEmitterNaturalDecayModelProperties implements Windows.Media.Audio.IAudioNodeEmitterNaturalDecayModelProperties {
+    readonly CutoffDistance: number;
+    readonly UnityGainDistance: number;
+  }
+
+  class AudioNodeEmitterShape implements Windows.Media.Audio.IAudioNodeEmitterShape {
+    static CreateCone(innerAngle: number, outerAngle: number, outerAngleGain: number): Windows.Media.Audio.AudioNodeEmitterShape;
+    static CreateOmnidirectional(): Windows.Media.Audio.AudioNodeEmitterShape;
+    readonly ConeProperties: Windows.Media.Audio.AudioNodeEmitterConeProperties;
+    readonly Kind: number;
+  }
+
+  class AudioNodeListener implements Windows.Media.Audio.IAudioNodeListener {
+    constructor();
+    DopplerVelocity: Windows.Foundation.Numerics.Vector3;
+    Orientation: Windows.Foundation.Numerics.Quaternion;
+    Position: Windows.Foundation.Numerics.Vector3;
+    SpeedOfSound: number;
+  }
+
+  class AudioPlaybackConnection implements Windows.Foundation.IClosable, Windows.Media.Audio.IAudioPlaybackConnection {
+    Close(): void;
+    static GetDeviceSelector(): string;
+    Open(): Windows.Media.Audio.AudioPlaybackConnectionOpenResult;
+    OpenAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.AudioPlaybackConnectionOpenResult>;
+    Start(): void;
+    StartAsync(): Windows.Foundation.IAsyncAction;
+    static TryCreateFromId(id: string): Windows.Media.Audio.AudioPlaybackConnection;
+    readonly DeviceId: string;
+    readonly State: number;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.AudioPlaybackConnection, Object> | null;
+  }
+
+  class AudioPlaybackConnectionOpenResult implements Windows.Media.Audio.IAudioPlaybackConnectionOpenResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+
+  class AudioStateMonitor implements Windows.Media.Audio.IAudioStateMonitor {
+    static CreateForCaptureMonitoring(): Windows.Media.Audio.AudioStateMonitor;
+    static CreateForCaptureMonitoring(category: number): Windows.Media.Audio.AudioStateMonitor;
+    static CreateForCaptureMonitoring(category: number, role: number): Windows.Media.Audio.AudioStateMonitor;
+    static CreateForCaptureMonitoringWithCategoryAndDeviceId(category: number, deviceId: string): Windows.Media.Audio.AudioStateMonitor;
+    static CreateForRenderMonitoring(): Windows.Media.Audio.AudioStateMonitor;
+    static CreateForRenderMonitoring(category: number): Windows.Media.Audio.AudioStateMonitor;
+    static CreateForRenderMonitoring(category: number, role: number): Windows.Media.Audio.AudioStateMonitor;
+    static CreateForRenderMonitoringWithCategoryAndDeviceId(category: number, deviceId: string): Windows.Media.Audio.AudioStateMonitor;
+    readonly SoundLevel: number;
+    SoundLevelChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.AudioStateMonitor, Object> | null;
+  }
+
+  class AudioSubmixNode implements Windows.Foundation.IClosable, Windows.Media.Audio.IAudioInputNode, Windows.Media.Audio.IAudioInputNode2, Windows.Media.Audio.IAudioNode {
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode, gain: number): void;
+    Close(): void;
+    DisableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    EnableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    RemoveOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    Reset(): void;
+    Start(): void;
+    Stop(): void;
+    ConsumeInput: boolean;
+    readonly EffectDefinitions: Windows.Foundation.Collections.IVector<Windows.Media.Effects.IAudioEffectDefinition> | Windows.Media.Effects.IAudioEffectDefinition[];
+    readonly Emitter: Windows.Media.Audio.AudioNodeEmitter;
+    readonly EncodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties;
+    readonly OutgoingConnections: Windows.Foundation.Collections.IVectorView<Windows.Media.Audio.AudioGraphConnection> | Windows.Media.Audio.AudioGraphConnection[];
+    OutgoingGain: number;
+  }
+
+  class CreateAudioDeviceInputNodeResult implements Windows.Media.Audio.ICreateAudioDeviceInputNodeResult, Windows.Media.Audio.ICreateAudioDeviceInputNodeResult2 {
+    readonly DeviceInputNode: Windows.Media.Audio.AudioDeviceInputNode;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+
+  class CreateAudioDeviceOutputNodeResult implements Windows.Media.Audio.ICreateAudioDeviceOutputNodeResult, Windows.Media.Audio.ICreateAudioDeviceOutputNodeResult2 {
+    readonly DeviceOutputNode: Windows.Media.Audio.AudioDeviceOutputNode;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+
+  class CreateAudioFileInputNodeResult implements Windows.Media.Audio.ICreateAudioFileInputNodeResult, Windows.Media.Audio.ICreateAudioFileInputNodeResult2 {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly FileInputNode: Windows.Media.Audio.AudioFileInputNode;
+    readonly Status: number;
+  }
+
+  class CreateAudioFileOutputNodeResult implements Windows.Media.Audio.ICreateAudioFileOutputNodeResult, Windows.Media.Audio.ICreateAudioFileOutputNodeResult2 {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly FileOutputNode: Windows.Media.Audio.AudioFileOutputNode;
+    readonly Status: number;
+  }
+
+  class CreateAudioGraphResult implements Windows.Media.Audio.ICreateAudioGraphResult, Windows.Media.Audio.ICreateAudioGraphResult2 {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Graph: Windows.Media.Audio.AudioGraph;
+    readonly Status: number;
+  }
+
+  class CreateMediaSourceAudioInputNodeResult implements Windows.Media.Audio.ICreateMediaSourceAudioInputNodeResult, Windows.Media.Audio.ICreateMediaSourceAudioInputNodeResult2 {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Node: Windows.Media.Audio.MediaSourceAudioInputNode;
+    readonly Status: number;
+  }
+
+  class EchoEffectDefinition implements Windows.Media.Audio.IEchoEffectDefinition, Windows.Media.Effects.IAudioEffectDefinition {
+    constructor(audioGraph: Windows.Media.Audio.AudioGraph);
+    readonly ActivatableClassId: string;
+    Delay: number;
+    Feedback: number;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+    WetDryMix: number;
+  }
+
+  class EqualizerBand implements Windows.Media.Audio.IEqualizerBand {
+    Bandwidth: number;
+    FrequencyCenter: number;
+    Gain: number;
+  }
+
+  class EqualizerEffectDefinition implements Windows.Media.Audio.IEqualizerEffectDefinition, Windows.Media.Effects.IAudioEffectDefinition {
+    constructor(audioGraph: Windows.Media.Audio.AudioGraph);
+    readonly ActivatableClassId: string;
+    readonly Bands: Windows.Foundation.Collections.IVectorView<Windows.Media.Audio.EqualizerBand> | Windows.Media.Audio.EqualizerBand[];
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+  }
+
+  class FrameInputNodeQuantumStartedEventArgs implements Windows.Media.Audio.IFrameInputNodeQuantumStartedEventArgs {
+    readonly RequiredSamples: number;
+  }
+
+  class LimiterEffectDefinition implements Windows.Media.Audio.ILimiterEffectDefinition, Windows.Media.Effects.IAudioEffectDefinition {
+    constructor(audioGraph: Windows.Media.Audio.AudioGraph);
+    readonly ActivatableClassId: string;
+    Loudness: number;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+    Release: number;
+  }
+
+  class MediaSourceAudioInputNode implements Windows.Foundation.IClosable, Windows.Media.Audio.IAudioInputNode, Windows.Media.Audio.IAudioInputNode2, Windows.Media.Audio.IAudioNode, Windows.Media.Audio.IMediaSourceAudioInputNode {
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode, gain: number): void;
+    Close(): void;
+    DisableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    EnableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    RemoveOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    Reset(): void;
+    Seek(position: Windows.Foundation.TimeSpan): void;
+    Start(): void;
+    Stop(): void;
+    ConsumeInput: boolean;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly EffectDefinitions: Windows.Foundation.Collections.IVector<Windows.Media.Effects.IAudioEffectDefinition> | Windows.Media.Effects.IAudioEffectDefinition[];
+    readonly Emitter: Windows.Media.Audio.AudioNodeEmitter;
+    readonly EncodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties;
+    EndTime: Windows.Foundation.TimeSpan | null;
+    LoopCount: number | null;
+    readonly MediaSource: Windows.Media.Core.MediaSource;
+    readonly OutgoingConnections: Windows.Foundation.Collections.IVectorView<Windows.Media.Audio.AudioGraphConnection> | Windows.Media.Audio.AudioGraphConnection[];
+    OutgoingGain: number;
+    PlaybackSpeedFactor: number;
+    readonly Position: Windows.Foundation.TimeSpan;
+    StartTime: Windows.Foundation.TimeSpan | null;
+    MediaSourceCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.MediaSourceAudioInputNode, Object> | null;
+  }
+
+  class ReverbEffectDefinition implements Windows.Media.Audio.IReverbEffectDefinition, Windows.Media.Effects.IAudioEffectDefinition {
+    constructor(audioGraph: Windows.Media.Audio.AudioGraph);
+    readonly ActivatableClassId: string;
+    DecayTime: number;
+    Density: number;
+    DisableLateField: boolean;
+    EarlyDiffusion: number;
+    HighEQCutoff: number;
+    HighEQGain: number;
+    LateDiffusion: number;
+    LowEQCutoff: number;
+    LowEQGain: number;
+    PositionLeft: number;
+    PositionMatrixLeft: number;
+    PositionMatrixRight: number;
+    PositionRight: number;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+    RearDelay: number;
+    ReflectionsDelay: number;
+    ReflectionsGain: number;
+    ReverbDelay: number;
+    ReverbGain: number;
+    RoomFilterFreq: number;
+    RoomFilterHF: number;
+    RoomFilterMain: number;
+    RoomSize: number;
+    WetDryMix: number;
+  }
+
+  class SetDefaultSpatialAudioFormatResult implements Windows.Media.Audio.ISetDefaultSpatialAudioFormatResult {
+    readonly Status: number;
+  }
+
+  class SpatialAudioDeviceConfiguration implements Windows.Media.Audio.ISpatialAudioDeviceConfiguration {
+    static GetForDeviceId(deviceId: string): Windows.Media.Audio.SpatialAudioDeviceConfiguration;
+    IsSpatialAudioFormatSupported(subtype: string): boolean;
+    SetDefaultSpatialAudioFormatAsync(subtype: string): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.SetDefaultSpatialAudioFormatResult>;
+    readonly ActiveSpatialAudioFormat: string;
+    readonly DefaultSpatialAudioFormat: string;
+    readonly DeviceId: string;
+    readonly IsSpatialAudioSupported: boolean;
+    ConfigurationChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.SpatialAudioDeviceConfiguration, Object> | null;
+  }
+
+  class SpatialAudioFormatConfiguration implements Windows.Media.Audio.ISpatialAudioFormatConfiguration {
+    static GetDefault(): Windows.Media.Audio.SpatialAudioFormatConfiguration;
+    ReportConfigurationChangedAsync(subtype: string): Windows.Foundation.IAsyncAction;
+    ReportLicenseChangedAsync(subtype: string): Windows.Foundation.IAsyncAction;
+    MixedRealityExclusiveModePolicy: number;
+  }
+
+  class SpatialAudioFormatSubtype {
+    static readonly DTSHeadphoneX: string;
+    static readonly DTSXForHomeTheater: string;
+    static readonly DTSXUltra: string;
+    static readonly DolbyAtmosForHeadphones: string;
+    static readonly DolbyAtmosForHomeTheater: string;
+    static readonly DolbyAtmosForSpeakers: string;
+    static readonly WindowsSonic: string;
+  }
+
+  enum AudioDeviceNodeCreationStatus {
+    Success = 0,
+    DeviceNotAvailable = 1,
+    FormatNotSupported = 2,
+    UnknownFailure = 3,
+    AccessDenied = 4,
+  }
+
+  enum AudioEffectsPackStatus {
+    NotEnabled = 0,
+    Enabled = 1,
+    NotSupported = 2,
+  }
+
+  enum AudioFileNodeCreationStatus {
+    Success = 0,
+    FileNotFound = 1,
+    InvalidFileType = 2,
+    FormatNotSupported = 3,
+    UnknownFailure = 4,
+  }
+
+  enum AudioGraphCreationStatus {
+    Success = 0,
+    DeviceNotAvailable = 1,
+    FormatNotSupported = 2,
+    UnknownFailure = 3,
+  }
+
+  enum AudioGraphUnrecoverableError {
+    None = 0,
+    AudioDeviceLost = 1,
+    AudioSessionDisconnected = 2,
+    UnknownFailure = 3,
+  }
+
+  enum AudioNodeEmitterDecayKind {
+    Natural = 0,
+    Custom = 1,
+  }
+
+  enum AudioNodeEmitterSettings {
+    None = 0,
+    DisableDoppler = 1,
+  }
+
+  enum AudioNodeEmitterShapeKind {
+    Omnidirectional = 0,
+    Cone = 1,
+  }
+
+  enum AudioPlaybackConnectionOpenResultStatus {
+    Success = 0,
+    RequestTimedOut = 1,
+    DeniedBySystem = 2,
+    UnknownFailure = 3,
+  }
+
+  enum AudioPlaybackConnectionState {
+    Closed = 0,
+    Opened = 1,
+  }
+
+  enum MediaSourceAudioInputNodeCreationStatus {
+    Success = 0,
+    FormatNotSupported = 1,
+    NetworkError = 2,
+    UnknownFailure = 3,
+  }
+
+  enum MixedRealitySpatialAudioFormatPolicy {
+    UseMixedRealityDefaultSpatialAudioFormat = 0,
+    UseDeviceConfigurationDefaultSpatialAudioFormat = 1,
+  }
+
+  enum QuantumSizeSelectionMode {
+    SystemDefault = 0,
+    LowestLatency = 1,
+    ClosestToDesired = 2,
+  }
+
+  enum SetDefaultSpatialAudioFormatStatus {
+    Succeeded = 0,
+    AccessDenied = 1,
+    LicenseExpired = 2,
+    LicenseNotValidForAudioEndpoint = 3,
+    NotSupportedOnAudioEndpoint = 4,
+    UnknownError = 5,
+  }
+
+  enum SpatialAudioModel {
+    ObjectBased = 0,
+    FoldDown = 1,
+  }
+
+  interface IAudioDeviceInputNode extends Windows.Foundation.IClosable, Windows.Media.Audio.IAudioInputNode, Windows.Media.Audio.IAudioNode {
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode, gain: number): void;
+    Close(): void;
+    DisableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    EnableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    RemoveOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    Reset(): void;
+    Start(): void;
+    Stop(): void;
+    readonly Device: Windows.Devices.Enumeration.DeviceInformation;
+  }
+  var IAudioDeviceInputNode: abstract new (...args: any[]) => IAudioDeviceInputNode;
+
+  interface IAudioDeviceOutputNode extends Windows.Foundation.IClosable, Windows.Media.Audio.IAudioNode {
+    Close(): void;
+    DisableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    EnableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    Reset(): void;
+    Start(): void;
+    Stop(): void;
+    readonly Device: Windows.Devices.Enumeration.DeviceInformation;
+  }
+  var IAudioDeviceOutputNode: abstract new (...args: any[]) => IAudioDeviceOutputNode;
+
+  interface IAudioEffectsPackConfiguration {
+    readonly DeviceId: string;
+    readonly EffectsPackId: string;
+    readonly Status: number;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.AudioEffectsPackConfiguration, Object> | null;
+  }
+  var IAudioEffectsPackConfiguration: abstract new (...args: any[]) => IAudioEffectsPackConfiguration;
+
+  interface IAudioEffectsPackConfigurationStatics {
+    GetForDeviceId(effectsPackId: string, deviceId: string): Windows.Media.Audio.AudioEffectsPackConfiguration;
+    IsDeviceIdSupported(effectsPackId: string, deviceId: string): boolean;
+  }
+  var IAudioEffectsPackConfigurationStatics: abstract new (...args: any[]) => IAudioEffectsPackConfigurationStatics;
+
+  interface IAudioFileInputNode extends Windows.Foundation.IClosable, Windows.Media.Audio.IAudioInputNode, Windows.Media.Audio.IAudioNode {
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode, gain: number): void;
+    Close(): void;
+    DisableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    EnableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    RemoveOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    Reset(): void;
+    Seek(position: Windows.Foundation.TimeSpan): void;
+    Start(): void;
+    Stop(): void;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    EndTime: Windows.Foundation.TimeSpan | null;
+    LoopCount: number | null;
+    PlaybackSpeedFactor: number;
+    readonly Position: Windows.Foundation.TimeSpan;
+    readonly SourceFile: Windows.Storage.StorageFile;
+    StartTime: Windows.Foundation.TimeSpan | null;
+    FileCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.AudioFileInputNode, Object> | null;
+  }
+  var IAudioFileInputNode: abstract new (...args: any[]) => IAudioFileInputNode;
+
+  interface IAudioFileOutputNode extends Windows.Foundation.IClosable, Windows.Media.Audio.IAudioNode {
+    Close(): void;
+    DisableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    EnableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    FinalizeAsync(): Windows.Foundation.IAsyncOperation<number>;
+    Reset(): void;
+    Start(): void;
+    Stop(): void;
+    readonly File: Windows.Storage.IStorageFile;
+    readonly FileEncodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile;
+  }
+  var IAudioFileOutputNode: abstract new (...args: any[]) => IAudioFileOutputNode;
+
+  interface IAudioFrameCompletedEventArgs {
+    readonly Frame: Windows.Media.AudioFrame;
+  }
+  var IAudioFrameCompletedEventArgs: abstract new (...args: any[]) => IAudioFrameCompletedEventArgs;
+
+  interface IAudioFrameInputNode extends Windows.Foundation.IClosable, Windows.Media.Audio.IAudioInputNode, Windows.Media.Audio.IAudioNode {
+    AddFrame(frame: Windows.Media.AudioFrame): void;
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode, gain: number): void;
+    Close(): void;
+    DisableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    DiscardQueuedFrames(): void;
+    EnableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    RemoveOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    Reset(): void;
+    Start(): void;
+    Stop(): void;
+    PlaybackSpeedFactor: number;
+    readonly QueuedSampleCount: number | bigint;
+    AudioFrameCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.AudioFrameInputNode, Windows.Media.Audio.AudioFrameCompletedEventArgs> | null;
+    QuantumStarted: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.AudioFrameInputNode, Windows.Media.Audio.FrameInputNodeQuantumStartedEventArgs> | null;
+  }
+  var IAudioFrameInputNode: abstract new (...args: any[]) => IAudioFrameInputNode;
+
+  interface IAudioFrameOutputNode extends Windows.Foundation.IClosable, Windows.Media.Audio.IAudioNode {
+    Close(): void;
+    DisableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    EnableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    GetFrame(): Windows.Media.AudioFrame;
+    Reset(): void;
+    Start(): void;
+    Stop(): void;
+  }
+  var IAudioFrameOutputNode: abstract new (...args: any[]) => IAudioFrameOutputNode;
+
+  interface IAudioGraph extends Windows.Foundation.IClosable {
+    Close(): void;
+    CreateDeviceInputNodeAsync(category: number): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioDeviceInputNodeResult>;
+    CreateDeviceInputNodeAsync(category: number, encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioDeviceInputNodeResult>;
+    CreateDeviceInputNodeAsync(category: number, encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties, device: Windows.Devices.Enumeration.DeviceInformation): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioDeviceInputNodeResult>;
+    CreateDeviceOutputNodeAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioDeviceOutputNodeResult>;
+    CreateFileInputNodeAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioFileInputNodeResult>;
+    CreateFileOutputNodeAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioFileOutputNodeResult>;
+    CreateFileOutputNodeAsync(file: Windows.Storage.IStorageFile, fileEncodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioFileOutputNodeResult>;
+    CreateFrameInputNode(): Windows.Media.Audio.AudioFrameInputNode;
+    CreateFrameInputNode(encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties): Windows.Media.Audio.AudioFrameInputNode;
+    CreateFrameOutputNode(): Windows.Media.Audio.AudioFrameOutputNode;
+    CreateFrameOutputNode(encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties): Windows.Media.Audio.AudioFrameOutputNode;
+    CreateSubmixNode(): Windows.Media.Audio.AudioSubmixNode;
+    CreateSubmixNode(encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties): Windows.Media.Audio.AudioSubmixNode;
+    ResetAllNodes(): void;
+    Start(): void;
+    Stop(): void;
+    readonly CompletedQuantumCount: number | bigint;
+    readonly EncodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties;
+    readonly LatencyInSamples: number;
+    readonly PrimaryRenderDevice: Windows.Devices.Enumeration.DeviceInformation;
+    readonly RenderDeviceAudioProcessing: number;
+    readonly SamplesPerQuantum: number;
+    QuantumProcessed: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.AudioGraph, Object> | null;
+    QuantumStarted: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.AudioGraph, Object> | null;
+    UnrecoverableErrorOccurred: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.AudioGraph, Windows.Media.Audio.AudioGraphUnrecoverableErrorOccurredEventArgs> | null;
+  }
+  var IAudioGraph: abstract new (...args: any[]) => IAudioGraph;
+
+  interface IAudioGraph2 extends Windows.Foundation.IClosable, Windows.Media.Audio.IAudioGraph {
+    Close(): void;
+    CreateBatchUpdater(): Windows.Media.Audio.AudioGraphBatchUpdater;
+    CreateDeviceInputNodeAsync(category: number, encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties, device: Windows.Devices.Enumeration.DeviceInformation, emitter: Windows.Media.Audio.AudioNodeEmitter): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioDeviceInputNodeResult>;
+    CreateDeviceInputNodeAsync(category: number): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioDeviceInputNodeResult>;
+    CreateDeviceInputNodeAsync(category: number, encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioDeviceInputNodeResult>;
+    CreateDeviceInputNodeAsync(category: number, encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties, device: Windows.Devices.Enumeration.DeviceInformation): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioDeviceInputNodeResult>;
+    CreateDeviceOutputNodeAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioDeviceOutputNodeResult>;
+    CreateFileInputNodeAsync(file: Windows.Storage.IStorageFile, emitter: Windows.Media.Audio.AudioNodeEmitter): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioFileInputNodeResult>;
+    CreateFileInputNodeAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioFileInputNodeResult>;
+    CreateFileOutputNodeAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioFileOutputNodeResult>;
+    CreateFileOutputNodeAsync(file: Windows.Storage.IStorageFile, fileEncodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioFileOutputNodeResult>;
+    CreateFrameInputNode(encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties, emitter: Windows.Media.Audio.AudioNodeEmitter): Windows.Media.Audio.AudioFrameInputNode;
+    CreateFrameInputNode(): Windows.Media.Audio.AudioFrameInputNode;
+    CreateFrameInputNode(encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties): Windows.Media.Audio.AudioFrameInputNode;
+    CreateFrameOutputNode(): Windows.Media.Audio.AudioFrameOutputNode;
+    CreateFrameOutputNode(encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties): Windows.Media.Audio.AudioFrameOutputNode;
+    CreateSubmixNode(encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties, emitter: Windows.Media.Audio.AudioNodeEmitter): Windows.Media.Audio.AudioSubmixNode;
+    CreateSubmixNode(): Windows.Media.Audio.AudioSubmixNode;
+    CreateSubmixNode(encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties): Windows.Media.Audio.AudioSubmixNode;
+    ResetAllNodes(): void;
+    Start(): void;
+    Stop(): void;
+  }
+  var IAudioGraph2: abstract new (...args: any[]) => IAudioGraph2;
+
+  interface IAudioGraph3 {
+    CreateMediaSourceAudioInputNodeAsync(mediaSource: Windows.Media.Core.MediaSource): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateMediaSourceAudioInputNodeResult>;
+    CreateMediaSourceAudioInputNodeAsync(mediaSource: Windows.Media.Core.MediaSource, emitter: Windows.Media.Audio.AudioNodeEmitter): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateMediaSourceAudioInputNodeResult>;
+  }
+  var IAudioGraph3: abstract new (...args: any[]) => IAudioGraph3;
+
+  interface IAudioGraphConnection {
+    readonly Destination: Windows.Media.Audio.IAudioNode;
+    Gain: number;
+  }
+  var IAudioGraphConnection: abstract new (...args: any[]) => IAudioGraphConnection;
+
+  interface IAudioGraphSettings {
+    AudioRenderCategory: number;
+    DesiredRenderDeviceAudioProcessing: number;
+    DesiredSamplesPerQuantum: number;
+    EncodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties;
+    PrimaryRenderDevice: Windows.Devices.Enumeration.DeviceInformation;
+    QuantumSizeSelectionMode: number;
+  }
+  var IAudioGraphSettings: abstract new (...args: any[]) => IAudioGraphSettings;
+
+  interface IAudioGraphSettings2 {
+    MaxPlaybackSpeedFactor: number;
+  }
+  var IAudioGraphSettings2: abstract new (...args: any[]) => IAudioGraphSettings2;
+
+  interface IAudioGraphSettingsFactory {
+    Create(audioRenderCategory: number): Windows.Media.Audio.AudioGraphSettings;
+  }
+  var IAudioGraphSettingsFactory: abstract new (...args: any[]) => IAudioGraphSettingsFactory;
+
+  interface IAudioGraphStatics {
+    CreateAsync(settings: Windows.Media.Audio.AudioGraphSettings): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.CreateAudioGraphResult>;
+  }
+  var IAudioGraphStatics: abstract new (...args: any[]) => IAudioGraphStatics;
+
+  interface IAudioGraphUnrecoverableErrorOccurredEventArgs {
+    readonly Error: number;
+  }
+  var IAudioGraphUnrecoverableErrorOccurredEventArgs: abstract new (...args: any[]) => IAudioGraphUnrecoverableErrorOccurredEventArgs;
+
+  interface IAudioInputNode extends Windows.Foundation.IClosable, Windows.Media.Audio.IAudioNode {
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode, gain: number): void;
+    Close(): void;
+    DisableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    EnableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    RemoveOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    Reset(): void;
+    Start(): void;
+    Stop(): void;
+    readonly OutgoingConnections: Windows.Foundation.Collections.IVectorView<Windows.Media.Audio.AudioGraphConnection> | Windows.Media.Audio.AudioGraphConnection[];
+  }
+  var IAudioInputNode: abstract new (...args: any[]) => IAudioInputNode;
+
+  interface IAudioInputNode2 extends Windows.Foundation.IClosable, Windows.Media.Audio.IAudioInputNode, Windows.Media.Audio.IAudioNode {
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode, gain: number): void;
+    Close(): void;
+    DisableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    EnableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    RemoveOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    Reset(): void;
+    Start(): void;
+    Stop(): void;
+    readonly Emitter: Windows.Media.Audio.AudioNodeEmitter;
+  }
+  var IAudioInputNode2: abstract new (...args: any[]) => IAudioInputNode2;
+
+  interface IAudioNode extends Windows.Foundation.IClosable {
+    Close(): void;
+    DisableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    EnableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    Reset(): void;
+    Start(): void;
+    Stop(): void;
+    ConsumeInput: boolean;
+    readonly EffectDefinitions: Windows.Foundation.Collections.IVector<Windows.Media.Effects.IAudioEffectDefinition> | Windows.Media.Effects.IAudioEffectDefinition[];
+    readonly EncodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties;
+    OutgoingGain: number;
+  }
+  var IAudioNode: abstract new (...args: any[]) => IAudioNode;
+
+  interface IAudioNodeEmitter {
+    readonly DecayModel: Windows.Media.Audio.AudioNodeEmitterDecayModel;
+    Direction: Windows.Foundation.Numerics.Vector3;
+    DistanceScale: number;
+    DopplerScale: number;
+    DopplerVelocity: Windows.Foundation.Numerics.Vector3;
+    Gain: number;
+    readonly IsDopplerDisabled: boolean;
+    Position: Windows.Foundation.Numerics.Vector3;
+    readonly Shape: Windows.Media.Audio.AudioNodeEmitterShape;
+  }
+  var IAudioNodeEmitter: abstract new (...args: any[]) => IAudioNodeEmitter;
+
+  interface IAudioNodeEmitter2 {
+    SpatialAudioModel: number;
+  }
+  var IAudioNodeEmitter2: abstract new (...args: any[]) => IAudioNodeEmitter2;
+
+  interface IAudioNodeEmitterConeProperties {
+    readonly InnerAngle: number;
+    readonly OuterAngle: number;
+    readonly OuterAngleGain: number;
+  }
+  var IAudioNodeEmitterConeProperties: abstract new (...args: any[]) => IAudioNodeEmitterConeProperties;
+
+  interface IAudioNodeEmitterDecayModel {
+    readonly Kind: number;
+    readonly MaxGain: number;
+    readonly MinGain: number;
+    readonly NaturalProperties: Windows.Media.Audio.AudioNodeEmitterNaturalDecayModelProperties;
+  }
+  var IAudioNodeEmitterDecayModel: abstract new (...args: any[]) => IAudioNodeEmitterDecayModel;
+
+  interface IAudioNodeEmitterDecayModelStatics {
+    CreateCustom(minGain: number, maxGain: number): Windows.Media.Audio.AudioNodeEmitterDecayModel;
+    CreateNatural(minGain: number, maxGain: number, unityGainDistance: number, cutoffDistance: number): Windows.Media.Audio.AudioNodeEmitterDecayModel;
+  }
+  var IAudioNodeEmitterDecayModelStatics: abstract new (...args: any[]) => IAudioNodeEmitterDecayModelStatics;
+
+  interface IAudioNodeEmitterFactory {
+    CreateAudioNodeEmitter(shape: Windows.Media.Audio.AudioNodeEmitterShape, decayModel: Windows.Media.Audio.AudioNodeEmitterDecayModel, settings: number): Windows.Media.Audio.AudioNodeEmitter;
+  }
+  var IAudioNodeEmitterFactory: abstract new (...args: any[]) => IAudioNodeEmitterFactory;
+
+  interface IAudioNodeEmitterNaturalDecayModelProperties {
+    readonly CutoffDistance: number;
+    readonly UnityGainDistance: number;
+  }
+  var IAudioNodeEmitterNaturalDecayModelProperties: abstract new (...args: any[]) => IAudioNodeEmitterNaturalDecayModelProperties;
+
+  interface IAudioNodeEmitterShape {
+    readonly ConeProperties: Windows.Media.Audio.AudioNodeEmitterConeProperties;
+    readonly Kind: number;
+  }
+  var IAudioNodeEmitterShape: abstract new (...args: any[]) => IAudioNodeEmitterShape;
+
+  interface IAudioNodeEmitterShapeStatics {
+    CreateCone(innerAngle: number, outerAngle: number, outerAngleGain: number): Windows.Media.Audio.AudioNodeEmitterShape;
+    CreateOmnidirectional(): Windows.Media.Audio.AudioNodeEmitterShape;
+  }
+  var IAudioNodeEmitterShapeStatics: abstract new (...args: any[]) => IAudioNodeEmitterShapeStatics;
+
+  interface IAudioNodeListener {
+    DopplerVelocity: Windows.Foundation.Numerics.Vector3;
+    Orientation: Windows.Foundation.Numerics.Quaternion;
+    Position: Windows.Foundation.Numerics.Vector3;
+    SpeedOfSound: number;
+  }
+  var IAudioNodeListener: abstract new (...args: any[]) => IAudioNodeListener;
+
+  interface IAudioNodeWithListener extends Windows.Foundation.IClosable, Windows.Media.Audio.IAudioNode {
+    Close(): void;
+    DisableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    EnableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    Reset(): void;
+    Start(): void;
+    Stop(): void;
+    Listener: Windows.Media.Audio.AudioNodeListener;
+  }
+  var IAudioNodeWithListener: abstract new (...args: any[]) => IAudioNodeWithListener;
+
+  interface IAudioPlaybackConnection {
+    Open(): Windows.Media.Audio.AudioPlaybackConnectionOpenResult;
+    OpenAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.AudioPlaybackConnectionOpenResult>;
+    Start(): void;
+    StartAsync(): Windows.Foundation.IAsyncAction;
+    readonly DeviceId: string;
+    readonly State: number;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.AudioPlaybackConnection, Object> | null;
+  }
+  var IAudioPlaybackConnection: abstract new (...args: any[]) => IAudioPlaybackConnection;
+
+  interface IAudioPlaybackConnectionOpenResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+  var IAudioPlaybackConnectionOpenResult: abstract new (...args: any[]) => IAudioPlaybackConnectionOpenResult;
+
+  interface IAudioPlaybackConnectionStatics {
+    GetDeviceSelector(): string;
+    TryCreateFromId(id: string): Windows.Media.Audio.AudioPlaybackConnection;
+  }
+  var IAudioPlaybackConnectionStatics: abstract new (...args: any[]) => IAudioPlaybackConnectionStatics;
+
+  interface IAudioStateMonitor {
+    readonly SoundLevel: number;
+    SoundLevelChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.AudioStateMonitor, Object> | null;
+  }
+  var IAudioStateMonitor: abstract new (...args: any[]) => IAudioStateMonitor;
+
+  interface IAudioStateMonitorStatics {
+    CreateForCaptureMonitoring(): Windows.Media.Audio.AudioStateMonitor;
+    CreateForCaptureMonitoring(category: number): Windows.Media.Audio.AudioStateMonitor;
+    CreateForCaptureMonitoring(category: number, role: number): Windows.Media.Audio.AudioStateMonitor;
+    CreateForCaptureMonitoringWithCategoryAndDeviceId(category: number, deviceId: string): Windows.Media.Audio.AudioStateMonitor;
+    CreateForRenderMonitoring(): Windows.Media.Audio.AudioStateMonitor;
+    CreateForRenderMonitoring(category: number): Windows.Media.Audio.AudioStateMonitor;
+    CreateForRenderMonitoring(category: number, role: number): Windows.Media.Audio.AudioStateMonitor;
+    CreateForRenderMonitoringWithCategoryAndDeviceId(category: number, deviceId: string): Windows.Media.Audio.AudioStateMonitor;
+  }
+  var IAudioStateMonitorStatics: abstract new (...args: any[]) => IAudioStateMonitorStatics;
+
+  interface ICreateAudioDeviceInputNodeResult {
+    readonly DeviceInputNode: Windows.Media.Audio.AudioDeviceInputNode;
+    readonly Status: number;
+  }
+  var ICreateAudioDeviceInputNodeResult: abstract new (...args: any[]) => ICreateAudioDeviceInputNodeResult;
+
+  interface ICreateAudioDeviceInputNodeResult2 {
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+  var ICreateAudioDeviceInputNodeResult2: abstract new (...args: any[]) => ICreateAudioDeviceInputNodeResult2;
+
+  interface ICreateAudioDeviceOutputNodeResult {
+    readonly DeviceOutputNode: Windows.Media.Audio.AudioDeviceOutputNode;
+    readonly Status: number;
+  }
+  var ICreateAudioDeviceOutputNodeResult: abstract new (...args: any[]) => ICreateAudioDeviceOutputNodeResult;
+
+  interface ICreateAudioDeviceOutputNodeResult2 {
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+  var ICreateAudioDeviceOutputNodeResult2: abstract new (...args: any[]) => ICreateAudioDeviceOutputNodeResult2;
+
+  interface ICreateAudioFileInputNodeResult {
+    readonly FileInputNode: Windows.Media.Audio.AudioFileInputNode;
+    readonly Status: number;
+  }
+  var ICreateAudioFileInputNodeResult: abstract new (...args: any[]) => ICreateAudioFileInputNodeResult;
+
+  interface ICreateAudioFileInputNodeResult2 {
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+  var ICreateAudioFileInputNodeResult2: abstract new (...args: any[]) => ICreateAudioFileInputNodeResult2;
+
+  interface ICreateAudioFileOutputNodeResult {
+    readonly FileOutputNode: Windows.Media.Audio.AudioFileOutputNode;
+    readonly Status: number;
+  }
+  var ICreateAudioFileOutputNodeResult: abstract new (...args: any[]) => ICreateAudioFileOutputNodeResult;
+
+  interface ICreateAudioFileOutputNodeResult2 {
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+  var ICreateAudioFileOutputNodeResult2: abstract new (...args: any[]) => ICreateAudioFileOutputNodeResult2;
+
+  interface ICreateAudioGraphResult {
+    readonly Graph: Windows.Media.Audio.AudioGraph;
+    readonly Status: number;
+  }
+  var ICreateAudioGraphResult: abstract new (...args: any[]) => ICreateAudioGraphResult;
+
+  interface ICreateAudioGraphResult2 {
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+  var ICreateAudioGraphResult2: abstract new (...args: any[]) => ICreateAudioGraphResult2;
+
+  interface ICreateMediaSourceAudioInputNodeResult {
+    readonly Node: Windows.Media.Audio.MediaSourceAudioInputNode;
+    readonly Status: number;
+  }
+  var ICreateMediaSourceAudioInputNodeResult: abstract new (...args: any[]) => ICreateMediaSourceAudioInputNodeResult;
+
+  interface ICreateMediaSourceAudioInputNodeResult2 {
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+  var ICreateMediaSourceAudioInputNodeResult2: abstract new (...args: any[]) => ICreateMediaSourceAudioInputNodeResult2;
+
+  interface IEchoEffectDefinition extends Windows.Media.Effects.IAudioEffectDefinition {
+    Delay: number;
+    Feedback: number;
+    WetDryMix: number;
+  }
+  var IEchoEffectDefinition: abstract new (...args: any[]) => IEchoEffectDefinition;
+
+  interface IEchoEffectDefinitionFactory {
+    Create(audioGraph: Windows.Media.Audio.AudioGraph): Windows.Media.Audio.EchoEffectDefinition;
+  }
+  var IEchoEffectDefinitionFactory: abstract new (...args: any[]) => IEchoEffectDefinitionFactory;
+
+  interface IEqualizerBand {
+    Bandwidth: number;
+    FrequencyCenter: number;
+    Gain: number;
+  }
+  var IEqualizerBand: abstract new (...args: any[]) => IEqualizerBand;
+
+  interface IEqualizerEffectDefinition extends Windows.Media.Effects.IAudioEffectDefinition {
+    readonly Bands: Windows.Foundation.Collections.IVectorView<Windows.Media.Audio.EqualizerBand> | Windows.Media.Audio.EqualizerBand[];
+  }
+  var IEqualizerEffectDefinition: abstract new (...args: any[]) => IEqualizerEffectDefinition;
+
+  interface IEqualizerEffectDefinitionFactory {
+    Create(audioGraph: Windows.Media.Audio.AudioGraph): Windows.Media.Audio.EqualizerEffectDefinition;
+  }
+  var IEqualizerEffectDefinitionFactory: abstract new (...args: any[]) => IEqualizerEffectDefinitionFactory;
+
+  interface IFrameInputNodeQuantumStartedEventArgs {
+    readonly RequiredSamples: number;
+  }
+  var IFrameInputNodeQuantumStartedEventArgs: abstract new (...args: any[]) => IFrameInputNodeQuantumStartedEventArgs;
+
+  interface ILimiterEffectDefinition extends Windows.Media.Effects.IAudioEffectDefinition {
+    Loudness: number;
+    Release: number;
+  }
+  var ILimiterEffectDefinition: abstract new (...args: any[]) => ILimiterEffectDefinition;
+
+  interface ILimiterEffectDefinitionFactory {
+    Create(audioGraph: Windows.Media.Audio.AudioGraph): Windows.Media.Audio.LimiterEffectDefinition;
+  }
+  var ILimiterEffectDefinitionFactory: abstract new (...args: any[]) => ILimiterEffectDefinitionFactory;
+
+  interface IMediaSourceAudioInputNode extends Windows.Foundation.IClosable, Windows.Media.Audio.IAudioInputNode, Windows.Media.Audio.IAudioInputNode2, Windows.Media.Audio.IAudioNode {
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    AddOutgoingConnection(destination: Windows.Media.Audio.IAudioNode, gain: number): void;
+    Close(): void;
+    DisableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    EnableEffectsByDefinition(definition: Windows.Media.Effects.IAudioEffectDefinition): void;
+    RemoveOutgoingConnection(destination: Windows.Media.Audio.IAudioNode): void;
+    Reset(): void;
+    Seek(position: Windows.Foundation.TimeSpan): void;
+    Start(): void;
+    Stop(): void;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    EndTime: Windows.Foundation.TimeSpan | null;
+    LoopCount: number | null;
+    readonly MediaSource: Windows.Media.Core.MediaSource;
+    PlaybackSpeedFactor: number;
+    readonly Position: Windows.Foundation.TimeSpan;
+    StartTime: Windows.Foundation.TimeSpan | null;
+    MediaSourceCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.MediaSourceAudioInputNode, Object> | null;
+  }
+  var IMediaSourceAudioInputNode: abstract new (...args: any[]) => IMediaSourceAudioInputNode;
+
+  interface IReverbEffectDefinition extends Windows.Media.Effects.IAudioEffectDefinition {
+    DecayTime: number;
+    Density: number;
+    DisableLateField: boolean;
+    EarlyDiffusion: number;
+    HighEQCutoff: number;
+    HighEQGain: number;
+    LateDiffusion: number;
+    LowEQCutoff: number;
+    LowEQGain: number;
+    PositionLeft: number;
+    PositionMatrixLeft: number;
+    PositionMatrixRight: number;
+    PositionRight: number;
+    RearDelay: number;
+    ReflectionsDelay: number;
+    ReflectionsGain: number;
+    ReverbDelay: number;
+    ReverbGain: number;
+    RoomFilterFreq: number;
+    RoomFilterHF: number;
+    RoomFilterMain: number;
+    RoomSize: number;
+    WetDryMix: number;
+  }
+  var IReverbEffectDefinition: abstract new (...args: any[]) => IReverbEffectDefinition;
+
+  interface IReverbEffectDefinitionFactory {
+    Create(audioGraph: Windows.Media.Audio.AudioGraph): Windows.Media.Audio.ReverbEffectDefinition;
+  }
+  var IReverbEffectDefinitionFactory: abstract new (...args: any[]) => IReverbEffectDefinitionFactory;
+
+  interface ISetDefaultSpatialAudioFormatResult {
+    readonly Status: number;
+  }
+  var ISetDefaultSpatialAudioFormatResult: abstract new (...args: any[]) => ISetDefaultSpatialAudioFormatResult;
+
+  interface ISpatialAudioDeviceConfiguration {
+    IsSpatialAudioFormatSupported(subtype: string): boolean;
+    SetDefaultSpatialAudioFormatAsync(subtype: string): Windows.Foundation.IAsyncOperation<Windows.Media.Audio.SetDefaultSpatialAudioFormatResult>;
+    readonly ActiveSpatialAudioFormat: string;
+    readonly DefaultSpatialAudioFormat: string;
+    readonly DeviceId: string;
+    readonly IsSpatialAudioSupported: boolean;
+    ConfigurationChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Audio.SpatialAudioDeviceConfiguration, Object> | null;
+  }
+  var ISpatialAudioDeviceConfiguration: abstract new (...args: any[]) => ISpatialAudioDeviceConfiguration;
+
+  interface ISpatialAudioDeviceConfigurationStatics {
+    GetForDeviceId(deviceId: string): Windows.Media.Audio.SpatialAudioDeviceConfiguration;
+  }
+  var ISpatialAudioDeviceConfigurationStatics: abstract new (...args: any[]) => ISpatialAudioDeviceConfigurationStatics;
+
+  interface ISpatialAudioFormatConfiguration {
+    ReportConfigurationChangedAsync(subtype: string): Windows.Foundation.IAsyncAction;
+    ReportLicenseChangedAsync(subtype: string): Windows.Foundation.IAsyncAction;
+    MixedRealityExclusiveModePolicy: number;
+  }
+  var ISpatialAudioFormatConfiguration: abstract new (...args: any[]) => ISpatialAudioFormatConfiguration;
+
+  interface ISpatialAudioFormatConfigurationStatics {
+    GetDefault(): Windows.Media.Audio.SpatialAudioFormatConfiguration;
+  }
+  var ISpatialAudioFormatConfigurationStatics: abstract new (...args: any[]) => ISpatialAudioFormatConfigurationStatics;
+
+  interface ISpatialAudioFormatSubtypeStatics {
+    readonly DTSHeadphoneX: string;
+    readonly DTSXUltra: string;
+    readonly DolbyAtmosForHeadphones: string;
+    readonly DolbyAtmosForHomeTheater: string;
+    readonly DolbyAtmosForSpeakers: string;
+    readonly WindowsSonic: string;
+  }
+  var ISpatialAudioFormatSubtypeStatics: abstract new (...args: any[]) => ISpatialAudioFormatSubtypeStatics;
+
+  interface ISpatialAudioFormatSubtypeStatics2 {
+    readonly DTSXForHomeTheater: string;
+  }
+  var ISpatialAudioFormatSubtypeStatics2: abstract new (...args: any[]) => ISpatialAudioFormatSubtypeStatics2;
+
+}
+
+declare namespace Windows.Media.Capture {
+  class AdvancedCapturedPhoto implements Windows.Media.Capture.IAdvancedCapturedPhoto, Windows.Media.Capture.IAdvancedCapturedPhoto2 {
+    readonly Context: Object;
+    readonly Frame: Windows.Media.Capture.CapturedFrame;
+    readonly FrameBoundsRelativeToReferencePhoto: Windows.Foundation.Rect | null;
+    readonly Mode: number;
+  }
+
+  class AdvancedPhotoCapture implements Windows.Media.Capture.IAdvancedPhotoCapture {
+    CaptureAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.AdvancedCapturedPhoto>;
+    CaptureAsync(context: Object): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.AdvancedCapturedPhoto>;
+    FinishAsync(): Windows.Foundation.IAsyncAction;
+    AllPhotosCaptured: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AdvancedPhotoCapture, Object> | null;
+    OptionalReferencePhotoCaptured: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AdvancedPhotoCapture, Windows.Media.Capture.OptionalReferencePhotoCapturedEventArgs> | null;
+  }
+
+  class AppBroadcastBackgroundService implements Windows.Media.Capture.IAppBroadcastBackgroundService, Windows.Media.Capture.IAppBroadcastBackgroundService2 {
+    TerminateBroadcast(reason: number, providerSpecificReason: number): void;
+    readonly AppId: string;
+    BroadcastChannel: string;
+    BroadcastLanguage: string;
+    BroadcastTitle: string;
+    PlugInState: number;
+    SignInInfo: Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo;
+    StreamInfo: Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo;
+    readonly TitleId: string;
+    ViewerCount: number;
+    HeartbeatRequested: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastBackgroundService, Windows.Media.Capture.AppBroadcastHeartbeatRequestedEventArgs> | null;
+    BroadcastChannelChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastBackgroundService, Object> | null;
+    BroadcastLanguageChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastBackgroundService, Object> | null;
+    BroadcastTitleChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastBackgroundService, Object> | null;
+  }
+
+  class AppBroadcastBackgroundServiceSignInInfo implements Windows.Media.Capture.IAppBroadcastBackgroundServiceSignInInfo, Windows.Media.Capture.IAppBroadcastBackgroundServiceSignInInfo2 {
+    readonly AuthenticationResult: Windows.Security.Authentication.Web.WebAuthenticationResult;
+    OAuthCallbackUri: Windows.Foundation.Uri;
+    OAuthRequestUri: Windows.Foundation.Uri;
+    readonly SignInState: number;
+    UserName: string;
+    SignInStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo, Windows.Media.Capture.AppBroadcastSignInStateChangedEventArgs> | null;
+    UserNameChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo, Object> | null;
+  }
+
+  class AppBroadcastBackgroundServiceStreamInfo implements Windows.Media.Capture.IAppBroadcastBackgroundServiceStreamInfo, Windows.Media.Capture.IAppBroadcastBackgroundServiceStreamInfo2 {
+    ReportProblemWithStream(): void;
+    AudioCodec: string;
+    BandwidthTestBitrate: number | bigint;
+    readonly BroadcastStreamReader: Windows.Media.Capture.AppBroadcastStreamReader;
+    DesiredVideoEncodingBitrate: number | bigint;
+    readonly StreamState: number;
+    StreamStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo, Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs> | null;
+    VideoEncodingBitrateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo, Object> | null;
+    VideoEncodingResolutionChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo, Object> | null;
+  }
+
+  class AppBroadcastCameraCaptureStateChangedEventArgs implements Windows.Media.Capture.IAppBroadcastCameraCaptureStateChangedEventArgs {
+    readonly ErrorCode: number;
+    readonly State: number;
+  }
+
+  class AppBroadcastGlobalSettings implements Windows.Media.Capture.IAppBroadcastGlobalSettings {
+    CameraOverlayLocation: number;
+    CameraOverlaySize: number;
+    readonly HasHardwareEncoder: boolean;
+    IsAudioCaptureEnabled: boolean;
+    readonly IsBroadcastEnabled: boolean;
+    IsCameraCaptureEnabledByDefault: boolean;
+    IsCursorImageCaptureEnabled: boolean;
+    readonly IsDisabledByPolicy: boolean;
+    IsEchoCancellationEnabled: boolean;
+    readonly IsGpuConstrained: boolean;
+    IsMicrophoneCaptureEnabledByDefault: boolean;
+    MicrophoneGain: number;
+    SelectedCameraId: string;
+    SystemAudioGain: number;
+  }
+
+  class AppBroadcastHeartbeatRequestedEventArgs implements Windows.Media.Capture.IAppBroadcastHeartbeatRequestedEventArgs {
+    Handled: boolean;
+  }
+
+  class AppBroadcastManager {
+    static ApplyGlobalSettings(value: Windows.Media.Capture.AppBroadcastGlobalSettings): void;
+    static ApplyProviderSettings(value: Windows.Media.Capture.AppBroadcastProviderSettings): void;
+    static GetGlobalSettings(): Windows.Media.Capture.AppBroadcastGlobalSettings;
+    static GetProviderSettings(): Windows.Media.Capture.AppBroadcastProviderSettings;
+  }
+
+  class AppBroadcastMicrophoneCaptureStateChangedEventArgs implements Windows.Media.Capture.IAppBroadcastMicrophoneCaptureStateChangedEventArgs {
+    readonly ErrorCode: number;
+    readonly State: number;
+  }
+
+  class AppBroadcastPlugIn implements Windows.Media.Capture.IAppBroadcastPlugIn {
+    readonly AppId: string;
+    readonly DisplayName: string;
+    readonly Logo: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly ProviderSettings: Windows.Media.Capture.AppBroadcastProviderSettings;
+  }
+
+  class AppBroadcastPlugInManager implements Windows.Media.Capture.IAppBroadcastPlugInManager {
+    static GetDefault(): Windows.Media.Capture.AppBroadcastPlugInManager;
+    static GetForUser(user: Windows.System.User): Windows.Media.Capture.AppBroadcastPlugInManager;
+    DefaultPlugIn: Windows.Media.Capture.AppBroadcastPlugIn;
+    readonly IsBroadcastProviderAvailable: boolean;
+    readonly PlugInList: Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.AppBroadcastPlugIn> | Windows.Media.Capture.AppBroadcastPlugIn[];
+  }
+
+  class AppBroadcastPlugInStateChangedEventArgs implements Windows.Media.Capture.IAppBroadcastPlugInStateChangedEventArgs {
+    readonly PlugInState: number;
+  }
+
+  class AppBroadcastPreview implements Windows.Media.Capture.IAppBroadcastPreview {
+    StopPreview(): void;
+    readonly ErrorCode: number | null;
+    readonly PreviewState: number;
+    readonly PreviewStreamReader: Windows.Media.Capture.AppBroadcastPreviewStreamReader;
+    PreviewStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastPreview, Windows.Media.Capture.AppBroadcastPreviewStateChangedEventArgs> | null;
+  }
+
+  class AppBroadcastPreviewStateChangedEventArgs implements Windows.Media.Capture.IAppBroadcastPreviewStateChangedEventArgs {
+    readonly ErrorCode: number;
+    readonly PreviewState: number;
+  }
+
+  class AppBroadcastPreviewStreamReader implements Windows.Media.Capture.IAppBroadcastPreviewStreamReader {
+    TryGetNextVideoFrame(): Windows.Media.Capture.AppBroadcastPreviewStreamVideoFrame;
+    readonly VideoBitmapAlphaMode: number;
+    readonly VideoBitmapPixelFormat: number;
+    readonly VideoHeight: number;
+    readonly VideoStride: number;
+    readonly VideoWidth: number;
+    VideoFrameArrived: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastPreviewStreamReader, Object> | null;
+  }
+
+  class AppBroadcastPreviewStreamVideoFrame implements Windows.Media.Capture.IAppBroadcastPreviewStreamVideoFrame {
+    readonly VideoBuffer: Windows.Storage.Streams.IBuffer;
+    readonly VideoHeader: Windows.Media.Capture.AppBroadcastPreviewStreamVideoHeader;
+  }
+
+  class AppBroadcastPreviewStreamVideoHeader implements Windows.Media.Capture.IAppBroadcastPreviewStreamVideoHeader {
+    readonly AbsoluteTimestamp: Windows.Foundation.DateTime;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly FrameId: number | bigint;
+    readonly RelativeTimestamp: Windows.Foundation.TimeSpan;
+  }
+
+  class AppBroadcastProviderSettings implements Windows.Media.Capture.IAppBroadcastProviderSettings {
+    AudioEncodingBitrate: number;
+    CustomVideoEncodingBitrate: number;
+    CustomVideoEncodingHeight: number;
+    CustomVideoEncodingWidth: number;
+    DefaultBroadcastTitle: string;
+    VideoEncodingBitrateMode: number;
+    VideoEncodingResolutionMode: number;
+  }
+
+  class AppBroadcastServices implements Windows.Media.Capture.IAppBroadcastServices {
+    EnterBroadcastModeAsync(plugIn: Windows.Media.Capture.AppBroadcastPlugIn): Windows.Foundation.IAsyncOperation<number>;
+    ExitBroadcastMode(reason: number): void;
+    PauseBroadcast(): void;
+    ResumeBroadcast(): void;
+    StartBroadcast(): void;
+    StartPreview(desiredSize: Windows.Foundation.Size): Windows.Media.Capture.AppBroadcastPreview;
+    BroadcastLanguage: string;
+    BroadcastTitle: string;
+    readonly CanCapture: boolean;
+    CaptureTargetType: number;
+    readonly State: Windows.Media.Capture.AppBroadcastState;
+    readonly UserName: string;
+  }
+
+  class AppBroadcastSignInStateChangedEventArgs implements Windows.Media.Capture.IAppBroadcastSignInStateChangedEventArgs {
+    readonly Result: number;
+    readonly SignInState: number;
+  }
+
+  class AppBroadcastState implements Windows.Media.Capture.IAppBroadcastState {
+    RestartCameraCapture(): void;
+    RestartMicrophoneCapture(): void;
+    AuthenticationResult: Windows.Security.Authentication.Web.WebAuthenticationResult;
+    readonly CameraCaptureError: number;
+    readonly CameraCaptureState: number;
+    readonly EncodedVideoSize: Windows.Foundation.Size;
+    readonly IsCaptureTargetRunning: boolean;
+    readonly MicrophoneCaptureError: number;
+    readonly MicrophoneCaptureState: number;
+    readonly OAuthCallbackUri: Windows.Foundation.Uri;
+    readonly OAuthRequestUri: Windows.Foundation.Uri;
+    readonly PlugInState: number;
+    ShouldCaptureCamera: boolean;
+    ShouldCaptureMicrophone: boolean;
+    SignInState: number;
+    readonly StreamState: number;
+    readonly TerminationReason: number;
+    readonly TerminationReasonPlugInSpecific: number;
+    readonly ViewerCount: number;
+    CameraCaptureStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastState, Windows.Media.Capture.AppBroadcastCameraCaptureStateChangedEventArgs> | null;
+    CaptureTargetClosed: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastState, Object> | null;
+    MicrophoneCaptureStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastState, Windows.Media.Capture.AppBroadcastMicrophoneCaptureStateChangedEventArgs> | null;
+    PlugInStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastState, Windows.Media.Capture.AppBroadcastPlugInStateChangedEventArgs> | null;
+    StreamStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastState, Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs> | null;
+    ViewerCountChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastState, Windows.Media.Capture.AppBroadcastViewerCountChangedEventArgs> | null;
+  }
+
+  class AppBroadcastStreamAudioFrame implements Windows.Media.Capture.IAppBroadcastStreamAudioFrame {
+    readonly AudioBuffer: Windows.Storage.Streams.IBuffer;
+    readonly AudioHeader: Windows.Media.Capture.AppBroadcastStreamAudioHeader;
+  }
+
+  class AppBroadcastStreamAudioHeader implements Windows.Media.Capture.IAppBroadcastStreamAudioHeader {
+    readonly AbsoluteTimestamp: Windows.Foundation.DateTime;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly FrameId: number | bigint;
+    readonly HasDiscontinuity: boolean;
+    readonly RelativeTimestamp: Windows.Foundation.TimeSpan;
+  }
+
+  class AppBroadcastStreamReader implements Windows.Media.Capture.IAppBroadcastStreamReader {
+    TryGetNextAudioFrame(): Windows.Media.Capture.AppBroadcastStreamAudioFrame;
+    TryGetNextVideoFrame(): Windows.Media.Capture.AppBroadcastStreamVideoFrame;
+    readonly AudioAacSequence: Windows.Storage.Streams.IBuffer;
+    readonly AudioBitrate: number;
+    readonly AudioChannels: number;
+    readonly AudioSampleRate: number;
+    readonly VideoBitrate: number;
+    readonly VideoHeight: number;
+    readonly VideoWidth: number;
+    AudioFrameArrived: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastStreamReader, Object> | null;
+    VideoFrameArrived: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastStreamReader, Object> | null;
+  }
+
+  class AppBroadcastStreamStateChangedEventArgs implements Windows.Media.Capture.IAppBroadcastStreamStateChangedEventArgs {
+    readonly StreamState: number;
+  }
+
+  class AppBroadcastStreamVideoFrame implements Windows.Media.Capture.IAppBroadcastStreamVideoFrame {
+    readonly VideoBuffer: Windows.Storage.Streams.IBuffer;
+    readonly VideoHeader: Windows.Media.Capture.AppBroadcastStreamVideoHeader;
+  }
+
+  class AppBroadcastStreamVideoHeader implements Windows.Media.Capture.IAppBroadcastStreamVideoHeader {
+    readonly AbsoluteTimestamp: Windows.Foundation.DateTime;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly FrameId: number | bigint;
+    readonly HasDiscontinuity: boolean;
+    readonly IsKeyFrame: boolean;
+    readonly RelativeTimestamp: Windows.Foundation.TimeSpan;
+  }
+
+  class AppBroadcastTriggerDetails implements Windows.Media.Capture.IAppBroadcastTriggerDetails {
+    readonly BackgroundService: Windows.Media.Capture.AppBroadcastBackgroundService;
+  }
+
+  class AppBroadcastViewerCountChangedEventArgs implements Windows.Media.Capture.IAppBroadcastViewerCountChangedEventArgs {
+    readonly ViewerCount: number;
+  }
+
+  class AppCapture implements Windows.Media.Capture.IAppCapture {
+    static GetForCurrentView(): Windows.Media.Capture.AppCapture;
+    static SetAllowedAsync(allowed: boolean): Windows.Foundation.IAsyncAction;
+    readonly IsCapturingAudio: boolean;
+    readonly IsCapturingVideo: boolean;
+    CapturingChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppCapture, Object> | null;
+  }
+
+  class AppCaptureAlternateShortcutKeys implements Windows.Media.Capture.IAppCaptureAlternateShortcutKeys, Windows.Media.Capture.IAppCaptureAlternateShortcutKeys2, Windows.Media.Capture.IAppCaptureAlternateShortcutKeys3 {
+    SaveHistoricalVideoKey: number;
+    SaveHistoricalVideoKeyModifiers: number;
+    TakeScreenshotKey: number;
+    TakeScreenshotKeyModifiers: number;
+    ToggleBroadcastKey: number;
+    ToggleBroadcastKeyModifiers: number;
+    ToggleCameraCaptureKey: number;
+    ToggleCameraCaptureKeyModifiers: number;
+    ToggleGameBarKey: number;
+    ToggleGameBarKeyModifiers: number;
+    ToggleMicrophoneCaptureKey: number;
+    ToggleMicrophoneCaptureKeyModifiers: number;
+    ToggleRecordingIndicatorKey: number;
+    ToggleRecordingIndicatorKeyModifiers: number;
+    ToggleRecordingKey: number;
+    ToggleRecordingKeyModifiers: number;
+  }
+
+  class AppCaptureDurationGeneratedEventArgs implements Windows.Media.Capture.IAppCaptureDurationGeneratedEventArgs {
+    readonly Duration: Windows.Foundation.TimeSpan;
+  }
+
+  class AppCaptureFileGeneratedEventArgs implements Windows.Media.Capture.IAppCaptureFileGeneratedEventArgs {
+    readonly File: Windows.Storage.StorageFile;
+  }
+
+  class AppCaptureManager {
+    static ApplySettings(appCaptureSettings: Windows.Media.Capture.AppCaptureSettings): void;
+    static GetCurrentSettings(): Windows.Media.Capture.AppCaptureSettings;
+  }
+
+  class AppCaptureMetadataWriter implements Windows.Foundation.IClosable, Windows.Media.Capture.IAppCaptureMetadataWriter {
+    constructor();
+    AddDoubleEvent(name: string, value: number, priority: number): void;
+    AddInt32Event(name: string, value: number, priority: number): void;
+    AddStringEvent(name: string, value: string, priority: number): void;
+    Close(): void;
+    StartDoubleState(name: string, value: number, priority: number): void;
+    StartInt32State(name: string, value: number, priority: number): void;
+    StartStringState(name: string, value: string, priority: number): void;
+    StopAllStates(): void;
+    StopState(name: string): void;
+    readonly RemainingStorageBytesAvailable: number | bigint;
+    MetadataPurged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppCaptureMetadataWriter, Object> | null;
+  }
+
+  class AppCaptureMicrophoneCaptureStateChangedEventArgs implements Windows.Media.Capture.IAppCaptureMicrophoneCaptureStateChangedEventArgs {
+    readonly ErrorCode: number;
+    readonly State: number;
+  }
+
+  class AppCaptureRecordOperation implements Windows.Media.Capture.IAppCaptureRecordOperation {
+    StopRecording(): void;
+    readonly Duration: Windows.Foundation.TimeSpan | null;
+    readonly ErrorCode: number | null;
+    readonly File: Windows.Storage.StorageFile;
+    readonly IsFileTruncated: boolean | null;
+    readonly State: number;
+    DurationGenerated: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppCaptureRecordOperation, Windows.Media.Capture.AppCaptureDurationGeneratedEventArgs> | null;
+    FileGenerated: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppCaptureRecordOperation, Windows.Media.Capture.AppCaptureFileGeneratedEventArgs> | null;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppCaptureRecordOperation, Windows.Media.Capture.AppCaptureRecordingStateChangedEventArgs> | null;
+  }
+
+  class AppCaptureRecordingStateChangedEventArgs implements Windows.Media.Capture.IAppCaptureRecordingStateChangedEventArgs {
+    readonly ErrorCode: number;
+    readonly State: number;
+  }
+
+  class AppCaptureServices implements Windows.Media.Capture.IAppCaptureServices {
+    Record(): Windows.Media.Capture.AppCaptureRecordOperation;
+    RecordTimeSpan(startTime: Windows.Foundation.DateTime, duration: Windows.Foundation.TimeSpan): Windows.Media.Capture.AppCaptureRecordOperation;
+    readonly CanCapture: boolean;
+    readonly State: Windows.Media.Capture.AppCaptureState;
+  }
+
+  class AppCaptureSettings implements Windows.Media.Capture.IAppCaptureSettings, Windows.Media.Capture.IAppCaptureSettings2, Windows.Media.Capture.IAppCaptureSettings3, Windows.Media.Capture.IAppCaptureSettings4, Windows.Media.Capture.IAppCaptureSettings5 {
+    readonly AlternateShortcutKeys: Windows.Media.Capture.AppCaptureAlternateShortcutKeys;
+    AppCaptureDestinationFolder: Windows.Storage.StorageFolder;
+    AudioEncodingBitrate: number;
+    CustomVideoEncodingBitrate: number;
+    CustomVideoEncodingHeight: number;
+    CustomVideoEncodingWidth: number;
+    readonly HasHardwareEncoder: boolean;
+    HistoricalBufferLength: number;
+    HistoricalBufferLengthUnit: number;
+    IsAppCaptureEnabled: boolean;
+    IsAudioCaptureEnabled: boolean;
+    readonly IsCpuConstrained: boolean;
+    IsCursorImageCaptureEnabled: boolean;
+    readonly IsDisabledByPolicy: boolean;
+    IsEchoCancellationEnabled: boolean;
+    readonly IsGpuConstrained: boolean;
+    IsHistoricalCaptureEnabled: boolean;
+    IsHistoricalCaptureOnBatteryAllowed: boolean;
+    IsHistoricalCaptureOnWirelessDisplayAllowed: boolean;
+    readonly IsMemoryConstrained: boolean;
+    IsMicrophoneCaptureEnabled: boolean;
+    IsMicrophoneCaptureEnabledByDefault: boolean;
+    MaximumRecordLength: Windows.Foundation.TimeSpan;
+    MicrophoneGain: number;
+    ScreenshotDestinationFolder: Windows.Storage.StorageFolder;
+    SystemAudioGain: number;
+    VideoEncodingBitrateMode: number;
+    VideoEncodingFrameRateMode: number;
+    VideoEncodingResolutionMode: number;
+  }
+
+  class AppCaptureState implements Windows.Media.Capture.IAppCaptureState {
+    RestartMicrophoneCapture(): void;
+    readonly IsHistoricalCaptureEnabled: boolean;
+    readonly IsTargetRunning: boolean;
+    readonly MicrophoneCaptureError: number;
+    readonly MicrophoneCaptureState: number;
+    ShouldCaptureMicrophone: boolean;
+    CaptureTargetClosed: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppCaptureState, Object> | null;
+    MicrophoneCaptureStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppCaptureState, Windows.Media.Capture.AppCaptureMicrophoneCaptureStateChangedEventArgs> | null;
+  }
+
+  class CameraCaptureUI implements Windows.Media.Capture.ICameraCaptureUI {
+    constructor();
+    CaptureFileAsync(mode: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    readonly PhotoSettings: Windows.Media.Capture.CameraCaptureUIPhotoCaptureSettings;
+    readonly VideoSettings: Windows.Media.Capture.CameraCaptureUIVideoCaptureSettings;
+  }
+
+  class CameraCaptureUIPhotoCaptureSettings implements Windows.Media.Capture.ICameraCaptureUIPhotoCaptureSettings {
+    AllowCropping: boolean;
+    CroppedAspectRatio: Windows.Foundation.Size;
+    CroppedSizeInPixels: Windows.Foundation.Size;
+    Format: number;
+    MaxResolution: number;
+  }
+
+  class CameraCaptureUIVideoCaptureSettings implements Windows.Media.Capture.ICameraCaptureUIVideoCaptureSettings {
+    AllowTrimming: boolean;
+    Format: number;
+    MaxDurationInSeconds: number;
+    MaxResolution: number;
+  }
+
+  class CameraOptionsUI {
+    static Show(mediaCapture: Windows.Media.Capture.MediaCapture): void;
+  }
+
+  class CapturedFrame implements Windows.Foundation.IClosable, Windows.Media.Capture.ICapturedFrame, Windows.Media.Capture.ICapturedFrame2, Windows.Media.Capture.ICapturedFrameWithSoftwareBitmap, Windows.Storage.Streams.IContentTypeProvider, Windows.Storage.Streams.IInputStream, Windows.Storage.Streams.IOutputStream, Windows.Storage.Streams.IRandomAccessStream, Windows.Storage.Streams.IRandomAccessStreamWithContentType {
+    CloneStream(): Windows.Storage.Streams.IRandomAccessStream;
+    Close(): void;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    GetInputStreamAt(position: number | bigint): Windows.Storage.Streams.IInputStream;
+    GetOutputStreamAt(position: number | bigint): Windows.Storage.Streams.IOutputStream;
+    ReadAsync(buffer: Windows.Storage.Streams.IBuffer, count: number, options: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number>;
+    Seek(position: number | bigint): void;
+    WriteAsync(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    readonly BitmapProperties: Windows.Graphics.Imaging.BitmapPropertySet;
+    readonly CanRead: boolean;
+    readonly CanWrite: boolean;
+    readonly ContentType: string;
+    readonly ControlValues: Windows.Media.Capture.CapturedFrameControlValues;
+    readonly Height: number;
+    readonly Position: number | bigint;
+    Size: number | bigint;
+    readonly SoftwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap;
+    readonly Width: number;
+  }
+
+  class CapturedFrameControlValues implements Windows.Media.Capture.ICapturedFrameControlValues, Windows.Media.Capture.ICapturedFrameControlValues2 {
+    readonly Exposure: Windows.Foundation.TimeSpan | null;
+    readonly ExposureCompensation: number | null;
+    readonly FlashPowerPercent: number | null;
+    readonly Flashed: boolean | null;
+    readonly Focus: number | null;
+    readonly FocusState: number | null;
+    readonly IsoAnalogGain: number | null;
+    readonly IsoDigitalGain: number | null;
+    readonly IsoSpeed: number | null;
+    readonly SceneMode: number | null;
+    readonly SensorFrameRate: Windows.Media.MediaProperties.MediaRatio;
+    readonly WhiteBalance: number | null;
+    readonly WhiteBalanceGain: Windows.Media.Capture.WhiteBalanceGain | null;
+    readonly ZoomFactor: number | null;
+  }
+
+  class CapturedPhoto implements Windows.Media.Capture.ICapturedPhoto {
+    readonly Frame: Windows.Media.Capture.CapturedFrame;
+    readonly Thumbnail: Windows.Media.Capture.CapturedFrame;
+  }
+
+  class GameBarServices implements Windows.Media.Capture.IGameBarServices {
+    DisableCapture(): void;
+    EnableCapture(): void;
+    readonly AppBroadcastServices: Windows.Media.Capture.AppBroadcastServices;
+    readonly AppCaptureServices: Windows.Media.Capture.AppCaptureServices;
+    readonly SessionId: string;
+    readonly TargetCapturePolicy: number;
+    readonly TargetInfo: Windows.Media.Capture.GameBarServicesTargetInfo;
+    CommandReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.GameBarServices, Windows.Media.Capture.GameBarServicesCommandEventArgs> | null;
+  }
+
+  class GameBarServicesCommandEventArgs implements Windows.Media.Capture.IGameBarServicesCommandEventArgs {
+    readonly Command: number;
+    readonly Origin: number;
+  }
+
+  class GameBarServicesManager implements Windows.Media.Capture.IGameBarServicesManager {
+    static GetDefault(): Windows.Media.Capture.GameBarServicesManager;
+    GameBarServicesCreated: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.GameBarServicesManager, Windows.Media.Capture.GameBarServicesManagerGameBarServicesCreatedEventArgs> | null;
+  }
+
+  class GameBarServicesManagerGameBarServicesCreatedEventArgs implements Windows.Media.Capture.IGameBarServicesManagerGameBarServicesCreatedEventArgs {
+    readonly GameBarServices: Windows.Media.Capture.GameBarServices;
+  }
+
+  class GameBarServicesTargetInfo implements Windows.Media.Capture.IGameBarServicesTargetInfo {
+    readonly AppId: string;
+    readonly DisplayMode: number;
+    readonly DisplayName: string;
+    readonly TitleId: string;
+  }
+
+  class LowLagMediaRecording implements Windows.Media.Capture.ILowLagMediaRecording, Windows.Media.Capture.ILowLagMediaRecording2, Windows.Media.Capture.ILowLagMediaRecording3 {
+    FinishAsync(): Windows.Foundation.IAsyncAction;
+    PauseAsync(behavior: number): Windows.Foundation.IAsyncAction;
+    PauseWithResultAsync(behavior: number): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.MediaCapturePauseResult>;
+    ResumeAsync(): Windows.Foundation.IAsyncAction;
+    StartAsync(): Windows.Foundation.IAsyncAction;
+    StopAsync(): Windows.Foundation.IAsyncAction;
+    StopWithResultAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.MediaCaptureStopResult>;
+  }
+
+  class LowLagPhotoCapture implements Windows.Media.Capture.ILowLagPhotoCapture {
+    CaptureAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.CapturedPhoto>;
+    FinishAsync(): Windows.Foundation.IAsyncAction;
+  }
+
+  class LowLagPhotoSequenceCapture implements Windows.Media.Capture.ILowLagPhotoSequenceCapture {
+    FinishAsync(): Windows.Foundation.IAsyncAction;
+    StartAsync(): Windows.Foundation.IAsyncAction;
+    StopAsync(): Windows.Foundation.IAsyncAction;
+    PhotoCaptured: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.LowLagPhotoSequenceCapture, Windows.Media.Capture.PhotoCapturedEventArgs> | null;
+  }
+
+  class MediaCapture implements Windows.Foundation.IClosable, Windows.Media.Capture.IMediaCapture, Windows.Media.Capture.IMediaCapture2, Windows.Media.Capture.IMediaCapture3, Windows.Media.Capture.IMediaCapture4, Windows.Media.Capture.IMediaCapture5, Windows.Media.Capture.IMediaCapture6, Windows.Media.Capture.IMediaCapture7, Windows.Media.Capture.IMediaCaptureVideoPreview {
+    constructor();
+    AddAudioEffectAsync(definition: Windows.Media.Effects.IAudioEffectDefinition): Windows.Foundation.IAsyncOperation<Windows.Media.IMediaExtension>;
+    AddEffectAsync(mediaStreamType: number, effectActivationID: string, effectSettings: Windows.Foundation.Collections.IPropertySet): Windows.Foundation.IAsyncAction;
+    AddVideoEffectAsync(definition: Windows.Media.Effects.IVideoEffectDefinition, mediaStreamType: number): Windows.Foundation.IAsyncOperation<Windows.Media.IMediaExtension>;
+    CapturePhotoToStorageFileAsync(type: Windows.Media.MediaProperties.ImageEncodingProperties, file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncAction;
+    CapturePhotoToStreamAsync(type: Windows.Media.MediaProperties.ImageEncodingProperties, stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    ClearEffectsAsync(mediaStreamType: number): Windows.Foundation.IAsyncAction;
+    Close(): void;
+    CreateFrameReaderAsync(inputSource: Windows.Media.Capture.Frames.MediaFrameSource): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.Frames.MediaFrameReader>;
+    CreateFrameReaderAsync(inputSource: Windows.Media.Capture.Frames.MediaFrameSource, outputSubtype: string): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.Frames.MediaFrameReader>;
+    CreateFrameReaderAsync(inputSource: Windows.Media.Capture.Frames.MediaFrameSource, outputSubtype: string, outputSize: Windows.Graphics.Imaging.BitmapSize): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.Frames.MediaFrameReader>;
+    CreateMultiSourceFrameReaderAsync(inputSources: Windows.Foundation.Collections.IIterable<Windows.Media.Capture.Frames.MediaFrameSource> | Windows.Media.Capture.Frames.MediaFrameSource[]): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.Frames.MultiSourceMediaFrameReader>;
+    CreateRelativePanelWatcher(captureMode: number, displayRegion: Windows.UI.WindowManagement.DisplayRegion): Windows.Media.Capture.MediaCaptureRelativePanelWatcher;
+    static FindAllVideoProfiles(videoDeviceId: string): Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.MediaCaptureVideoProfile> | Windows.Media.Capture.MediaCaptureVideoProfile[];
+    static FindConcurrentProfiles(videoDeviceId: string): Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.MediaCaptureVideoProfile> | Windows.Media.Capture.MediaCaptureVideoProfile[];
+    static FindKnownVideoProfiles(videoDeviceId: string, name: number): Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.MediaCaptureVideoProfile> | Windows.Media.Capture.MediaCaptureVideoProfile[];
+    GetEncoderProperty(mediaStreamType: number, propertyId: Guid): Object;
+    GetPreviewFrameAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.VideoFrame>;
+    GetPreviewFrameAsync(destination: Windows.Media.VideoFrame): Windows.Foundation.IAsyncOperation<Windows.Media.VideoFrame>;
+    GetPreviewMirroring(): boolean;
+    GetPreviewRotation(): number;
+    GetRecordRotation(): number;
+    InitializeAsync(): Windows.Foundation.IAsyncAction;
+    InitializeAsync(mediaCaptureInitializationSettings: Windows.Media.Capture.MediaCaptureInitializationSettings): Windows.Foundation.IAsyncAction;
+    static IsVideoProfileSupported(videoDeviceId: string): boolean;
+    PauseRecordAsync(behavior: number): Windows.Foundation.IAsyncAction;
+    PauseRecordWithResultAsync(behavior: number): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.MediaCapturePauseResult>;
+    PrepareAdvancedPhotoCaptureAsync(encodingProperties: Windows.Media.MediaProperties.ImageEncodingProperties): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.AdvancedPhotoCapture>;
+    PrepareLowLagPhotoCaptureAsync(type: Windows.Media.MediaProperties.ImageEncodingProperties): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.LowLagPhotoCapture>;
+    PrepareLowLagPhotoSequenceCaptureAsync(type: Windows.Media.MediaProperties.ImageEncodingProperties): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.LowLagPhotoSequenceCapture>;
+    PrepareLowLagRecordToCustomSinkAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, customMediaSink: Windows.Media.IMediaExtension): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.LowLagMediaRecording>;
+    PrepareLowLagRecordToCustomSinkAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, customSinkActivationId: string, customSinkSettings: Windows.Foundation.Collections.IPropertySet): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.LowLagMediaRecording>;
+    PrepareLowLagRecordToStorageFileAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.LowLagMediaRecording>;
+    PrepareLowLagRecordToStreamAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.LowLagMediaRecording>;
+    PrepareVariablePhotoSequenceCaptureAsync(type: Windows.Media.MediaProperties.ImageEncodingProperties): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.Core.VariablePhotoSequenceCapture>;
+    RemoveEffectAsync(effect: Windows.Media.IMediaExtension): Windows.Foundation.IAsyncAction;
+    ResumeRecordAsync(): Windows.Foundation.IAsyncAction;
+    SetEncoderProperty(mediaStreamType: number, propertyId: Guid, propertyValue: Object): void;
+    SetEncodingPropertiesAsync(mediaStreamType: number, mediaEncodingProperties: Windows.Media.MediaProperties.IMediaEncodingProperties, encoderProperties: Windows.Media.MediaProperties.MediaPropertySet): Windows.Foundation.IAsyncAction;
+    SetPreviewMirroring(value: boolean): void;
+    SetPreviewRotation(value: number): void;
+    SetRecordRotation(value: number): void;
+    StartPreviewAsync(): Windows.Foundation.IAsyncAction;
+    StartPreviewToCustomSinkAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, customMediaSink: Windows.Media.IMediaExtension): Windows.Foundation.IAsyncAction;
+    StartPreviewToCustomSinkAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, customSinkActivationId: string, customSinkSettings: Windows.Foundation.Collections.IPropertySet): Windows.Foundation.IAsyncAction;
+    StartRecordToCustomSinkAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, customMediaSink: Windows.Media.IMediaExtension): Windows.Foundation.IAsyncAction;
+    StartRecordToCustomSinkAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, customSinkActivationId: string, customSinkSettings: Windows.Foundation.Collections.IPropertySet): Windows.Foundation.IAsyncAction;
+    StartRecordToStorageFileAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncAction;
+    StartRecordToStreamAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    StopPreviewAsync(): Windows.Foundation.IAsyncAction;
+    StopRecordAsync(): Windows.Foundation.IAsyncAction;
+    StopRecordWithResultAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.MediaCaptureStopResult>;
+    readonly AudioDeviceController: Windows.Media.Devices.AudioDeviceController;
+    readonly CameraStreamState: number;
+    readonly FrameSources: Windows.Foundation.Collections.IMapView<string, Windows.Media.Capture.Frames.MediaFrameSource>;
+    readonly MediaCaptureSettings: Windows.Media.Capture.MediaCaptureSettings;
+    readonly ThermalStatus: number;
+    readonly VideoDeviceController: Windows.Media.Devices.VideoDeviceController;
+    Failed: Windows.Media.Capture.MediaCaptureFailedEventHandler | null;
+    RecordLimitationExceeded: Windows.Media.Capture.RecordLimitationExceededEventHandler | null;
+    FocusChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.MediaCapture, Windows.Media.Capture.MediaCaptureFocusChangedEventArgs> | null;
+    PhotoConfirmationCaptured: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.MediaCapture, Windows.Media.Capture.PhotoConfirmationCapturedEventArgs> | null;
+    CameraStreamStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.MediaCapture, Object> | null;
+    ThermalStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.MediaCapture, Object> | null;
+    CaptureDeviceExclusiveControlStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.MediaCapture, Windows.Media.Capture.MediaCaptureDeviceExclusiveControlStatusChangedEventArgs> | null;
+  }
+
+  class MediaCaptureDeviceExclusiveControlStatusChangedEventArgs implements Windows.Media.Capture.IMediaCaptureDeviceExclusiveControlStatusChangedEventArgs {
+    readonly DeviceId: string;
+    readonly Status: number;
+  }
+
+  class MediaCaptureFailedEventArgs implements Windows.Media.Capture.IMediaCaptureFailedEventArgs {
+    readonly Code: number;
+    readonly Message: string;
+  }
+
+  class MediaCaptureFocusChangedEventArgs implements Windows.Media.Capture.IMediaCaptureFocusChangedEventArgs {
+    readonly FocusState: number;
+  }
+
+  class MediaCaptureInitializationSettings implements Windows.Media.Capture.IMediaCaptureInitializationSettings, Windows.Media.Capture.IMediaCaptureInitializationSettings2, Windows.Media.Capture.IMediaCaptureInitializationSettings3, Windows.Media.Capture.IMediaCaptureInitializationSettings4, Windows.Media.Capture.IMediaCaptureInitializationSettings5, Windows.Media.Capture.IMediaCaptureInitializationSettings6, Windows.Media.Capture.IMediaCaptureInitializationSettings7 {
+    constructor();
+    AlwaysPlaySystemShutterSound: boolean;
+    AudioDeviceId: string;
+    AudioProcessing: number;
+    AudioSource: Windows.Media.Core.IMediaSource;
+    DeviceUri: Windows.Foundation.Uri;
+    DeviceUriPasswordCredential: Windows.Security.Credentials.PasswordCredential;
+    MediaCategory: number;
+    MemoryPreference: number;
+    PhotoCaptureSource: number;
+    PhotoMediaDescription: Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription;
+    PreviewMediaDescription: Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription;
+    RecordMediaDescription: Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription;
+    SharingMode: number;
+    SourceGroup: Windows.Media.Capture.Frames.MediaFrameSourceGroup;
+    StreamingCaptureMode: number;
+    VideoDeviceId: string;
+    VideoProfile: Windows.Media.Capture.MediaCaptureVideoProfile;
+    VideoSource: Windows.Media.Core.IMediaSource;
+  }
+
+  class MediaCapturePauseResult implements Windows.Foundation.IClosable, Windows.Media.Capture.IMediaCapturePauseResult {
+    Close(): void;
+    readonly LastFrame: Windows.Media.VideoFrame;
+    readonly RecordDuration: Windows.Foundation.TimeSpan;
+  }
+
+  class MediaCaptureRelativePanelWatcher implements Windows.Foundation.IClosable, Windows.Media.Capture.IMediaCaptureRelativePanelWatcher {
+    Close(): void;
+    Start(): void;
+    Stop(): void;
+    readonly RelativePanel: number;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.MediaCaptureRelativePanelWatcher, Object> | null;
+  }
+
+  class MediaCaptureSettings implements Windows.Media.Capture.IMediaCaptureSettings, Windows.Media.Capture.IMediaCaptureSettings2, Windows.Media.Capture.IMediaCaptureSettings3 {
+    readonly AudioDeviceId: string;
+    readonly AudioProcessing: number;
+    readonly CameraSoundRequiredForRegion: boolean;
+    readonly ConcurrentRecordAndPhotoSequenceSupported: boolean;
+    readonly ConcurrentRecordAndPhotoSupported: boolean;
+    readonly Direct3D11Device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice;
+    readonly Horizontal35mmEquivalentFocalLength: number | null;
+    readonly MediaCategory: number;
+    readonly PhotoCaptureSource: number;
+    readonly PitchOffsetDegrees: number | null;
+    readonly StreamingCaptureMode: number;
+    readonly Vertical35mmEquivalentFocalLength: number | null;
+    readonly VideoDeviceCharacteristic: number;
+    readonly VideoDeviceId: string;
+  }
+
+  class MediaCaptureStopResult implements Windows.Foundation.IClosable, Windows.Media.Capture.IMediaCaptureStopResult {
+    Close(): void;
+    readonly LastFrame: Windows.Media.VideoFrame;
+    readonly RecordDuration: Windows.Foundation.TimeSpan;
+  }
+
+  class MediaCaptureVideoProfile implements Windows.Media.Capture.IMediaCaptureVideoProfile, Windows.Media.Capture.IMediaCaptureVideoProfile2 {
+    GetConcurrency(): Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.MediaCaptureVideoProfile> | Windows.Media.Capture.MediaCaptureVideoProfile[];
+    readonly FrameSourceInfos: Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.Frames.MediaFrameSourceInfo> | Windows.Media.Capture.Frames.MediaFrameSourceInfo[];
+    readonly Id: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+    readonly SupportedPhotoMediaDescription: Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription> | Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription[];
+    readonly SupportedPreviewMediaDescription: Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription> | Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription[];
+    readonly SupportedRecordMediaDescription: Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription> | Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription[];
+    readonly VideoDeviceId: string;
+  }
+
+  class MediaCaptureVideoProfileMediaDescription implements Windows.Media.Capture.IMediaCaptureVideoProfileMediaDescription, Windows.Media.Capture.IMediaCaptureVideoProfileMediaDescription2 {
+    readonly FrameRate: number;
+    readonly Height: number;
+    readonly IsHdrVideoSupported: boolean;
+    readonly IsVariablePhotoSequenceSupported: boolean;
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+    readonly Subtype: string;
+    readonly Width: number;
+  }
+
+  class OptionalReferencePhotoCapturedEventArgs implements Windows.Media.Capture.IOptionalReferencePhotoCapturedEventArgs {
+    readonly Context: Object;
+    readonly Frame: Windows.Media.Capture.CapturedFrame;
+  }
+
+  class PhotoCapturedEventArgs implements Windows.Media.Capture.IPhotoCapturedEventArgs {
+    readonly CaptureTimeOffset: Windows.Foundation.TimeSpan;
+    readonly Frame: Windows.Media.Capture.CapturedFrame;
+    readonly Thumbnail: Windows.Media.Capture.CapturedFrame;
+  }
+
+  class PhotoConfirmationCapturedEventArgs implements Windows.Media.Capture.IPhotoConfirmationCapturedEventArgs {
+    readonly CaptureTimeOffset: Windows.Foundation.TimeSpan;
+    readonly Frame: Windows.Media.Capture.CapturedFrame;
+  }
+
+  class VideoStreamConfiguration implements Windows.Media.Capture.IVideoStreamConfiguration {
+    readonly InputProperties: Windows.Media.MediaProperties.VideoEncodingProperties;
+    readonly OutputProperties: Windows.Media.MediaProperties.VideoEncodingProperties;
+  }
+
+  enum AppBroadcastCameraCaptureState {
+    Stopped = 0,
+    Started = 1,
+    Failed = 2,
+  }
+
+  enum AppBroadcastCameraOverlayLocation {
+    TopLeft = 0,
+    TopCenter = 1,
+    TopRight = 2,
+    MiddleLeft = 3,
+    MiddleCenter = 4,
+    MiddleRight = 5,
+    BottomLeft = 6,
+    BottomCenter = 7,
+    BottomRight = 8,
+  }
+
+  enum AppBroadcastCameraOverlaySize {
+    Small = 0,
+    Medium = 1,
+    Large = 2,
+  }
+
+  enum AppBroadcastCaptureTargetType {
+    AppView = 0,
+    EntireDisplay = 1,
+  }
+
+  enum AppBroadcastExitBroadcastModeReason {
+    NormalExit = 0,
+    UserCanceled = 1,
+    AuthorizationFail = 2,
+    ForegroundAppActivated = 3,
+  }
+
+  enum AppBroadcastMicrophoneCaptureState {
+    Stopped = 0,
+    Started = 1,
+    Failed = 2,
+  }
+
+  enum AppBroadcastPlugInState {
+    Unknown = 0,
+    Initialized = 1,
+    MicrosoftSignInRequired = 2,
+    OAuthSignInRequired = 3,
+    ProviderSignInRequired = 4,
+    InBandwidthTest = 5,
+    ReadyToBroadcast = 6,
+  }
+
+  enum AppBroadcastPreviewState {
+    Started = 0,
+    Stopped = 1,
+    Failed = 2,
+  }
+
+  enum AppBroadcastSignInResult {
+    Success = 0,
+    AuthenticationFailed = 1,
+    Unauthorized = 2,
+    ServiceUnavailable = 3,
+    Unknown = 4,
+  }
+
+  enum AppBroadcastSignInState {
+    NotSignedIn = 0,
+    MicrosoftSignInInProgress = 1,
+    MicrosoftSignInComplete = 2,
+    OAuthSignInInProgress = 3,
+    OAuthSignInComplete = 4,
+  }
+
+  enum AppBroadcastStreamState {
+    Initializing = 0,
+    StreamReady = 1,
+    Started = 2,
+    Paused = 3,
+    Terminated = 4,
+  }
+
+  enum AppBroadcastTerminationReason {
+    NormalTermination = 0,
+    LostConnectionToService = 1,
+    NoNetworkConnectivity = 2,
+    ServiceAbort = 3,
+    ServiceError = 4,
+    ServiceUnavailable = 5,
+    InternalError = 6,
+    UnsupportedFormat = 7,
+    BackgroundTaskTerminated = 8,
+    BackgroundTaskUnresponsive = 9,
+  }
+
+  enum AppBroadcastVideoEncodingBitrateMode {
+    Custom = 0,
+    Auto = 1,
+  }
+
+  enum AppBroadcastVideoEncodingResolutionMode {
+    Custom = 0,
+    Auto = 1,
+  }
+
+  enum AppCaptureHistoricalBufferLengthUnit {
+    Megabytes = 0,
+    Seconds = 1,
+  }
+
+  enum AppCaptureMetadataPriority {
+    Informational = 0,
+    Important = 1,
+  }
+
+  enum AppCaptureMicrophoneCaptureState {
+    Stopped = 0,
+    Started = 1,
+    Failed = 2,
+  }
+
+  enum AppCaptureRecordingState {
+    InProgress = 0,
+    Completed = 1,
+    Failed = 2,
+  }
+
+  enum AppCaptureVideoEncodingBitrateMode {
+    Custom = 0,
+    High = 1,
+    Standard = 2,
+  }
+
+  enum AppCaptureVideoEncodingFrameRateMode {
+    Standard = 0,
+    High = 1,
+  }
+
+  enum AppCaptureVideoEncodingResolutionMode {
+    Custom = 0,
+    High = 1,
+    Standard = 2,
+  }
+
+  enum CameraCaptureUIMaxPhotoResolution {
+    HighestAvailable = 0,
+    VerySmallQvga = 1,
+    SmallVga = 2,
+    MediumXga = 3,
+    Large3M = 4,
+    VeryLarge5M = 5,
+  }
+
+  enum CameraCaptureUIMaxVideoResolution {
+    HighestAvailable = 0,
+    LowDefinition = 1,
+    StandardDefinition = 2,
+    HighDefinition = 3,
+  }
+
+  enum CameraCaptureUIMode {
+    PhotoOrVideo = 0,
+    Photo = 1,
+    Video = 2,
+  }
+
+  enum CameraCaptureUIPhotoFormat {
+    Jpeg = 0,
+    Png = 1,
+    JpegXR = 2,
+  }
+
+  enum CameraCaptureUIVideoFormat {
+    Mp4 = 0,
+    Wmv = 1,
+  }
+
+  enum ForegroundActivationArgument {
+    SignInRequired = 0,
+    MoreSettings = 1,
+  }
+
+  enum GameBarCommand {
+    OpenGameBar = 0,
+    RecordHistoricalBuffer = 1,
+    ToggleStartStopRecord = 2,
+    StartRecord = 3,
+    StopRecord = 4,
+    TakeScreenshot = 5,
+    StartBroadcast = 6,
+    StopBroadcast = 7,
+    PauseBroadcast = 8,
+    ResumeBroadcast = 9,
+    ToggleStartStopBroadcast = 10,
+    ToggleMicrophoneCapture = 11,
+    ToggleCameraCapture = 12,
+    ToggleRecordingIndicator = 13,
+  }
+
+  enum GameBarCommandOrigin {
+    ShortcutKey = 0,
+    Cortana = 1,
+    AppCommand = 2,
+  }
+
+  enum GameBarServicesDisplayMode {
+    Windowed = 0,
+    FullScreenExclusive = 1,
+  }
+
+  enum GameBarTargetCapturePolicy {
+    EnabledBySystem = 0,
+    EnabledByUser = 1,
+    NotEnabled = 2,
+    ProhibitedBySystem = 3,
+    ProhibitedByPublisher = 4,
+  }
+
+  enum KnownVideoProfile {
+    VideoRecording = 0,
+    HighQualityPhoto = 1,
+    BalancedVideoAndPhoto = 2,
+    VideoConferencing = 3,
+    PhotoSequence = 4,
+    HighFrameRate = 5,
+    VariablePhotoSequence = 6,
+    HdrWithWcgVideo = 7,
+    HdrWithWcgPhoto = 8,
+    VideoHdr8 = 9,
+    CompressedCamera = 10,
+  }
+
+  enum MediaCaptureDeviceExclusiveControlReleaseMode {
+    OnDispose = 0,
+    OnAllStreamsStopped = 1,
+  }
+
+  enum MediaCaptureDeviceExclusiveControlStatus {
+    ExclusiveControlAvailable = 0,
+    SharedReadOnlyAvailable = 1,
+  }
+
+  enum MediaCaptureMemoryPreference {
+    Auto = 0,
+    Cpu = 1,
+  }
+
+  enum MediaCaptureSharingMode {
+    ExclusiveControl = 0,
+    SharedReadOnly = 1,
+  }
+
+  enum MediaCaptureThermalStatus {
+    Normal = 0,
+    Overheated = 1,
+  }
+
+  enum MediaCategory {
+    Other = 0,
+    Communications = 1,
+    Media = 2,
+    GameChat = 3,
+    Speech = 4,
+    FarFieldSpeech = 5,
+    UniformSpeech = 6,
+    VoiceTyping = 7,
+  }
+
+  enum MediaStreamType {
+    VideoPreview = 0,
+    VideoRecord = 1,
+    Audio = 2,
+    Photo = 3,
+    Metadata = 4,
+  }
+
+  enum PhotoCaptureSource {
+    Auto = 0,
+    VideoPreview = 1,
+    Photo = 2,
+  }
+
+  enum PowerlineFrequency {
+    Disabled = 0,
+    FiftyHertz = 1,
+    SixtyHertz = 2,
+    Auto = 3,
+  }
+
+  enum StreamingCaptureMode {
+    AudioAndVideo = 0,
+    Audio = 1,
+    Video = 2,
+  }
+
+  enum VideoDeviceCharacteristic {
+    AllStreamsIndependent = 0,
+    PreviewRecordStreamsIdentical = 1,
+    PreviewPhotoStreamsIdentical = 2,
+    RecordPhotoStreamsIdentical = 3,
+    AllStreamsIdentical = 4,
+  }
+
+  enum VideoRotation {
+    None = 0,
+    Clockwise90Degrees = 1,
+    Clockwise180Degrees = 2,
+    Clockwise270Degrees = 3,
+  }
+
+  interface AppBroadcastContract {
+  }
+  var AppBroadcastContract: {
+    new(fields: {  }): AppBroadcastContract;
+  };
+
+  interface AppCaptureContract {
+  }
+  var AppCaptureContract: {
+    new(fields: {  }): AppCaptureContract;
+  };
+
+  interface AppCaptureMetadataContract {
+  }
+  var AppCaptureMetadataContract: {
+    new(fields: {  }): AppCaptureMetadataContract;
+  };
+
+  interface CameraCaptureUIContract {
+  }
+  var CameraCaptureUIContract: {
+    new(fields: {  }): CameraCaptureUIContract;
+  };
+
+  interface GameBarContract {
+  }
+  var GameBarContract: {
+    new(fields: {  }): GameBarContract;
+  };
+
+  interface IAdvancedCapturedPhoto {
+    readonly Context: Object;
+    readonly Frame: Windows.Media.Capture.CapturedFrame;
+    readonly Mode: number;
+  }
+  var IAdvancedCapturedPhoto: abstract new (...args: any[]) => IAdvancedCapturedPhoto;
+
+  interface IAdvancedCapturedPhoto2 {
+    readonly FrameBoundsRelativeToReferencePhoto: Windows.Foundation.Rect | null;
+  }
+  var IAdvancedCapturedPhoto2: abstract new (...args: any[]) => IAdvancedCapturedPhoto2;
+
+  interface IAdvancedPhotoCapture {
+    CaptureAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.AdvancedCapturedPhoto>;
+    CaptureAsync(context: Object): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.AdvancedCapturedPhoto>;
+    FinishAsync(): Windows.Foundation.IAsyncAction;
+    AllPhotosCaptured: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AdvancedPhotoCapture, Object> | null;
+    OptionalReferencePhotoCaptured: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AdvancedPhotoCapture, Windows.Media.Capture.OptionalReferencePhotoCapturedEventArgs> | null;
+  }
+  var IAdvancedPhotoCapture: abstract new (...args: any[]) => IAdvancedPhotoCapture;
+
+  interface IAppBroadcastBackgroundService {
+    TerminateBroadcast(reason: number, providerSpecificReason: number): void;
+    readonly AppId: string;
+    readonly BroadcastTitle: string;
+    PlugInState: number;
+    SignInInfo: Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo;
+    StreamInfo: Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo;
+    readonly TitleId: string;
+    ViewerCount: number;
+    HeartbeatRequested: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastBackgroundService, Windows.Media.Capture.AppBroadcastHeartbeatRequestedEventArgs> | null;
+  }
+  var IAppBroadcastBackgroundService: abstract new (...args: any[]) => IAppBroadcastBackgroundService;
+
+  interface IAppBroadcastBackgroundService2 {
+    BroadcastChannel: string;
+    BroadcastLanguage: string;
+    BroadcastTitle: Object;
+    BroadcastChannelChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastBackgroundService, Object> | null;
+    BroadcastLanguageChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastBackgroundService, Object> | null;
+    BroadcastTitleChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastBackgroundService, Object> | null;
+  }
+  var IAppBroadcastBackgroundService2: abstract new (...args: any[]) => IAppBroadcastBackgroundService2;
+
+  interface IAppBroadcastBackgroundServiceSignInInfo {
+    readonly AuthenticationResult: Windows.Security.Authentication.Web.WebAuthenticationResult;
+    OAuthCallbackUri: Windows.Foundation.Uri;
+    OAuthRequestUri: Windows.Foundation.Uri;
+    readonly SignInState: number;
+    UserName: string;
+    SignInStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo, Windows.Media.Capture.AppBroadcastSignInStateChangedEventArgs> | null;
+  }
+  var IAppBroadcastBackgroundServiceSignInInfo: abstract new (...args: any[]) => IAppBroadcastBackgroundServiceSignInInfo;
+
+  interface IAppBroadcastBackgroundServiceSignInInfo2 {
+    UserNameChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastBackgroundServiceSignInInfo, Object> | null;
+  }
+  var IAppBroadcastBackgroundServiceSignInInfo2: abstract new (...args: any[]) => IAppBroadcastBackgroundServiceSignInInfo2;
+
+  interface IAppBroadcastBackgroundServiceStreamInfo {
+    AudioCodec: string;
+    BandwidthTestBitrate: number | bigint;
+    readonly BroadcastStreamReader: Windows.Media.Capture.AppBroadcastStreamReader;
+    DesiredVideoEncodingBitrate: number | bigint;
+    readonly StreamState: number;
+    StreamStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo, Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs> | null;
+    VideoEncodingBitrateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo, Object> | null;
+    VideoEncodingResolutionChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastBackgroundServiceStreamInfo, Object> | null;
+  }
+  var IAppBroadcastBackgroundServiceStreamInfo: abstract new (...args: any[]) => IAppBroadcastBackgroundServiceStreamInfo;
+
+  interface IAppBroadcastBackgroundServiceStreamInfo2 {
+    ReportProblemWithStream(): void;
+  }
+  var IAppBroadcastBackgroundServiceStreamInfo2: abstract new (...args: any[]) => IAppBroadcastBackgroundServiceStreamInfo2;
+
+  interface IAppBroadcastCameraCaptureStateChangedEventArgs {
+    readonly ErrorCode: number;
+    readonly State: number;
+  }
+  var IAppBroadcastCameraCaptureStateChangedEventArgs: abstract new (...args: any[]) => IAppBroadcastCameraCaptureStateChangedEventArgs;
+
+  interface IAppBroadcastGlobalSettings {
+    CameraOverlayLocation: number;
+    CameraOverlaySize: number;
+    readonly HasHardwareEncoder: boolean;
+    IsAudioCaptureEnabled: boolean;
+    readonly IsBroadcastEnabled: boolean;
+    IsCameraCaptureEnabledByDefault: boolean;
+    IsCursorImageCaptureEnabled: boolean;
+    readonly IsDisabledByPolicy: boolean;
+    IsEchoCancellationEnabled: boolean;
+    readonly IsGpuConstrained: boolean;
+    IsMicrophoneCaptureEnabledByDefault: boolean;
+    MicrophoneGain: number;
+    SelectedCameraId: string;
+    SystemAudioGain: number;
+  }
+  var IAppBroadcastGlobalSettings: abstract new (...args: any[]) => IAppBroadcastGlobalSettings;
+
+  interface IAppBroadcastHeartbeatRequestedEventArgs {
+    Handled: boolean;
+  }
+  var IAppBroadcastHeartbeatRequestedEventArgs: abstract new (...args: any[]) => IAppBroadcastHeartbeatRequestedEventArgs;
+
+  interface IAppBroadcastManagerStatics {
+    ApplyGlobalSettings(value: Windows.Media.Capture.AppBroadcastGlobalSettings): void;
+    ApplyProviderSettings(value: Windows.Media.Capture.AppBroadcastProviderSettings): void;
+    GetGlobalSettings(): Windows.Media.Capture.AppBroadcastGlobalSettings;
+    GetProviderSettings(): Windows.Media.Capture.AppBroadcastProviderSettings;
+  }
+  var IAppBroadcastManagerStatics: abstract new (...args: any[]) => IAppBroadcastManagerStatics;
+
+  interface IAppBroadcastMicrophoneCaptureStateChangedEventArgs {
+    readonly ErrorCode: number;
+    readonly State: number;
+  }
+  var IAppBroadcastMicrophoneCaptureStateChangedEventArgs: abstract new (...args: any[]) => IAppBroadcastMicrophoneCaptureStateChangedEventArgs;
+
+  interface IAppBroadcastPlugIn {
+    readonly AppId: string;
+    readonly DisplayName: string;
+    readonly Logo: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly ProviderSettings: Windows.Media.Capture.AppBroadcastProviderSettings;
+  }
+  var IAppBroadcastPlugIn: abstract new (...args: any[]) => IAppBroadcastPlugIn;
+
+  interface IAppBroadcastPlugInManager {
+    DefaultPlugIn: Windows.Media.Capture.AppBroadcastPlugIn;
+    readonly IsBroadcastProviderAvailable: boolean;
+    readonly PlugInList: Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.AppBroadcastPlugIn> | Windows.Media.Capture.AppBroadcastPlugIn[];
+  }
+  var IAppBroadcastPlugInManager: abstract new (...args: any[]) => IAppBroadcastPlugInManager;
+
+  interface IAppBroadcastPlugInManagerStatics {
+    GetDefault(): Windows.Media.Capture.AppBroadcastPlugInManager;
+    GetForUser(user: Windows.System.User): Windows.Media.Capture.AppBroadcastPlugInManager;
+  }
+  var IAppBroadcastPlugInManagerStatics: abstract new (...args: any[]) => IAppBroadcastPlugInManagerStatics;
+
+  interface IAppBroadcastPlugInStateChangedEventArgs {
+    readonly PlugInState: number;
+  }
+  var IAppBroadcastPlugInStateChangedEventArgs: abstract new (...args: any[]) => IAppBroadcastPlugInStateChangedEventArgs;
+
+  interface IAppBroadcastPreview {
+    StopPreview(): void;
+    readonly ErrorCode: number | null;
+    readonly PreviewState: number;
+    readonly PreviewStreamReader: Windows.Media.Capture.AppBroadcastPreviewStreamReader;
+    PreviewStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastPreview, Windows.Media.Capture.AppBroadcastPreviewStateChangedEventArgs> | null;
+  }
+  var IAppBroadcastPreview: abstract new (...args: any[]) => IAppBroadcastPreview;
+
+  interface IAppBroadcastPreviewStateChangedEventArgs {
+    readonly ErrorCode: number;
+    readonly PreviewState: number;
+  }
+  var IAppBroadcastPreviewStateChangedEventArgs: abstract new (...args: any[]) => IAppBroadcastPreviewStateChangedEventArgs;
+
+  interface IAppBroadcastPreviewStreamReader {
+    TryGetNextVideoFrame(): Windows.Media.Capture.AppBroadcastPreviewStreamVideoFrame;
+    readonly VideoBitmapAlphaMode: number;
+    readonly VideoBitmapPixelFormat: number;
+    readonly VideoHeight: number;
+    readonly VideoStride: number;
+    readonly VideoWidth: number;
+    VideoFrameArrived: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastPreviewStreamReader, Object> | null;
+  }
+  var IAppBroadcastPreviewStreamReader: abstract new (...args: any[]) => IAppBroadcastPreviewStreamReader;
+
+  interface IAppBroadcastPreviewStreamVideoFrame {
+    readonly VideoBuffer: Windows.Storage.Streams.IBuffer;
+    readonly VideoHeader: Windows.Media.Capture.AppBroadcastPreviewStreamVideoHeader;
+  }
+  var IAppBroadcastPreviewStreamVideoFrame: abstract new (...args: any[]) => IAppBroadcastPreviewStreamVideoFrame;
+
+  interface IAppBroadcastPreviewStreamVideoHeader {
+    readonly AbsoluteTimestamp: Windows.Foundation.DateTime;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly FrameId: number | bigint;
+    readonly RelativeTimestamp: Windows.Foundation.TimeSpan;
+  }
+  var IAppBroadcastPreviewStreamVideoHeader: abstract new (...args: any[]) => IAppBroadcastPreviewStreamVideoHeader;
+
+  interface IAppBroadcastProviderSettings {
+    AudioEncodingBitrate: number;
+    CustomVideoEncodingBitrate: number;
+    CustomVideoEncodingHeight: number;
+    CustomVideoEncodingWidth: number;
+    DefaultBroadcastTitle: string;
+    VideoEncodingBitrateMode: number;
+    VideoEncodingResolutionMode: number;
+  }
+  var IAppBroadcastProviderSettings: abstract new (...args: any[]) => IAppBroadcastProviderSettings;
+
+  interface IAppBroadcastServices {
+    EnterBroadcastModeAsync(plugIn: Windows.Media.Capture.AppBroadcastPlugIn): Windows.Foundation.IAsyncOperation<number>;
+    ExitBroadcastMode(reason: number): void;
+    PauseBroadcast(): void;
+    ResumeBroadcast(): void;
+    StartBroadcast(): void;
+    StartPreview(desiredSize: Windows.Foundation.Size): Windows.Media.Capture.AppBroadcastPreview;
+    BroadcastLanguage: string;
+    BroadcastTitle: string;
+    readonly CanCapture: boolean;
+    CaptureTargetType: number;
+    readonly State: Windows.Media.Capture.AppBroadcastState;
+    readonly UserName: string;
+  }
+  var IAppBroadcastServices: abstract new (...args: any[]) => IAppBroadcastServices;
+
+  interface IAppBroadcastSignInStateChangedEventArgs {
+    readonly Result: number;
+    readonly SignInState: number;
+  }
+  var IAppBroadcastSignInStateChangedEventArgs: abstract new (...args: any[]) => IAppBroadcastSignInStateChangedEventArgs;
+
+  interface IAppBroadcastState {
+    RestartCameraCapture(): void;
+    RestartMicrophoneCapture(): void;
+    AuthenticationResult: Windows.Security.Authentication.Web.WebAuthenticationResult;
+    readonly CameraCaptureError: number;
+    readonly CameraCaptureState: number;
+    readonly EncodedVideoSize: Windows.Foundation.Size;
+    readonly IsCaptureTargetRunning: boolean;
+    readonly MicrophoneCaptureError: number;
+    readonly MicrophoneCaptureState: number;
+    readonly OAuthCallbackUri: Windows.Foundation.Uri;
+    readonly OAuthRequestUri: Windows.Foundation.Uri;
+    readonly PlugInState: number;
+    ShouldCaptureCamera: boolean;
+    ShouldCaptureMicrophone: boolean;
+    SignInState: number;
+    readonly StreamState: number;
+    readonly TerminationReason: number;
+    readonly TerminationReasonPlugInSpecific: number;
+    readonly ViewerCount: number;
+    CameraCaptureStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastState, Windows.Media.Capture.AppBroadcastCameraCaptureStateChangedEventArgs> | null;
+    CaptureTargetClosed: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastState, Object> | null;
+    MicrophoneCaptureStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastState, Windows.Media.Capture.AppBroadcastMicrophoneCaptureStateChangedEventArgs> | null;
+    PlugInStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastState, Windows.Media.Capture.AppBroadcastPlugInStateChangedEventArgs> | null;
+    StreamStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastState, Windows.Media.Capture.AppBroadcastStreamStateChangedEventArgs> | null;
+    ViewerCountChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastState, Windows.Media.Capture.AppBroadcastViewerCountChangedEventArgs> | null;
+  }
+  var IAppBroadcastState: abstract new (...args: any[]) => IAppBroadcastState;
+
+  interface IAppBroadcastStreamAudioFrame {
+    readonly AudioBuffer: Windows.Storage.Streams.IBuffer;
+    readonly AudioHeader: Windows.Media.Capture.AppBroadcastStreamAudioHeader;
+  }
+  var IAppBroadcastStreamAudioFrame: abstract new (...args: any[]) => IAppBroadcastStreamAudioFrame;
+
+  interface IAppBroadcastStreamAudioHeader {
+    readonly AbsoluteTimestamp: Windows.Foundation.DateTime;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly FrameId: number | bigint;
+    readonly HasDiscontinuity: boolean;
+    readonly RelativeTimestamp: Windows.Foundation.TimeSpan;
+  }
+  var IAppBroadcastStreamAudioHeader: abstract new (...args: any[]) => IAppBroadcastStreamAudioHeader;
+
+  interface IAppBroadcastStreamReader {
+    TryGetNextAudioFrame(): Windows.Media.Capture.AppBroadcastStreamAudioFrame;
+    TryGetNextVideoFrame(): Windows.Media.Capture.AppBroadcastStreamVideoFrame;
+    readonly AudioAacSequence: Windows.Storage.Streams.IBuffer;
+    readonly AudioBitrate: number;
+    readonly AudioChannels: number;
+    readonly AudioSampleRate: number;
+    readonly VideoBitrate: number;
+    readonly VideoHeight: number;
+    readonly VideoWidth: number;
+    AudioFrameArrived: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastStreamReader, Object> | null;
+    VideoFrameArrived: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppBroadcastStreamReader, Object> | null;
+  }
+  var IAppBroadcastStreamReader: abstract new (...args: any[]) => IAppBroadcastStreamReader;
+
+  interface IAppBroadcastStreamStateChangedEventArgs {
+    readonly StreamState: number;
+  }
+  var IAppBroadcastStreamStateChangedEventArgs: abstract new (...args: any[]) => IAppBroadcastStreamStateChangedEventArgs;
+
+  interface IAppBroadcastStreamVideoFrame {
+    readonly VideoBuffer: Windows.Storage.Streams.IBuffer;
+    readonly VideoHeader: Windows.Media.Capture.AppBroadcastStreamVideoHeader;
+  }
+  var IAppBroadcastStreamVideoFrame: abstract new (...args: any[]) => IAppBroadcastStreamVideoFrame;
+
+  interface IAppBroadcastStreamVideoHeader {
+    readonly AbsoluteTimestamp: Windows.Foundation.DateTime;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly FrameId: number | bigint;
+    readonly HasDiscontinuity: boolean;
+    readonly IsKeyFrame: boolean;
+    readonly RelativeTimestamp: Windows.Foundation.TimeSpan;
+  }
+  var IAppBroadcastStreamVideoHeader: abstract new (...args: any[]) => IAppBroadcastStreamVideoHeader;
+
+  interface IAppBroadcastTriggerDetails {
+    readonly BackgroundService: Windows.Media.Capture.AppBroadcastBackgroundService;
+  }
+  var IAppBroadcastTriggerDetails: abstract new (...args: any[]) => IAppBroadcastTriggerDetails;
+
+  interface IAppBroadcastViewerCountChangedEventArgs {
+    readonly ViewerCount: number;
+  }
+  var IAppBroadcastViewerCountChangedEventArgs: abstract new (...args: any[]) => IAppBroadcastViewerCountChangedEventArgs;
+
+  interface IAppCapture {
+    readonly IsCapturingAudio: boolean;
+    readonly IsCapturingVideo: boolean;
+    CapturingChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppCapture, Object> | null;
+  }
+  var IAppCapture: abstract new (...args: any[]) => IAppCapture;
+
+  interface IAppCaptureAlternateShortcutKeys {
+    SaveHistoricalVideoKey: number;
+    SaveHistoricalVideoKeyModifiers: number;
+    TakeScreenshotKey: number;
+    TakeScreenshotKeyModifiers: number;
+    ToggleGameBarKey: number;
+    ToggleGameBarKeyModifiers: number;
+    ToggleRecordingIndicatorKey: number;
+    ToggleRecordingIndicatorKeyModifiers: number;
+    ToggleRecordingKey: number;
+    ToggleRecordingKeyModifiers: number;
+  }
+  var IAppCaptureAlternateShortcutKeys: abstract new (...args: any[]) => IAppCaptureAlternateShortcutKeys;
+
+  interface IAppCaptureAlternateShortcutKeys2 {
+    ToggleMicrophoneCaptureKey: number;
+    ToggleMicrophoneCaptureKeyModifiers: number;
+  }
+  var IAppCaptureAlternateShortcutKeys2: abstract new (...args: any[]) => IAppCaptureAlternateShortcutKeys2;
+
+  interface IAppCaptureAlternateShortcutKeys3 {
+    ToggleBroadcastKey: number;
+    ToggleBroadcastKeyModifiers: number;
+    ToggleCameraCaptureKey: number;
+    ToggleCameraCaptureKeyModifiers: number;
+  }
+  var IAppCaptureAlternateShortcutKeys3: abstract new (...args: any[]) => IAppCaptureAlternateShortcutKeys3;
+
+  interface IAppCaptureDurationGeneratedEventArgs {
+    readonly Duration: Windows.Foundation.TimeSpan;
+  }
+  var IAppCaptureDurationGeneratedEventArgs: abstract new (...args: any[]) => IAppCaptureDurationGeneratedEventArgs;
+
+  interface IAppCaptureFileGeneratedEventArgs {
+    readonly File: Windows.Storage.StorageFile;
+  }
+  var IAppCaptureFileGeneratedEventArgs: abstract new (...args: any[]) => IAppCaptureFileGeneratedEventArgs;
+
+  interface IAppCaptureManagerStatics {
+    ApplySettings(appCaptureSettings: Windows.Media.Capture.AppCaptureSettings): void;
+    GetCurrentSettings(): Windows.Media.Capture.AppCaptureSettings;
+  }
+  var IAppCaptureManagerStatics: abstract new (...args: any[]) => IAppCaptureManagerStatics;
+
+  interface IAppCaptureMetadataWriter {
+    AddDoubleEvent(name: string, value: number, priority: number): void;
+    AddInt32Event(name: string, value: number, priority: number): void;
+    AddStringEvent(name: string, value: string, priority: number): void;
+    StartDoubleState(name: string, value: number, priority: number): void;
+    StartInt32State(name: string, value: number, priority: number): void;
+    StartStringState(name: string, value: string, priority: number): void;
+    StopAllStates(): void;
+    StopState(name: string): void;
+    readonly RemainingStorageBytesAvailable: number | bigint;
+    MetadataPurged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppCaptureMetadataWriter, Object> | null;
+  }
+  var IAppCaptureMetadataWriter: abstract new (...args: any[]) => IAppCaptureMetadataWriter;
+
+  interface IAppCaptureMicrophoneCaptureStateChangedEventArgs {
+    readonly ErrorCode: number;
+    readonly State: number;
+  }
+  var IAppCaptureMicrophoneCaptureStateChangedEventArgs: abstract new (...args: any[]) => IAppCaptureMicrophoneCaptureStateChangedEventArgs;
+
+  interface IAppCaptureRecordOperation {
+    StopRecording(): void;
+    readonly Duration: Windows.Foundation.TimeSpan | null;
+    readonly ErrorCode: number | null;
+    readonly File: Windows.Storage.StorageFile;
+    readonly IsFileTruncated: boolean | null;
+    readonly State: number;
+    DurationGenerated: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppCaptureRecordOperation, Windows.Media.Capture.AppCaptureDurationGeneratedEventArgs> | null;
+    FileGenerated: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppCaptureRecordOperation, Windows.Media.Capture.AppCaptureFileGeneratedEventArgs> | null;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppCaptureRecordOperation, Windows.Media.Capture.AppCaptureRecordingStateChangedEventArgs> | null;
+  }
+  var IAppCaptureRecordOperation: abstract new (...args: any[]) => IAppCaptureRecordOperation;
+
+  interface IAppCaptureRecordingStateChangedEventArgs {
+    readonly ErrorCode: number;
+    readonly State: number;
+  }
+  var IAppCaptureRecordingStateChangedEventArgs: abstract new (...args: any[]) => IAppCaptureRecordingStateChangedEventArgs;
+
+  interface IAppCaptureServices {
+    Record(): Windows.Media.Capture.AppCaptureRecordOperation;
+    RecordTimeSpan(startTime: Windows.Foundation.DateTime, duration: Windows.Foundation.TimeSpan): Windows.Media.Capture.AppCaptureRecordOperation;
+    readonly CanCapture: boolean;
+    readonly State: Windows.Media.Capture.AppCaptureState;
+  }
+  var IAppCaptureServices: abstract new (...args: any[]) => IAppCaptureServices;
+
+  interface IAppCaptureSettings {
+    AppCaptureDestinationFolder: Windows.Storage.StorageFolder;
+    AudioEncodingBitrate: number;
+    CustomVideoEncodingBitrate: number;
+    CustomVideoEncodingHeight: number;
+    CustomVideoEncodingWidth: number;
+    readonly HasHardwareEncoder: boolean;
+    HistoricalBufferLength: number;
+    HistoricalBufferLengthUnit: number;
+    IsAppCaptureEnabled: boolean;
+    IsAudioCaptureEnabled: boolean;
+    readonly IsCpuConstrained: boolean;
+    readonly IsDisabledByPolicy: boolean;
+    IsHistoricalCaptureEnabled: boolean;
+    IsHistoricalCaptureOnBatteryAllowed: boolean;
+    IsHistoricalCaptureOnWirelessDisplayAllowed: boolean;
+    readonly IsMemoryConstrained: boolean;
+    MaximumRecordLength: Windows.Foundation.TimeSpan;
+    ScreenshotDestinationFolder: Windows.Storage.StorageFolder;
+    VideoEncodingBitrateMode: number;
+    VideoEncodingResolutionMode: number;
+  }
+  var IAppCaptureSettings: abstract new (...args: any[]) => IAppCaptureSettings;
+
+  interface IAppCaptureSettings2 {
+    readonly AlternateShortcutKeys: Windows.Media.Capture.AppCaptureAlternateShortcutKeys;
+    readonly IsGpuConstrained: boolean;
+  }
+  var IAppCaptureSettings2: abstract new (...args: any[]) => IAppCaptureSettings2;
+
+  interface IAppCaptureSettings3 {
+    IsMicrophoneCaptureEnabled: boolean;
+  }
+  var IAppCaptureSettings3: abstract new (...args: any[]) => IAppCaptureSettings3;
+
+  interface IAppCaptureSettings4 {
+    IsMicrophoneCaptureEnabledByDefault: boolean;
+    MicrophoneGain: number;
+    SystemAudioGain: number;
+    VideoEncodingFrameRateMode: number;
+  }
+  var IAppCaptureSettings4: abstract new (...args: any[]) => IAppCaptureSettings4;
+
+  interface IAppCaptureSettings5 {
+    IsCursorImageCaptureEnabled: boolean;
+    IsEchoCancellationEnabled: boolean;
+  }
+  var IAppCaptureSettings5: abstract new (...args: any[]) => IAppCaptureSettings5;
+
+  interface IAppCaptureState {
+    RestartMicrophoneCapture(): void;
+    readonly IsHistoricalCaptureEnabled: boolean;
+    readonly IsTargetRunning: boolean;
+    readonly MicrophoneCaptureError: number;
+    readonly MicrophoneCaptureState: number;
+    ShouldCaptureMicrophone: boolean;
+    CaptureTargetClosed: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppCaptureState, Object> | null;
+    MicrophoneCaptureStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.AppCaptureState, Windows.Media.Capture.AppCaptureMicrophoneCaptureStateChangedEventArgs> | null;
+  }
+  var IAppCaptureState: abstract new (...args: any[]) => IAppCaptureState;
+
+  interface IAppCaptureStatics {
+    GetForCurrentView(): Windows.Media.Capture.AppCapture;
+  }
+  var IAppCaptureStatics: abstract new (...args: any[]) => IAppCaptureStatics;
+
+  interface IAppCaptureStatics2 {
+    SetAllowedAsync(allowed: boolean): Windows.Foundation.IAsyncAction;
+  }
+  var IAppCaptureStatics2: abstract new (...args: any[]) => IAppCaptureStatics2;
+
+  interface ICameraCaptureUI {
+    CaptureFileAsync(mode: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    readonly PhotoSettings: Windows.Media.Capture.CameraCaptureUIPhotoCaptureSettings;
+    readonly VideoSettings: Windows.Media.Capture.CameraCaptureUIVideoCaptureSettings;
+  }
+  var ICameraCaptureUI: abstract new (...args: any[]) => ICameraCaptureUI;
+
+  interface ICameraCaptureUIPhotoCaptureSettings {
+    AllowCropping: boolean;
+    CroppedAspectRatio: Windows.Foundation.Size;
+    CroppedSizeInPixels: Windows.Foundation.Size;
+    Format: number;
+    MaxResolution: number;
+  }
+  var ICameraCaptureUIPhotoCaptureSettings: abstract new (...args: any[]) => ICameraCaptureUIPhotoCaptureSettings;
+
+  interface ICameraCaptureUIVideoCaptureSettings {
+    AllowTrimming: boolean;
+    Format: number;
+    MaxDurationInSeconds: number;
+    MaxResolution: number;
+  }
+  var ICameraCaptureUIVideoCaptureSettings: abstract new (...args: any[]) => ICameraCaptureUIVideoCaptureSettings;
+
+  interface ICameraOptionsUIStatics {
+    Show(mediaCapture: Windows.Media.Capture.MediaCapture): void;
+  }
+  var ICameraOptionsUIStatics: abstract new (...args: any[]) => ICameraOptionsUIStatics;
+
+  interface ICapturedFrame extends Windows.Foundation.IClosable, Windows.Storage.Streams.IContentTypeProvider, Windows.Storage.Streams.IInputStream, Windows.Storage.Streams.IOutputStream, Windows.Storage.Streams.IRandomAccessStream, Windows.Storage.Streams.IRandomAccessStreamWithContentType {
+    CloneStream(): Windows.Storage.Streams.IRandomAccessStream;
+    Close(): void;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    GetInputStreamAt(position: number | bigint): Windows.Storage.Streams.IInputStream;
+    GetOutputStreamAt(position: number | bigint): Windows.Storage.Streams.IOutputStream;
+    ReadAsync(buffer: Windows.Storage.Streams.IBuffer, count: number, options: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number>;
+    Seek(position: number | bigint): void;
+    WriteAsync(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    readonly Height: number;
+    readonly Width: number;
+  }
+  var ICapturedFrame: abstract new (...args: any[]) => ICapturedFrame;
+
+  interface ICapturedFrame2 {
+    readonly BitmapProperties: Windows.Graphics.Imaging.BitmapPropertySet;
+    readonly ControlValues: Windows.Media.Capture.CapturedFrameControlValues;
+  }
+  var ICapturedFrame2: abstract new (...args: any[]) => ICapturedFrame2;
+
+  interface ICapturedFrameControlValues {
+    readonly Exposure: Windows.Foundation.TimeSpan | null;
+    readonly ExposureCompensation: number | null;
+    readonly FlashPowerPercent: number | null;
+    readonly Flashed: boolean | null;
+    readonly Focus: number | null;
+    readonly IsoSpeed: number | null;
+    readonly SceneMode: number | null;
+    readonly WhiteBalance: number | null;
+    readonly ZoomFactor: number | null;
+  }
+  var ICapturedFrameControlValues: abstract new (...args: any[]) => ICapturedFrameControlValues;
+
+  interface ICapturedFrameControlValues2 {
+    readonly FocusState: number | null;
+    readonly IsoAnalogGain: number | null;
+    readonly IsoDigitalGain: number | null;
+    readonly SensorFrameRate: Windows.Media.MediaProperties.MediaRatio;
+    readonly WhiteBalanceGain: Windows.Media.Capture.WhiteBalanceGain | null;
+  }
+  var ICapturedFrameControlValues2: abstract new (...args: any[]) => ICapturedFrameControlValues2;
+
+  interface ICapturedFrameWithSoftwareBitmap {
+    readonly SoftwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap;
+  }
+  var ICapturedFrameWithSoftwareBitmap: abstract new (...args: any[]) => ICapturedFrameWithSoftwareBitmap;
+
+  interface ICapturedPhoto {
+    readonly Frame: Windows.Media.Capture.CapturedFrame;
+    readonly Thumbnail: Windows.Media.Capture.CapturedFrame;
+  }
+  var ICapturedPhoto: abstract new (...args: any[]) => ICapturedPhoto;
+
+  interface IGameBarServices {
+    DisableCapture(): void;
+    EnableCapture(): void;
+    readonly AppBroadcastServices: Windows.Media.Capture.AppBroadcastServices;
+    readonly AppCaptureServices: Windows.Media.Capture.AppCaptureServices;
+    readonly SessionId: string;
+    readonly TargetCapturePolicy: number;
+    readonly TargetInfo: Windows.Media.Capture.GameBarServicesTargetInfo;
+    CommandReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.GameBarServices, Windows.Media.Capture.GameBarServicesCommandEventArgs> | null;
+  }
+  var IGameBarServices: abstract new (...args: any[]) => IGameBarServices;
+
+  interface IGameBarServicesCommandEventArgs {
+    readonly Command: number;
+    readonly Origin: number;
+  }
+  var IGameBarServicesCommandEventArgs: abstract new (...args: any[]) => IGameBarServicesCommandEventArgs;
+
+  interface IGameBarServicesManager {
+    GameBarServicesCreated: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.GameBarServicesManager, Windows.Media.Capture.GameBarServicesManagerGameBarServicesCreatedEventArgs> | null;
+  }
+  var IGameBarServicesManager: abstract new (...args: any[]) => IGameBarServicesManager;
+
+  interface IGameBarServicesManagerGameBarServicesCreatedEventArgs {
+    readonly GameBarServices: Windows.Media.Capture.GameBarServices;
+  }
+  var IGameBarServicesManagerGameBarServicesCreatedEventArgs: abstract new (...args: any[]) => IGameBarServicesManagerGameBarServicesCreatedEventArgs;
+
+  interface IGameBarServicesManagerStatics {
+    GetDefault(): Windows.Media.Capture.GameBarServicesManager;
+  }
+  var IGameBarServicesManagerStatics: abstract new (...args: any[]) => IGameBarServicesManagerStatics;
+
+  interface IGameBarServicesTargetInfo {
+    readonly AppId: string;
+    readonly DisplayMode: number;
+    readonly DisplayName: string;
+    readonly TitleId: string;
+  }
+  var IGameBarServicesTargetInfo: abstract new (...args: any[]) => IGameBarServicesTargetInfo;
+
+  interface ILowLagMediaRecording {
+    FinishAsync(): Windows.Foundation.IAsyncAction;
+    StartAsync(): Windows.Foundation.IAsyncAction;
+    StopAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var ILowLagMediaRecording: abstract new (...args: any[]) => ILowLagMediaRecording;
+
+  interface ILowLagMediaRecording2 {
+    PauseAsync(behavior: number): Windows.Foundation.IAsyncAction;
+    ResumeAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var ILowLagMediaRecording2: abstract new (...args: any[]) => ILowLagMediaRecording2;
+
+  interface ILowLagMediaRecording3 {
+    PauseWithResultAsync(behavior: number): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.MediaCapturePauseResult>;
+    StopWithResultAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.MediaCaptureStopResult>;
+  }
+  var ILowLagMediaRecording3: abstract new (...args: any[]) => ILowLagMediaRecording3;
+
+  interface ILowLagPhotoCapture {
+    CaptureAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.CapturedPhoto>;
+    FinishAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var ILowLagPhotoCapture: abstract new (...args: any[]) => ILowLagPhotoCapture;
+
+  interface ILowLagPhotoSequenceCapture {
+    FinishAsync(): Windows.Foundation.IAsyncAction;
+    StartAsync(): Windows.Foundation.IAsyncAction;
+    StopAsync(): Windows.Foundation.IAsyncAction;
+    PhotoCaptured: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.LowLagPhotoSequenceCapture, Windows.Media.Capture.PhotoCapturedEventArgs> | null;
+  }
+  var ILowLagPhotoSequenceCapture: abstract new (...args: any[]) => ILowLagPhotoSequenceCapture;
+
+  interface IMediaCapture {
+    AddEffectAsync(mediaStreamType: number, effectActivationID: string, effectSettings: Windows.Foundation.Collections.IPropertySet): Windows.Foundation.IAsyncAction;
+    CapturePhotoToStorageFileAsync(type: Windows.Media.MediaProperties.ImageEncodingProperties, file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncAction;
+    CapturePhotoToStreamAsync(type: Windows.Media.MediaProperties.ImageEncodingProperties, stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    ClearEffectsAsync(mediaStreamType: number): Windows.Foundation.IAsyncAction;
+    GetEncoderProperty(mediaStreamType: number, propertyId: Guid): Object;
+    GetPreviewMirroring(): boolean;
+    GetPreviewRotation(): number;
+    GetRecordRotation(): number;
+    InitializeAsync(): Windows.Foundation.IAsyncAction;
+    InitializeAsync(mediaCaptureInitializationSettings: Windows.Media.Capture.MediaCaptureInitializationSettings): Windows.Foundation.IAsyncAction;
+    SetEncoderProperty(mediaStreamType: number, propertyId: Guid, propertyValue: Object): void;
+    SetPreviewMirroring(value: boolean): void;
+    SetPreviewRotation(value: number): void;
+    SetRecordRotation(value: number): void;
+    StartRecordToCustomSinkAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, customMediaSink: Windows.Media.IMediaExtension): Windows.Foundation.IAsyncAction;
+    StartRecordToCustomSinkAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, customSinkActivationId: string, customSinkSettings: Windows.Foundation.Collections.IPropertySet): Windows.Foundation.IAsyncAction;
+    StartRecordToStorageFileAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncAction;
+    StartRecordToStreamAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    StopRecordAsync(): Windows.Foundation.IAsyncAction;
+    readonly AudioDeviceController: Windows.Media.Devices.AudioDeviceController;
+    readonly MediaCaptureSettings: Windows.Media.Capture.MediaCaptureSettings;
+    readonly VideoDeviceController: Windows.Media.Devices.VideoDeviceController;
+    Failed: Windows.Media.Capture.MediaCaptureFailedEventHandler | null;
+    RecordLimitationExceeded: Windows.Media.Capture.RecordLimitationExceededEventHandler | null;
+  }
+  var IMediaCapture: abstract new (...args: any[]) => IMediaCapture;
+
+  interface IMediaCapture2 {
+    PrepareLowLagPhotoCaptureAsync(type: Windows.Media.MediaProperties.ImageEncodingProperties): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.LowLagPhotoCapture>;
+    PrepareLowLagPhotoSequenceCaptureAsync(type: Windows.Media.MediaProperties.ImageEncodingProperties): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.LowLagPhotoSequenceCapture>;
+    PrepareLowLagRecordToCustomSinkAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, customMediaSink: Windows.Media.IMediaExtension): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.LowLagMediaRecording>;
+    PrepareLowLagRecordToCustomSinkAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, customSinkActivationId: string, customSinkSettings: Windows.Foundation.Collections.IPropertySet): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.LowLagMediaRecording>;
+    PrepareLowLagRecordToStorageFileAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.LowLagMediaRecording>;
+    PrepareLowLagRecordToStreamAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.LowLagMediaRecording>;
+    SetEncodingPropertiesAsync(mediaStreamType: number, mediaEncodingProperties: Windows.Media.MediaProperties.IMediaEncodingProperties, encoderProperties: Windows.Media.MediaProperties.MediaPropertySet): Windows.Foundation.IAsyncAction;
+  }
+  var IMediaCapture2: abstract new (...args: any[]) => IMediaCapture2;
+
+  interface IMediaCapture3 {
+    PrepareVariablePhotoSequenceCaptureAsync(type: Windows.Media.MediaProperties.ImageEncodingProperties): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.Core.VariablePhotoSequenceCapture>;
+    FocusChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.MediaCapture, Windows.Media.Capture.MediaCaptureFocusChangedEventArgs> | null;
+    PhotoConfirmationCaptured: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.MediaCapture, Windows.Media.Capture.PhotoConfirmationCapturedEventArgs> | null;
+  }
+  var IMediaCapture3: abstract new (...args: any[]) => IMediaCapture3;
+
+  interface IMediaCapture4 {
+    AddAudioEffectAsync(definition: Windows.Media.Effects.IAudioEffectDefinition): Windows.Foundation.IAsyncOperation<Windows.Media.IMediaExtension>;
+    AddVideoEffectAsync(definition: Windows.Media.Effects.IVideoEffectDefinition, mediaStreamType: number): Windows.Foundation.IAsyncOperation<Windows.Media.IMediaExtension>;
+    GetPreviewFrameAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.VideoFrame>;
+    GetPreviewFrameAsync(destination: Windows.Media.VideoFrame): Windows.Foundation.IAsyncOperation<Windows.Media.VideoFrame>;
+    PauseRecordAsync(behavior: number): Windows.Foundation.IAsyncAction;
+    PrepareAdvancedPhotoCaptureAsync(encodingProperties: Windows.Media.MediaProperties.ImageEncodingProperties): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.AdvancedPhotoCapture>;
+    ResumeRecordAsync(): Windows.Foundation.IAsyncAction;
+    readonly CameraStreamState: number;
+    readonly ThermalStatus: number;
+    CameraStreamStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.MediaCapture, Object> | null;
+    ThermalStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.MediaCapture, Object> | null;
+  }
+  var IMediaCapture4: abstract new (...args: any[]) => IMediaCapture4;
+
+  interface IMediaCapture5 {
+    CreateFrameReaderAsync(inputSource: Windows.Media.Capture.Frames.MediaFrameSource): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.Frames.MediaFrameReader>;
+    CreateFrameReaderAsync(inputSource: Windows.Media.Capture.Frames.MediaFrameSource, outputSubtype: string): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.Frames.MediaFrameReader>;
+    CreateFrameReaderAsync(inputSource: Windows.Media.Capture.Frames.MediaFrameSource, outputSubtype: string, outputSize: Windows.Graphics.Imaging.BitmapSize): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.Frames.MediaFrameReader>;
+    PauseRecordWithResultAsync(behavior: number): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.MediaCapturePauseResult>;
+    RemoveEffectAsync(effect: Windows.Media.IMediaExtension): Windows.Foundation.IAsyncAction;
+    StopRecordWithResultAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.MediaCaptureStopResult>;
+    readonly FrameSources: Windows.Foundation.Collections.IMapView<string, Windows.Media.Capture.Frames.MediaFrameSource>;
+  }
+  var IMediaCapture5: abstract new (...args: any[]) => IMediaCapture5;
+
+  interface IMediaCapture6 {
+    CreateMultiSourceFrameReaderAsync(inputSources: Windows.Foundation.Collections.IIterable<Windows.Media.Capture.Frames.MediaFrameSource> | Windows.Media.Capture.Frames.MediaFrameSource[]): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.Frames.MultiSourceMediaFrameReader>;
+    CaptureDeviceExclusiveControlStatusChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.MediaCapture, Windows.Media.Capture.MediaCaptureDeviceExclusiveControlStatusChangedEventArgs> | null;
+  }
+  var IMediaCapture6: abstract new (...args: any[]) => IMediaCapture6;
+
+  interface IMediaCapture7 {
+    CreateRelativePanelWatcher(captureMode: number, displayRegion: Windows.UI.WindowManagement.DisplayRegion): Windows.Media.Capture.MediaCaptureRelativePanelWatcher;
+  }
+  var IMediaCapture7: abstract new (...args: any[]) => IMediaCapture7;
+
+  interface IMediaCaptureDeviceExclusiveControlStatusChangedEventArgs {
+    readonly DeviceId: string;
+    readonly Status: number;
+  }
+  var IMediaCaptureDeviceExclusiveControlStatusChangedEventArgs: abstract new (...args: any[]) => IMediaCaptureDeviceExclusiveControlStatusChangedEventArgs;
+
+  interface IMediaCaptureFailedEventArgs {
+    readonly Code: number;
+    readonly Message: string;
+  }
+  var IMediaCaptureFailedEventArgs: abstract new (...args: any[]) => IMediaCaptureFailedEventArgs;
+
+  interface IMediaCaptureFocusChangedEventArgs {
+    readonly FocusState: number;
+  }
+  var IMediaCaptureFocusChangedEventArgs: abstract new (...args: any[]) => IMediaCaptureFocusChangedEventArgs;
+
+  interface IMediaCaptureInitializationSettings {
+    AudioDeviceId: string;
+    PhotoCaptureSource: number;
+    StreamingCaptureMode: number;
+    VideoDeviceId: string;
+  }
+  var IMediaCaptureInitializationSettings: abstract new (...args: any[]) => IMediaCaptureInitializationSettings;
+
+  interface IMediaCaptureInitializationSettings2 {
+    AudioProcessing: number;
+    MediaCategory: number;
+  }
+  var IMediaCaptureInitializationSettings2: abstract new (...args: any[]) => IMediaCaptureInitializationSettings2;
+
+  interface IMediaCaptureInitializationSettings3 {
+    AudioSource: Windows.Media.Core.IMediaSource;
+    VideoSource: Windows.Media.Core.IMediaSource;
+  }
+  var IMediaCaptureInitializationSettings3: abstract new (...args: any[]) => IMediaCaptureInitializationSettings3;
+
+  interface IMediaCaptureInitializationSettings4 {
+    PhotoMediaDescription: Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription;
+    PreviewMediaDescription: Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription;
+    RecordMediaDescription: Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription;
+    VideoProfile: Windows.Media.Capture.MediaCaptureVideoProfile;
+  }
+  var IMediaCaptureInitializationSettings4: abstract new (...args: any[]) => IMediaCaptureInitializationSettings4;
+
+  interface IMediaCaptureInitializationSettings5 {
+    MemoryPreference: number;
+    SharingMode: number;
+    SourceGroup: Windows.Media.Capture.Frames.MediaFrameSourceGroup;
+  }
+  var IMediaCaptureInitializationSettings5: abstract new (...args: any[]) => IMediaCaptureInitializationSettings5;
+
+  interface IMediaCaptureInitializationSettings6 {
+    AlwaysPlaySystemShutterSound: boolean;
+  }
+  var IMediaCaptureInitializationSettings6: abstract new (...args: any[]) => IMediaCaptureInitializationSettings6;
+
+  interface IMediaCaptureInitializationSettings7 {
+    DeviceUri: Windows.Foundation.Uri;
+    DeviceUriPasswordCredential: Windows.Security.Credentials.PasswordCredential;
+  }
+  var IMediaCaptureInitializationSettings7: abstract new (...args: any[]) => IMediaCaptureInitializationSettings7;
+
+  interface IMediaCapturePauseResult {
+    readonly LastFrame: Windows.Media.VideoFrame;
+    readonly RecordDuration: Windows.Foundation.TimeSpan;
+  }
+  var IMediaCapturePauseResult: abstract new (...args: any[]) => IMediaCapturePauseResult;
+
+  interface IMediaCaptureRelativePanelWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly RelativePanel: number;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.MediaCaptureRelativePanelWatcher, Object> | null;
+  }
+  var IMediaCaptureRelativePanelWatcher: abstract new (...args: any[]) => IMediaCaptureRelativePanelWatcher;
+
+  interface IMediaCaptureSettings {
+    readonly AudioDeviceId: string;
+    readonly PhotoCaptureSource: number;
+    readonly StreamingCaptureMode: number;
+    readonly VideoDeviceCharacteristic: number;
+    readonly VideoDeviceId: string;
+  }
+  var IMediaCaptureSettings: abstract new (...args: any[]) => IMediaCaptureSettings;
+
+  interface IMediaCaptureSettings2 {
+    readonly AudioProcessing: number;
+    readonly CameraSoundRequiredForRegion: boolean;
+    readonly ConcurrentRecordAndPhotoSequenceSupported: boolean;
+    readonly ConcurrentRecordAndPhotoSupported: boolean;
+    readonly Horizontal35mmEquivalentFocalLength: number | null;
+    readonly MediaCategory: number;
+    readonly PitchOffsetDegrees: number | null;
+    readonly Vertical35mmEquivalentFocalLength: number | null;
+  }
+  var IMediaCaptureSettings2: abstract new (...args: any[]) => IMediaCaptureSettings2;
+
+  interface IMediaCaptureSettings3 {
+    readonly Direct3D11Device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice;
+  }
+  var IMediaCaptureSettings3: abstract new (...args: any[]) => IMediaCaptureSettings3;
+
+  interface IMediaCaptureStatics {
+    FindAllVideoProfiles(videoDeviceId: string): Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.MediaCaptureVideoProfile> | Windows.Media.Capture.MediaCaptureVideoProfile[];
+    FindConcurrentProfiles(videoDeviceId: string): Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.MediaCaptureVideoProfile> | Windows.Media.Capture.MediaCaptureVideoProfile[];
+    FindKnownVideoProfiles(videoDeviceId: string, name: number): Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.MediaCaptureVideoProfile> | Windows.Media.Capture.MediaCaptureVideoProfile[];
+    IsVideoProfileSupported(videoDeviceId: string): boolean;
+  }
+  var IMediaCaptureStatics: abstract new (...args: any[]) => IMediaCaptureStatics;
+
+  interface IMediaCaptureStopResult {
+    readonly LastFrame: Windows.Media.VideoFrame;
+    readonly RecordDuration: Windows.Foundation.TimeSpan;
+  }
+  var IMediaCaptureStopResult: abstract new (...args: any[]) => IMediaCaptureStopResult;
+
+  interface IMediaCaptureVideoPreview {
+    StartPreviewAsync(): Windows.Foundation.IAsyncAction;
+    StartPreviewToCustomSinkAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, customMediaSink: Windows.Media.IMediaExtension): Windows.Foundation.IAsyncAction;
+    StartPreviewToCustomSinkAsync(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile, customSinkActivationId: string, customSinkSettings: Windows.Foundation.Collections.IPropertySet): Windows.Foundation.IAsyncAction;
+    StopPreviewAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var IMediaCaptureVideoPreview: abstract new (...args: any[]) => IMediaCaptureVideoPreview;
+
+  interface IMediaCaptureVideoProfile {
+    GetConcurrency(): Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.MediaCaptureVideoProfile> | Windows.Media.Capture.MediaCaptureVideoProfile[];
+    readonly Id: string;
+    readonly SupportedPhotoMediaDescription: Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription> | Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription[];
+    readonly SupportedPreviewMediaDescription: Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription> | Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription[];
+    readonly SupportedRecordMediaDescription: Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription> | Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription[];
+    readonly VideoDeviceId: string;
+  }
+  var IMediaCaptureVideoProfile: abstract new (...args: any[]) => IMediaCaptureVideoProfile;
+
+  interface IMediaCaptureVideoProfile2 {
+    readonly FrameSourceInfos: Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.Frames.MediaFrameSourceInfo> | Windows.Media.Capture.Frames.MediaFrameSourceInfo[];
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+  }
+  var IMediaCaptureVideoProfile2: abstract new (...args: any[]) => IMediaCaptureVideoProfile2;
+
+  interface IMediaCaptureVideoProfileMediaDescription {
+    readonly FrameRate: number;
+    readonly Height: number;
+    readonly IsHdrVideoSupported: boolean;
+    readonly IsVariablePhotoSequenceSupported: boolean;
+    readonly Width: number;
+  }
+  var IMediaCaptureVideoProfileMediaDescription: abstract new (...args: any[]) => IMediaCaptureVideoProfileMediaDescription;
+
+  interface IMediaCaptureVideoProfileMediaDescription2 {
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+    readonly Subtype: string;
+  }
+  var IMediaCaptureVideoProfileMediaDescription2: abstract new (...args: any[]) => IMediaCaptureVideoProfileMediaDescription2;
+
+  interface IOptionalReferencePhotoCapturedEventArgs {
+    readonly Context: Object;
+    readonly Frame: Windows.Media.Capture.CapturedFrame;
+  }
+  var IOptionalReferencePhotoCapturedEventArgs: abstract new (...args: any[]) => IOptionalReferencePhotoCapturedEventArgs;
+
+  interface IPhotoCapturedEventArgs {
+    readonly CaptureTimeOffset: Windows.Foundation.TimeSpan;
+    readonly Frame: Windows.Media.Capture.CapturedFrame;
+    readonly Thumbnail: Windows.Media.Capture.CapturedFrame;
+  }
+  var IPhotoCapturedEventArgs: abstract new (...args: any[]) => IPhotoCapturedEventArgs;
+
+  interface IPhotoConfirmationCapturedEventArgs {
+    readonly CaptureTimeOffset: Windows.Foundation.TimeSpan;
+    readonly Frame: Windows.Media.Capture.CapturedFrame;
+  }
+  var IPhotoConfirmationCapturedEventArgs: abstract new (...args: any[]) => IPhotoConfirmationCapturedEventArgs;
+
+  interface IVideoStreamConfiguration {
+    readonly InputProperties: Windows.Media.MediaProperties.VideoEncodingProperties;
+    readonly OutputProperties: Windows.Media.MediaProperties.VideoEncodingProperties;
+  }
+  var IVideoStreamConfiguration: abstract new (...args: any[]) => IVideoStreamConfiguration;
+
+  interface MediaCaptureFailedEventHandler {
+    (sender: Windows.Media.Capture.MediaCapture, errorEventArgs: Windows.Media.Capture.MediaCaptureFailedEventArgs): void;
+  }
+  var MediaCaptureFailedEventHandler: {
+    new(callback: (sender: Windows.Media.Capture.MediaCapture, errorEventArgs: Windows.Media.Capture.MediaCaptureFailedEventArgs) => void): MediaCaptureFailedEventHandler;
+  };
+
+  interface RecordLimitationExceededEventHandler {
+    (sender: Windows.Media.Capture.MediaCapture): void;
+  }
+  var RecordLimitationExceededEventHandler: {
+    new(callback: (sender: Windows.Media.Capture.MediaCapture) => void): RecordLimitationExceededEventHandler;
+  };
+
+  interface WhiteBalanceGain {
+    R: number;
+    G: number;
+    B: number;
+  }
+  var WhiteBalanceGain: {
+    new(r: number, g: number, b: number): WhiteBalanceGain;
+    new(fields: { R?: number; G?: number; B?: number }): WhiteBalanceGain;
+  };
+
+}
+
+declare namespace Windows.Media.Capture.Core {
+  class VariablePhotoCapturedEventArgs implements Windows.Media.Capture.Core.IVariablePhotoCapturedEventArgs {
+    readonly CaptureTimeOffset: Windows.Foundation.TimeSpan;
+    readonly CapturedFrameControlValues: Windows.Media.Capture.CapturedFrameControlValues;
+    readonly Frame: Windows.Media.Capture.CapturedFrame;
+    readonly UsedFrameControllerIndex: number | null;
+  }
+
+  class VariablePhotoSequenceCapture implements Windows.Media.Capture.Core.IVariablePhotoSequenceCapture, Windows.Media.Capture.Core.IVariablePhotoSequenceCapture2 {
+    FinishAsync(): Windows.Foundation.IAsyncAction;
+    StartAsync(): Windows.Foundation.IAsyncAction;
+    StopAsync(): Windows.Foundation.IAsyncAction;
+    UpdateSettingsAsync(): Windows.Foundation.IAsyncAction;
+    PhotoCaptured: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.Core.VariablePhotoSequenceCapture, Windows.Media.Capture.Core.VariablePhotoCapturedEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.Core.VariablePhotoSequenceCapture, Object> | null;
+  }
+
+  interface IVariablePhotoCapturedEventArgs {
+    readonly CaptureTimeOffset: Windows.Foundation.TimeSpan;
+    readonly CapturedFrameControlValues: Windows.Media.Capture.CapturedFrameControlValues;
+    readonly Frame: Windows.Media.Capture.CapturedFrame;
+    readonly UsedFrameControllerIndex: number | null;
+  }
+  var IVariablePhotoCapturedEventArgs: abstract new (...args: any[]) => IVariablePhotoCapturedEventArgs;
+
+  interface IVariablePhotoSequenceCapture {
+    FinishAsync(): Windows.Foundation.IAsyncAction;
+    StartAsync(): Windows.Foundation.IAsyncAction;
+    StopAsync(): Windows.Foundation.IAsyncAction;
+    PhotoCaptured: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.Core.VariablePhotoSequenceCapture, Windows.Media.Capture.Core.VariablePhotoCapturedEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.Core.VariablePhotoSequenceCapture, Object> | null;
+  }
+  var IVariablePhotoSequenceCapture: abstract new (...args: any[]) => IVariablePhotoSequenceCapture;
+
+  interface IVariablePhotoSequenceCapture2 {
+    UpdateSettingsAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var IVariablePhotoSequenceCapture2: abstract new (...args: any[]) => IVariablePhotoSequenceCapture2;
+
+}
+
+declare namespace Windows.Media.Capture.Frames {
+  class AudioMediaFrame implements Windows.Media.Capture.Frames.IAudioMediaFrame {
+    GetAudioFrame(): Windows.Media.AudioFrame;
+    readonly AudioEncodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties;
+    readonly FrameReference: Windows.Media.Capture.Frames.MediaFrameReference;
+  }
+
+  class BufferMediaFrame implements Windows.Media.Capture.Frames.IBufferMediaFrame {
+    readonly Buffer: Windows.Storage.Streams.IBuffer;
+    readonly FrameReference: Windows.Media.Capture.Frames.MediaFrameReference;
+  }
+
+  class DepthMediaFrame implements Windows.Media.Capture.Frames.IDepthMediaFrame, Windows.Media.Capture.Frames.IDepthMediaFrame2 {
+    TryCreateCoordinateMapper(cameraIntrinsics: Windows.Media.Devices.Core.CameraIntrinsics, coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Media.Devices.Core.DepthCorrelatedCoordinateMapper;
+    readonly DepthFormat: Windows.Media.Capture.Frames.DepthMediaFrameFormat;
+    readonly FrameReference: Windows.Media.Capture.Frames.MediaFrameReference;
+    readonly MaxReliableDepth: number;
+    readonly MinReliableDepth: number;
+    readonly VideoMediaFrame: Windows.Media.Capture.Frames.VideoMediaFrame;
+  }
+
+  class DepthMediaFrameFormat implements Windows.Media.Capture.Frames.IDepthMediaFrameFormat {
+    readonly DepthScaleInMeters: number;
+    readonly VideoFormat: Windows.Media.Capture.Frames.VideoMediaFrameFormat;
+  }
+
+  class InfraredMediaFrame implements Windows.Media.Capture.Frames.IInfraredMediaFrame {
+    readonly FrameReference: Windows.Media.Capture.Frames.MediaFrameReference;
+    readonly IsIlluminated: boolean;
+    readonly VideoMediaFrame: Windows.Media.Capture.Frames.VideoMediaFrame;
+  }
+
+  class MediaFrameArrivedEventArgs implements Windows.Media.Capture.Frames.IMediaFrameArrivedEventArgs {
+  }
+
+  class MediaFrameFormat implements Windows.Media.Capture.Frames.IMediaFrameFormat, Windows.Media.Capture.Frames.IMediaFrameFormat2 {
+    readonly AudioEncodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties;
+    readonly FrameRate: Windows.Media.MediaProperties.MediaRatio;
+    readonly MajorType: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+    readonly Subtype: string;
+    readonly VideoFormat: Windows.Media.Capture.Frames.VideoMediaFrameFormat;
+  }
+
+  class MediaFrameReader implements Windows.Foundation.IClosable, Windows.Media.Capture.Frames.IMediaFrameReader, Windows.Media.Capture.Frames.IMediaFrameReader2 {
+    Close(): void;
+    StartAsync(): Windows.Foundation.IAsyncOperation<number>;
+    StopAsync(): Windows.Foundation.IAsyncAction;
+    TryAcquireLatestFrame(): Windows.Media.Capture.Frames.MediaFrameReference;
+    AcquisitionMode: number;
+    FrameArrived: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.Frames.MediaFrameReader, Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs> | null;
+  }
+
+  class MediaFrameReference implements Windows.Foundation.IClosable, Windows.Media.Capture.Frames.IMediaFrameReference, Windows.Media.Capture.Frames.IMediaFrameReference2 {
+    Close(): void;
+    readonly AudioMediaFrame: Windows.Media.Capture.Frames.AudioMediaFrame;
+    readonly BufferMediaFrame: Windows.Media.Capture.Frames.BufferMediaFrame;
+    readonly CoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly Format: Windows.Media.Capture.Frames.MediaFrameFormat;
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+    readonly SourceKind: number;
+    readonly SystemRelativeTime: Windows.Foundation.TimeSpan | null;
+    readonly VideoMediaFrame: Windows.Media.Capture.Frames.VideoMediaFrame;
+  }
+
+  class MediaFrameSource implements Windows.Media.Capture.Frames.IMediaFrameSource {
+    SetFormatAsync(format: Windows.Media.Capture.Frames.MediaFrameFormat): Windows.Foundation.IAsyncAction;
+    TryGetCameraIntrinsics(format: Windows.Media.Capture.Frames.MediaFrameFormat): Windows.Media.Devices.Core.CameraIntrinsics;
+    readonly Controller: Windows.Media.Capture.Frames.MediaFrameSourceController;
+    readonly CurrentFormat: Windows.Media.Capture.Frames.MediaFrameFormat;
+    readonly Info: Windows.Media.Capture.Frames.MediaFrameSourceInfo;
+    readonly SupportedFormats: Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.Frames.MediaFrameFormat> | Windows.Media.Capture.Frames.MediaFrameFormat[];
+    FormatChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.Frames.MediaFrameSource, Object> | null;
+  }
+
+  class MediaFrameSourceController implements Windows.Media.Capture.Frames.IMediaFrameSourceController, Windows.Media.Capture.Frames.IMediaFrameSourceController2, Windows.Media.Capture.Frames.IMediaFrameSourceController3 {
+    GetPropertyAsync(propertyId: string): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.Frames.MediaFrameSourceGetPropertyResult>;
+    GetPropertyByExtendedIdAsync(extendedPropertyId: number[], maxPropertyValueSize: number | null): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.Frames.MediaFrameSourceGetPropertyResult>;
+    SetPropertyAsync(propertyId: string, propertyValue: Object): Windows.Foundation.IAsyncOperation<number>;
+    SetPropertyByExtendedIdAsync(extendedPropertyId: number[], propertyValue: number[]): Windows.Foundation.IAsyncOperation<number>;
+    readonly AudioDeviceController: Windows.Media.Devices.AudioDeviceController;
+    readonly VideoDeviceController: Windows.Media.Devices.VideoDeviceController;
+  }
+
+  class MediaFrameSourceGetPropertyResult implements Windows.Media.Capture.Frames.IMediaFrameSourceGetPropertyResult {
+    readonly Status: number;
+    readonly Value: Object;
+  }
+
+  class MediaFrameSourceGroup implements Windows.Media.Capture.Frames.IMediaFrameSourceGroup {
+    static FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.Frames.MediaFrameSourceGroup> | Windows.Media.Capture.Frames.MediaFrameSourceGroup[]>;
+    static FromIdAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.Frames.MediaFrameSourceGroup>;
+    static GetDeviceSelector(): string;
+    readonly DisplayName: string;
+    readonly Id: string;
+    readonly SourceInfos: Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.Frames.MediaFrameSourceInfo> | Windows.Media.Capture.Frames.MediaFrameSourceInfo[];
+  }
+
+  class MediaFrameSourceInfo implements Windows.Media.Capture.Frames.IMediaFrameSourceInfo, Windows.Media.Capture.Frames.IMediaFrameSourceInfo2, Windows.Media.Capture.Frames.IMediaFrameSourceInfo3, Windows.Media.Capture.Frames.IMediaFrameSourceInfo4 {
+    GetRelativePanel(displayRegion: Windows.UI.WindowManagement.DisplayRegion): number;
+    readonly CoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem;
+    readonly DeviceInformation: Windows.Devices.Enumeration.DeviceInformation;
+    readonly Id: string;
+    readonly IsShareable: boolean;
+    readonly MediaStreamType: number;
+    readonly ProfileId: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+    readonly SourceGroup: Windows.Media.Capture.Frames.MediaFrameSourceGroup;
+    readonly SourceKind: number;
+    readonly VideoProfileMediaDescription: Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription> | Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription[];
+  }
+
+  class MultiSourceMediaFrameArrivedEventArgs implements Windows.Media.Capture.Frames.IMultiSourceMediaFrameArrivedEventArgs {
+  }
+
+  class MultiSourceMediaFrameReader implements Windows.Foundation.IClosable, Windows.Media.Capture.Frames.IMultiSourceMediaFrameReader, Windows.Media.Capture.Frames.IMultiSourceMediaFrameReader2 {
+    Close(): void;
+    StartAsync(): Windows.Foundation.IAsyncOperation<number>;
+    StopAsync(): Windows.Foundation.IAsyncAction;
+    TryAcquireLatestFrame(): Windows.Media.Capture.Frames.MultiSourceMediaFrameReference;
+    AcquisitionMode: number;
+    FrameArrived: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.Frames.MultiSourceMediaFrameReader, Windows.Media.Capture.Frames.MultiSourceMediaFrameArrivedEventArgs> | null;
+  }
+
+  class MultiSourceMediaFrameReference implements Windows.Foundation.IClosable, Windows.Media.Capture.Frames.IMultiSourceMediaFrameReference {
+    Close(): void;
+    TryGetFrameReferenceBySourceId(sourceId: string): Windows.Media.Capture.Frames.MediaFrameReference;
+  }
+
+  class VideoMediaFrame implements Windows.Media.Capture.Frames.IVideoMediaFrame {
+    GetVideoFrame(): Windows.Media.VideoFrame;
+    readonly CameraIntrinsics: Windows.Media.Devices.Core.CameraIntrinsics;
+    readonly DepthMediaFrame: Windows.Media.Capture.Frames.DepthMediaFrame;
+    readonly Direct3DSurface: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface;
+    readonly FrameReference: Windows.Media.Capture.Frames.MediaFrameReference;
+    readonly InfraredMediaFrame: Windows.Media.Capture.Frames.InfraredMediaFrame;
+    readonly SoftwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap;
+    readonly VideoFormat: Windows.Media.Capture.Frames.VideoMediaFrameFormat;
+  }
+
+  class VideoMediaFrameFormat implements Windows.Media.Capture.Frames.IVideoMediaFrameFormat {
+    readonly DepthFormat: Windows.Media.Capture.Frames.DepthMediaFrameFormat;
+    readonly Height: number;
+    readonly MediaFrameFormat: Windows.Media.Capture.Frames.MediaFrameFormat;
+    readonly Width: number;
+  }
+
+  enum MediaFrameReaderAcquisitionMode {
+    Realtime = 0,
+    Buffered = 1,
+  }
+
+  enum MediaFrameReaderStartStatus {
+    Success = 0,
+    UnknownFailure = 1,
+    DeviceNotAvailable = 2,
+    OutputFormatNotSupported = 3,
+    ExclusiveControlNotAvailable = 4,
+  }
+
+  enum MediaFrameSourceGetPropertyStatus {
+    Success = 0,
+    UnknownFailure = 1,
+    NotSupported = 2,
+    DeviceNotAvailable = 3,
+    MaxPropertyValueSizeTooSmall = 4,
+    MaxPropertyValueSizeRequired = 5,
+  }
+
+  enum MediaFrameSourceKind {
+    Custom = 0,
+    Color = 1,
+    Infrared = 2,
+    Depth = 3,
+    Audio = 4,
+    Image = 5,
+    Metadata = 6,
+  }
+
+  enum MediaFrameSourceSetPropertyStatus {
+    Success = 0,
+    UnknownFailure = 1,
+    NotSupported = 2,
+    InvalidValue = 3,
+    DeviceNotAvailable = 4,
+    NotInControl = 5,
+  }
+
+  enum MultiSourceMediaFrameReaderStartStatus {
+    Success = 0,
+    NotSupported = 1,
+    InsufficientResources = 2,
+    DeviceNotAvailable = 3,
+    UnknownFailure = 4,
+  }
+
+  interface IAudioMediaFrame {
+    GetAudioFrame(): Windows.Media.AudioFrame;
+    readonly AudioEncodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties;
+    readonly FrameReference: Windows.Media.Capture.Frames.MediaFrameReference;
+  }
+  var IAudioMediaFrame: abstract new (...args: any[]) => IAudioMediaFrame;
+
+  interface IBufferMediaFrame {
+    readonly Buffer: Windows.Storage.Streams.IBuffer;
+    readonly FrameReference: Windows.Media.Capture.Frames.MediaFrameReference;
+  }
+  var IBufferMediaFrame: abstract new (...args: any[]) => IBufferMediaFrame;
+
+  interface IDepthMediaFrame {
+    TryCreateCoordinateMapper(cameraIntrinsics: Windows.Media.Devices.Core.CameraIntrinsics, coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Media.Devices.Core.DepthCorrelatedCoordinateMapper;
+    readonly DepthFormat: Windows.Media.Capture.Frames.DepthMediaFrameFormat;
+    readonly FrameReference: Windows.Media.Capture.Frames.MediaFrameReference;
+    readonly VideoMediaFrame: Windows.Media.Capture.Frames.VideoMediaFrame;
+  }
+  var IDepthMediaFrame: abstract new (...args: any[]) => IDepthMediaFrame;
+
+  interface IDepthMediaFrame2 {
+    readonly MaxReliableDepth: number;
+    readonly MinReliableDepth: number;
+  }
+  var IDepthMediaFrame2: abstract new (...args: any[]) => IDepthMediaFrame2;
+
+  interface IDepthMediaFrameFormat {
+    readonly DepthScaleInMeters: number;
+    readonly VideoFormat: Windows.Media.Capture.Frames.VideoMediaFrameFormat;
+  }
+  var IDepthMediaFrameFormat: abstract new (...args: any[]) => IDepthMediaFrameFormat;
+
+  interface IInfraredMediaFrame {
+    readonly FrameReference: Windows.Media.Capture.Frames.MediaFrameReference;
+    readonly IsIlluminated: boolean;
+    readonly VideoMediaFrame: Windows.Media.Capture.Frames.VideoMediaFrame;
+  }
+  var IInfraredMediaFrame: abstract new (...args: any[]) => IInfraredMediaFrame;
+
+  interface IMediaFrameArrivedEventArgs {
+  }
+  var IMediaFrameArrivedEventArgs: abstract new (...args: any[]) => IMediaFrameArrivedEventArgs;
+
+  interface IMediaFrameFormat {
+    readonly FrameRate: Windows.Media.MediaProperties.MediaRatio;
+    readonly MajorType: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+    readonly Subtype: string;
+    readonly VideoFormat: Windows.Media.Capture.Frames.VideoMediaFrameFormat;
+  }
+  var IMediaFrameFormat: abstract new (...args: any[]) => IMediaFrameFormat;
+
+  interface IMediaFrameFormat2 {
+    readonly AudioEncodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties;
+  }
+  var IMediaFrameFormat2: abstract new (...args: any[]) => IMediaFrameFormat2;
+
+  interface IMediaFrameReader extends Windows.Foundation.IClosable {
+    Close(): void;
+    StartAsync(): Windows.Foundation.IAsyncOperation<number>;
+    StopAsync(): Windows.Foundation.IAsyncAction;
+    TryAcquireLatestFrame(): Windows.Media.Capture.Frames.MediaFrameReference;
+    FrameArrived: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.Frames.MediaFrameReader, Windows.Media.Capture.Frames.MediaFrameArrivedEventArgs> | null;
+  }
+  var IMediaFrameReader: abstract new (...args: any[]) => IMediaFrameReader;
+
+  interface IMediaFrameReader2 {
+    AcquisitionMode: number;
+  }
+  var IMediaFrameReader2: abstract new (...args: any[]) => IMediaFrameReader2;
+
+  interface IMediaFrameReference extends Windows.Foundation.IClosable {
+    Close(): void;
+    readonly BufferMediaFrame: Windows.Media.Capture.Frames.BufferMediaFrame;
+    readonly CoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly Format: Windows.Media.Capture.Frames.MediaFrameFormat;
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+    readonly SourceKind: number;
+    readonly SystemRelativeTime: Windows.Foundation.TimeSpan | null;
+    readonly VideoMediaFrame: Windows.Media.Capture.Frames.VideoMediaFrame;
+  }
+  var IMediaFrameReference: abstract new (...args: any[]) => IMediaFrameReference;
+
+  interface IMediaFrameReference2 {
+    readonly AudioMediaFrame: Windows.Media.Capture.Frames.AudioMediaFrame;
+  }
+  var IMediaFrameReference2: abstract new (...args: any[]) => IMediaFrameReference2;
+
+  interface IMediaFrameSource {
+    SetFormatAsync(format: Windows.Media.Capture.Frames.MediaFrameFormat): Windows.Foundation.IAsyncAction;
+    TryGetCameraIntrinsics(format: Windows.Media.Capture.Frames.MediaFrameFormat): Windows.Media.Devices.Core.CameraIntrinsics;
+    readonly Controller: Windows.Media.Capture.Frames.MediaFrameSourceController;
+    readonly CurrentFormat: Windows.Media.Capture.Frames.MediaFrameFormat;
+    readonly Info: Windows.Media.Capture.Frames.MediaFrameSourceInfo;
+    readonly SupportedFormats: Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.Frames.MediaFrameFormat> | Windows.Media.Capture.Frames.MediaFrameFormat[];
+    FormatChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.Frames.MediaFrameSource, Object> | null;
+  }
+  var IMediaFrameSource: abstract new (...args: any[]) => IMediaFrameSource;
+
+  interface IMediaFrameSourceController {
+    GetPropertyAsync(propertyId: string): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.Frames.MediaFrameSourceGetPropertyResult>;
+    SetPropertyAsync(propertyId: string, propertyValue: Object): Windows.Foundation.IAsyncOperation<number>;
+    readonly VideoDeviceController: Windows.Media.Devices.VideoDeviceController;
+  }
+  var IMediaFrameSourceController: abstract new (...args: any[]) => IMediaFrameSourceController;
+
+  interface IMediaFrameSourceController2 {
+    GetPropertyByExtendedIdAsync(extendedPropertyId: number[], maxPropertyValueSize: number | null): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.Frames.MediaFrameSourceGetPropertyResult>;
+    SetPropertyByExtendedIdAsync(extendedPropertyId: number[], propertyValue: number[]): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IMediaFrameSourceController2: abstract new (...args: any[]) => IMediaFrameSourceController2;
+
+  interface IMediaFrameSourceController3 {
+    readonly AudioDeviceController: Windows.Media.Devices.AudioDeviceController;
+  }
+  var IMediaFrameSourceController3: abstract new (...args: any[]) => IMediaFrameSourceController3;
+
+  interface IMediaFrameSourceGetPropertyResult {
+    readonly Status: number;
+    readonly Value: Object;
+  }
+  var IMediaFrameSourceGetPropertyResult: abstract new (...args: any[]) => IMediaFrameSourceGetPropertyResult;
+
+  interface IMediaFrameSourceGroup {
+    readonly DisplayName: string;
+    readonly Id: string;
+    readonly SourceInfos: Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.Frames.MediaFrameSourceInfo> | Windows.Media.Capture.Frames.MediaFrameSourceInfo[];
+  }
+  var IMediaFrameSourceGroup: abstract new (...args: any[]) => IMediaFrameSourceGroup;
+
+  interface IMediaFrameSourceGroupStatics {
+    FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.Frames.MediaFrameSourceGroup> | Windows.Media.Capture.Frames.MediaFrameSourceGroup[]>;
+    FromIdAsync(id: string): Windows.Foundation.IAsyncOperation<Windows.Media.Capture.Frames.MediaFrameSourceGroup>;
+    GetDeviceSelector(): string;
+  }
+  var IMediaFrameSourceGroupStatics: abstract new (...args: any[]) => IMediaFrameSourceGroupStatics;
+
+  interface IMediaFrameSourceInfo {
+    readonly CoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem;
+    readonly DeviceInformation: Windows.Devices.Enumeration.DeviceInformation;
+    readonly Id: string;
+    readonly MediaStreamType: number;
+    readonly Properties: Windows.Foundation.Collections.IMapView<Guid, Object>;
+    readonly SourceGroup: Windows.Media.Capture.Frames.MediaFrameSourceGroup;
+    readonly SourceKind: number;
+  }
+  var IMediaFrameSourceInfo: abstract new (...args: any[]) => IMediaFrameSourceInfo;
+
+  interface IMediaFrameSourceInfo2 {
+    readonly ProfileId: string;
+    readonly VideoProfileMediaDescription: Windows.Foundation.Collections.IVectorView<Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription> | Windows.Media.Capture.MediaCaptureVideoProfileMediaDescription[];
+  }
+  var IMediaFrameSourceInfo2: abstract new (...args: any[]) => IMediaFrameSourceInfo2;
+
+  interface IMediaFrameSourceInfo3 {
+    GetRelativePanel(displayRegion: Windows.UI.WindowManagement.DisplayRegion): number;
+  }
+  var IMediaFrameSourceInfo3: abstract new (...args: any[]) => IMediaFrameSourceInfo3;
+
+  interface IMediaFrameSourceInfo4 {
+    readonly IsShareable: boolean;
+  }
+  var IMediaFrameSourceInfo4: abstract new (...args: any[]) => IMediaFrameSourceInfo4;
+
+  interface IMultiSourceMediaFrameArrivedEventArgs {
+  }
+  var IMultiSourceMediaFrameArrivedEventArgs: abstract new (...args: any[]) => IMultiSourceMediaFrameArrivedEventArgs;
+
+  interface IMultiSourceMediaFrameReader extends Windows.Foundation.IClosable {
+    Close(): void;
+    StartAsync(): Windows.Foundation.IAsyncOperation<number>;
+    StopAsync(): Windows.Foundation.IAsyncAction;
+    TryAcquireLatestFrame(): Windows.Media.Capture.Frames.MultiSourceMediaFrameReference;
+    FrameArrived: Windows.Foundation.TypedEventHandler<Windows.Media.Capture.Frames.MultiSourceMediaFrameReader, Windows.Media.Capture.Frames.MultiSourceMediaFrameArrivedEventArgs> | null;
+  }
+  var IMultiSourceMediaFrameReader: abstract new (...args: any[]) => IMultiSourceMediaFrameReader;
+
+  interface IMultiSourceMediaFrameReader2 {
+    AcquisitionMode: number;
+  }
+  var IMultiSourceMediaFrameReader2: abstract new (...args: any[]) => IMultiSourceMediaFrameReader2;
+
+  interface IMultiSourceMediaFrameReference extends Windows.Foundation.IClosable {
+    Close(): void;
+    TryGetFrameReferenceBySourceId(sourceId: string): Windows.Media.Capture.Frames.MediaFrameReference;
+  }
+  var IMultiSourceMediaFrameReference: abstract new (...args: any[]) => IMultiSourceMediaFrameReference;
+
+  interface IVideoMediaFrame {
+    GetVideoFrame(): Windows.Media.VideoFrame;
+    readonly CameraIntrinsics: Windows.Media.Devices.Core.CameraIntrinsics;
+    readonly DepthMediaFrame: Windows.Media.Capture.Frames.DepthMediaFrame;
+    readonly Direct3DSurface: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface;
+    readonly FrameReference: Windows.Media.Capture.Frames.MediaFrameReference;
+    readonly InfraredMediaFrame: Windows.Media.Capture.Frames.InfraredMediaFrame;
+    readonly SoftwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap;
+    readonly VideoFormat: Windows.Media.Capture.Frames.VideoMediaFrameFormat;
+  }
+  var IVideoMediaFrame: abstract new (...args: any[]) => IVideoMediaFrame;
+
+  interface IVideoMediaFrameFormat {
+    readonly DepthFormat: Windows.Media.Capture.Frames.DepthMediaFrameFormat;
+    readonly Height: number;
+    readonly MediaFrameFormat: Windows.Media.Capture.Frames.MediaFrameFormat;
+    readonly Width: number;
+  }
+  var IVideoMediaFrameFormat: abstract new (...args: any[]) => IVideoMediaFrameFormat;
+
+}
+
+declare namespace Windows.Media.Casting {
+  class CastingConnection implements Windows.Foundation.IClosable, Windows.Media.Casting.ICastingConnection {
+    Close(): void;
+    DisconnectAsync(): Windows.Foundation.IAsyncOperation<number>;
+    RequestStartCastingAsync(value: Windows.Media.Casting.CastingSource): Windows.Foundation.IAsyncOperation<number>;
+    readonly Device: Windows.Media.Casting.CastingDevice;
+    Source: Windows.Media.Casting.CastingSource;
+    readonly State: number;
+    ErrorOccurred: Windows.Foundation.TypedEventHandler<Windows.Media.Casting.CastingConnection, Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs> | null;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Casting.CastingConnection, Object> | null;
+  }
+
+  class CastingConnectionErrorOccurredEventArgs implements Windows.Media.Casting.ICastingConnectionErrorOccurredEventArgs {
+    readonly ErrorStatus: number;
+    readonly Message: string;
+  }
+
+  class CastingDevice implements Windows.Media.Casting.ICastingDevice {
+    CreateCastingConnection(): Windows.Media.Casting.CastingConnection;
+    static DeviceInfoSupportsCastingAsync(device: Windows.Devices.Enumeration.DeviceInformation): Windows.Foundation.IAsyncOperation<boolean>;
+    static FromIdAsync(value: string): Windows.Foundation.IAsyncOperation<Windows.Media.Casting.CastingDevice>;
+    static GetDeviceSelector(type: number): string;
+    static GetDeviceSelectorFromCastingSourceAsync(castingSource: Windows.Media.Casting.CastingSource): Windows.Foundation.IAsyncOperation<string>;
+    GetSupportedCastingPlaybackTypesAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly FriendlyName: string;
+    readonly Icon: Windows.Storage.Streams.IRandomAccessStreamWithContentType;
+    readonly Id: string;
+  }
+
+  class CastingDevicePicker implements Windows.Media.Casting.ICastingDevicePicker {
+    constructor();
+    Hide(): void;
+    Show(selection: Windows.Foundation.Rect): void;
+    Show(selection: Windows.Foundation.Rect, preferredPlacement: number): void;
+    readonly Appearance: Windows.Devices.Enumeration.DevicePickerAppearance;
+    readonly Filter: Windows.Media.Casting.CastingDevicePickerFilter;
+    CastingDevicePickerDismissed: Windows.Foundation.TypedEventHandler<Windows.Media.Casting.CastingDevicePicker, Object> | null;
+    CastingDeviceSelected: Windows.Foundation.TypedEventHandler<Windows.Media.Casting.CastingDevicePicker, Windows.Media.Casting.CastingDeviceSelectedEventArgs> | null;
+  }
+
+  class CastingDevicePickerFilter implements Windows.Media.Casting.ICastingDevicePickerFilter {
+    readonly SupportedCastingSources: Windows.Foundation.Collections.IVector<Windows.Media.Casting.CastingSource> | Windows.Media.Casting.CastingSource[];
+    SupportsAudio: boolean;
+    SupportsPictures: boolean;
+    SupportsVideo: boolean;
+  }
+
+  class CastingDeviceSelectedEventArgs implements Windows.Media.Casting.ICastingDeviceSelectedEventArgs {
+    readonly SelectedCastingDevice: Windows.Media.Casting.CastingDevice;
+  }
+
+  class CastingSource implements Windows.Media.Casting.ICastingSource {
+    PreferredSourceUri: Windows.Foundation.Uri;
+  }
+
+  enum CastingConnectionErrorStatus {
+    Succeeded = 0,
+    DeviceDidNotRespond = 1,
+    DeviceError = 2,
+    DeviceLocked = 3,
+    ProtectedPlaybackFailed = 4,
+    InvalidCastingSource = 5,
+    Unknown = 6,
+  }
+
+  enum CastingConnectionState {
+    Disconnected = 0,
+    Connected = 1,
+    Rendering = 2,
+    Disconnecting = 3,
+    Connecting = 4,
+  }
+
+  enum CastingPlaybackTypes {
+    None = 0,
+    Audio = 1,
+    Video = 2,
+    Picture = 4,
+  }
+
+  interface ICastingConnection extends Windows.Foundation.IClosable {
+    Close(): void;
+    DisconnectAsync(): Windows.Foundation.IAsyncOperation<number>;
+    RequestStartCastingAsync(value: Windows.Media.Casting.CastingSource): Windows.Foundation.IAsyncOperation<number>;
+    readonly Device: Windows.Media.Casting.CastingDevice;
+    Source: Windows.Media.Casting.CastingSource;
+    readonly State: number;
+    ErrorOccurred: Windows.Foundation.TypedEventHandler<Windows.Media.Casting.CastingConnection, Windows.Media.Casting.CastingConnectionErrorOccurredEventArgs> | null;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Casting.CastingConnection, Object> | null;
+  }
+  var ICastingConnection: abstract new (...args: any[]) => ICastingConnection;
+
+  interface ICastingConnectionErrorOccurredEventArgs {
+    readonly ErrorStatus: number;
+    readonly Message: string;
+  }
+  var ICastingConnectionErrorOccurredEventArgs: abstract new (...args: any[]) => ICastingConnectionErrorOccurredEventArgs;
+
+  interface ICastingDevice {
+    CreateCastingConnection(): Windows.Media.Casting.CastingConnection;
+    GetSupportedCastingPlaybackTypesAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly FriendlyName: string;
+    readonly Icon: Windows.Storage.Streams.IRandomAccessStreamWithContentType;
+    readonly Id: string;
+  }
+  var ICastingDevice: abstract new (...args: any[]) => ICastingDevice;
+
+  interface ICastingDevicePicker {
+    Hide(): void;
+    Show(selection: Windows.Foundation.Rect): void;
+    Show(selection: Windows.Foundation.Rect, preferredPlacement: number): void;
+    readonly Appearance: Windows.Devices.Enumeration.DevicePickerAppearance;
+    readonly Filter: Windows.Media.Casting.CastingDevicePickerFilter;
+    CastingDevicePickerDismissed: Windows.Foundation.TypedEventHandler<Windows.Media.Casting.CastingDevicePicker, Object> | null;
+    CastingDeviceSelected: Windows.Foundation.TypedEventHandler<Windows.Media.Casting.CastingDevicePicker, Windows.Media.Casting.CastingDeviceSelectedEventArgs> | null;
+  }
+  var ICastingDevicePicker: abstract new (...args: any[]) => ICastingDevicePicker;
+
+  interface ICastingDevicePickerFilter {
+    readonly SupportedCastingSources: Windows.Foundation.Collections.IVector<Windows.Media.Casting.CastingSource> | Windows.Media.Casting.CastingSource[];
+    SupportsAudio: boolean;
+    SupportsPictures: boolean;
+    SupportsVideo: boolean;
+  }
+  var ICastingDevicePickerFilter: abstract new (...args: any[]) => ICastingDevicePickerFilter;
+
+  interface ICastingDeviceSelectedEventArgs {
+    readonly SelectedCastingDevice: Windows.Media.Casting.CastingDevice;
+  }
+  var ICastingDeviceSelectedEventArgs: abstract new (...args: any[]) => ICastingDeviceSelectedEventArgs;
+
+  interface ICastingDeviceStatics {
+    DeviceInfoSupportsCastingAsync(device: Windows.Devices.Enumeration.DeviceInformation): Windows.Foundation.IAsyncOperation<boolean>;
+    FromIdAsync(value: string): Windows.Foundation.IAsyncOperation<Windows.Media.Casting.CastingDevice>;
+    GetDeviceSelector(type: number): string;
+    GetDeviceSelectorFromCastingSourceAsync(castingSource: Windows.Media.Casting.CastingSource): Windows.Foundation.IAsyncOperation<string>;
+  }
+  var ICastingDeviceStatics: abstract new (...args: any[]) => ICastingDeviceStatics;
+
+  interface ICastingSource {
+    PreferredSourceUri: Windows.Foundation.Uri;
+  }
+  var ICastingSource: abstract new (...args: any[]) => ICastingSource;
+
+}
+
+declare namespace Windows.Media.ClosedCaptioning {
+  class ClosedCaptionProperties {
+    static readonly BackgroundColor: number;
+    static readonly BackgroundOpacity: number;
+    static readonly ComputedBackgroundColor: Windows.UI.Color;
+    static readonly ComputedFontColor: Windows.UI.Color;
+    static readonly ComputedRegionColor: Windows.UI.Color;
+    static readonly FontColor: number;
+    static readonly FontEffect: number;
+    static readonly FontOpacity: number;
+    static readonly FontSize: number;
+    static readonly FontStyle: number;
+    static readonly RegionColor: number;
+    static readonly RegionOpacity: number;
+    static PropertiesChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  enum ClosedCaptionColor {
+    Default = 0,
+    White = 1,
+    Black = 2,
+    Red = 3,
+    Green = 4,
+    Blue = 5,
+    Yellow = 6,
+    Magenta = 7,
+    Cyan = 8,
+  }
+
+  enum ClosedCaptionEdgeEffect {
+    Default = 0,
+    None = 1,
+    Raised = 2,
+    Depressed = 3,
+    Uniform = 4,
+    DropShadow = 5,
+  }
+
+  enum ClosedCaptionOpacity {
+    Default = 0,
+    OneHundredPercent = 1,
+    SeventyFivePercent = 2,
+    TwentyFivePercent = 3,
+    ZeroPercent = 4,
+  }
+
+  enum ClosedCaptionSize {
+    Default = 0,
+    FiftyPercent = 1,
+    OneHundredPercent = 2,
+    OneHundredFiftyPercent = 3,
+    TwoHundredPercent = 4,
+  }
+
+  enum ClosedCaptionStyle {
+    Default = 0,
+    MonospacedWithSerifs = 1,
+    ProportionalWithSerifs = 2,
+    MonospacedWithoutSerifs = 3,
+    ProportionalWithoutSerifs = 4,
+    Casual = 5,
+    Cursive = 6,
+    SmallCapitals = 7,
+  }
+
+  interface IClosedCaptionPropertiesStatics {
+    readonly BackgroundColor: number;
+    readonly BackgroundOpacity: number;
+    readonly ComputedBackgroundColor: Windows.UI.Color;
+    readonly ComputedFontColor: Windows.UI.Color;
+    readonly ComputedRegionColor: Windows.UI.Color;
+    readonly FontColor: number;
+    readonly FontEffect: number;
+    readonly FontOpacity: number;
+    readonly FontSize: number;
+    readonly FontStyle: number;
+    readonly RegionColor: number;
+    readonly RegionOpacity: number;
+  }
+  var IClosedCaptionPropertiesStatics: abstract new (...args: any[]) => IClosedCaptionPropertiesStatics;
+
+  interface IClosedCaptionPropertiesStatics2 {
+    PropertiesChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IClosedCaptionPropertiesStatics2: abstract new (...args: any[]) => IClosedCaptionPropertiesStatics2;
+
+}
+
+declare namespace Windows.Media.ContentRestrictions {
+  class ContentRestrictionsBrowsePolicy implements Windows.Media.ContentRestrictions.IContentRestrictionsBrowsePolicy {
+    readonly GeographicRegion: string;
+    readonly MaxBrowsableAgeRating: number | null;
+    readonly PreferredAgeRating: number | null;
+  }
+
+  class RatedContentDescription implements Windows.Media.ContentRestrictions.IRatedContentDescription {
+    constructor(id: string, title: string, category: number);
+    Category: number;
+    Id: string;
+    Image: Windows.Storage.Streams.IRandomAccessStreamReference;
+    Ratings: Windows.Foundation.Collections.IVector<string> | string[];
+    Title: string;
+  }
+
+  class RatedContentRestrictions implements Windows.Media.ContentRestrictions.IRatedContentRestrictions {
+    constructor(maxAgeRating: number);
+    constructor();
+    GetBrowsePolicyAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.ContentRestrictions.ContentRestrictionsBrowsePolicy>;
+    GetRestrictionLevelAsync(RatedContentDescription: Windows.Media.ContentRestrictions.RatedContentDescription): Windows.Foundation.IAsyncOperation<number>;
+    RequestContentAccessAsync(RatedContentDescription: Windows.Media.ContentRestrictions.RatedContentDescription): Windows.Foundation.IAsyncOperation<boolean>;
+    RestrictionsChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  enum ContentAccessRestrictionLevel {
+    Allow = 0,
+    Warn = 1,
+    Block = 2,
+    Hide = 3,
+  }
+
+  enum RatedContentCategory {
+    General = 0,
+    Application = 1,
+    Game = 2,
+    Movie = 3,
+    Television = 4,
+    Music = 5,
+  }
+
+  interface IContentRestrictionsBrowsePolicy {
+    readonly GeographicRegion: string;
+    readonly MaxBrowsableAgeRating: number | null;
+    readonly PreferredAgeRating: number | null;
+  }
+  var IContentRestrictionsBrowsePolicy: abstract new (...args: any[]) => IContentRestrictionsBrowsePolicy;
+
+  interface IRatedContentDescription {
+    Category: number;
+    Id: string;
+    Image: Windows.Storage.Streams.IRandomAccessStreamReference;
+    Ratings: Windows.Foundation.Collections.IVector<string> | string[];
+    Title: string;
+  }
+  var IRatedContentDescription: abstract new (...args: any[]) => IRatedContentDescription;
+
+  interface IRatedContentDescriptionFactory {
+    Create(id: string, title: string, category: number): Windows.Media.ContentRestrictions.RatedContentDescription;
+  }
+  var IRatedContentDescriptionFactory: abstract new (...args: any[]) => IRatedContentDescriptionFactory;
+
+  interface IRatedContentRestrictions {
+    GetBrowsePolicyAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.ContentRestrictions.ContentRestrictionsBrowsePolicy>;
+    GetRestrictionLevelAsync(RatedContentDescription: Windows.Media.ContentRestrictions.RatedContentDescription): Windows.Foundation.IAsyncOperation<number>;
+    RequestContentAccessAsync(RatedContentDescription: Windows.Media.ContentRestrictions.RatedContentDescription): Windows.Foundation.IAsyncOperation<boolean>;
+    RestrictionsChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IRatedContentRestrictions: abstract new (...args: any[]) => IRatedContentRestrictions;
+
+  interface IRatedContentRestrictionsFactory {
+    CreateWithMaxAgeRating(maxAgeRating: number): Windows.Media.ContentRestrictions.RatedContentRestrictions;
+  }
+  var IRatedContentRestrictionsFactory: abstract new (...args: any[]) => IRatedContentRestrictionsFactory;
+
+}
+
+declare namespace Windows.Media.Control {
+  class CurrentSessionChangedEventArgs implements Windows.Media.Control.ICurrentSessionChangedEventArgs {
+  }
+
+  class GlobalSystemMediaTransportControlsSession implements Windows.Media.Control.IGlobalSystemMediaTransportControlsSession {
+    GetPlaybackInfo(): Windows.Media.Control.GlobalSystemMediaTransportControlsSessionPlaybackInfo;
+    GetTimelineProperties(): Windows.Media.Control.GlobalSystemMediaTransportControlsSessionTimelineProperties;
+    TryChangeAutoRepeatModeAsync(requestedAutoRepeatMode: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryChangeChannelDownAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryChangeChannelUpAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryChangePlaybackPositionAsync(requestedPlaybackPosition: number | bigint): Windows.Foundation.IAsyncOperation<boolean>;
+    TryChangePlaybackRateAsync(requestedPlaybackRate: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryChangeShuffleActiveAsync(requestedShuffleState: boolean): Windows.Foundation.IAsyncOperation<boolean>;
+    TryFastForwardAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryGetMediaPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Control.GlobalSystemMediaTransportControlsSessionMediaProperties>;
+    TryPauseAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryPlayAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryRecordAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryRewindAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySkipNextAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySkipPreviousAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryStopAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryTogglePlayPauseAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly SourceAppUserModelId: string;
+    MediaPropertiesChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Control.GlobalSystemMediaTransportControlsSession, Windows.Media.Control.MediaPropertiesChangedEventArgs> | null;
+    PlaybackInfoChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Control.GlobalSystemMediaTransportControlsSession, Windows.Media.Control.PlaybackInfoChangedEventArgs> | null;
+    TimelinePropertiesChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Control.GlobalSystemMediaTransportControlsSession, Windows.Media.Control.TimelinePropertiesChangedEventArgs> | null;
+  }
+
+  class GlobalSystemMediaTransportControlsSessionManager implements Windows.Media.Control.IGlobalSystemMediaTransportControlsSessionManager {
+    GetCurrentSession(): Windows.Media.Control.GlobalSystemMediaTransportControlsSession;
+    GetSessions(): Windows.Foundation.Collections.IVectorView<Windows.Media.Control.GlobalSystemMediaTransportControlsSession> | Windows.Media.Control.GlobalSystemMediaTransportControlsSession[];
+    static RequestAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager>;
+    CurrentSessionChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager, Windows.Media.Control.CurrentSessionChangedEventArgs> | null;
+    SessionsChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager, Windows.Media.Control.SessionsChangedEventArgs> | null;
+  }
+
+  class GlobalSystemMediaTransportControlsSessionMediaProperties implements Windows.Media.Control.IGlobalSystemMediaTransportControlsSessionMediaProperties {
+    readonly AlbumArtist: string;
+    readonly AlbumTitle: string;
+    readonly AlbumTrackCount: number;
+    readonly Artist: string;
+    readonly Genres: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly PlaybackType: number | null;
+    readonly Subtitle: string;
+    readonly Thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly Title: string;
+    readonly TrackNumber: number;
+  }
+
+  class GlobalSystemMediaTransportControlsSessionPlaybackControls implements Windows.Media.Control.IGlobalSystemMediaTransportControlsSessionPlaybackControls {
+    readonly IsChannelDownEnabled: boolean;
+    readonly IsChannelUpEnabled: boolean;
+    readonly IsFastForwardEnabled: boolean;
+    readonly IsNextEnabled: boolean;
+    readonly IsPauseEnabled: boolean;
+    readonly IsPlayEnabled: boolean;
+    readonly IsPlayPauseToggleEnabled: boolean;
+    readonly IsPlaybackPositionEnabled: boolean;
+    readonly IsPlaybackRateEnabled: boolean;
+    readonly IsPreviousEnabled: boolean;
+    readonly IsRecordEnabled: boolean;
+    readonly IsRepeatEnabled: boolean;
+    readonly IsRewindEnabled: boolean;
+    readonly IsShuffleEnabled: boolean;
+    readonly IsStopEnabled: boolean;
+  }
+
+  class GlobalSystemMediaTransportControlsSessionPlaybackInfo implements Windows.Media.Control.IGlobalSystemMediaTransportControlsSessionPlaybackInfo {
+    readonly AutoRepeatMode: number | null;
+    readonly Controls: Windows.Media.Control.GlobalSystemMediaTransportControlsSessionPlaybackControls;
+    readonly IsShuffleActive: boolean | null;
+    readonly PlaybackRate: number | null;
+    readonly PlaybackStatus: number;
+    readonly PlaybackType: number | null;
+  }
+
+  class GlobalSystemMediaTransportControlsSessionTimelineProperties implements Windows.Media.Control.IGlobalSystemMediaTransportControlsSessionTimelineProperties {
+    readonly EndTime: Windows.Foundation.TimeSpan;
+    readonly LastUpdatedTime: Windows.Foundation.DateTime;
+    readonly MaxSeekTime: Windows.Foundation.TimeSpan;
+    readonly MinSeekTime: Windows.Foundation.TimeSpan;
+    readonly Position: Windows.Foundation.TimeSpan;
+    readonly StartTime: Windows.Foundation.TimeSpan;
+  }
+
+  class MediaPropertiesChangedEventArgs implements Windows.Media.Control.IMediaPropertiesChangedEventArgs {
+  }
+
+  class PlaybackInfoChangedEventArgs implements Windows.Media.Control.IPlaybackInfoChangedEventArgs {
+  }
+
+  class SessionsChangedEventArgs implements Windows.Media.Control.ISessionsChangedEventArgs {
+  }
+
+  class TimelinePropertiesChangedEventArgs implements Windows.Media.Control.ITimelinePropertiesChangedEventArgs {
+  }
+
+  enum GlobalSystemMediaTransportControlsSessionPlaybackStatus {
+    Closed = 0,
+    Opened = 1,
+    Changing = 2,
+    Stopped = 3,
+    Playing = 4,
+    Paused = 5,
+  }
+
+  interface ICurrentSessionChangedEventArgs {
+  }
+  var ICurrentSessionChangedEventArgs: abstract new (...args: any[]) => ICurrentSessionChangedEventArgs;
+
+  interface IGlobalSystemMediaTransportControlsSession {
+    GetPlaybackInfo(): Windows.Media.Control.GlobalSystemMediaTransportControlsSessionPlaybackInfo;
+    GetTimelineProperties(): Windows.Media.Control.GlobalSystemMediaTransportControlsSessionTimelineProperties;
+    TryChangeAutoRepeatModeAsync(requestedAutoRepeatMode: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryChangeChannelDownAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryChangeChannelUpAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryChangePlaybackPositionAsync(requestedPlaybackPosition: number | bigint): Windows.Foundation.IAsyncOperation<boolean>;
+    TryChangePlaybackRateAsync(requestedPlaybackRate: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryChangeShuffleActiveAsync(requestedShuffleState: boolean): Windows.Foundation.IAsyncOperation<boolean>;
+    TryFastForwardAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryGetMediaPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Control.GlobalSystemMediaTransportControlsSessionMediaProperties>;
+    TryPauseAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryPlayAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryRecordAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryRewindAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySkipNextAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySkipPreviousAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryStopAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryTogglePlayPauseAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly SourceAppUserModelId: string;
+    MediaPropertiesChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Control.GlobalSystemMediaTransportControlsSession, Windows.Media.Control.MediaPropertiesChangedEventArgs> | null;
+    PlaybackInfoChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Control.GlobalSystemMediaTransportControlsSession, Windows.Media.Control.PlaybackInfoChangedEventArgs> | null;
+    TimelinePropertiesChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Control.GlobalSystemMediaTransportControlsSession, Windows.Media.Control.TimelinePropertiesChangedEventArgs> | null;
+  }
+  var IGlobalSystemMediaTransportControlsSession: abstract new (...args: any[]) => IGlobalSystemMediaTransportControlsSession;
+
+  interface IGlobalSystemMediaTransportControlsSessionManager {
+    GetCurrentSession(): Windows.Media.Control.GlobalSystemMediaTransportControlsSession;
+    GetSessions(): Windows.Foundation.Collections.IVectorView<Windows.Media.Control.GlobalSystemMediaTransportControlsSession> | Windows.Media.Control.GlobalSystemMediaTransportControlsSession[];
+    CurrentSessionChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager, Windows.Media.Control.CurrentSessionChangedEventArgs> | null;
+    SessionsChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager, Windows.Media.Control.SessionsChangedEventArgs> | null;
+  }
+  var IGlobalSystemMediaTransportControlsSessionManager: abstract new (...args: any[]) => IGlobalSystemMediaTransportControlsSessionManager;
+
+  interface IGlobalSystemMediaTransportControlsSessionManagerStatics {
+    RequestAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Control.GlobalSystemMediaTransportControlsSessionManager>;
+  }
+  var IGlobalSystemMediaTransportControlsSessionManagerStatics: abstract new (...args: any[]) => IGlobalSystemMediaTransportControlsSessionManagerStatics;
+
+  interface IGlobalSystemMediaTransportControlsSessionMediaProperties {
+    readonly AlbumArtist: string;
+    readonly AlbumTitle: string;
+    readonly AlbumTrackCount: number;
+    readonly Artist: string;
+    readonly Genres: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly PlaybackType: number | null;
+    readonly Subtitle: string;
+    readonly Thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly Title: string;
+    readonly TrackNumber: number;
+  }
+  var IGlobalSystemMediaTransportControlsSessionMediaProperties: abstract new (...args: any[]) => IGlobalSystemMediaTransportControlsSessionMediaProperties;
+
+  interface IGlobalSystemMediaTransportControlsSessionPlaybackControls {
+    readonly IsChannelDownEnabled: boolean;
+    readonly IsChannelUpEnabled: boolean;
+    readonly IsFastForwardEnabled: boolean;
+    readonly IsNextEnabled: boolean;
+    readonly IsPauseEnabled: boolean;
+    readonly IsPlayEnabled: boolean;
+    readonly IsPlayPauseToggleEnabled: boolean;
+    readonly IsPlaybackPositionEnabled: boolean;
+    readonly IsPlaybackRateEnabled: boolean;
+    readonly IsPreviousEnabled: boolean;
+    readonly IsRecordEnabled: boolean;
+    readonly IsRepeatEnabled: boolean;
+    readonly IsRewindEnabled: boolean;
+    readonly IsShuffleEnabled: boolean;
+    readonly IsStopEnabled: boolean;
+  }
+  var IGlobalSystemMediaTransportControlsSessionPlaybackControls: abstract new (...args: any[]) => IGlobalSystemMediaTransportControlsSessionPlaybackControls;
+
+  interface IGlobalSystemMediaTransportControlsSessionPlaybackInfo {
+    readonly AutoRepeatMode: number | null;
+    readonly Controls: Windows.Media.Control.GlobalSystemMediaTransportControlsSessionPlaybackControls;
+    readonly IsShuffleActive: boolean | null;
+    readonly PlaybackRate: number | null;
+    readonly PlaybackStatus: number;
+    readonly PlaybackType: number | null;
+  }
+  var IGlobalSystemMediaTransportControlsSessionPlaybackInfo: abstract new (...args: any[]) => IGlobalSystemMediaTransportControlsSessionPlaybackInfo;
+
+  interface IGlobalSystemMediaTransportControlsSessionTimelineProperties {
+    readonly EndTime: Windows.Foundation.TimeSpan;
+    readonly LastUpdatedTime: Windows.Foundation.DateTime;
+    readonly MaxSeekTime: Windows.Foundation.TimeSpan;
+    readonly MinSeekTime: Windows.Foundation.TimeSpan;
+    readonly Position: Windows.Foundation.TimeSpan;
+    readonly StartTime: Windows.Foundation.TimeSpan;
+  }
+  var IGlobalSystemMediaTransportControlsSessionTimelineProperties: abstract new (...args: any[]) => IGlobalSystemMediaTransportControlsSessionTimelineProperties;
+
+  interface IMediaPropertiesChangedEventArgs {
+  }
+  var IMediaPropertiesChangedEventArgs: abstract new (...args: any[]) => IMediaPropertiesChangedEventArgs;
+
+  interface IPlaybackInfoChangedEventArgs {
+  }
+  var IPlaybackInfoChangedEventArgs: abstract new (...args: any[]) => IPlaybackInfoChangedEventArgs;
+
+  interface ISessionsChangedEventArgs {
+  }
+  var ISessionsChangedEventArgs: abstract new (...args: any[]) => ISessionsChangedEventArgs;
+
+  interface ITimelinePropertiesChangedEventArgs {
+  }
+  var ITimelinePropertiesChangedEventArgs: abstract new (...args: any[]) => ITimelinePropertiesChangedEventArgs;
+
+}
+
+declare namespace Windows.Media.Core {
+  class AudioStreamDescriptor implements Windows.Media.Core.IAudioStreamDescriptor, Windows.Media.Core.IAudioStreamDescriptor2, Windows.Media.Core.IAudioStreamDescriptor3, Windows.Media.Core.IMediaStreamDescriptor, Windows.Media.Core.IMediaStreamDescriptor2 {
+    constructor(encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties);
+    Copy(): Windows.Media.Core.AudioStreamDescriptor;
+    readonly EncodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties;
+    readonly IsSelected: boolean;
+    Label: string;
+    Language: string;
+    LeadingEncoderPadding: number | null;
+    Name: string;
+    TrailingEncoderPadding: number | null;
+  }
+
+  class AudioTrack implements Windows.Media.Core.IAudioTrack, Windows.Media.Core.IMediaTrack {
+    GetEncodingProperties(): Windows.Media.MediaProperties.AudioEncodingProperties;
+    readonly Id: string;
+    Label: string;
+    readonly Language: string;
+    readonly Name: string;
+    readonly PlaybackItem: Windows.Media.Playback.MediaPlaybackItem;
+    readonly SupportInfo: Windows.Media.Core.AudioTrackSupportInfo;
+    readonly TrackKind: number;
+    OpenFailed: Windows.Foundation.TypedEventHandler<Windows.Media.Core.AudioTrack, Windows.Media.Core.AudioTrackOpenFailedEventArgs> | null;
+  }
+
+  class AudioTrackOpenFailedEventArgs implements Windows.Media.Core.IAudioTrackOpenFailedEventArgs {
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+
+  class AudioTrackSupportInfo implements Windows.Media.Core.IAudioTrackSupportInfo {
+    readonly DecoderStatus: number;
+    readonly Degradation: number;
+    readonly DegradationReason: number;
+    readonly MediaSourceStatus: number;
+  }
+
+  class ChapterCue implements Windows.Media.Core.IChapterCue, Windows.Media.Core.IMediaCue {
+    constructor();
+    Duration: Windows.Foundation.TimeSpan;
+    Id: string;
+    StartTime: Windows.Foundation.TimeSpan;
+    Title: string;
+  }
+
+  class CodecInfo implements Windows.Media.Core.ICodecInfo {
+    readonly Category: number;
+    readonly DisplayName: string;
+    readonly IsTrusted: boolean;
+    readonly Kind: number;
+    readonly Subtypes: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+
+  class CodecQuery implements Windows.Media.Core.ICodecQuery {
+    constructor();
+    FindAllAsync(kind: number, category: number, subType: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Media.Core.CodecInfo> | Windows.Media.Core.CodecInfo[]>;
+  }
+
+  class CodecSubtypes {
+    static readonly AudioFormatAac: string;
+    static readonly AudioFormatAdts: string;
+    static readonly AudioFormatAlac: string;
+    static readonly AudioFormatAmrNB: string;
+    static readonly AudioFormatAmrWB: string;
+    static readonly AudioFormatAmrWP: string;
+    static readonly AudioFormatDolbyAC3: string;
+    static readonly AudioFormatDolbyAC3Spdif: string;
+    static readonly AudioFormatDolbyDDPlus: string;
+    static readonly AudioFormatDrm: string;
+    static readonly AudioFormatDts: string;
+    static readonly AudioFormatFlac: string;
+    static readonly AudioFormatFloat: string;
+    static readonly AudioFormatMP3: string;
+    static readonly AudioFormatMPeg: string;
+    static readonly AudioFormatMsp1: string;
+    static readonly AudioFormatOpus: string;
+    static readonly AudioFormatPcm: string;
+    static readonly AudioFormatWMAudioLossless: string;
+    static readonly AudioFormatWMAudioV8: string;
+    static readonly AudioFormatWMAudioV9: string;
+    static readonly AudioFormatWmaSpdif: string;
+    static readonly VideoFormat420O: string;
+    static readonly VideoFormatDV25: string;
+    static readonly VideoFormatDV50: string;
+    static readonly VideoFormatDvc: string;
+    static readonly VideoFormatDvh1: string;
+    static readonly VideoFormatDvhD: string;
+    static readonly VideoFormatDvsd: string;
+    static readonly VideoFormatDvsl: string;
+    static readonly VideoFormatH263: string;
+    static readonly VideoFormatH264: string;
+    static readonly VideoFormatH264ES: string;
+    static readonly VideoFormatH265: string;
+    static readonly VideoFormatHevc: string;
+    static readonly VideoFormatHevcES: string;
+    static readonly VideoFormatM4S2: string;
+    static readonly VideoFormatMP43: string;
+    static readonly VideoFormatMP4S: string;
+    static readonly VideoFormatMP4V: string;
+    static readonly VideoFormatMjpg: string;
+    static readonly VideoFormatMpeg2: string;
+    static readonly VideoFormatMpg1: string;
+    static readonly VideoFormatMss1: string;
+    static readonly VideoFormatMss2: string;
+    static readonly VideoFormatVP80: string;
+    static readonly VideoFormatVP90: string;
+    static readonly VideoFormatWmv1: string;
+    static readonly VideoFormatWmv2: string;
+    static readonly VideoFormatWmv3: string;
+    static readonly VideoFormatWvc1: string;
+  }
+
+  class DataCue implements Windows.Media.Core.IDataCue, Windows.Media.Core.IDataCue2, Windows.Media.Core.IMediaCue {
+    constructor();
+    Data: Windows.Storage.Streams.IBuffer;
+    Duration: Windows.Foundation.TimeSpan;
+    Id: string;
+    readonly Properties: Windows.Foundation.Collections.PropertySet;
+    StartTime: Windows.Foundation.TimeSpan;
+  }
+
+  class FaceDetectedEventArgs implements Windows.Media.Core.IFaceDetectedEventArgs {
+    readonly ResultFrame: Windows.Media.Core.FaceDetectionEffectFrame;
+  }
+
+  class FaceDetectionEffect implements Windows.Media.Core.IFaceDetectionEffect, Windows.Media.IMediaExtension {
+    SetProperties(configuration: Windows.Foundation.Collections.IPropertySet): void;
+    DesiredDetectionInterval: Windows.Foundation.TimeSpan;
+    Enabled: boolean;
+    FaceDetected: Windows.Foundation.TypedEventHandler<Windows.Media.Core.FaceDetectionEffect, Windows.Media.Core.FaceDetectedEventArgs> | null;
+  }
+
+  class FaceDetectionEffectDefinition implements Windows.Media.Core.IFaceDetectionEffectDefinition, Windows.Media.Effects.IVideoEffectDefinition {
+    constructor();
+    readonly ActivatableClassId: string;
+    DetectionMode: number;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+    SynchronousDetectionEnabled: boolean;
+  }
+
+  class FaceDetectionEffectFrame implements Windows.Foundation.IClosable, Windows.Media.Core.IFaceDetectionEffectFrame, Windows.Media.IMediaFrame {
+    Close(): void;
+    readonly DetectedFaces: Windows.Foundation.Collections.IVectorView<Windows.Media.FaceAnalysis.DetectedFace> | Windows.Media.FaceAnalysis.DetectedFace[];
+    Duration: Windows.Foundation.TimeSpan | null;
+    readonly ExtendedProperties: Windows.Foundation.Collections.IPropertySet;
+    IsDiscontinuous: boolean;
+    readonly IsReadOnly: boolean;
+    RelativeTime: Windows.Foundation.TimeSpan | null;
+    SystemRelativeTime: Windows.Foundation.TimeSpan | null;
+    readonly Type: string;
+  }
+
+  class HighDynamicRangeControl implements Windows.Media.Core.IHighDynamicRangeControl {
+    Enabled: boolean;
+  }
+
+  class HighDynamicRangeOutput implements Windows.Media.Core.IHighDynamicRangeOutput {
+    readonly Certainty: number;
+    readonly FrameControllers: Windows.Foundation.Collections.IVectorView<Windows.Media.Devices.Core.FrameController> | Windows.Media.Devices.Core.FrameController[];
+  }
+
+  class ImageCue implements Windows.Media.Core.IImageCue, Windows.Media.Core.IMediaCue {
+    constructor();
+    Duration: Windows.Foundation.TimeSpan;
+    Extent: Windows.Media.Core.TimedTextSize;
+    Id: string;
+    Position: Windows.Media.Core.TimedTextPoint;
+    SoftwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap;
+    StartTime: Windows.Foundation.TimeSpan;
+  }
+
+  class InitializeMediaStreamSourceRequestedEventArgs implements Windows.Media.Core.IInitializeMediaStreamSourceRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly RandomAccessStream: Windows.Storage.Streams.IRandomAccessStream;
+    readonly Source: Windows.Media.Core.MediaStreamSource;
+  }
+
+  class LowLightFusion {
+    static FuseAsync(frameSet: Windows.Foundation.Collections.IIterable<Windows.Graphics.Imaging.SoftwareBitmap> | Windows.Graphics.Imaging.SoftwareBitmap[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Media.Core.LowLightFusionResult, number>;
+    static readonly MaxSupportedFrameCount: number;
+    static readonly SupportedBitmapPixelFormats: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class LowLightFusionResult implements Windows.Foundation.IClosable, Windows.Media.Core.ILowLightFusionResult {
+    Close(): void;
+    readonly Frame: Windows.Graphics.Imaging.SoftwareBitmap;
+  }
+
+  class MediaBinder implements Windows.Media.Core.IMediaBinder {
+    constructor();
+    readonly Source: Windows.Media.Core.MediaSource;
+    Token: string;
+    Binding: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaBinder, Windows.Media.Core.MediaBindingEventArgs> | null;
+  }
+
+  class MediaBindingEventArgs implements Windows.Media.Core.IMediaBindingEventArgs, Windows.Media.Core.IMediaBindingEventArgs2, Windows.Media.Core.IMediaBindingEventArgs3 {
+    GetDeferral(): Windows.Foundation.Deferral;
+    SetAdaptiveMediaSource(mediaSource: Windows.Media.Streaming.Adaptive.AdaptiveMediaSource): void;
+    SetDownloadOperation(downloadOperation: Windows.Networking.BackgroundTransfer.DownloadOperation): void;
+    SetStorageFile(file: Windows.Storage.IStorageFile): void;
+    SetStream(stream: Windows.Storage.Streams.IRandomAccessStream, contentType: string): void;
+    SetStreamReference(stream: Windows.Storage.Streams.IRandomAccessStreamReference, contentType: string): void;
+    SetUri(uri: Windows.Foundation.Uri): void;
+    readonly MediaBinder: Windows.Media.Core.MediaBinder;
+    Canceled: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaBindingEventArgs, Object> | null;
+  }
+
+  class MediaCueEventArgs implements Windows.Media.Core.IMediaCueEventArgs {
+    readonly Cue: Windows.Media.Core.IMediaCue;
+  }
+
+  class MediaSource implements Windows.Foundation.IClosable, Windows.Media.Core.IMediaSource2, Windows.Media.Core.IMediaSource3, Windows.Media.Core.IMediaSource4, Windows.Media.Core.IMediaSource5, Windows.Media.Playback.IMediaPlaybackSource {
+    Close(): void;
+    static CreateFromAdaptiveMediaSource(mediaSource: Windows.Media.Streaming.Adaptive.AdaptiveMediaSource): Windows.Media.Core.MediaSource;
+    static CreateFromDownloadOperation(downloadOperation: Windows.Networking.BackgroundTransfer.DownloadOperation): Windows.Media.Core.MediaSource;
+    static CreateFromIMediaSource(mediaSource: Windows.Media.Core.IMediaSource): Windows.Media.Core.MediaSource;
+    static CreateFromMediaBinder(binder: Windows.Media.Core.MediaBinder): Windows.Media.Core.MediaSource;
+    static CreateFromMediaFrameSource(frameSource: Windows.Media.Capture.Frames.MediaFrameSource): Windows.Media.Core.MediaSource;
+    static CreateFromMediaStreamSource(mediaSource: Windows.Media.Core.MediaStreamSource): Windows.Media.Core.MediaSource;
+    static CreateFromMseStreamSource(mediaSource: Windows.Media.Core.MseStreamSource): Windows.Media.Core.MediaSource;
+    static CreateFromStorageFile(file: Windows.Storage.IStorageFile): Windows.Media.Core.MediaSource;
+    static CreateFromStream(stream: Windows.Storage.Streams.IRandomAccessStream, contentType: string): Windows.Media.Core.MediaSource;
+    static CreateFromStreamReference(stream: Windows.Storage.Streams.IRandomAccessStreamReference, contentType: string): Windows.Media.Core.MediaSource;
+    static CreateFromUri(uri: Windows.Foundation.Uri): Windows.Media.Core.MediaSource;
+    OpenAsync(): Windows.Foundation.IAsyncAction;
+    Reset(): void;
+    readonly AdaptiveMediaSource: Windows.Media.Streaming.Adaptive.AdaptiveMediaSource;
+    readonly CustomProperties: Windows.Foundation.Collections.ValueSet;
+    readonly DownloadOperation: Windows.Networking.BackgroundTransfer.DownloadOperation;
+    readonly Duration: Windows.Foundation.TimeSpan | null;
+    readonly ExternalTimedMetadataTracks: Windows.Foundation.Collections.IObservableVector<Windows.Media.Core.TimedMetadataTrack>;
+    readonly ExternalTimedTextSources: Windows.Foundation.Collections.IObservableVector<Windows.Media.Core.TimedTextSource>;
+    readonly IsOpen: boolean;
+    readonly MediaStreamSource: Windows.Media.Core.MediaStreamSource;
+    readonly MseStreamSource: Windows.Media.Core.MseStreamSource;
+    readonly State: number;
+    readonly Uri: Windows.Foundation.Uri;
+    OpenOperationCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaSource, Windows.Media.Core.MediaSourceOpenOperationCompletedEventArgs> | null;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaSource, Windows.Media.Core.MediaSourceStateChangedEventArgs> | null;
+  }
+
+  class MediaSourceAppServiceConnection implements Windows.Media.Core.IMediaSourceAppServiceConnection {
+    constructor(appServiceConnection: Windows.ApplicationModel.AppService.AppServiceConnection);
+    Start(): void;
+    InitializeMediaStreamSourceRequested: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaSourceAppServiceConnection, Windows.Media.Core.InitializeMediaStreamSourceRequestedEventArgs> | null;
+  }
+
+  class MediaSourceError implements Windows.Media.Core.IMediaSourceError {
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+
+  class MediaSourceOpenOperationCompletedEventArgs implements Windows.Media.Core.IMediaSourceOpenOperationCompletedEventArgs {
+    readonly Error: Windows.Media.Core.MediaSourceError;
+  }
+
+  class MediaSourceStateChangedEventArgs implements Windows.Media.Core.IMediaSourceStateChangedEventArgs {
+    readonly NewState: number;
+    readonly OldState: number;
+  }
+
+  class MediaStreamSample implements Windows.Media.Core.IMediaStreamSample, Windows.Media.Core.IMediaStreamSample2 {
+    static CreateFromBuffer(buffer: Windows.Storage.Streams.IBuffer, timestamp: Windows.Foundation.TimeSpan): Windows.Media.Core.MediaStreamSample;
+    static CreateFromDirect3D11Surface(surface: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface, timestamp: Windows.Foundation.TimeSpan): Windows.Media.Core.MediaStreamSample;
+    static CreateFromStreamAsync(stream: Windows.Storage.Streams.IInputStream, count: number, timestamp: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Media.Core.MediaStreamSample>;
+    readonly Buffer: Windows.Storage.Streams.Buffer;
+    DecodeTimestamp: Windows.Foundation.TimeSpan;
+    readonly Direct3D11Surface: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface;
+    Discontinuous: boolean;
+    Duration: Windows.Foundation.TimeSpan;
+    readonly ExtendedProperties: Windows.Media.Core.MediaStreamSamplePropertySet;
+    KeyFrame: boolean;
+    readonly Protection: Windows.Media.Core.MediaStreamSampleProtectionProperties;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    Processed: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaStreamSample, Object> | null;
+  }
+
+  class MediaStreamSamplePropertySet {
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<Guid, Object>>;
+    GetView(): Windows.Foundation.Collections.IMapView<Guid, Object>;
+    HasKey(key: Guid): boolean;
+    Insert(key: Guid, value: Object): boolean;
+    Lookup(key: Guid): Object;
+    Remove(key: Guid): void;
+    readonly Size: number;
+  }
+
+  class MediaStreamSampleProtectionProperties implements Windows.Media.Core.IMediaStreamSampleProtectionProperties {
+    GetInitializationVector(value: number[]): void;
+    GetKeyIdentifier(value: number[]): void;
+    GetSubSampleMapping(value: number[]): void;
+    SetInitializationVector(value: number[]): void;
+    SetKeyIdentifier(value: number[]): void;
+    SetSubSampleMapping(value: number[]): void;
+  }
+
+  class MediaStreamSource implements Windows.Media.Core.IMediaSource, Windows.Media.Core.IMediaStreamSource, Windows.Media.Core.IMediaStreamSource2, Windows.Media.Core.IMediaStreamSource3, Windows.Media.Core.IMediaStreamSource4 {
+    constructor(descriptor: Windows.Media.Core.IMediaStreamDescriptor);
+    constructor(descriptor: Windows.Media.Core.IMediaStreamDescriptor, descriptor2: Windows.Media.Core.IMediaStreamDescriptor);
+    AddProtectionKey(streamDescriptor: Windows.Media.Core.IMediaStreamDescriptor, keyIdentifier: number[], licenseData: number[]): void;
+    AddStreamDescriptor(descriptor: Windows.Media.Core.IMediaStreamDescriptor): void;
+    NotifyError(errorStatus: number): void;
+    SetBufferedRange(startOffset: Windows.Foundation.TimeSpan, endOffset: Windows.Foundation.TimeSpan): void;
+    BufferTime: Windows.Foundation.TimeSpan;
+    CanSeek: boolean;
+    Duration: Windows.Foundation.TimeSpan;
+    IsLive: boolean;
+    MaxSupportedPlaybackRate: number | null;
+    MediaProtectionManager: Windows.Media.Protection.MediaProtectionManager;
+    readonly MusicProperties: Windows.Storage.FileProperties.MusicProperties;
+    Thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly VideoProperties: Windows.Storage.FileProperties.VideoProperties;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaStreamSource, Windows.Media.Core.MediaStreamSourceClosedEventArgs> | null;
+    Paused: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaStreamSource, Object> | null;
+    SampleRequested: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaStreamSource, Windows.Media.Core.MediaStreamSourceSampleRequestedEventArgs> | null;
+    Starting: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaStreamSource, Windows.Media.Core.MediaStreamSourceStartingEventArgs> | null;
+    SwitchStreamsRequested: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaStreamSource, Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestedEventArgs> | null;
+    SampleRendered: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaStreamSource, Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs> | null;
+  }
+
+  class MediaStreamSourceClosedEventArgs implements Windows.Media.Core.IMediaStreamSourceClosedEventArgs {
+    readonly Request: Windows.Media.Core.MediaStreamSourceClosedRequest;
+  }
+
+  class MediaStreamSourceClosedRequest implements Windows.Media.Core.IMediaStreamSourceClosedRequest {
+    readonly Reason: number;
+  }
+
+  class MediaStreamSourceSampleRenderedEventArgs implements Windows.Media.Core.IMediaStreamSourceSampleRenderedEventArgs {
+    readonly SampleLag: Windows.Foundation.TimeSpan;
+  }
+
+  class MediaStreamSourceSampleRequest implements Windows.Media.Core.IMediaStreamSourceSampleRequest {
+    GetDeferral(): Windows.Media.Core.MediaStreamSourceSampleRequestDeferral;
+    ReportSampleProgress(progress: number): void;
+    Sample: Windows.Media.Core.MediaStreamSample;
+    readonly StreamDescriptor: Windows.Media.Core.IMediaStreamDescriptor;
+  }
+
+  class MediaStreamSourceSampleRequestDeferral implements Windows.Media.Core.IMediaStreamSourceSampleRequestDeferral {
+    Complete(): void;
+  }
+
+  class MediaStreamSourceSampleRequestedEventArgs implements Windows.Media.Core.IMediaStreamSourceSampleRequestedEventArgs {
+    readonly Request: Windows.Media.Core.MediaStreamSourceSampleRequest;
+  }
+
+  class MediaStreamSourceStartingEventArgs implements Windows.Media.Core.IMediaStreamSourceStartingEventArgs {
+    readonly Request: Windows.Media.Core.MediaStreamSourceStartingRequest;
+  }
+
+  class MediaStreamSourceStartingRequest implements Windows.Media.Core.IMediaStreamSourceStartingRequest {
+    GetDeferral(): Windows.Media.Core.MediaStreamSourceStartingRequestDeferral;
+    SetActualStartPosition(position: Windows.Foundation.TimeSpan): void;
+    readonly StartPosition: Windows.Foundation.TimeSpan | null;
+  }
+
+  class MediaStreamSourceStartingRequestDeferral implements Windows.Media.Core.IMediaStreamSourceStartingRequestDeferral {
+    Complete(): void;
+  }
+
+  class MediaStreamSourceSwitchStreamsRequest implements Windows.Media.Core.IMediaStreamSourceSwitchStreamsRequest {
+    GetDeferral(): Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestDeferral;
+    readonly NewStreamDescriptor: Windows.Media.Core.IMediaStreamDescriptor;
+    readonly OldStreamDescriptor: Windows.Media.Core.IMediaStreamDescriptor;
+  }
+
+  class MediaStreamSourceSwitchStreamsRequestDeferral implements Windows.Media.Core.IMediaStreamSourceSwitchStreamsRequestDeferral {
+    Complete(): void;
+  }
+
+  class MediaStreamSourceSwitchStreamsRequestedEventArgs implements Windows.Media.Core.IMediaStreamSourceSwitchStreamsRequestedEventArgs {
+    readonly Request: Windows.Media.Core.MediaStreamSourceSwitchStreamsRequest;
+  }
+
+  class MseSourceBuffer implements Windows.Media.Core.IMseSourceBuffer {
+    Abort(): void;
+    AppendBuffer(buffer: Windows.Storage.Streams.IBuffer): void;
+    AppendStream(stream: Windows.Storage.Streams.IInputStream): void;
+    AppendStream(stream: Windows.Storage.Streams.IInputStream, maxSize: number | bigint): void;
+    Remove(start: Windows.Foundation.TimeSpan, end: Windows.Foundation.TimeSpan | null): void;
+    AppendWindowEnd: Windows.Foundation.TimeSpan | null;
+    AppendWindowStart: Windows.Foundation.TimeSpan;
+    readonly Buffered: Windows.Foundation.Collections.IVectorView<Windows.Media.Core.MseTimeRange> | Windows.Media.Core.MseTimeRange[];
+    readonly IsUpdating: boolean;
+    Mode: number;
+    TimestampOffset: Windows.Foundation.TimeSpan;
+    Aborted: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseSourceBuffer, Object> | null;
+    ErrorOccurred: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseSourceBuffer, Object> | null;
+    UpdateEnded: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseSourceBuffer, Object> | null;
+    UpdateStarting: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseSourceBuffer, Object> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseSourceBuffer, Object> | null;
+  }
+
+  class MseSourceBufferList implements Windows.Media.Core.IMseSourceBufferList {
+    readonly Buffers: Windows.Foundation.Collections.IVectorView<Windows.Media.Core.MseSourceBuffer> | Windows.Media.Core.MseSourceBuffer[];
+    SourceBufferAdded: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseSourceBufferList, Object> | null;
+    SourceBufferRemoved: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseSourceBufferList, Object> | null;
+  }
+
+  class MseStreamSource implements Windows.Media.Core.IMediaSource, Windows.Media.Core.IMseStreamSource, Windows.Media.Core.IMseStreamSource2 {
+    constructor();
+    AddSourceBuffer(mimeType: string): Windows.Media.Core.MseSourceBuffer;
+    EndOfStream(status: number): void;
+    static IsContentTypeSupported(contentType: string): boolean;
+    RemoveSourceBuffer(buffer: Windows.Media.Core.MseSourceBuffer): void;
+    readonly ActiveSourceBuffers: Windows.Media.Core.MseSourceBufferList;
+    Duration: Windows.Foundation.TimeSpan | null;
+    LiveSeekableRange: Windows.Media.Core.MseTimeRange | null;
+    readonly ReadyState: number;
+    readonly SourceBuffers: Windows.Media.Core.MseSourceBufferList;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseStreamSource, Object> | null;
+    Ended: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseStreamSource, Object> | null;
+    Opened: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseStreamSource, Object> | null;
+  }
+
+  class SceneAnalysisEffect implements Windows.Media.Core.ISceneAnalysisEffect, Windows.Media.IMediaExtension {
+    SetProperties(configuration: Windows.Foundation.Collections.IPropertySet): void;
+    DesiredAnalysisInterval: Windows.Foundation.TimeSpan;
+    readonly HighDynamicRangeAnalyzer: Windows.Media.Core.HighDynamicRangeControl;
+    SceneAnalyzed: Windows.Foundation.TypedEventHandler<Windows.Media.Core.SceneAnalysisEffect, Windows.Media.Core.SceneAnalyzedEventArgs> | null;
+  }
+
+  class SceneAnalysisEffectDefinition implements Windows.Media.Effects.IVideoEffectDefinition {
+    constructor();
+    readonly ActivatableClassId: string;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+  }
+
+  class SceneAnalysisEffectFrame implements Windows.Foundation.IClosable, Windows.Media.Core.ISceneAnalysisEffectFrame, Windows.Media.Core.ISceneAnalysisEffectFrame2, Windows.Media.IMediaFrame {
+    Close(): void;
+    readonly AnalysisRecommendation: number;
+    Duration: Windows.Foundation.TimeSpan | null;
+    readonly ExtendedProperties: Windows.Foundation.Collections.IPropertySet;
+    readonly FrameControlValues: Windows.Media.Capture.CapturedFrameControlValues;
+    readonly HighDynamicRange: Windows.Media.Core.HighDynamicRangeOutput;
+    IsDiscontinuous: boolean;
+    readonly IsReadOnly: boolean;
+    RelativeTime: Windows.Foundation.TimeSpan | null;
+    SystemRelativeTime: Windows.Foundation.TimeSpan | null;
+    readonly Type: string;
+  }
+
+  class SceneAnalyzedEventArgs implements Windows.Media.Core.ISceneAnalyzedEventArgs {
+    readonly ResultFrame: Windows.Media.Core.SceneAnalysisEffectFrame;
+  }
+
+  class SpeechCue implements Windows.Media.Core.IMediaCue, Windows.Media.Core.ISpeechCue {
+    constructor();
+    Duration: Windows.Foundation.TimeSpan;
+    EndPositionInInput: number | null;
+    Id: string;
+    StartPositionInInput: number | null;
+    StartTime: Windows.Foundation.TimeSpan;
+    Text: string;
+  }
+
+  class TimedMetadataStreamDescriptor implements Windows.Media.Core.IMediaStreamDescriptor, Windows.Media.Core.IMediaStreamDescriptor2, Windows.Media.Core.ITimedMetadataStreamDescriptor {
+    constructor(encodingProperties: Windows.Media.MediaProperties.TimedMetadataEncodingProperties);
+    Copy(): Windows.Media.Core.TimedMetadataStreamDescriptor;
+    readonly EncodingProperties: Windows.Media.MediaProperties.TimedMetadataEncodingProperties;
+    readonly IsSelected: boolean;
+    Label: string;
+    Language: string;
+    Name: string;
+  }
+
+  class TimedMetadataTrack implements Windows.Media.Core.IMediaTrack, Windows.Media.Core.ITimedMetadataTrack, Windows.Media.Core.ITimedMetadataTrack2 {
+    constructor(id: string, language: string, kind: number);
+    AddCue(cue: Windows.Media.Core.IMediaCue): void;
+    RemoveCue(cue: Windows.Media.Core.IMediaCue): void;
+    readonly ActiveCues: Windows.Foundation.Collections.IVectorView<Windows.Media.Core.IMediaCue> | Windows.Media.Core.IMediaCue[];
+    readonly Cues: Windows.Foundation.Collections.IVectorView<Windows.Media.Core.IMediaCue> | Windows.Media.Core.IMediaCue[];
+    readonly DispatchType: string;
+    readonly Id: string;
+    Label: string;
+    readonly Language: string;
+    readonly Name: string;
+    readonly PlaybackItem: Windows.Media.Playback.MediaPlaybackItem;
+    readonly TimedMetadataKind: number;
+    readonly TrackKind: number;
+    CueEntered: Windows.Foundation.TypedEventHandler<Windows.Media.Core.TimedMetadataTrack, Windows.Media.Core.MediaCueEventArgs> | null;
+    CueExited: Windows.Foundation.TypedEventHandler<Windows.Media.Core.TimedMetadataTrack, Windows.Media.Core.MediaCueEventArgs> | null;
+    TrackFailed: Windows.Foundation.TypedEventHandler<Windows.Media.Core.TimedMetadataTrack, Windows.Media.Core.TimedMetadataTrackFailedEventArgs> | null;
+  }
+
+  class TimedMetadataTrackError implements Windows.Media.Core.ITimedMetadataTrackError {
+    readonly ErrorCode: number;
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+
+  class TimedMetadataTrackFailedEventArgs implements Windows.Media.Core.ITimedMetadataTrackFailedEventArgs {
+    readonly Error: Windows.Media.Core.TimedMetadataTrackError;
+  }
+
+  class TimedTextBouten implements Windows.Media.Core.ITimedTextBouten {
+    Color: Windows.UI.Color;
+    Position: number;
+    Type: number;
+  }
+
+  class TimedTextCue implements Windows.Media.Core.IMediaCue, Windows.Media.Core.ITimedTextCue {
+    constructor();
+    CueRegion: Windows.Media.Core.TimedTextRegion;
+    CueStyle: Windows.Media.Core.TimedTextStyle;
+    Duration: Windows.Foundation.TimeSpan;
+    Id: string;
+    readonly Lines: Windows.Foundation.Collections.IVector<Windows.Media.Core.TimedTextLine> | Windows.Media.Core.TimedTextLine[];
+    StartTime: Windows.Foundation.TimeSpan;
+  }
+
+  class TimedTextLine implements Windows.Media.Core.ITimedTextLine {
+    constructor();
+    readonly Subformats: Windows.Foundation.Collections.IVector<Windows.Media.Core.TimedTextSubformat> | Windows.Media.Core.TimedTextSubformat[];
+    Text: string;
+  }
+
+  class TimedTextRegion implements Windows.Media.Core.ITimedTextRegion {
+    constructor();
+    Background: Windows.UI.Color;
+    DisplayAlignment: number;
+    Extent: Windows.Media.Core.TimedTextSize;
+    IsOverflowClipped: boolean;
+    LineHeight: Windows.Media.Core.TimedTextDouble;
+    Name: string;
+    Padding: Windows.Media.Core.TimedTextPadding;
+    Position: Windows.Media.Core.TimedTextPoint;
+    ScrollMode: number;
+    TextWrapping: number;
+    WritingMode: number;
+    ZIndex: number;
+  }
+
+  class TimedTextRuby implements Windows.Media.Core.ITimedTextRuby {
+    Align: number;
+    Position: number;
+    Reserve: number;
+    Text: string;
+  }
+
+  class TimedTextSource implements Windows.Media.Core.ITimedTextSource {
+    static CreateFromStream(stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Media.Core.TimedTextSource;
+    static CreateFromStream(stream: Windows.Storage.Streams.IRandomAccessStream, defaultLanguage: string): Windows.Media.Core.TimedTextSource;
+    static CreateFromStreamWithIndex(stream: Windows.Storage.Streams.IRandomAccessStream, indexStream: Windows.Storage.Streams.IRandomAccessStream): Windows.Media.Core.TimedTextSource;
+    static CreateFromStreamWithIndex(stream: Windows.Storage.Streams.IRandomAccessStream, indexStream: Windows.Storage.Streams.IRandomAccessStream, defaultLanguage: string): Windows.Media.Core.TimedTextSource;
+    static CreateFromUri(uri: Windows.Foundation.Uri): Windows.Media.Core.TimedTextSource;
+    static CreateFromUri(uri: Windows.Foundation.Uri, defaultLanguage: string): Windows.Media.Core.TimedTextSource;
+    static CreateFromUriWithIndex(uri: Windows.Foundation.Uri, indexUri: Windows.Foundation.Uri): Windows.Media.Core.TimedTextSource;
+    static CreateFromUriWithIndex(uri: Windows.Foundation.Uri, indexUri: Windows.Foundation.Uri, defaultLanguage: string): Windows.Media.Core.TimedTextSource;
+    Resolved: Windows.Foundation.TypedEventHandler<Windows.Media.Core.TimedTextSource, Windows.Media.Core.TimedTextSourceResolveResultEventArgs> | null;
+  }
+
+  class TimedTextSourceResolveResultEventArgs implements Windows.Media.Core.ITimedTextSourceResolveResultEventArgs {
+    readonly Error: Windows.Media.Core.TimedMetadataTrackError;
+    readonly Tracks: Windows.Foundation.Collections.IVectorView<Windows.Media.Core.TimedMetadataTrack> | Windows.Media.Core.TimedMetadataTrack[];
+  }
+
+  class TimedTextStyle implements Windows.Media.Core.ITimedTextStyle, Windows.Media.Core.ITimedTextStyle2, Windows.Media.Core.ITimedTextStyle3 {
+    constructor();
+    Background: Windows.UI.Color;
+    readonly Bouten: Windows.Media.Core.TimedTextBouten;
+    FlowDirection: number;
+    FontAngleInDegrees: number;
+    FontFamily: string;
+    FontSize: Windows.Media.Core.TimedTextDouble;
+    FontStyle: number;
+    FontWeight: number;
+    Foreground: Windows.UI.Color;
+    IsBackgroundAlwaysShown: boolean;
+    IsLineThroughEnabled: boolean;
+    IsOverlineEnabled: boolean;
+    IsTextCombined: boolean;
+    IsUnderlineEnabled: boolean;
+    LineAlignment: number;
+    Name: string;
+    OutlineColor: Windows.UI.Color;
+    OutlineRadius: Windows.Media.Core.TimedTextDouble;
+    OutlineThickness: Windows.Media.Core.TimedTextDouble;
+    readonly Ruby: Windows.Media.Core.TimedTextRuby;
+  }
+
+  class TimedTextSubformat implements Windows.Media.Core.ITimedTextSubformat {
+    constructor();
+    Length: number;
+    StartIndex: number;
+    SubformatStyle: Windows.Media.Core.TimedTextStyle;
+  }
+
+  class VideoStabilizationEffect implements Windows.Media.Core.IVideoStabilizationEffect, Windows.Media.IMediaExtension {
+    GetRecommendedStreamConfiguration(controller: Windows.Media.Devices.VideoDeviceController, desiredProperties: Windows.Media.MediaProperties.VideoEncodingProperties): Windows.Media.Capture.VideoStreamConfiguration;
+    SetProperties(configuration: Windows.Foundation.Collections.IPropertySet): void;
+    Enabled: boolean;
+    EnabledChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Core.VideoStabilizationEffect, Windows.Media.Core.VideoStabilizationEffectEnabledChangedEventArgs> | null;
+  }
+
+  class VideoStabilizationEffectDefinition implements Windows.Media.Effects.IVideoEffectDefinition {
+    constructor();
+    readonly ActivatableClassId: string;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+  }
+
+  class VideoStabilizationEffectEnabledChangedEventArgs implements Windows.Media.Core.IVideoStabilizationEffectEnabledChangedEventArgs {
+    readonly Reason: number;
+  }
+
+  class VideoStreamDescriptor implements Windows.Media.Core.IMediaStreamDescriptor, Windows.Media.Core.IMediaStreamDescriptor2, Windows.Media.Core.IVideoStreamDescriptor, Windows.Media.Core.IVideoStreamDescriptor2 {
+    constructor(encodingProperties: Windows.Media.MediaProperties.VideoEncodingProperties);
+    Copy(): Windows.Media.Core.VideoStreamDescriptor;
+    readonly EncodingProperties: Windows.Media.MediaProperties.VideoEncodingProperties;
+    readonly IsSelected: boolean;
+    Label: string;
+    Language: string;
+    Name: string;
+  }
+
+  class VideoTrack implements Windows.Media.Core.IMediaTrack, Windows.Media.Core.IVideoTrack {
+    GetEncodingProperties(): Windows.Media.MediaProperties.VideoEncodingProperties;
+    readonly Id: string;
+    Label: string;
+    readonly Language: string;
+    readonly Name: string;
+    readonly PlaybackItem: Windows.Media.Playback.MediaPlaybackItem;
+    readonly SupportInfo: Windows.Media.Core.VideoTrackSupportInfo;
+    readonly TrackKind: number;
+    OpenFailed: Windows.Foundation.TypedEventHandler<Windows.Media.Core.VideoTrack, Windows.Media.Core.VideoTrackOpenFailedEventArgs> | null;
+  }
+
+  class VideoTrackOpenFailedEventArgs implements Windows.Media.Core.IVideoTrackOpenFailedEventArgs {
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+
+  class VideoTrackSupportInfo implements Windows.Media.Core.IVideoTrackSupportInfo {
+    readonly DecoderStatus: number;
+    readonly MediaSourceStatus: number;
+  }
+
+  enum AudioDecoderDegradation {
+    None = 0,
+    DownmixTo2Channels = 1,
+    DownmixTo6Channels = 2,
+    DownmixTo8Channels = 3,
+  }
+
+  enum AudioDecoderDegradationReason {
+    None = 0,
+    LicensingRequirement = 1,
+    SpatialAudioNotSupported = 2,
+  }
+
+  enum CodecCategory {
+    Encoder = 0,
+    Decoder = 1,
+  }
+
+  enum CodecKind {
+    Audio = 0,
+    Video = 1,
+  }
+
+  enum FaceDetectionMode {
+    HighPerformance = 0,
+    Balanced = 1,
+    HighQuality = 2,
+  }
+
+  enum MediaDecoderStatus {
+    FullySupported = 0,
+    UnsupportedSubtype = 1,
+    UnsupportedEncoderProperties = 2,
+    Degraded = 3,
+  }
+
+  enum MediaSourceState {
+    Initial = 0,
+    Opening = 1,
+    Opened = 2,
+    Failed = 3,
+    Closed = 4,
+  }
+
+  enum MediaSourceStatus {
+    FullySupported = 0,
+    Unknown = 1,
+  }
+
+  enum MediaStreamSourceClosedReason {
+    Done = 0,
+    UnknownError = 1,
+    AppReportedError = 2,
+    UnsupportedProtectionSystem = 3,
+    ProtectionSystemFailure = 4,
+    UnsupportedEncodingFormat = 5,
+    MissingSampleRequestedEventHandler = 6,
+  }
+
+  enum MediaStreamSourceErrorStatus {
+    Other = 0,
+    OutOfMemory = 1,
+    FailedToOpenFile = 2,
+    FailedToConnectToServer = 3,
+    ConnectionToServerLost = 4,
+    UnspecifiedNetworkError = 5,
+    DecodeError = 6,
+    UnsupportedMediaFormat = 7,
+  }
+
+  enum MediaTrackKind {
+    Audio = 0,
+    Video = 1,
+    TimedMetadata = 2,
+  }
+
+  enum MseAppendMode {
+    Segments = 0,
+    Sequence = 1,
+  }
+
+  enum MseEndOfStreamStatus {
+    Success = 0,
+    NetworkError = 1,
+    DecodeError = 2,
+    UnknownError = 3,
+  }
+
+  enum MseReadyState {
+    Closed = 0,
+    Open = 1,
+    Ended = 2,
+  }
+
+  enum SceneAnalysisRecommendation {
+    Standard = 0,
+    Hdr = 1,
+    LowLight = 2,
+  }
+
+  enum TimedMetadataKind {
+    Caption = 0,
+    Chapter = 1,
+    Custom = 2,
+    Data = 3,
+    Description = 4,
+    Subtitle = 5,
+    ImageSubtitle = 6,
+    Speech = 7,
+  }
+
+  enum TimedMetadataTrackErrorCode {
+    None = 0,
+    DataFormatError = 1,
+    NetworkError = 2,
+    InternalError = 3,
+  }
+
+  enum TimedTextBoutenPosition {
+    Before = 0,
+    After = 1,
+    Outside = 2,
+  }
+
+  enum TimedTextBoutenType {
+    None = 0,
+    Auto = 1,
+    FilledCircle = 2,
+    OpenCircle = 3,
+    FilledDot = 4,
+    OpenDot = 5,
+    FilledSesame = 6,
+    OpenSesame = 7,
+  }
+
+  enum TimedTextDisplayAlignment {
+    Before = 0,
+    After = 1,
+    Center = 2,
+  }
+
+  enum TimedTextFlowDirection {
+    LeftToRight = 0,
+    RightToLeft = 1,
+  }
+
+  enum TimedTextFontStyle {
+    Normal = 0,
+    Oblique = 1,
+    Italic = 2,
+  }
+
+  enum TimedTextLineAlignment {
+    Start = 0,
+    End = 1,
+    Center = 2,
+  }
+
+  enum TimedTextRubyAlign {
+    Center = 0,
+    Start = 1,
+    End = 2,
+    SpaceAround = 3,
+    SpaceBetween = 4,
+    WithBase = 5,
+  }
+
+  enum TimedTextRubyPosition {
+    Before = 0,
+    After = 1,
+    Outside = 2,
+  }
+
+  enum TimedTextRubyReserve {
+    None = 0,
+    Before = 1,
+    After = 2,
+    Both = 3,
+    Outside = 4,
+  }
+
+  enum TimedTextScrollMode {
+    Popon = 0,
+    Rollup = 1,
+  }
+
+  enum TimedTextUnit {
+    Pixels = 0,
+    Percentage = 1,
+  }
+
+  enum TimedTextWeight {
+    Normal = 400,
+    Bold = 700,
+  }
+
+  enum TimedTextWrapping {
+    NoWrap = 0,
+    Wrap = 1,
+  }
+
+  enum TimedTextWritingMode {
+    LeftRightTopBottom = 0,
+    RightLeftTopBottom = 1,
+    TopBottomRightLeft = 2,
+    TopBottomLeftRight = 3,
+    LeftRight = 4,
+    RightLeft = 5,
+    TopBottom = 6,
+  }
+
+  enum VideoStabilizationEffectEnabledChangedReason {
+    Programmatic = 0,
+    PixelRateTooHigh = 1,
+    RunningSlowly = 2,
+  }
+
+  interface IAudioStreamDescriptor extends Windows.Media.Core.IMediaStreamDescriptor {
+    readonly EncodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties;
+  }
+  var IAudioStreamDescriptor: abstract new (...args: any[]) => IAudioStreamDescriptor;
+
+  interface IAudioStreamDescriptor2 extends Windows.Media.Core.IMediaStreamDescriptor {
+    LeadingEncoderPadding: number | null;
+    TrailingEncoderPadding: number | null;
+  }
+  var IAudioStreamDescriptor2: abstract new (...args: any[]) => IAudioStreamDescriptor2;
+
+  interface IAudioStreamDescriptor3 {
+    Copy(): Windows.Media.Core.AudioStreamDescriptor;
+  }
+  var IAudioStreamDescriptor3: abstract new (...args: any[]) => IAudioStreamDescriptor3;
+
+  interface IAudioStreamDescriptorFactory {
+    Create(encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties): Windows.Media.Core.AudioStreamDescriptor;
+  }
+  var IAudioStreamDescriptorFactory: abstract new (...args: any[]) => IAudioStreamDescriptorFactory;
+
+  interface IAudioTrack {
+    GetEncodingProperties(): Windows.Media.MediaProperties.AudioEncodingProperties;
+    readonly Name: string;
+    readonly PlaybackItem: Windows.Media.Playback.MediaPlaybackItem;
+    readonly SupportInfo: Windows.Media.Core.AudioTrackSupportInfo;
+    OpenFailed: Windows.Foundation.TypedEventHandler<Windows.Media.Core.AudioTrack, Windows.Media.Core.AudioTrackOpenFailedEventArgs> | null;
+  }
+  var IAudioTrack: abstract new (...args: any[]) => IAudioTrack;
+
+  interface IAudioTrackOpenFailedEventArgs {
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+  var IAudioTrackOpenFailedEventArgs: abstract new (...args: any[]) => IAudioTrackOpenFailedEventArgs;
+
+  interface IAudioTrackSupportInfo {
+    readonly DecoderStatus: number;
+    readonly Degradation: number;
+    readonly DegradationReason: number;
+    readonly MediaSourceStatus: number;
+  }
+  var IAudioTrackSupportInfo: abstract new (...args: any[]) => IAudioTrackSupportInfo;
+
+  interface IChapterCue extends Windows.Media.Core.IMediaCue {
+    Title: string;
+  }
+  var IChapterCue: abstract new (...args: any[]) => IChapterCue;
+
+  interface ICodecInfo {
+    readonly Category: number;
+    readonly DisplayName: string;
+    readonly IsTrusted: boolean;
+    readonly Kind: number;
+    readonly Subtypes: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var ICodecInfo: abstract new (...args: any[]) => ICodecInfo;
+
+  interface ICodecQuery {
+    FindAllAsync(kind: number, category: number, subType: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Media.Core.CodecInfo> | Windows.Media.Core.CodecInfo[]>;
+  }
+  var ICodecQuery: abstract new (...args: any[]) => ICodecQuery;
+
+  interface ICodecSubtypesStatics {
+    readonly AudioFormatAac: string;
+    readonly AudioFormatAdts: string;
+    readonly AudioFormatAlac: string;
+    readonly AudioFormatAmrNB: string;
+    readonly AudioFormatAmrWB: string;
+    readonly AudioFormatAmrWP: string;
+    readonly AudioFormatDolbyAC3: string;
+    readonly AudioFormatDolbyAC3Spdif: string;
+    readonly AudioFormatDolbyDDPlus: string;
+    readonly AudioFormatDrm: string;
+    readonly AudioFormatDts: string;
+    readonly AudioFormatFlac: string;
+    readonly AudioFormatFloat: string;
+    readonly AudioFormatMP3: string;
+    readonly AudioFormatMPeg: string;
+    readonly AudioFormatMsp1: string;
+    readonly AudioFormatOpus: string;
+    readonly AudioFormatPcm: string;
+    readonly AudioFormatWMAudioLossless: string;
+    readonly AudioFormatWMAudioV8: string;
+    readonly AudioFormatWMAudioV9: string;
+    readonly AudioFormatWmaSpdif: string;
+    readonly VideoFormat420O: string;
+    readonly VideoFormatDV25: string;
+    readonly VideoFormatDV50: string;
+    readonly VideoFormatDvc: string;
+    readonly VideoFormatDvh1: string;
+    readonly VideoFormatDvhD: string;
+    readonly VideoFormatDvsd: string;
+    readonly VideoFormatDvsl: string;
+    readonly VideoFormatH263: string;
+    readonly VideoFormatH264: string;
+    readonly VideoFormatH264ES: string;
+    readonly VideoFormatH265: string;
+    readonly VideoFormatHevc: string;
+    readonly VideoFormatHevcES: string;
+    readonly VideoFormatM4S2: string;
+    readonly VideoFormatMP43: string;
+    readonly VideoFormatMP4S: string;
+    readonly VideoFormatMP4V: string;
+    readonly VideoFormatMjpg: string;
+    readonly VideoFormatMpeg2: string;
+    readonly VideoFormatMpg1: string;
+    readonly VideoFormatMss1: string;
+    readonly VideoFormatMss2: string;
+    readonly VideoFormatVP80: string;
+    readonly VideoFormatVP90: string;
+    readonly VideoFormatWmv1: string;
+    readonly VideoFormatWmv2: string;
+    readonly VideoFormatWmv3: string;
+    readonly VideoFormatWvc1: string;
+  }
+  var ICodecSubtypesStatics: abstract new (...args: any[]) => ICodecSubtypesStatics;
+
+  interface IDataCue extends Windows.Media.Core.IMediaCue {
+    Data: Windows.Storage.Streams.IBuffer;
+  }
+  var IDataCue: abstract new (...args: any[]) => IDataCue;
+
+  interface IDataCue2 extends Windows.Media.Core.IDataCue, Windows.Media.Core.IMediaCue {
+    readonly Properties: Windows.Foundation.Collections.PropertySet;
+  }
+  var IDataCue2: abstract new (...args: any[]) => IDataCue2;
+
+  interface IFaceDetectedEventArgs {
+    readonly ResultFrame: Windows.Media.Core.FaceDetectionEffectFrame;
+  }
+  var IFaceDetectedEventArgs: abstract new (...args: any[]) => IFaceDetectedEventArgs;
+
+  interface IFaceDetectionEffect extends Windows.Media.IMediaExtension {
+    SetProperties(configuration: Windows.Foundation.Collections.IPropertySet): void;
+    DesiredDetectionInterval: Windows.Foundation.TimeSpan;
+    Enabled: boolean;
+    FaceDetected: Windows.Foundation.TypedEventHandler<Windows.Media.Core.FaceDetectionEffect, Windows.Media.Core.FaceDetectedEventArgs> | null;
+  }
+  var IFaceDetectionEffect: abstract new (...args: any[]) => IFaceDetectionEffect;
+
+  interface IFaceDetectionEffectDefinition extends Windows.Media.Effects.IVideoEffectDefinition {
+    DetectionMode: number;
+    SynchronousDetectionEnabled: boolean;
+  }
+  var IFaceDetectionEffectDefinition: abstract new (...args: any[]) => IFaceDetectionEffectDefinition;
+
+  interface IFaceDetectionEffectFrame extends Windows.Foundation.IClosable, Windows.Media.IMediaFrame {
+    Close(): void;
+    readonly DetectedFaces: Windows.Foundation.Collections.IVectorView<Windows.Media.FaceAnalysis.DetectedFace> | Windows.Media.FaceAnalysis.DetectedFace[];
+  }
+  var IFaceDetectionEffectFrame: abstract new (...args: any[]) => IFaceDetectionEffectFrame;
+
+  interface IHighDynamicRangeControl {
+    Enabled: boolean;
+  }
+  var IHighDynamicRangeControl: abstract new (...args: any[]) => IHighDynamicRangeControl;
+
+  interface IHighDynamicRangeOutput {
+    readonly Certainty: number;
+    readonly FrameControllers: Windows.Foundation.Collections.IVectorView<Windows.Media.Devices.Core.FrameController> | Windows.Media.Devices.Core.FrameController[];
+  }
+  var IHighDynamicRangeOutput: abstract new (...args: any[]) => IHighDynamicRangeOutput;
+
+  interface IImageCue extends Windows.Media.Core.IMediaCue {
+    Extent: Windows.Media.Core.TimedTextSize;
+    Position: Windows.Media.Core.TimedTextPoint;
+    SoftwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap;
+  }
+  var IImageCue: abstract new (...args: any[]) => IImageCue;
+
+  interface IInitializeMediaStreamSourceRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly RandomAccessStream: Windows.Storage.Streams.IRandomAccessStream;
+    readonly Source: Windows.Media.Core.MediaStreamSource;
+  }
+  var IInitializeMediaStreamSourceRequestedEventArgs: abstract new (...args: any[]) => IInitializeMediaStreamSourceRequestedEventArgs;
+
+  interface ILowLightFusionResult {
+    readonly Frame: Windows.Graphics.Imaging.SoftwareBitmap;
+  }
+  var ILowLightFusionResult: abstract new (...args: any[]) => ILowLightFusionResult;
+
+  interface ILowLightFusionStatics {
+    FuseAsync(frameSet: Windows.Foundation.Collections.IIterable<Windows.Graphics.Imaging.SoftwareBitmap> | Windows.Graphics.Imaging.SoftwareBitmap[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Media.Core.LowLightFusionResult, number>;
+    readonly MaxSupportedFrameCount: number;
+    readonly SupportedBitmapPixelFormats: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var ILowLightFusionStatics: abstract new (...args: any[]) => ILowLightFusionStatics;
+
+  interface IMediaBinder {
+    readonly Source: Windows.Media.Core.MediaSource;
+    Token: string;
+    Binding: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaBinder, Windows.Media.Core.MediaBindingEventArgs> | null;
+  }
+  var IMediaBinder: abstract new (...args: any[]) => IMediaBinder;
+
+  interface IMediaBindingEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    SetStream(stream: Windows.Storage.Streams.IRandomAccessStream, contentType: string): void;
+    SetStreamReference(stream: Windows.Storage.Streams.IRandomAccessStreamReference, contentType: string): void;
+    SetUri(uri: Windows.Foundation.Uri): void;
+    readonly MediaBinder: Windows.Media.Core.MediaBinder;
+    Canceled: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaBindingEventArgs, Object> | null;
+  }
+  var IMediaBindingEventArgs: abstract new (...args: any[]) => IMediaBindingEventArgs;
+
+  interface IMediaBindingEventArgs2 {
+    SetAdaptiveMediaSource(mediaSource: Windows.Media.Streaming.Adaptive.AdaptiveMediaSource): void;
+    SetStorageFile(file: Windows.Storage.IStorageFile): void;
+  }
+  var IMediaBindingEventArgs2: abstract new (...args: any[]) => IMediaBindingEventArgs2;
+
+  interface IMediaBindingEventArgs3 {
+    SetDownloadOperation(downloadOperation: Windows.Networking.BackgroundTransfer.DownloadOperation): void;
+  }
+  var IMediaBindingEventArgs3: abstract new (...args: any[]) => IMediaBindingEventArgs3;
+
+  interface IMediaCue {
+    Duration: Windows.Foundation.TimeSpan;
+    Id: string;
+    StartTime: Windows.Foundation.TimeSpan;
+  }
+  var IMediaCue: abstract new (...args: any[]) => IMediaCue;
+
+  interface IMediaCueEventArgs {
+    readonly Cue: Windows.Media.Core.IMediaCue;
+  }
+  var IMediaCueEventArgs: abstract new (...args: any[]) => IMediaCueEventArgs;
+
+  interface IMediaSource {
+  }
+  var IMediaSource: abstract new (...args: any[]) => IMediaSource;
+
+  interface IMediaSource2 extends Windows.Foundation.IClosable, Windows.Media.Playback.IMediaPlaybackSource {
+    Close(): void;
+    readonly CustomProperties: Windows.Foundation.Collections.ValueSet;
+    readonly Duration: Windows.Foundation.TimeSpan | null;
+    readonly ExternalTimedMetadataTracks: Windows.Foundation.Collections.IObservableVector<Windows.Media.Core.TimedMetadataTrack>;
+    readonly ExternalTimedTextSources: Windows.Foundation.Collections.IObservableVector<Windows.Media.Core.TimedTextSource>;
+    readonly IsOpen: boolean;
+    OpenOperationCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaSource, Windows.Media.Core.MediaSourceOpenOperationCompletedEventArgs> | null;
+  }
+  var IMediaSource2: abstract new (...args: any[]) => IMediaSource2;
+
+  interface IMediaSource3 extends Windows.Foundation.IClosable, Windows.Media.Core.IMediaSource2, Windows.Media.Playback.IMediaPlaybackSource {
+    Close(): void;
+    Reset(): void;
+    readonly State: number;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaSource, Windows.Media.Core.MediaSourceStateChangedEventArgs> | null;
+  }
+  var IMediaSource3: abstract new (...args: any[]) => IMediaSource3;
+
+  interface IMediaSource4 extends Windows.Foundation.IClosable, Windows.Media.Core.IMediaSource2, Windows.Media.Core.IMediaSource3, Windows.Media.Playback.IMediaPlaybackSource {
+    Close(): void;
+    OpenAsync(): Windows.Foundation.IAsyncAction;
+    Reset(): void;
+    readonly AdaptiveMediaSource: Windows.Media.Streaming.Adaptive.AdaptiveMediaSource;
+    readonly MediaStreamSource: Windows.Media.Core.MediaStreamSource;
+    readonly MseStreamSource: Windows.Media.Core.MseStreamSource;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IMediaSource4: abstract new (...args: any[]) => IMediaSource4;
+
+  interface IMediaSource5 {
+    readonly DownloadOperation: Windows.Networking.BackgroundTransfer.DownloadOperation;
+  }
+  var IMediaSource5: abstract new (...args: any[]) => IMediaSource5;
+
+  interface IMediaSourceAppServiceConnection {
+    Start(): void;
+    InitializeMediaStreamSourceRequested: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaSourceAppServiceConnection, Windows.Media.Core.InitializeMediaStreamSourceRequestedEventArgs> | null;
+  }
+  var IMediaSourceAppServiceConnection: abstract new (...args: any[]) => IMediaSourceAppServiceConnection;
+
+  interface IMediaSourceAppServiceConnectionFactory {
+    Create(appServiceConnection: Windows.ApplicationModel.AppService.AppServiceConnection): Windows.Media.Core.MediaSourceAppServiceConnection;
+  }
+  var IMediaSourceAppServiceConnectionFactory: abstract new (...args: any[]) => IMediaSourceAppServiceConnectionFactory;
+
+  interface IMediaSourceError {
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+  var IMediaSourceError: abstract new (...args: any[]) => IMediaSourceError;
+
+  interface IMediaSourceOpenOperationCompletedEventArgs {
+    readonly Error: Windows.Media.Core.MediaSourceError;
+  }
+  var IMediaSourceOpenOperationCompletedEventArgs: abstract new (...args: any[]) => IMediaSourceOpenOperationCompletedEventArgs;
+
+  interface IMediaSourceStateChangedEventArgs {
+    readonly NewState: number;
+    readonly OldState: number;
+  }
+  var IMediaSourceStateChangedEventArgs: abstract new (...args: any[]) => IMediaSourceStateChangedEventArgs;
+
+  interface IMediaSourceStatics {
+    CreateFromAdaptiveMediaSource(mediaSource: Windows.Media.Streaming.Adaptive.AdaptiveMediaSource): Windows.Media.Core.MediaSource;
+    CreateFromIMediaSource(mediaSource: Windows.Media.Core.IMediaSource): Windows.Media.Core.MediaSource;
+    CreateFromMediaStreamSource(mediaSource: Windows.Media.Core.MediaStreamSource): Windows.Media.Core.MediaSource;
+    CreateFromMseStreamSource(mediaSource: Windows.Media.Core.MseStreamSource): Windows.Media.Core.MediaSource;
+    CreateFromStorageFile(file: Windows.Storage.IStorageFile): Windows.Media.Core.MediaSource;
+    CreateFromStream(stream: Windows.Storage.Streams.IRandomAccessStream, contentType: string): Windows.Media.Core.MediaSource;
+    CreateFromStreamReference(stream: Windows.Storage.Streams.IRandomAccessStreamReference, contentType: string): Windows.Media.Core.MediaSource;
+    CreateFromUri(uri: Windows.Foundation.Uri): Windows.Media.Core.MediaSource;
+  }
+  var IMediaSourceStatics: abstract new (...args: any[]) => IMediaSourceStatics;
+
+  interface IMediaSourceStatics2 {
+    CreateFromMediaBinder(binder: Windows.Media.Core.MediaBinder): Windows.Media.Core.MediaSource;
+  }
+  var IMediaSourceStatics2: abstract new (...args: any[]) => IMediaSourceStatics2;
+
+  interface IMediaSourceStatics3 {
+    CreateFromMediaFrameSource(frameSource: Windows.Media.Capture.Frames.MediaFrameSource): Windows.Media.Core.MediaSource;
+  }
+  var IMediaSourceStatics3: abstract new (...args: any[]) => IMediaSourceStatics3;
+
+  interface IMediaSourceStatics4 {
+    CreateFromDownloadOperation(downloadOperation: Windows.Networking.BackgroundTransfer.DownloadOperation): Windows.Media.Core.MediaSource;
+  }
+  var IMediaSourceStatics4: abstract new (...args: any[]) => IMediaSourceStatics4;
+
+  interface IMediaStreamDescriptor {
+    readonly IsSelected: boolean;
+    Language: string;
+    Name: string;
+  }
+  var IMediaStreamDescriptor: abstract new (...args: any[]) => IMediaStreamDescriptor;
+
+  interface IMediaStreamDescriptor2 extends Windows.Media.Core.IMediaStreamDescriptor {
+    Label: string;
+  }
+  var IMediaStreamDescriptor2: abstract new (...args: any[]) => IMediaStreamDescriptor2;
+
+  interface IMediaStreamSample {
+    readonly Buffer: Windows.Storage.Streams.Buffer;
+    DecodeTimestamp: Windows.Foundation.TimeSpan;
+    Discontinuous: boolean;
+    Duration: Windows.Foundation.TimeSpan;
+    readonly ExtendedProperties: Windows.Media.Core.MediaStreamSamplePropertySet;
+    KeyFrame: boolean;
+    readonly Protection: Windows.Media.Core.MediaStreamSampleProtectionProperties;
+    readonly Timestamp: Windows.Foundation.TimeSpan;
+    Processed: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaStreamSample, Object> | null;
+  }
+  var IMediaStreamSample: abstract new (...args: any[]) => IMediaStreamSample;
+
+  interface IMediaStreamSample2 {
+    readonly Direct3D11Surface: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface;
+  }
+  var IMediaStreamSample2: abstract new (...args: any[]) => IMediaStreamSample2;
+
+  interface IMediaStreamSampleProtectionProperties {
+    GetInitializationVector(value: number[]): void;
+    GetKeyIdentifier(value: number[]): void;
+    GetSubSampleMapping(value: number[]): void;
+    SetInitializationVector(value: number[]): void;
+    SetKeyIdentifier(value: number[]): void;
+    SetSubSampleMapping(value: number[]): void;
+  }
+  var IMediaStreamSampleProtectionProperties: abstract new (...args: any[]) => IMediaStreamSampleProtectionProperties;
+
+  interface IMediaStreamSampleStatics {
+    CreateFromBuffer(buffer: Windows.Storage.Streams.IBuffer, timestamp: Windows.Foundation.TimeSpan): Windows.Media.Core.MediaStreamSample;
+    CreateFromStreamAsync(stream: Windows.Storage.Streams.IInputStream, count: number, timestamp: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Media.Core.MediaStreamSample>;
+  }
+  var IMediaStreamSampleStatics: abstract new (...args: any[]) => IMediaStreamSampleStatics;
+
+  interface IMediaStreamSampleStatics2 {
+    CreateFromDirect3D11Surface(surface: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface, timestamp: Windows.Foundation.TimeSpan): Windows.Media.Core.MediaStreamSample;
+  }
+  var IMediaStreamSampleStatics2: abstract new (...args: any[]) => IMediaStreamSampleStatics2;
+
+  interface IMediaStreamSource extends Windows.Media.Core.IMediaSource {
+    AddProtectionKey(streamDescriptor: Windows.Media.Core.IMediaStreamDescriptor, keyIdentifier: number[], licenseData: number[]): void;
+    AddStreamDescriptor(descriptor: Windows.Media.Core.IMediaStreamDescriptor): void;
+    NotifyError(errorStatus: number): void;
+    SetBufferedRange(startOffset: Windows.Foundation.TimeSpan, endOffset: Windows.Foundation.TimeSpan): void;
+    BufferTime: Windows.Foundation.TimeSpan;
+    CanSeek: boolean;
+    Duration: Windows.Foundation.TimeSpan;
+    MediaProtectionManager: Windows.Media.Protection.MediaProtectionManager;
+    readonly MusicProperties: Windows.Storage.FileProperties.MusicProperties;
+    Thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly VideoProperties: Windows.Storage.FileProperties.VideoProperties;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaStreamSource, Windows.Media.Core.MediaStreamSourceClosedEventArgs> | null;
+    Paused: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaStreamSource, Object> | null;
+    SampleRequested: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaStreamSource, Windows.Media.Core.MediaStreamSourceSampleRequestedEventArgs> | null;
+    Starting: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaStreamSource, Windows.Media.Core.MediaStreamSourceStartingEventArgs> | null;
+    SwitchStreamsRequested: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaStreamSource, Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestedEventArgs> | null;
+  }
+  var IMediaStreamSource: abstract new (...args: any[]) => IMediaStreamSource;
+
+  interface IMediaStreamSource2 extends Windows.Media.Core.IMediaSource, Windows.Media.Core.IMediaStreamSource {
+    AddProtectionKey(streamDescriptor: Windows.Media.Core.IMediaStreamDescriptor, keyIdentifier: number[], licenseData: number[]): void;
+    AddStreamDescriptor(descriptor: Windows.Media.Core.IMediaStreamDescriptor): void;
+    NotifyError(errorStatus: number): void;
+    SetBufferedRange(startOffset: Windows.Foundation.TimeSpan, endOffset: Windows.Foundation.TimeSpan): void;
+    SampleRendered: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MediaStreamSource, Windows.Media.Core.MediaStreamSourceSampleRenderedEventArgs> | null;
+  }
+  var IMediaStreamSource2: abstract new (...args: any[]) => IMediaStreamSource2;
+
+  interface IMediaStreamSource3 extends Windows.Media.Core.IMediaSource, Windows.Media.Core.IMediaStreamSource {
+    AddProtectionKey(streamDescriptor: Windows.Media.Core.IMediaStreamDescriptor, keyIdentifier: number[], licenseData: number[]): void;
+    AddStreamDescriptor(descriptor: Windows.Media.Core.IMediaStreamDescriptor): void;
+    NotifyError(errorStatus: number): void;
+    SetBufferedRange(startOffset: Windows.Foundation.TimeSpan, endOffset: Windows.Foundation.TimeSpan): void;
+    MaxSupportedPlaybackRate: number | null;
+  }
+  var IMediaStreamSource3: abstract new (...args: any[]) => IMediaStreamSource3;
+
+  interface IMediaStreamSource4 extends Windows.Media.Core.IMediaSource, Windows.Media.Core.IMediaStreamSource {
+    AddProtectionKey(streamDescriptor: Windows.Media.Core.IMediaStreamDescriptor, keyIdentifier: number[], licenseData: number[]): void;
+    AddStreamDescriptor(descriptor: Windows.Media.Core.IMediaStreamDescriptor): void;
+    NotifyError(errorStatus: number): void;
+    SetBufferedRange(startOffset: Windows.Foundation.TimeSpan, endOffset: Windows.Foundation.TimeSpan): void;
+    IsLive: boolean;
+  }
+  var IMediaStreamSource4: abstract new (...args: any[]) => IMediaStreamSource4;
+
+  interface IMediaStreamSourceClosedEventArgs {
+    readonly Request: Windows.Media.Core.MediaStreamSourceClosedRequest;
+  }
+  var IMediaStreamSourceClosedEventArgs: abstract new (...args: any[]) => IMediaStreamSourceClosedEventArgs;
+
+  interface IMediaStreamSourceClosedRequest {
+    readonly Reason: number;
+  }
+  var IMediaStreamSourceClosedRequest: abstract new (...args: any[]) => IMediaStreamSourceClosedRequest;
+
+  interface IMediaStreamSourceFactory {
+    CreateFromDescriptor(descriptor: Windows.Media.Core.IMediaStreamDescriptor): Windows.Media.Core.MediaStreamSource;
+    CreateFromDescriptors(descriptor: Windows.Media.Core.IMediaStreamDescriptor, descriptor2: Windows.Media.Core.IMediaStreamDescriptor): Windows.Media.Core.MediaStreamSource;
+  }
+  var IMediaStreamSourceFactory: abstract new (...args: any[]) => IMediaStreamSourceFactory;
+
+  interface IMediaStreamSourceSampleRenderedEventArgs {
+    readonly SampleLag: Windows.Foundation.TimeSpan;
+  }
+  var IMediaStreamSourceSampleRenderedEventArgs: abstract new (...args: any[]) => IMediaStreamSourceSampleRenderedEventArgs;
+
+  interface IMediaStreamSourceSampleRequest {
+    GetDeferral(): Windows.Media.Core.MediaStreamSourceSampleRequestDeferral;
+    ReportSampleProgress(progress: number): void;
+    Sample: Windows.Media.Core.MediaStreamSample;
+    readonly StreamDescriptor: Windows.Media.Core.IMediaStreamDescriptor;
+  }
+  var IMediaStreamSourceSampleRequest: abstract new (...args: any[]) => IMediaStreamSourceSampleRequest;
+
+  interface IMediaStreamSourceSampleRequestDeferral {
+    Complete(): void;
+  }
+  var IMediaStreamSourceSampleRequestDeferral: abstract new (...args: any[]) => IMediaStreamSourceSampleRequestDeferral;
+
+  interface IMediaStreamSourceSampleRequestedEventArgs {
+    readonly Request: Windows.Media.Core.MediaStreamSourceSampleRequest;
+  }
+  var IMediaStreamSourceSampleRequestedEventArgs: abstract new (...args: any[]) => IMediaStreamSourceSampleRequestedEventArgs;
+
+  interface IMediaStreamSourceStartingEventArgs {
+    readonly Request: Windows.Media.Core.MediaStreamSourceStartingRequest;
+  }
+  var IMediaStreamSourceStartingEventArgs: abstract new (...args: any[]) => IMediaStreamSourceStartingEventArgs;
+
+  interface IMediaStreamSourceStartingRequest {
+    GetDeferral(): Windows.Media.Core.MediaStreamSourceStartingRequestDeferral;
+    SetActualStartPosition(position: Windows.Foundation.TimeSpan): void;
+    readonly StartPosition: Windows.Foundation.TimeSpan | null;
+  }
+  var IMediaStreamSourceStartingRequest: abstract new (...args: any[]) => IMediaStreamSourceStartingRequest;
+
+  interface IMediaStreamSourceStartingRequestDeferral {
+    Complete(): void;
+  }
+  var IMediaStreamSourceStartingRequestDeferral: abstract new (...args: any[]) => IMediaStreamSourceStartingRequestDeferral;
+
+  interface IMediaStreamSourceSwitchStreamsRequest {
+    GetDeferral(): Windows.Media.Core.MediaStreamSourceSwitchStreamsRequestDeferral;
+    readonly NewStreamDescriptor: Windows.Media.Core.IMediaStreamDescriptor;
+    readonly OldStreamDescriptor: Windows.Media.Core.IMediaStreamDescriptor;
+  }
+  var IMediaStreamSourceSwitchStreamsRequest: abstract new (...args: any[]) => IMediaStreamSourceSwitchStreamsRequest;
+
+  interface IMediaStreamSourceSwitchStreamsRequestDeferral {
+    Complete(): void;
+  }
+  var IMediaStreamSourceSwitchStreamsRequestDeferral: abstract new (...args: any[]) => IMediaStreamSourceSwitchStreamsRequestDeferral;
+
+  interface IMediaStreamSourceSwitchStreamsRequestedEventArgs {
+    readonly Request: Windows.Media.Core.MediaStreamSourceSwitchStreamsRequest;
+  }
+  var IMediaStreamSourceSwitchStreamsRequestedEventArgs: abstract new (...args: any[]) => IMediaStreamSourceSwitchStreamsRequestedEventArgs;
+
+  interface IMediaTrack {
+    readonly Id: string;
+    Label: string;
+    readonly Language: string;
+    readonly TrackKind: number;
+  }
+  var IMediaTrack: abstract new (...args: any[]) => IMediaTrack;
+
+  interface IMseSourceBuffer {
+    Abort(): void;
+    AppendBuffer(buffer: Windows.Storage.Streams.IBuffer): void;
+    AppendStream(stream: Windows.Storage.Streams.IInputStream): void;
+    AppendStream(stream: Windows.Storage.Streams.IInputStream, maxSize: number | bigint): void;
+    Remove(start: Windows.Foundation.TimeSpan, end: Windows.Foundation.TimeSpan | null): void;
+    AppendWindowEnd: Windows.Foundation.TimeSpan | null;
+    AppendWindowStart: Windows.Foundation.TimeSpan;
+    readonly Buffered: Windows.Foundation.Collections.IVectorView<Windows.Media.Core.MseTimeRange> | Windows.Media.Core.MseTimeRange[];
+    readonly IsUpdating: boolean;
+    Mode: number;
+    TimestampOffset: Windows.Foundation.TimeSpan;
+    Aborted: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseSourceBuffer, Object> | null;
+    ErrorOccurred: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseSourceBuffer, Object> | null;
+    UpdateEnded: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseSourceBuffer, Object> | null;
+    UpdateStarting: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseSourceBuffer, Object> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseSourceBuffer, Object> | null;
+  }
+  var IMseSourceBuffer: abstract new (...args: any[]) => IMseSourceBuffer;
+
+  interface IMseSourceBufferList {
+    readonly Buffers: Windows.Foundation.Collections.IVectorView<Windows.Media.Core.MseSourceBuffer> | Windows.Media.Core.MseSourceBuffer[];
+    SourceBufferAdded: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseSourceBufferList, Object> | null;
+    SourceBufferRemoved: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseSourceBufferList, Object> | null;
+  }
+  var IMseSourceBufferList: abstract new (...args: any[]) => IMseSourceBufferList;
+
+  interface IMseStreamSource extends Windows.Media.Core.IMediaSource {
+    AddSourceBuffer(mimeType: string): Windows.Media.Core.MseSourceBuffer;
+    EndOfStream(status: number): void;
+    RemoveSourceBuffer(buffer: Windows.Media.Core.MseSourceBuffer): void;
+    readonly ActiveSourceBuffers: Windows.Media.Core.MseSourceBufferList;
+    Duration: Windows.Foundation.TimeSpan | null;
+    readonly ReadyState: number;
+    readonly SourceBuffers: Windows.Media.Core.MseSourceBufferList;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseStreamSource, Object> | null;
+    Ended: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseStreamSource, Object> | null;
+    Opened: Windows.Foundation.TypedEventHandler<Windows.Media.Core.MseStreamSource, Object> | null;
+  }
+  var IMseStreamSource: abstract new (...args: any[]) => IMseStreamSource;
+
+  interface IMseStreamSource2 {
+    LiveSeekableRange: Windows.Media.Core.MseTimeRange | null;
+  }
+  var IMseStreamSource2: abstract new (...args: any[]) => IMseStreamSource2;
+
+  interface IMseStreamSourceStatics {
+    IsContentTypeSupported(contentType: string): boolean;
+  }
+  var IMseStreamSourceStatics: abstract new (...args: any[]) => IMseStreamSourceStatics;
+
+  interface ISceneAnalysisEffect extends Windows.Media.IMediaExtension {
+    SetProperties(configuration: Windows.Foundation.Collections.IPropertySet): void;
+    DesiredAnalysisInterval: Windows.Foundation.TimeSpan;
+    readonly HighDynamicRangeAnalyzer: Windows.Media.Core.HighDynamicRangeControl;
+    SceneAnalyzed: Windows.Foundation.TypedEventHandler<Windows.Media.Core.SceneAnalysisEffect, Windows.Media.Core.SceneAnalyzedEventArgs> | null;
+  }
+  var ISceneAnalysisEffect: abstract new (...args: any[]) => ISceneAnalysisEffect;
+
+  interface ISceneAnalysisEffectFrame extends Windows.Foundation.IClosable, Windows.Media.IMediaFrame {
+    Close(): void;
+    readonly FrameControlValues: Windows.Media.Capture.CapturedFrameControlValues;
+    readonly HighDynamicRange: Windows.Media.Core.HighDynamicRangeOutput;
+  }
+  var ISceneAnalysisEffectFrame: abstract new (...args: any[]) => ISceneAnalysisEffectFrame;
+
+  interface ISceneAnalysisEffectFrame2 extends Windows.Foundation.IClosable, Windows.Media.IMediaFrame {
+    Close(): void;
+    readonly AnalysisRecommendation: number;
+  }
+  var ISceneAnalysisEffectFrame2: abstract new (...args: any[]) => ISceneAnalysisEffectFrame2;
+
+  interface ISceneAnalyzedEventArgs {
+    readonly ResultFrame: Windows.Media.Core.SceneAnalysisEffectFrame;
+  }
+  var ISceneAnalyzedEventArgs: abstract new (...args: any[]) => ISceneAnalyzedEventArgs;
+
+  interface ISingleSelectMediaTrackList {
+    SelectedIndex: number;
+    SelectedIndexChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Core.ISingleSelectMediaTrackList, Object> | null;
+  }
+  var ISingleSelectMediaTrackList: abstract new (...args: any[]) => ISingleSelectMediaTrackList;
+
+  interface ISpeechCue extends Windows.Media.Core.IMediaCue {
+    EndPositionInInput: number | null;
+    StartPositionInInput: number | null;
+    Text: string;
+  }
+  var ISpeechCue: abstract new (...args: any[]) => ISpeechCue;
+
+  interface ITimedMetadataStreamDescriptor {
+    Copy(): Windows.Media.Core.TimedMetadataStreamDescriptor;
+    readonly EncodingProperties: Windows.Media.MediaProperties.TimedMetadataEncodingProperties;
+  }
+  var ITimedMetadataStreamDescriptor: abstract new (...args: any[]) => ITimedMetadataStreamDescriptor;
+
+  interface ITimedMetadataStreamDescriptorFactory {
+    Create(encodingProperties: Windows.Media.MediaProperties.TimedMetadataEncodingProperties): Windows.Media.Core.TimedMetadataStreamDescriptor;
+  }
+  var ITimedMetadataStreamDescriptorFactory: abstract new (...args: any[]) => ITimedMetadataStreamDescriptorFactory;
+
+  interface ITimedMetadataTrack extends Windows.Media.Core.IMediaTrack {
+    AddCue(cue: Windows.Media.Core.IMediaCue): void;
+    RemoveCue(cue: Windows.Media.Core.IMediaCue): void;
+    readonly ActiveCues: Windows.Foundation.Collections.IVectorView<Windows.Media.Core.IMediaCue> | Windows.Media.Core.IMediaCue[];
+    readonly Cues: Windows.Foundation.Collections.IVectorView<Windows.Media.Core.IMediaCue> | Windows.Media.Core.IMediaCue[];
+    readonly DispatchType: string;
+    readonly TimedMetadataKind: number;
+    CueEntered: Windows.Foundation.TypedEventHandler<Windows.Media.Core.TimedMetadataTrack, Windows.Media.Core.MediaCueEventArgs> | null;
+    CueExited: Windows.Foundation.TypedEventHandler<Windows.Media.Core.TimedMetadataTrack, Windows.Media.Core.MediaCueEventArgs> | null;
+    TrackFailed: Windows.Foundation.TypedEventHandler<Windows.Media.Core.TimedMetadataTrack, Windows.Media.Core.TimedMetadataTrackFailedEventArgs> | null;
+  }
+  var ITimedMetadataTrack: abstract new (...args: any[]) => ITimedMetadataTrack;
+
+  interface ITimedMetadataTrack2 extends Windows.Media.Core.IMediaTrack, Windows.Media.Core.ITimedMetadataTrack {
+    AddCue(cue: Windows.Media.Core.IMediaCue): void;
+    RemoveCue(cue: Windows.Media.Core.IMediaCue): void;
+    readonly Name: string;
+    readonly PlaybackItem: Windows.Media.Playback.MediaPlaybackItem;
+  }
+  var ITimedMetadataTrack2: abstract new (...args: any[]) => ITimedMetadataTrack2;
+
+  interface ITimedMetadataTrackError {
+    readonly ErrorCode: number;
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+  var ITimedMetadataTrackError: abstract new (...args: any[]) => ITimedMetadataTrackError;
+
+  interface ITimedMetadataTrackFactory {
+    Create(id: string, language: string, kind: number): Windows.Media.Core.TimedMetadataTrack;
+  }
+  var ITimedMetadataTrackFactory: abstract new (...args: any[]) => ITimedMetadataTrackFactory;
+
+  interface ITimedMetadataTrackFailedEventArgs {
+    readonly Error: Windows.Media.Core.TimedMetadataTrackError;
+  }
+  var ITimedMetadataTrackFailedEventArgs: abstract new (...args: any[]) => ITimedMetadataTrackFailedEventArgs;
+
+  interface ITimedMetadataTrackProvider {
+    readonly TimedMetadataTracks: Windows.Foundation.Collections.IVectorView<Windows.Media.Core.TimedMetadataTrack> | Windows.Media.Core.TimedMetadataTrack[];
+  }
+  var ITimedMetadataTrackProvider: abstract new (...args: any[]) => ITimedMetadataTrackProvider;
+
+  interface ITimedTextBouten {
+    Color: Windows.UI.Color;
+    Position: number;
+    Type: number;
+  }
+  var ITimedTextBouten: abstract new (...args: any[]) => ITimedTextBouten;
+
+  interface ITimedTextCue extends Windows.Media.Core.IMediaCue {
+    CueRegion: Windows.Media.Core.TimedTextRegion;
+    CueStyle: Windows.Media.Core.TimedTextStyle;
+    readonly Lines: Windows.Foundation.Collections.IVector<Windows.Media.Core.TimedTextLine> | Windows.Media.Core.TimedTextLine[];
+  }
+  var ITimedTextCue: abstract new (...args: any[]) => ITimedTextCue;
+
+  interface ITimedTextLine {
+    readonly Subformats: Windows.Foundation.Collections.IVector<Windows.Media.Core.TimedTextSubformat> | Windows.Media.Core.TimedTextSubformat[];
+    Text: string;
+  }
+  var ITimedTextLine: abstract new (...args: any[]) => ITimedTextLine;
+
+  interface ITimedTextRegion {
+    Background: Windows.UI.Color;
+    DisplayAlignment: number;
+    Extent: Windows.Media.Core.TimedTextSize;
+    IsOverflowClipped: boolean;
+    LineHeight: Windows.Media.Core.TimedTextDouble;
+    Name: string;
+    Padding: Windows.Media.Core.TimedTextPadding;
+    Position: Windows.Media.Core.TimedTextPoint;
+    ScrollMode: number;
+    TextWrapping: number;
+    WritingMode: number;
+    ZIndex: number;
+  }
+  var ITimedTextRegion: abstract new (...args: any[]) => ITimedTextRegion;
+
+  interface ITimedTextRuby {
+    Align: number;
+    Position: number;
+    Reserve: number;
+    Text: string;
+  }
+  var ITimedTextRuby: abstract new (...args: any[]) => ITimedTextRuby;
+
+  interface ITimedTextSource {
+    Resolved: Windows.Foundation.TypedEventHandler<Windows.Media.Core.TimedTextSource, Windows.Media.Core.TimedTextSourceResolveResultEventArgs> | null;
+  }
+  var ITimedTextSource: abstract new (...args: any[]) => ITimedTextSource;
+
+  interface ITimedTextSourceResolveResultEventArgs {
+    readonly Error: Windows.Media.Core.TimedMetadataTrackError;
+    readonly Tracks: Windows.Foundation.Collections.IVectorView<Windows.Media.Core.TimedMetadataTrack> | Windows.Media.Core.TimedMetadataTrack[];
+  }
+  var ITimedTextSourceResolveResultEventArgs: abstract new (...args: any[]) => ITimedTextSourceResolveResultEventArgs;
+
+  interface ITimedTextSourceStatics {
+    CreateFromStream(stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Media.Core.TimedTextSource;
+    CreateFromStream(stream: Windows.Storage.Streams.IRandomAccessStream, defaultLanguage: string): Windows.Media.Core.TimedTextSource;
+    CreateFromUri(uri: Windows.Foundation.Uri): Windows.Media.Core.TimedTextSource;
+    CreateFromUri(uri: Windows.Foundation.Uri, defaultLanguage: string): Windows.Media.Core.TimedTextSource;
+  }
+  var ITimedTextSourceStatics: abstract new (...args: any[]) => ITimedTextSourceStatics;
+
+  interface ITimedTextSourceStatics2 {
+    CreateFromStreamWithIndex(stream: Windows.Storage.Streams.IRandomAccessStream, indexStream: Windows.Storage.Streams.IRandomAccessStream): Windows.Media.Core.TimedTextSource;
+    CreateFromStreamWithIndex(stream: Windows.Storage.Streams.IRandomAccessStream, indexStream: Windows.Storage.Streams.IRandomAccessStream, defaultLanguage: string): Windows.Media.Core.TimedTextSource;
+    CreateFromUriWithIndex(uri: Windows.Foundation.Uri, indexUri: Windows.Foundation.Uri): Windows.Media.Core.TimedTextSource;
+    CreateFromUriWithIndex(uri: Windows.Foundation.Uri, indexUri: Windows.Foundation.Uri, defaultLanguage: string): Windows.Media.Core.TimedTextSource;
+  }
+  var ITimedTextSourceStatics2: abstract new (...args: any[]) => ITimedTextSourceStatics2;
+
+  interface ITimedTextStyle {
+    Background: Windows.UI.Color;
+    FlowDirection: number;
+    FontFamily: string;
+    FontSize: Windows.Media.Core.TimedTextDouble;
+    FontWeight: number;
+    Foreground: Windows.UI.Color;
+    IsBackgroundAlwaysShown: boolean;
+    LineAlignment: number;
+    Name: string;
+    OutlineColor: Windows.UI.Color;
+    OutlineRadius: Windows.Media.Core.TimedTextDouble;
+    OutlineThickness: Windows.Media.Core.TimedTextDouble;
+  }
+  var ITimedTextStyle: abstract new (...args: any[]) => ITimedTextStyle;
+
+  interface ITimedTextStyle2 {
+    FontStyle: number;
+    IsLineThroughEnabled: boolean;
+    IsOverlineEnabled: boolean;
+    IsUnderlineEnabled: boolean;
+  }
+  var ITimedTextStyle2: abstract new (...args: any[]) => ITimedTextStyle2;
+
+  interface ITimedTextStyle3 {
+    readonly Bouten: Windows.Media.Core.TimedTextBouten;
+    FontAngleInDegrees: number;
+    IsTextCombined: boolean;
+    readonly Ruby: Windows.Media.Core.TimedTextRuby;
+  }
+  var ITimedTextStyle3: abstract new (...args: any[]) => ITimedTextStyle3;
+
+  interface ITimedTextSubformat {
+    Length: number;
+    StartIndex: number;
+    SubformatStyle: Windows.Media.Core.TimedTextStyle;
+  }
+  var ITimedTextSubformat: abstract new (...args: any[]) => ITimedTextSubformat;
+
+  interface IVideoStabilizationEffect extends Windows.Media.IMediaExtension {
+    GetRecommendedStreamConfiguration(controller: Windows.Media.Devices.VideoDeviceController, desiredProperties: Windows.Media.MediaProperties.VideoEncodingProperties): Windows.Media.Capture.VideoStreamConfiguration;
+    SetProperties(configuration: Windows.Foundation.Collections.IPropertySet): void;
+    Enabled: boolean;
+    EnabledChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Core.VideoStabilizationEffect, Windows.Media.Core.VideoStabilizationEffectEnabledChangedEventArgs> | null;
+  }
+  var IVideoStabilizationEffect: abstract new (...args: any[]) => IVideoStabilizationEffect;
+
+  interface IVideoStabilizationEffectEnabledChangedEventArgs {
+    readonly Reason: number;
+  }
+  var IVideoStabilizationEffectEnabledChangedEventArgs: abstract new (...args: any[]) => IVideoStabilizationEffectEnabledChangedEventArgs;
+
+  interface IVideoStreamDescriptor extends Windows.Media.Core.IMediaStreamDescriptor {
+    readonly EncodingProperties: Windows.Media.MediaProperties.VideoEncodingProperties;
+  }
+  var IVideoStreamDescriptor: abstract new (...args: any[]) => IVideoStreamDescriptor;
+
+  interface IVideoStreamDescriptor2 {
+    Copy(): Windows.Media.Core.VideoStreamDescriptor;
+  }
+  var IVideoStreamDescriptor2: abstract new (...args: any[]) => IVideoStreamDescriptor2;
+
+  interface IVideoStreamDescriptorFactory {
+    Create(encodingProperties: Windows.Media.MediaProperties.VideoEncodingProperties): Windows.Media.Core.VideoStreamDescriptor;
+  }
+  var IVideoStreamDescriptorFactory: abstract new (...args: any[]) => IVideoStreamDescriptorFactory;
+
+  interface IVideoTrack {
+    GetEncodingProperties(): Windows.Media.MediaProperties.VideoEncodingProperties;
+    readonly Name: string;
+    readonly PlaybackItem: Windows.Media.Playback.MediaPlaybackItem;
+    readonly SupportInfo: Windows.Media.Core.VideoTrackSupportInfo;
+    OpenFailed: Windows.Foundation.TypedEventHandler<Windows.Media.Core.VideoTrack, Windows.Media.Core.VideoTrackOpenFailedEventArgs> | null;
+  }
+  var IVideoTrack: abstract new (...args: any[]) => IVideoTrack;
+
+  interface IVideoTrackOpenFailedEventArgs {
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+  var IVideoTrackOpenFailedEventArgs: abstract new (...args: any[]) => IVideoTrackOpenFailedEventArgs;
+
+  interface IVideoTrackSupportInfo {
+    readonly DecoderStatus: number;
+    readonly MediaSourceStatus: number;
+  }
+  var IVideoTrackSupportInfo: abstract new (...args: any[]) => IVideoTrackSupportInfo;
+
+  interface MseTimeRange {
+    Start: Windows.Foundation.TimeSpan;
+    End: Windows.Foundation.TimeSpan;
+  }
+  var MseTimeRange: {
+    new(start: Windows.Foundation.TimeSpan, end: Windows.Foundation.TimeSpan): MseTimeRange;
+    new(fields: { Start?: Windows.Foundation.TimeSpan; End?: Windows.Foundation.TimeSpan }): MseTimeRange;
+  };
+
+  interface TimedTextDouble {
+    Value: number;
+    Unit: number;
+  }
+  var TimedTextDouble: {
+    new(value: number, unit: number): TimedTextDouble;
+    new(fields: { Value?: number; Unit?: number }): TimedTextDouble;
+  };
+
+  interface TimedTextPadding {
+    Before: number;
+    After: number;
+    Start: number;
+    End: number;
+    Unit: number;
+  }
+  var TimedTextPadding: {
+    new(before: number, after: number, start: number, end: number, unit: number): TimedTextPadding;
+    new(fields: { Before?: number; After?: number; Start?: number; End?: number; Unit?: number }): TimedTextPadding;
+  };
+
+  interface TimedTextPoint {
+    X: number;
+    Y: number;
+    Unit: number;
+  }
+  var TimedTextPoint: {
+    new(x: number, y: number, unit: number): TimedTextPoint;
+    new(fields: { X?: number; Y?: number; Unit?: number }): TimedTextPoint;
+  };
+
+  interface TimedTextSize {
+    Height: number;
+    Width: number;
+    Unit: number;
+  }
+  var TimedTextSize: {
+    new(height: number, width: number, unit: number): TimedTextSize;
+    new(fields: { Height?: number; Width?: number; Unit?: number }): TimedTextSize;
+  };
+
+}
+
+declare namespace Windows.Media.Core.Preview {
+  class SoundLevelBroker {
+    static readonly SoundLevel: number;
+    static SoundLevelChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  interface ISoundLevelBrokerStatics {
+    readonly SoundLevel: number;
+    SoundLevelChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var ISoundLevelBrokerStatics: abstract new (...args: any[]) => ISoundLevelBrokerStatics;
+
+}
+
+declare namespace Windows.Media.Devices {
+  class AdvancedPhotoCaptureSettings implements Windows.Media.Devices.IAdvancedPhotoCaptureSettings {
+    constructor();
+    Mode: number;
+  }
+
+  class AdvancedPhotoControl implements Windows.Media.Devices.IAdvancedPhotoControl {
+    Configure(settings: Windows.Media.Devices.AdvancedPhotoCaptureSettings): void;
+    readonly Mode: number;
+    readonly Supported: boolean;
+    readonly SupportedModes: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class AudioDeviceController implements Windows.Media.Devices.IAudioDeviceController, Windows.Media.Devices.IAudioDeviceController2, Windows.Media.Devices.IMediaDeviceController {
+    GetAvailableMediaStreamProperties(mediaStreamType: number): Windows.Foundation.Collections.IVectorView<Windows.Media.MediaProperties.IMediaEncodingProperties> | Windows.Media.MediaProperties.IMediaEncodingProperties[];
+    GetMediaStreamProperties(mediaStreamType: number): Windows.Media.MediaProperties.IMediaEncodingProperties;
+    SetMediaStreamPropertiesAsync(mediaStreamType: number, mediaEncodingProperties: Windows.Media.MediaProperties.IMediaEncodingProperties): Windows.Foundation.IAsyncAction;
+    readonly AudioCaptureEffectsManager: Windows.Media.Effects.AudioCaptureEffectsManager;
+    Muted: boolean;
+    VolumePercent: number;
+  }
+
+  class AudioDeviceModule implements Windows.Media.Devices.IAudioDeviceModule {
+    SendCommandAsync(Command: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Media.Devices.ModuleCommandResult>;
+    readonly ClassId: string;
+    readonly DisplayName: string;
+    readonly InstanceId: number;
+    readonly MajorVersion: number;
+    readonly MinorVersion: number;
+  }
+
+  class AudioDeviceModuleNotificationEventArgs implements Windows.Media.Devices.IAudioDeviceModuleNotificationEventArgs {
+    readonly Module: Windows.Media.Devices.AudioDeviceModule;
+    readonly NotificationData: Windows.Storage.Streams.IBuffer;
+  }
+
+  class AudioDeviceModulesManager implements Windows.Media.Devices.IAudioDeviceModulesManager {
+    constructor(deviceId: string);
+    FindAll(): Windows.Foundation.Collections.IVectorView<Windows.Media.Devices.AudioDeviceModule> | Windows.Media.Devices.AudioDeviceModule[];
+    FindAllById(moduleId: string): Windows.Foundation.Collections.IVectorView<Windows.Media.Devices.AudioDeviceModule> | Windows.Media.Devices.AudioDeviceModule[];
+    ModuleNotificationReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Devices.AudioDeviceModulesManager, Windows.Media.Devices.AudioDeviceModuleNotificationEventArgs> | null;
+  }
+
+  class CallControl implements Windows.Media.Devices.ICallControl {
+    EndCall(callToken: number | bigint): void;
+    static FromId(deviceId: string): Windows.Media.Devices.CallControl;
+    static GetDefault(): Windows.Media.Devices.CallControl;
+    IndicateActiveCall(callToken: number | bigint): void;
+    IndicateNewIncomingCall(enableRinger: boolean, callerId: string): number | bigint;
+    IndicateNewOutgoingCall(): number | bigint;
+    readonly HasRinger: boolean;
+    AnswerRequested: Windows.Media.Devices.CallControlEventHandler | null;
+    AudioTransferRequested: Windows.Media.Devices.CallControlEventHandler | null;
+    DialRequested: Windows.Media.Devices.DialRequestedEventHandler | null;
+    HangUpRequested: Windows.Media.Devices.CallControlEventHandler | null;
+    KeypadPressed: Windows.Media.Devices.KeypadPressedEventHandler | null;
+    RedialRequested: Windows.Media.Devices.RedialRequestedEventHandler | null;
+  }
+
+  class CameraOcclusionInfo implements Windows.Media.Devices.ICameraOcclusionInfo {
+    GetState(): Windows.Media.Devices.CameraOcclusionState;
+    IsOcclusionKindSupported(occlusionKind: number): boolean;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Devices.CameraOcclusionInfo, Windows.Media.Devices.CameraOcclusionStateChangedEventArgs> | null;
+  }
+
+  class CameraOcclusionState implements Windows.Media.Devices.ICameraOcclusionState {
+    IsOcclusionKind(occlusionKind: number): boolean;
+    readonly IsOccluded: boolean;
+  }
+
+  class CameraOcclusionStateChangedEventArgs implements Windows.Media.Devices.ICameraOcclusionStateChangedEventArgs {
+    readonly State: Windows.Media.Devices.CameraOcclusionState;
+  }
+
+  class DefaultAudioCaptureDeviceChangedEventArgs implements Windows.Media.Devices.IDefaultAudioDeviceChangedEventArgs {
+    readonly Id: string;
+    readonly Role: number;
+  }
+
+  class DefaultAudioRenderDeviceChangedEventArgs implements Windows.Media.Devices.IDefaultAudioDeviceChangedEventArgs {
+    readonly Id: string;
+    readonly Role: number;
+  }
+
+  class DialRequestedEventArgs implements Windows.Media.Devices.IDialRequestedEventArgs {
+    Handled(): void;
+    readonly Contact: Object;
+  }
+
+  class DigitalWindowBounds implements Windows.Media.Devices.IDigitalWindowBounds {
+    constructor();
+    NormalizedOriginLeft: number;
+    NormalizedOriginTop: number;
+    Scale: number;
+  }
+
+  class DigitalWindowCapability implements Windows.Media.Devices.IDigitalWindowCapability {
+    readonly Height: number;
+    readonly MaxScaleValue: number;
+    readonly MinScaleValue: number;
+    readonly MinScaleValueWithoutUpsampling: number;
+    readonly NormalizedFieldOfViewLimit: Windows.Foundation.Rect;
+    readonly Width: number;
+  }
+
+  class DigitalWindowControl implements Windows.Media.Devices.IDigitalWindowControl {
+    Configure(digitalWindowMode: number): void;
+    Configure(digitalWindowMode: number, digitalWindowBounds: Windows.Media.Devices.DigitalWindowBounds): void;
+    GetBounds(): Windows.Media.Devices.DigitalWindowBounds;
+    GetCapabilityForSize(width: number, height: number): Windows.Media.Devices.DigitalWindowCapability;
+    readonly CurrentMode: number;
+    readonly IsSupported: boolean;
+    readonly SupportedCapabilities: Windows.Foundation.Collections.IVectorView<Windows.Media.Devices.DigitalWindowCapability> | Windows.Media.Devices.DigitalWindowCapability[];
+    readonly SupportedModes: number[];
+  }
+
+  class ExposureCompensationControl implements Windows.Media.Devices.IExposureCompensationControl {
+    SetValueAsync(value: number): Windows.Foundation.IAsyncAction;
+    readonly Max: number;
+    readonly Min: number;
+    readonly Step: number;
+    readonly Supported: boolean;
+    readonly Value: number;
+  }
+
+  class ExposureControl implements Windows.Media.Devices.IExposureControl {
+    SetAutoAsync(value: boolean): Windows.Foundation.IAsyncAction;
+    SetValueAsync(shutterDuration: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncAction;
+    readonly Auto: boolean;
+    readonly Max: Windows.Foundation.TimeSpan;
+    readonly Min: Windows.Foundation.TimeSpan;
+    readonly Step: Windows.Foundation.TimeSpan;
+    readonly Supported: boolean;
+    readonly Value: Windows.Foundation.TimeSpan;
+  }
+
+  class ExposurePriorityVideoControl implements Windows.Media.Devices.IExposurePriorityVideoControl {
+    Enabled: boolean;
+    readonly Supported: boolean;
+  }
+
+  class FlashControl implements Windows.Media.Devices.IFlashControl, Windows.Media.Devices.IFlashControl2 {
+    AssistantLightEnabled: boolean;
+    readonly AssistantLightSupported: boolean;
+    Auto: boolean;
+    Enabled: boolean;
+    PowerPercent: number;
+    readonly PowerSupported: boolean;
+    RedEyeReduction: boolean;
+    readonly RedEyeReductionSupported: boolean;
+    readonly Supported: boolean;
+  }
+
+  class FocusControl implements Windows.Media.Devices.IFocusControl, Windows.Media.Devices.IFocusControl2 {
+    Configure(settings: Windows.Media.Devices.FocusSettings): void;
+    FocusAsync(): Windows.Foundation.IAsyncAction;
+    LockAsync(): Windows.Foundation.IAsyncAction;
+    SetPresetAsync(preset: number): Windows.Foundation.IAsyncAction;
+    SetPresetAsync(preset: number, completeBeforeFocus: boolean): Windows.Foundation.IAsyncAction;
+    SetValueAsync(focus: number): Windows.Foundation.IAsyncAction;
+    UnlockAsync(): Windows.Foundation.IAsyncAction;
+    readonly FocusChangedSupported: boolean;
+    readonly FocusState: number;
+    readonly Max: number;
+    readonly Min: number;
+    readonly Mode: number;
+    readonly Preset: number;
+    readonly Step: number;
+    readonly Supported: boolean;
+    readonly SupportedFocusDistances: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedFocusModes: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedFocusRanges: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedPresets: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Value: number;
+    readonly WaitForFocusSupported: boolean;
+  }
+
+  class FocusSettings implements Windows.Media.Devices.IFocusSettings {
+    constructor();
+    AutoFocusRange: number;
+    DisableDriverFallback: boolean;
+    Distance: number | null;
+    Mode: number;
+    Value: number | null;
+    WaitForFocus: boolean;
+  }
+
+  class HdrVideoControl implements Windows.Media.Devices.IHdrVideoControl {
+    Mode: number;
+    readonly Supported: boolean;
+    readonly SupportedModes: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class InfraredTorchControl implements Windows.Media.Devices.IInfraredTorchControl {
+    CurrentMode: number;
+    readonly IsSupported: boolean;
+    readonly MaxPower: number;
+    readonly MinPower: number;
+    Power: number;
+    readonly PowerStep: number;
+    readonly SupportedModes: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class IsoSpeedControl implements Windows.Media.Devices.IIsoSpeedControl, Windows.Media.Devices.IIsoSpeedControl2 {
+    SetAutoAsync(): Windows.Foundation.IAsyncAction;
+    SetPresetAsync(preset: number): Windows.Foundation.IAsyncAction;
+    SetValueAsync(isoSpeed: number): Windows.Foundation.IAsyncAction;
+    readonly Auto: boolean;
+    readonly Max: number;
+    readonly Min: number;
+    readonly Preset: number;
+    readonly Step: number;
+    readonly Supported: boolean;
+    readonly SupportedPresets: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Value: number;
+  }
+
+  class KeypadPressedEventArgs implements Windows.Media.Devices.IKeypadPressedEventArgs {
+    readonly TelephonyKey: number;
+  }
+
+  class LowLagPhotoControl implements Windows.Media.Devices.ILowLagPhotoControl {
+    GetCurrentFrameRate(): Windows.Media.MediaProperties.MediaRatio;
+    GetHighestConcurrentFrameRate(captureProperties: Windows.Media.MediaProperties.IMediaEncodingProperties): Windows.Media.MediaProperties.MediaRatio;
+    DesiredThumbnailSize: number;
+    readonly HardwareAcceleratedThumbnailSupported: number;
+    ThumbnailEnabled: boolean;
+    ThumbnailFormat: number;
+  }
+
+  class LowLagPhotoSequenceControl implements Windows.Media.Devices.ILowLagPhotoSequenceControl {
+    GetCurrentFrameRate(): Windows.Media.MediaProperties.MediaRatio;
+    GetHighestConcurrentFrameRate(captureProperties: Windows.Media.MediaProperties.IMediaEncodingProperties): Windows.Media.MediaProperties.MediaRatio;
+    DesiredThumbnailSize: number;
+    readonly HardwareAcceleratedThumbnailSupported: number;
+    readonly MaxPastPhotos: number;
+    readonly MaxPhotosPerSecond: number;
+    PastPhotoLimit: number;
+    PhotosPerSecondLimit: number;
+    readonly Supported: boolean;
+    ThumbnailEnabled: boolean;
+    ThumbnailFormat: number;
+  }
+
+  class MediaDevice {
+    static GetAudioCaptureSelector(): string;
+    static GetAudioRenderSelector(): string;
+    static GetDefaultAudioCaptureId(role: number): string;
+    static GetDefaultAudioRenderId(role: number): string;
+    static GetVideoCaptureSelector(): string;
+    static DefaultAudioCaptureDeviceChanged: Windows.Foundation.TypedEventHandler<Object, Windows.Media.Devices.DefaultAudioCaptureDeviceChangedEventArgs> | null;
+    static DefaultAudioRenderDeviceChanged: Windows.Foundation.TypedEventHandler<Object, Windows.Media.Devices.DefaultAudioRenderDeviceChangedEventArgs> | null;
+  }
+
+  class MediaDeviceControl implements Windows.Media.Devices.IMediaDeviceControl {
+    TryGetAuto(value: boolean): boolean;
+    TryGetValue(value: number): boolean;
+    TrySetAuto(value: boolean): boolean;
+    TrySetValue(value: number): boolean;
+    readonly Capabilities: Windows.Media.Devices.MediaDeviceControlCapabilities;
+  }
+
+  class MediaDeviceControlCapabilities implements Windows.Media.Devices.IMediaDeviceControlCapabilities {
+    readonly AutoModeSupported: boolean;
+    readonly Default: number;
+    readonly Max: number;
+    readonly Min: number;
+    readonly Step: number;
+    readonly Supported: boolean;
+  }
+
+  class ModuleCommandResult implements Windows.Media.Devices.IModuleCommandResult {
+    readonly Result: Windows.Storage.Streams.IBuffer;
+    readonly Status: number;
+  }
+
+  class OpticalImageStabilizationControl implements Windows.Media.Devices.IOpticalImageStabilizationControl {
+    Mode: number;
+    readonly Supported: boolean;
+    readonly SupportedModes: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class PanelBasedOptimizationControl implements Windows.Media.Devices.IPanelBasedOptimizationControl {
+    readonly IsSupported: boolean;
+    Panel: number;
+  }
+
+  class PhotoConfirmationControl implements Windows.Media.Devices.IPhotoConfirmationControl {
+    Enabled: boolean;
+    PixelFormat: number;
+    readonly Supported: boolean;
+  }
+
+  class RedialRequestedEventArgs implements Windows.Media.Devices.IRedialRequestedEventArgs {
+    Handled(): void;
+  }
+
+  class RegionOfInterest implements Windows.Media.Devices.IRegionOfInterest, Windows.Media.Devices.IRegionOfInterest2 {
+    constructor();
+    AutoExposureEnabled: boolean;
+    AutoFocusEnabled: boolean;
+    AutoWhiteBalanceEnabled: boolean;
+    Bounds: Windows.Foundation.Rect;
+    BoundsNormalized: boolean;
+    Type: number;
+    Weight: number;
+  }
+
+  class RegionsOfInterestControl implements Windows.Media.Devices.IRegionsOfInterestControl {
+    ClearRegionsAsync(): Windows.Foundation.IAsyncAction;
+    SetRegionsAsync(regions: Windows.Foundation.Collections.IIterable<Windows.Media.Devices.RegionOfInterest> | Windows.Media.Devices.RegionOfInterest[]): Windows.Foundation.IAsyncAction;
+    SetRegionsAsync(regions: Windows.Foundation.Collections.IIterable<Windows.Media.Devices.RegionOfInterest> | Windows.Media.Devices.RegionOfInterest[], lockValues: boolean): Windows.Foundation.IAsyncAction;
+    readonly AutoExposureSupported: boolean;
+    readonly AutoFocusSupported: boolean;
+    readonly AutoWhiteBalanceSupported: boolean;
+    readonly MaxRegions: number;
+  }
+
+  class SceneModeControl implements Windows.Media.Devices.ISceneModeControl {
+    SetValueAsync(sceneMode: number): Windows.Foundation.IAsyncAction;
+    readonly SupportedModes: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Value: number;
+  }
+
+  class TorchControl implements Windows.Media.Devices.ITorchControl {
+    Enabled: boolean;
+    PowerPercent: number;
+    readonly PowerSupported: boolean;
+    readonly Supported: boolean;
+  }
+
+  class VideoDeviceController implements Windows.Media.Devices.IAdvancedVideoCaptureDeviceController, Windows.Media.Devices.IAdvancedVideoCaptureDeviceController10, Windows.Media.Devices.IAdvancedVideoCaptureDeviceController11, Windows.Media.Devices.IAdvancedVideoCaptureDeviceController2, Windows.Media.Devices.IAdvancedVideoCaptureDeviceController3, Windows.Media.Devices.IAdvancedVideoCaptureDeviceController4, Windows.Media.Devices.IAdvancedVideoCaptureDeviceController5, Windows.Media.Devices.IAdvancedVideoCaptureDeviceController6, Windows.Media.Devices.IAdvancedVideoCaptureDeviceController7, Windows.Media.Devices.IAdvancedVideoCaptureDeviceController8, Windows.Media.Devices.IAdvancedVideoCaptureDeviceController9, Windows.Media.Devices.IMediaDeviceController, Windows.Media.Devices.IVideoDeviceController {
+    GetAvailableMediaStreamProperties(mediaStreamType: number): Windows.Foundation.Collections.IVectorView<Windows.Media.MediaProperties.IMediaEncodingProperties> | Windows.Media.MediaProperties.IMediaEncodingProperties[];
+    GetDeviceProperty(propertyId: string): Object;
+    GetDevicePropertyByExtendedId(extendedPropertyId: number[], maxPropertyValueSize: number | null): Windows.Media.Devices.VideoDeviceControllerGetDevicePropertyResult;
+    GetDevicePropertyById(propertyId: string, maxPropertyValueSize: number | null): Windows.Media.Devices.VideoDeviceControllerGetDevicePropertyResult;
+    GetMediaStreamProperties(mediaStreamType: number): Windows.Media.MediaProperties.IMediaEncodingProperties;
+    SetDeviceProperty(propertyId: string, propertyValue: Object): void;
+    SetDevicePropertyByExtendedId(extendedPropertyId: number[], propertyValue: number[]): number;
+    SetDevicePropertyById(propertyId: string, propertyValue: Object): number;
+    SetMediaStreamPropertiesAsync(mediaStreamType: number, mediaEncodingProperties: Windows.Media.MediaProperties.IMediaEncodingProperties): Windows.Foundation.IAsyncAction;
+    TryAcquireExclusiveControl(deviceId: string, mode: number): boolean;
+    TryGetPowerlineFrequency(value: number): boolean;
+    TrySetPowerlineFrequency(value: number): boolean;
+    readonly AdvancedPhotoControl: Windows.Media.Devices.AdvancedPhotoControl;
+    readonly BacklightCompensation: Windows.Media.Devices.MediaDeviceControl;
+    readonly Brightness: Windows.Media.Devices.MediaDeviceControl;
+    readonly CameraOcclusionInfo: Windows.Media.Devices.CameraOcclusionInfo;
+    readonly Contrast: Windows.Media.Devices.MediaDeviceControl;
+    DesiredOptimization: number;
+    readonly DigitalWindowControl: Windows.Media.Devices.DigitalWindowControl;
+    readonly Exposure: Windows.Media.Devices.MediaDeviceControl;
+    readonly ExposureCompensationControl: Windows.Media.Devices.ExposureCompensationControl;
+    readonly ExposureControl: Windows.Media.Devices.ExposureControl;
+    readonly ExposurePriorityVideoControl: Windows.Media.Devices.ExposurePriorityVideoControl;
+    readonly FlashControl: Windows.Media.Devices.FlashControl;
+    readonly Focus: Windows.Media.Devices.MediaDeviceControl;
+    readonly FocusControl: Windows.Media.Devices.FocusControl;
+    readonly HdrVideoControl: Windows.Media.Devices.HdrVideoControl;
+    readonly Hue: Windows.Media.Devices.MediaDeviceControl;
+    readonly Id: string;
+    readonly InfraredTorchControl: Windows.Media.Devices.InfraredTorchControl;
+    readonly IsoSpeedControl: Windows.Media.Devices.IsoSpeedControl;
+    readonly LowLagPhoto: Windows.Media.Devices.LowLagPhotoControl;
+    readonly LowLagPhotoSequence: Windows.Media.Devices.LowLagPhotoSequenceControl;
+    readonly OpticalImageStabilizationControl: Windows.Media.Devices.OpticalImageStabilizationControl;
+    readonly Pan: Windows.Media.Devices.MediaDeviceControl;
+    readonly PanelBasedOptimizationControl: Windows.Media.Devices.PanelBasedOptimizationControl;
+    readonly PhotoConfirmationControl: Windows.Media.Devices.PhotoConfirmationControl;
+    PrimaryUse: number;
+    readonly RegionsOfInterestControl: Windows.Media.Devices.RegionsOfInterestControl;
+    readonly Roll: Windows.Media.Devices.MediaDeviceControl;
+    readonly SceneModeControl: Windows.Media.Devices.SceneModeControl;
+    readonly Tilt: Windows.Media.Devices.MediaDeviceControl;
+    readonly TorchControl: Windows.Media.Devices.TorchControl;
+    readonly VariablePhotoSequenceController: Windows.Media.Devices.Core.VariablePhotoSequenceController;
+    readonly VideoTemporalDenoisingControl: Windows.Media.Devices.VideoTemporalDenoisingControl;
+    readonly WhiteBalance: Windows.Media.Devices.MediaDeviceControl;
+    readonly WhiteBalanceControl: Windows.Media.Devices.WhiteBalanceControl;
+    readonly Zoom: Windows.Media.Devices.MediaDeviceControl;
+    readonly ZoomControl: Windows.Media.Devices.ZoomControl;
+  }
+
+  class VideoDeviceControllerGetDevicePropertyResult implements Windows.Media.Devices.IVideoDeviceControllerGetDevicePropertyResult {
+    readonly Status: number;
+    readonly Value: Object;
+  }
+
+  class VideoTemporalDenoisingControl implements Windows.Media.Devices.IVideoTemporalDenoisingControl {
+    Mode: number;
+    readonly Supported: boolean;
+    readonly SupportedModes: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class WhiteBalanceControl implements Windows.Media.Devices.IWhiteBalanceControl {
+    SetPresetAsync(preset: number): Windows.Foundation.IAsyncAction;
+    SetValueAsync(temperature: number): Windows.Foundation.IAsyncAction;
+    readonly Max: number;
+    readonly Min: number;
+    readonly Preset: number;
+    readonly Step: number;
+    readonly Supported: boolean;
+    readonly Value: number;
+  }
+
+  class ZoomControl implements Windows.Media.Devices.IZoomControl, Windows.Media.Devices.IZoomControl2 {
+    Configure(settings: Windows.Media.Devices.ZoomSettings): void;
+    readonly Max: number;
+    readonly Min: number;
+    readonly Mode: number;
+    readonly Step: number;
+    readonly Supported: boolean;
+    readonly SupportedModes: Windows.Foundation.Collections.IVectorView<number> | number[];
+    Value: number;
+  }
+
+  class ZoomSettings implements Windows.Media.Devices.IZoomSettings {
+    constructor();
+    Mode: number;
+    Value: number;
+  }
+
+  enum AdvancedPhotoMode {
+    Auto = 0,
+    Standard = 1,
+    Hdr = 2,
+    LowLight = 3,
+  }
+
+  enum AudioDeviceRole {
+    Default = 0,
+    Communications = 1,
+  }
+
+  enum AutoFocusRange {
+    FullRange = 0,
+    Macro = 1,
+    Normal = 2,
+  }
+
+  enum CameraOcclusionKind {
+    Lid = 0,
+    CameraHardware = 1,
+  }
+
+  enum CameraStreamState {
+    NotStreaming = 0,
+    Streaming = 1,
+    BlockedForPrivacy = 2,
+    Shutdown = 3,
+  }
+
+  enum CaptureSceneMode {
+    Auto = 0,
+    Manual = 1,
+    Macro = 2,
+    Portrait = 3,
+    Sport = 4,
+    Snow = 5,
+    Night = 6,
+    Beach = 7,
+    Sunset = 8,
+    Candlelight = 9,
+    Landscape = 10,
+    NightPortrait = 11,
+    Backlit = 12,
+  }
+
+  enum CaptureUse {
+    None = 0,
+    Photo = 1,
+    Video = 2,
+  }
+
+  enum ColorTemperaturePreset {
+    Auto = 0,
+    Manual = 1,
+    Cloudy = 2,
+    Daylight = 3,
+    Flash = 4,
+    Fluorescent = 5,
+    Tungsten = 6,
+    Candlelight = 7,
+  }
+
+  enum DigitalWindowMode {
+    Off = 0,
+    On = 1,
+    Auto = 2,
+  }
+
+  enum FocusMode {
+    Auto = 0,
+    Single = 1,
+    Continuous = 2,
+    Manual = 3,
+  }
+
+  enum FocusPreset {
+    Auto = 0,
+    Manual = 1,
+    AutoMacro = 2,
+    AutoNormal = 3,
+    AutoInfinity = 4,
+    AutoHyperfocal = 5,
+  }
+
+  enum HdrVideoMode {
+    Off = 0,
+    On = 1,
+    Auto = 2,
+  }
+
+  enum InfraredTorchMode {
+    Off = 0,
+    On = 1,
+    AlternatingFrameIllumination = 2,
+  }
+
+  enum IsoSpeedPreset {
+    Auto = 0,
+    Iso50 = 1,
+    Iso80 = 2,
+    Iso100 = 3,
+    Iso200 = 4,
+    Iso400 = 5,
+    Iso800 = 6,
+    Iso1600 = 7,
+    Iso3200 = 8,
+    Iso6400 = 9,
+    Iso12800 = 10,
+    Iso25600 = 11,
+  }
+
+  enum ManualFocusDistance {
+    Infinity = 0,
+    Hyperfocal = 1,
+    Nearest = 2,
+  }
+
+  enum MediaCaptureFocusState {
+    Uninitialized = 0,
+    Lost = 1,
+    Searching = 2,
+    Focused = 3,
+    Failed = 4,
+  }
+
+  enum MediaCaptureOptimization {
+    Default = 0,
+    Quality = 1,
+    Latency = 2,
+    Power = 3,
+    LatencyThenQuality = 4,
+    LatencyThenPower = 5,
+    PowerAndQuality = 6,
+  }
+
+  enum MediaCapturePauseBehavior {
+    RetainHardwareResources = 0,
+    ReleaseHardwareResources = 1,
+  }
+
+  enum OpticalImageStabilizationMode {
+    Off = 0,
+    On = 1,
+    Auto = 2,
+  }
+
+  enum RegionOfInterestType {
+    Unknown = 0,
+    Face = 1,
+  }
+
+  enum SendCommandStatus {
+    Success = 0,
+    DeviceNotAvailable = 1,
+  }
+
+  enum TelephonyKey {
+    D0 = 0,
+    D1 = 1,
+    D2 = 2,
+    D3 = 3,
+    D4 = 4,
+    D5 = 5,
+    D6 = 6,
+    D7 = 7,
+    D8 = 8,
+    D9 = 9,
+    Star = 10,
+    Pound = 11,
+    A = 12,
+    B = 13,
+    C = 14,
+    D = 15,
+  }
+
+  enum VideoDeviceControllerGetDevicePropertyStatus {
+    Success = 0,
+    UnknownFailure = 1,
+    BufferTooSmall = 2,
+    NotSupported = 3,
+    DeviceNotAvailable = 4,
+    MaxPropertyValueSizeTooSmall = 5,
+    MaxPropertyValueSizeRequired = 6,
+  }
+
+  enum VideoDeviceControllerSetDevicePropertyStatus {
+    Success = 0,
+    UnknownFailure = 1,
+    NotSupported = 2,
+    InvalidValue = 3,
+    DeviceNotAvailable = 4,
+    NotInControl = 5,
+  }
+
+  enum VideoTemporalDenoisingMode {
+    Off = 0,
+    On = 1,
+    Auto = 2,
+  }
+
+  enum ZoomTransitionMode {
+    Auto = 0,
+    Direct = 1,
+    Smooth = 2,
+  }
+
+  interface CallControlContract {
+  }
+  var CallControlContract: {
+    new(fields: {  }): CallControlContract;
+  };
+
+  interface CallControlEventHandler {
+    (sender: Windows.Media.Devices.CallControl): void;
+  }
+  var CallControlEventHandler: {
+    new(callback: (sender: Windows.Media.Devices.CallControl) => void): CallControlEventHandler;
+  };
+
+  interface DialRequestedEventHandler {
+    (sender: Windows.Media.Devices.CallControl, e: Windows.Media.Devices.DialRequestedEventArgs): void;
+  }
+  var DialRequestedEventHandler: {
+    new(callback: (sender: Windows.Media.Devices.CallControl, e: Windows.Media.Devices.DialRequestedEventArgs) => void): DialRequestedEventHandler;
+  };
+
+  interface IAdvancedPhotoCaptureSettings {
+    Mode: number;
+  }
+  var IAdvancedPhotoCaptureSettings: abstract new (...args: any[]) => IAdvancedPhotoCaptureSettings;
+
+  interface IAdvancedPhotoControl {
+    Configure(settings: Windows.Media.Devices.AdvancedPhotoCaptureSettings): void;
+    readonly Mode: number;
+    readonly Supported: boolean;
+    readonly SupportedModes: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IAdvancedPhotoControl: abstract new (...args: any[]) => IAdvancedPhotoControl;
+
+  interface IAdvancedVideoCaptureDeviceController {
+    GetDeviceProperty(propertyId: string): Object;
+    SetDeviceProperty(propertyId: string, propertyValue: Object): void;
+  }
+  var IAdvancedVideoCaptureDeviceController: abstract new (...args: any[]) => IAdvancedVideoCaptureDeviceController;
+
+  interface IAdvancedVideoCaptureDeviceController10 {
+    readonly CameraOcclusionInfo: Windows.Media.Devices.CameraOcclusionInfo;
+  }
+  var IAdvancedVideoCaptureDeviceController10: abstract new (...args: any[]) => IAdvancedVideoCaptureDeviceController10;
+
+  interface IAdvancedVideoCaptureDeviceController11 {
+    TryAcquireExclusiveControl(deviceId: string, mode: number): boolean;
+  }
+  var IAdvancedVideoCaptureDeviceController11: abstract new (...args: any[]) => IAdvancedVideoCaptureDeviceController11;
+
+  interface IAdvancedVideoCaptureDeviceController2 {
+    readonly ExposureCompensationControl: Windows.Media.Devices.ExposureCompensationControl;
+    readonly ExposureControl: Windows.Media.Devices.ExposureControl;
+    readonly FlashControl: Windows.Media.Devices.FlashControl;
+    readonly FocusControl: Windows.Media.Devices.FocusControl;
+    readonly IsoSpeedControl: Windows.Media.Devices.IsoSpeedControl;
+    readonly LowLagPhoto: Windows.Media.Devices.LowLagPhotoControl;
+    readonly LowLagPhotoSequence: Windows.Media.Devices.LowLagPhotoSequenceControl;
+    PrimaryUse: number;
+    readonly RegionsOfInterestControl: Windows.Media.Devices.RegionsOfInterestControl;
+    readonly SceneModeControl: Windows.Media.Devices.SceneModeControl;
+    readonly TorchControl: Windows.Media.Devices.TorchControl;
+    readonly WhiteBalanceControl: Windows.Media.Devices.WhiteBalanceControl;
+  }
+  var IAdvancedVideoCaptureDeviceController2: abstract new (...args: any[]) => IAdvancedVideoCaptureDeviceController2;
+
+  interface IAdvancedVideoCaptureDeviceController3 {
+    readonly PhotoConfirmationControl: Windows.Media.Devices.PhotoConfirmationControl;
+    readonly VariablePhotoSequenceController: Windows.Media.Devices.Core.VariablePhotoSequenceController;
+    readonly ZoomControl: Windows.Media.Devices.ZoomControl;
+  }
+  var IAdvancedVideoCaptureDeviceController3: abstract new (...args: any[]) => IAdvancedVideoCaptureDeviceController3;
+
+  interface IAdvancedVideoCaptureDeviceController4 {
+    readonly AdvancedPhotoControl: Windows.Media.Devices.AdvancedPhotoControl;
+    DesiredOptimization: number;
+    readonly ExposurePriorityVideoControl: Windows.Media.Devices.ExposurePriorityVideoControl;
+    readonly HdrVideoControl: Windows.Media.Devices.HdrVideoControl;
+    readonly OpticalImageStabilizationControl: Windows.Media.Devices.OpticalImageStabilizationControl;
+  }
+  var IAdvancedVideoCaptureDeviceController4: abstract new (...args: any[]) => IAdvancedVideoCaptureDeviceController4;
+
+  interface IAdvancedVideoCaptureDeviceController5 {
+    GetDevicePropertyByExtendedId(extendedPropertyId: number[], maxPropertyValueSize: number | null): Windows.Media.Devices.VideoDeviceControllerGetDevicePropertyResult;
+    GetDevicePropertyById(propertyId: string, maxPropertyValueSize: number | null): Windows.Media.Devices.VideoDeviceControllerGetDevicePropertyResult;
+    SetDevicePropertyByExtendedId(extendedPropertyId: number[], propertyValue: number[]): number;
+    SetDevicePropertyById(propertyId: string, propertyValue: Object): number;
+    readonly Id: string;
+  }
+  var IAdvancedVideoCaptureDeviceController5: abstract new (...args: any[]) => IAdvancedVideoCaptureDeviceController5;
+
+  interface IAdvancedVideoCaptureDeviceController6 {
+    readonly VideoTemporalDenoisingControl: Windows.Media.Devices.VideoTemporalDenoisingControl;
+  }
+  var IAdvancedVideoCaptureDeviceController6: abstract new (...args: any[]) => IAdvancedVideoCaptureDeviceController6;
+
+  interface IAdvancedVideoCaptureDeviceController7 {
+    readonly InfraredTorchControl: Windows.Media.Devices.InfraredTorchControl;
+  }
+  var IAdvancedVideoCaptureDeviceController7: abstract new (...args: any[]) => IAdvancedVideoCaptureDeviceController7;
+
+  interface IAdvancedVideoCaptureDeviceController8 {
+    readonly PanelBasedOptimizationControl: Windows.Media.Devices.PanelBasedOptimizationControl;
+  }
+  var IAdvancedVideoCaptureDeviceController8: abstract new (...args: any[]) => IAdvancedVideoCaptureDeviceController8;
+
+  interface IAdvancedVideoCaptureDeviceController9 {
+    readonly DigitalWindowControl: Windows.Media.Devices.DigitalWindowControl;
+  }
+  var IAdvancedVideoCaptureDeviceController9: abstract new (...args: any[]) => IAdvancedVideoCaptureDeviceController9;
+
+  interface IAudioDeviceController extends Windows.Media.Devices.IMediaDeviceController {
+    GetAvailableMediaStreamProperties(mediaStreamType: number): Windows.Foundation.Collections.IVectorView<Windows.Media.MediaProperties.IMediaEncodingProperties> | Windows.Media.MediaProperties.IMediaEncodingProperties[];
+    GetMediaStreamProperties(mediaStreamType: number): Windows.Media.MediaProperties.IMediaEncodingProperties;
+    SetMediaStreamPropertiesAsync(mediaStreamType: number, mediaEncodingProperties: Windows.Media.MediaProperties.IMediaEncodingProperties): Windows.Foundation.IAsyncAction;
+    Muted: boolean;
+    VolumePercent: number;
+  }
+  var IAudioDeviceController: abstract new (...args: any[]) => IAudioDeviceController;
+
+  interface IAudioDeviceController2 {
+    readonly AudioCaptureEffectsManager: Windows.Media.Effects.AudioCaptureEffectsManager;
+  }
+  var IAudioDeviceController2: abstract new (...args: any[]) => IAudioDeviceController2;
+
+  interface IAudioDeviceModule {
+    SendCommandAsync(Command: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Media.Devices.ModuleCommandResult>;
+    readonly ClassId: string;
+    readonly DisplayName: string;
+    readonly InstanceId: number;
+    readonly MajorVersion: number;
+    readonly MinorVersion: number;
+  }
+  var IAudioDeviceModule: abstract new (...args: any[]) => IAudioDeviceModule;
+
+  interface IAudioDeviceModuleNotificationEventArgs {
+    readonly Module: Windows.Media.Devices.AudioDeviceModule;
+    readonly NotificationData: Windows.Storage.Streams.IBuffer;
+  }
+  var IAudioDeviceModuleNotificationEventArgs: abstract new (...args: any[]) => IAudioDeviceModuleNotificationEventArgs;
+
+  interface IAudioDeviceModulesManager {
+    FindAll(): Windows.Foundation.Collections.IVectorView<Windows.Media.Devices.AudioDeviceModule> | Windows.Media.Devices.AudioDeviceModule[];
+    FindAllById(moduleId: string): Windows.Foundation.Collections.IVectorView<Windows.Media.Devices.AudioDeviceModule> | Windows.Media.Devices.AudioDeviceModule[];
+    ModuleNotificationReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Devices.AudioDeviceModulesManager, Windows.Media.Devices.AudioDeviceModuleNotificationEventArgs> | null;
+  }
+  var IAudioDeviceModulesManager: abstract new (...args: any[]) => IAudioDeviceModulesManager;
+
+  interface IAudioDeviceModulesManagerFactory {
+    Create(deviceId: string): Windows.Media.Devices.AudioDeviceModulesManager;
+  }
+  var IAudioDeviceModulesManagerFactory: abstract new (...args: any[]) => IAudioDeviceModulesManagerFactory;
+
+  interface ICallControl {
+    EndCall(callToken: number | bigint): void;
+    IndicateActiveCall(callToken: number | bigint): void;
+    IndicateNewIncomingCall(enableRinger: boolean, callerId: string): number | bigint;
+    IndicateNewOutgoingCall(): number | bigint;
+    readonly HasRinger: boolean;
+    AnswerRequested: Windows.Media.Devices.CallControlEventHandler | null;
+    AudioTransferRequested: Windows.Media.Devices.CallControlEventHandler | null;
+    DialRequested: Windows.Media.Devices.DialRequestedEventHandler | null;
+    HangUpRequested: Windows.Media.Devices.CallControlEventHandler | null;
+    KeypadPressed: Windows.Media.Devices.KeypadPressedEventHandler | null;
+    RedialRequested: Windows.Media.Devices.RedialRequestedEventHandler | null;
+  }
+  var ICallControl: abstract new (...args: any[]) => ICallControl;
+
+  interface ICallControlStatics {
+    FromId(deviceId: string): Windows.Media.Devices.CallControl;
+    GetDefault(): Windows.Media.Devices.CallControl;
+  }
+  var ICallControlStatics: abstract new (...args: any[]) => ICallControlStatics;
+
+  interface ICameraOcclusionInfo {
+    GetState(): Windows.Media.Devices.CameraOcclusionState;
+    IsOcclusionKindSupported(occlusionKind: number): boolean;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Devices.CameraOcclusionInfo, Windows.Media.Devices.CameraOcclusionStateChangedEventArgs> | null;
+  }
+  var ICameraOcclusionInfo: abstract new (...args: any[]) => ICameraOcclusionInfo;
+
+  interface ICameraOcclusionState {
+    IsOcclusionKind(occlusionKind: number): boolean;
+    readonly IsOccluded: boolean;
+  }
+  var ICameraOcclusionState: abstract new (...args: any[]) => ICameraOcclusionState;
+
+  interface ICameraOcclusionStateChangedEventArgs {
+    readonly State: Windows.Media.Devices.CameraOcclusionState;
+  }
+  var ICameraOcclusionStateChangedEventArgs: abstract new (...args: any[]) => ICameraOcclusionStateChangedEventArgs;
+
+  interface IDefaultAudioDeviceChangedEventArgs {
+    readonly Id: string;
+    readonly Role: number;
+  }
+  var IDefaultAudioDeviceChangedEventArgs: abstract new (...args: any[]) => IDefaultAudioDeviceChangedEventArgs;
+
+  interface IDialRequestedEventArgs {
+    Handled(): void;
+    readonly Contact: Object;
+  }
+  var IDialRequestedEventArgs: abstract new (...args: any[]) => IDialRequestedEventArgs;
+
+  interface IDigitalWindowBounds {
+    NormalizedOriginLeft: number;
+    NormalizedOriginTop: number;
+    Scale: number;
+  }
+  var IDigitalWindowBounds: abstract new (...args: any[]) => IDigitalWindowBounds;
+
+  interface IDigitalWindowCapability {
+    readonly Height: number;
+    readonly MaxScaleValue: number;
+    readonly MinScaleValue: number;
+    readonly MinScaleValueWithoutUpsampling: number;
+    readonly NormalizedFieldOfViewLimit: Windows.Foundation.Rect;
+    readonly Width: number;
+  }
+  var IDigitalWindowCapability: abstract new (...args: any[]) => IDigitalWindowCapability;
+
+  interface IDigitalWindowControl {
+    Configure(digitalWindowMode: number): void;
+    Configure(digitalWindowMode: number, digitalWindowBounds: Windows.Media.Devices.DigitalWindowBounds): void;
+    GetBounds(): Windows.Media.Devices.DigitalWindowBounds;
+    GetCapabilityForSize(width: number, height: number): Windows.Media.Devices.DigitalWindowCapability;
+    readonly CurrentMode: number;
+    readonly IsSupported: boolean;
+    readonly SupportedCapabilities: Windows.Foundation.Collections.IVectorView<Windows.Media.Devices.DigitalWindowCapability> | Windows.Media.Devices.DigitalWindowCapability[];
+    readonly SupportedModes: number[];
+  }
+  var IDigitalWindowControl: abstract new (...args: any[]) => IDigitalWindowControl;
+
+  interface IExposureCompensationControl {
+    SetValueAsync(value: number): Windows.Foundation.IAsyncAction;
+    readonly Max: number;
+    readonly Min: number;
+    readonly Step: number;
+    readonly Supported: boolean;
+    readonly Value: number;
+  }
+  var IExposureCompensationControl: abstract new (...args: any[]) => IExposureCompensationControl;
+
+  interface IExposureControl {
+    SetAutoAsync(value: boolean): Windows.Foundation.IAsyncAction;
+    SetValueAsync(shutterDuration: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncAction;
+    readonly Auto: boolean;
+    readonly Max: Windows.Foundation.TimeSpan;
+    readonly Min: Windows.Foundation.TimeSpan;
+    readonly Step: Windows.Foundation.TimeSpan;
+    readonly Supported: boolean;
+    readonly Value: Windows.Foundation.TimeSpan;
+  }
+  var IExposureControl: abstract new (...args: any[]) => IExposureControl;
+
+  interface IExposurePriorityVideoControl {
+    Enabled: boolean;
+    readonly Supported: boolean;
+  }
+  var IExposurePriorityVideoControl: abstract new (...args: any[]) => IExposurePriorityVideoControl;
+
+  interface IFlashControl {
+    Auto: boolean;
+    Enabled: boolean;
+    PowerPercent: number;
+    readonly PowerSupported: boolean;
+    RedEyeReduction: boolean;
+    readonly RedEyeReductionSupported: boolean;
+    readonly Supported: boolean;
+  }
+  var IFlashControl: abstract new (...args: any[]) => IFlashControl;
+
+  interface IFlashControl2 {
+    AssistantLightEnabled: boolean;
+    readonly AssistantLightSupported: boolean;
+  }
+  var IFlashControl2: abstract new (...args: any[]) => IFlashControl2;
+
+  interface IFocusControl {
+    FocusAsync(): Windows.Foundation.IAsyncAction;
+    SetPresetAsync(preset: number): Windows.Foundation.IAsyncAction;
+    SetPresetAsync(preset: number, completeBeforeFocus: boolean): Windows.Foundation.IAsyncAction;
+    SetValueAsync(focus: number): Windows.Foundation.IAsyncAction;
+    readonly Max: number;
+    readonly Min: number;
+    readonly Preset: number;
+    readonly Step: number;
+    readonly Supported: boolean;
+    readonly SupportedPresets: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Value: number;
+  }
+  var IFocusControl: abstract new (...args: any[]) => IFocusControl;
+
+  interface IFocusControl2 {
+    Configure(settings: Windows.Media.Devices.FocusSettings): void;
+    LockAsync(): Windows.Foundation.IAsyncAction;
+    UnlockAsync(): Windows.Foundation.IAsyncAction;
+    readonly FocusChangedSupported: boolean;
+    readonly FocusState: number;
+    readonly Mode: number;
+    readonly SupportedFocusDistances: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedFocusModes: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedFocusRanges: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly WaitForFocusSupported: boolean;
+  }
+  var IFocusControl2: abstract new (...args: any[]) => IFocusControl2;
+
+  interface IFocusSettings {
+    AutoFocusRange: number;
+    DisableDriverFallback: boolean;
+    Distance: number | null;
+    Mode: number;
+    Value: number | null;
+    WaitForFocus: boolean;
+  }
+  var IFocusSettings: abstract new (...args: any[]) => IFocusSettings;
+
+  interface IHdrVideoControl {
+    Mode: number;
+    readonly Supported: boolean;
+    readonly SupportedModes: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IHdrVideoControl: abstract new (...args: any[]) => IHdrVideoControl;
+
+  interface IInfraredTorchControl {
+    CurrentMode: number;
+    readonly IsSupported: boolean;
+    readonly MaxPower: number;
+    readonly MinPower: number;
+    Power: number;
+    readonly PowerStep: number;
+    readonly SupportedModes: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IInfraredTorchControl: abstract new (...args: any[]) => IInfraredTorchControl;
+
+  interface IIsoSpeedControl {
+    SetPresetAsync(preset: number): Windows.Foundation.IAsyncAction;
+    readonly Preset: number;
+    readonly Supported: boolean;
+    readonly SupportedPresets: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IIsoSpeedControl: abstract new (...args: any[]) => IIsoSpeedControl;
+
+  interface IIsoSpeedControl2 {
+    SetAutoAsync(): Windows.Foundation.IAsyncAction;
+    SetValueAsync(isoSpeed: number): Windows.Foundation.IAsyncAction;
+    readonly Auto: boolean;
+    readonly Max: number;
+    readonly Min: number;
+    readonly Step: number;
+    readonly Value: number;
+  }
+  var IIsoSpeedControl2: abstract new (...args: any[]) => IIsoSpeedControl2;
+
+  interface IKeypadPressedEventArgs {
+    readonly TelephonyKey: number;
+  }
+  var IKeypadPressedEventArgs: abstract new (...args: any[]) => IKeypadPressedEventArgs;
+
+  interface ILowLagPhotoControl {
+    GetCurrentFrameRate(): Windows.Media.MediaProperties.MediaRatio;
+    GetHighestConcurrentFrameRate(captureProperties: Windows.Media.MediaProperties.IMediaEncodingProperties): Windows.Media.MediaProperties.MediaRatio;
+    DesiredThumbnailSize: number;
+    readonly HardwareAcceleratedThumbnailSupported: number;
+    ThumbnailEnabled: boolean;
+    ThumbnailFormat: number;
+  }
+  var ILowLagPhotoControl: abstract new (...args: any[]) => ILowLagPhotoControl;
+
+  interface ILowLagPhotoSequenceControl {
+    GetCurrentFrameRate(): Windows.Media.MediaProperties.MediaRatio;
+    GetHighestConcurrentFrameRate(captureProperties: Windows.Media.MediaProperties.IMediaEncodingProperties): Windows.Media.MediaProperties.MediaRatio;
+    DesiredThumbnailSize: number;
+    readonly HardwareAcceleratedThumbnailSupported: number;
+    readonly MaxPastPhotos: number;
+    readonly MaxPhotosPerSecond: number;
+    PastPhotoLimit: number;
+    PhotosPerSecondLimit: number;
+    readonly Supported: boolean;
+    ThumbnailEnabled: boolean;
+    ThumbnailFormat: number;
+  }
+  var ILowLagPhotoSequenceControl: abstract new (...args: any[]) => ILowLagPhotoSequenceControl;
+
+  interface IMediaDeviceControl {
+    TryGetAuto(value: boolean): boolean;
+    TryGetValue(value: number): boolean;
+    TrySetAuto(value: boolean): boolean;
+    TrySetValue(value: number): boolean;
+    readonly Capabilities: Windows.Media.Devices.MediaDeviceControlCapabilities;
+  }
+  var IMediaDeviceControl: abstract new (...args: any[]) => IMediaDeviceControl;
+
+  interface IMediaDeviceControlCapabilities {
+    readonly AutoModeSupported: boolean;
+    readonly Default: number;
+    readonly Max: number;
+    readonly Min: number;
+    readonly Step: number;
+    readonly Supported: boolean;
+  }
+  var IMediaDeviceControlCapabilities: abstract new (...args: any[]) => IMediaDeviceControlCapabilities;
+
+  interface IMediaDeviceController {
+    GetAvailableMediaStreamProperties(mediaStreamType: number): Windows.Foundation.Collections.IVectorView<Windows.Media.MediaProperties.IMediaEncodingProperties> | Windows.Media.MediaProperties.IMediaEncodingProperties[];
+    GetMediaStreamProperties(mediaStreamType: number): Windows.Media.MediaProperties.IMediaEncodingProperties;
+    SetMediaStreamPropertiesAsync(mediaStreamType: number, mediaEncodingProperties: Windows.Media.MediaProperties.IMediaEncodingProperties): Windows.Foundation.IAsyncAction;
+  }
+  var IMediaDeviceController: abstract new (...args: any[]) => IMediaDeviceController;
+
+  interface IMediaDeviceStatics {
+    GetAudioCaptureSelector(): string;
+    GetAudioRenderSelector(): string;
+    GetDefaultAudioCaptureId(role: number): string;
+    GetDefaultAudioRenderId(role: number): string;
+    GetVideoCaptureSelector(): string;
+    DefaultAudioCaptureDeviceChanged: Windows.Foundation.TypedEventHandler<Object, Windows.Media.Devices.DefaultAudioCaptureDeviceChangedEventArgs> | null;
+    DefaultAudioRenderDeviceChanged: Windows.Foundation.TypedEventHandler<Object, Windows.Media.Devices.DefaultAudioRenderDeviceChangedEventArgs> | null;
+  }
+  var IMediaDeviceStatics: abstract new (...args: any[]) => IMediaDeviceStatics;
+
+  interface IModuleCommandResult {
+    readonly Result: Windows.Storage.Streams.IBuffer;
+    readonly Status: number;
+  }
+  var IModuleCommandResult: abstract new (...args: any[]) => IModuleCommandResult;
+
+  interface IOpticalImageStabilizationControl {
+    Mode: number;
+    readonly Supported: boolean;
+    readonly SupportedModes: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IOpticalImageStabilizationControl: abstract new (...args: any[]) => IOpticalImageStabilizationControl;
+
+  interface IPanelBasedOptimizationControl {
+    readonly IsSupported: boolean;
+    Panel: number;
+  }
+  var IPanelBasedOptimizationControl: abstract new (...args: any[]) => IPanelBasedOptimizationControl;
+
+  interface IPhotoConfirmationControl {
+    Enabled: boolean;
+    PixelFormat: number;
+    readonly Supported: boolean;
+  }
+  var IPhotoConfirmationControl: abstract new (...args: any[]) => IPhotoConfirmationControl;
+
+  interface IRedialRequestedEventArgs {
+    Handled(): void;
+  }
+  var IRedialRequestedEventArgs: abstract new (...args: any[]) => IRedialRequestedEventArgs;
+
+  interface IRegionOfInterest {
+    AutoExposureEnabled: boolean;
+    AutoFocusEnabled: boolean;
+    AutoWhiteBalanceEnabled: boolean;
+    Bounds: Windows.Foundation.Rect;
+  }
+  var IRegionOfInterest: abstract new (...args: any[]) => IRegionOfInterest;
+
+  interface IRegionOfInterest2 {
+    BoundsNormalized: boolean;
+    Type: number;
+    Weight: number;
+  }
+  var IRegionOfInterest2: abstract new (...args: any[]) => IRegionOfInterest2;
+
+  interface IRegionsOfInterestControl {
+    ClearRegionsAsync(): Windows.Foundation.IAsyncAction;
+    SetRegionsAsync(regions: Windows.Foundation.Collections.IIterable<Windows.Media.Devices.RegionOfInterest> | Windows.Media.Devices.RegionOfInterest[]): Windows.Foundation.IAsyncAction;
+    SetRegionsAsync(regions: Windows.Foundation.Collections.IIterable<Windows.Media.Devices.RegionOfInterest> | Windows.Media.Devices.RegionOfInterest[], lockValues: boolean): Windows.Foundation.IAsyncAction;
+    readonly AutoExposureSupported: boolean;
+    readonly AutoFocusSupported: boolean;
+    readonly AutoWhiteBalanceSupported: boolean;
+    readonly MaxRegions: number;
+  }
+  var IRegionsOfInterestControl: abstract new (...args: any[]) => IRegionsOfInterestControl;
+
+  interface ISceneModeControl {
+    SetValueAsync(sceneMode: number): Windows.Foundation.IAsyncAction;
+    readonly SupportedModes: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Value: number;
+  }
+  var ISceneModeControl: abstract new (...args: any[]) => ISceneModeControl;
+
+  interface ITorchControl {
+    Enabled: boolean;
+    PowerPercent: number;
+    readonly PowerSupported: boolean;
+    readonly Supported: boolean;
+  }
+  var ITorchControl: abstract new (...args: any[]) => ITorchControl;
+
+  interface IVideoDeviceController extends Windows.Media.Devices.IMediaDeviceController {
+    GetAvailableMediaStreamProperties(mediaStreamType: number): Windows.Foundation.Collections.IVectorView<Windows.Media.MediaProperties.IMediaEncodingProperties> | Windows.Media.MediaProperties.IMediaEncodingProperties[];
+    GetMediaStreamProperties(mediaStreamType: number): Windows.Media.MediaProperties.IMediaEncodingProperties;
+    SetMediaStreamPropertiesAsync(mediaStreamType: number, mediaEncodingProperties: Windows.Media.MediaProperties.IMediaEncodingProperties): Windows.Foundation.IAsyncAction;
+    TryGetPowerlineFrequency(value: number): boolean;
+    TrySetPowerlineFrequency(value: number): boolean;
+    readonly BacklightCompensation: Windows.Media.Devices.MediaDeviceControl;
+    readonly Brightness: Windows.Media.Devices.MediaDeviceControl;
+    readonly Contrast: Windows.Media.Devices.MediaDeviceControl;
+    readonly Exposure: Windows.Media.Devices.MediaDeviceControl;
+    readonly Focus: Windows.Media.Devices.MediaDeviceControl;
+    readonly Hue: Windows.Media.Devices.MediaDeviceControl;
+    readonly Pan: Windows.Media.Devices.MediaDeviceControl;
+    readonly Roll: Windows.Media.Devices.MediaDeviceControl;
+    readonly Tilt: Windows.Media.Devices.MediaDeviceControl;
+    readonly WhiteBalance: Windows.Media.Devices.MediaDeviceControl;
+    readonly Zoom: Windows.Media.Devices.MediaDeviceControl;
+  }
+  var IVideoDeviceController: abstract new (...args: any[]) => IVideoDeviceController;
+
+  interface IVideoDeviceControllerGetDevicePropertyResult {
+    readonly Status: number;
+    readonly Value: Object;
+  }
+  var IVideoDeviceControllerGetDevicePropertyResult: abstract new (...args: any[]) => IVideoDeviceControllerGetDevicePropertyResult;
+
+  interface IVideoTemporalDenoisingControl {
+    Mode: number;
+    readonly Supported: boolean;
+    readonly SupportedModes: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IVideoTemporalDenoisingControl: abstract new (...args: any[]) => IVideoTemporalDenoisingControl;
+
+  interface IWhiteBalanceControl {
+    SetPresetAsync(preset: number): Windows.Foundation.IAsyncAction;
+    SetValueAsync(temperature: number): Windows.Foundation.IAsyncAction;
+    readonly Max: number;
+    readonly Min: number;
+    readonly Preset: number;
+    readonly Step: number;
+    readonly Supported: boolean;
+    readonly Value: number;
+  }
+  var IWhiteBalanceControl: abstract new (...args: any[]) => IWhiteBalanceControl;
+
+  interface IZoomControl {
+    readonly Max: number;
+    readonly Min: number;
+    readonly Step: number;
+    readonly Supported: boolean;
+    Value: number;
+  }
+  var IZoomControl: abstract new (...args: any[]) => IZoomControl;
+
+  interface IZoomControl2 {
+    Configure(settings: Windows.Media.Devices.ZoomSettings): void;
+    readonly Mode: number;
+    readonly SupportedModes: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IZoomControl2: abstract new (...args: any[]) => IZoomControl2;
+
+  interface IZoomSettings {
+    Mode: number;
+    Value: number;
+  }
+  var IZoomSettings: abstract new (...args: any[]) => IZoomSettings;
+
+  interface KeypadPressedEventHandler {
+    (sender: Windows.Media.Devices.CallControl, e: Windows.Media.Devices.KeypadPressedEventArgs): void;
+  }
+  var KeypadPressedEventHandler: {
+    new(callback: (sender: Windows.Media.Devices.CallControl, e: Windows.Media.Devices.KeypadPressedEventArgs) => void): KeypadPressedEventHandler;
+  };
+
+  interface RedialRequestedEventHandler {
+    (sender: Windows.Media.Devices.CallControl, e: Windows.Media.Devices.RedialRequestedEventArgs): void;
+  }
+  var RedialRequestedEventHandler: {
+    new(callback: (sender: Windows.Media.Devices.CallControl, e: Windows.Media.Devices.RedialRequestedEventArgs) => void): RedialRequestedEventHandler;
+  };
+
+}
+
+declare namespace Windows.Media.Devices.Core {
+  class CameraIntrinsics implements Windows.Media.Devices.Core.ICameraIntrinsics, Windows.Media.Devices.Core.ICameraIntrinsics2 {
+    constructor(focalLength: Windows.Foundation.Numerics.Vector2, principalPoint: Windows.Foundation.Numerics.Vector2, radialDistortion: Windows.Foundation.Numerics.Vector3, tangentialDistortion: Windows.Foundation.Numerics.Vector2, imageWidth: number, imageHeight: number);
+    DistortPoint(input: Windows.Foundation.Point): Windows.Foundation.Point;
+    DistortPoints(inputs: Windows.Foundation.Point[], results: Windows.Foundation.Point[]): void;
+    ProjectManyOntoFrame(coordinates: Windows.Foundation.Numerics.Vector3[], results: Windows.Foundation.Point[]): void;
+    ProjectOntoFrame(coordinate: Windows.Foundation.Numerics.Vector3): Windows.Foundation.Point;
+    UndistortPoint(input: Windows.Foundation.Point): Windows.Foundation.Point;
+    UndistortPoints(inputs: Windows.Foundation.Point[], results: Windows.Foundation.Point[]): void;
+    UnprojectAtUnitDepth(pixelCoordinate: Windows.Foundation.Point): Windows.Foundation.Numerics.Vector2;
+    UnprojectPixelsAtUnitDepth(pixelCoordinates: Windows.Foundation.Point[], results: Windows.Foundation.Numerics.Vector2[]): void;
+    readonly FocalLength: Windows.Foundation.Numerics.Vector2;
+    readonly ImageHeight: number;
+    readonly ImageWidth: number;
+    readonly PrincipalPoint: Windows.Foundation.Numerics.Vector2;
+    readonly RadialDistortion: Windows.Foundation.Numerics.Vector3;
+    readonly TangentialDistortion: Windows.Foundation.Numerics.Vector2;
+    readonly UndistortedProjectionTransform: Windows.Foundation.Numerics.Matrix4x4;
+  }
+
+  class DepthCorrelatedCoordinateMapper implements Windows.Foundation.IClosable, Windows.Media.Devices.Core.IDepthCorrelatedCoordinateMapper {
+    Close(): void;
+    MapPoint(sourcePoint: Windows.Foundation.Point, targetCoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, targetCameraIntrinsics: Windows.Media.Devices.Core.CameraIntrinsics): Windows.Foundation.Point;
+    MapPoints(sourcePoints: Windows.Foundation.Point[], targetCoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, targetCameraIntrinsics: Windows.Media.Devices.Core.CameraIntrinsics, results: Windows.Foundation.Point[]): void;
+    UnprojectPoint(sourcePoint: Windows.Foundation.Point, targetCoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Foundation.Numerics.Vector3;
+    UnprojectPoints(sourcePoints: Windows.Foundation.Point[], targetCoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, results: Windows.Foundation.Numerics.Vector3[]): void;
+  }
+
+  class FrameControlCapabilities implements Windows.Media.Devices.Core.IFrameControlCapabilities, Windows.Media.Devices.Core.IFrameControlCapabilities2 {
+    readonly Exposure: Windows.Media.Devices.Core.FrameExposureCapabilities;
+    readonly ExposureCompensation: Windows.Media.Devices.Core.FrameExposureCompensationCapabilities;
+    readonly Flash: Windows.Media.Devices.Core.FrameFlashCapabilities;
+    readonly Focus: Windows.Media.Devices.Core.FrameFocusCapabilities;
+    readonly IsoSpeed: Windows.Media.Devices.Core.FrameIsoSpeedCapabilities;
+    readonly PhotoConfirmationSupported: boolean;
+  }
+
+  class FrameController implements Windows.Media.Devices.Core.IFrameController, Windows.Media.Devices.Core.IFrameController2 {
+    constructor();
+    readonly ExposureCompensationControl: Windows.Media.Devices.Core.FrameExposureCompensationControl;
+    readonly ExposureControl: Windows.Media.Devices.Core.FrameExposureControl;
+    readonly FlashControl: Windows.Media.Devices.Core.FrameFlashControl;
+    readonly FocusControl: Windows.Media.Devices.Core.FrameFocusControl;
+    readonly IsoSpeedControl: Windows.Media.Devices.Core.FrameIsoSpeedControl;
+    PhotoConfirmationEnabled: boolean | null;
+  }
+
+  class FrameExposureCapabilities implements Windows.Media.Devices.Core.IFrameExposureCapabilities {
+    readonly Max: Windows.Foundation.TimeSpan;
+    readonly Min: Windows.Foundation.TimeSpan;
+    readonly Step: Windows.Foundation.TimeSpan;
+    readonly Supported: boolean;
+  }
+
+  class FrameExposureCompensationCapabilities implements Windows.Media.Devices.Core.IFrameExposureCompensationCapabilities {
+    readonly Max: number;
+    readonly Min: number;
+    readonly Step: number;
+    readonly Supported: boolean;
+  }
+
+  class FrameExposureCompensationControl implements Windows.Media.Devices.Core.IFrameExposureCompensationControl {
+    Value: number | null;
+  }
+
+  class FrameExposureControl implements Windows.Media.Devices.Core.IFrameExposureControl {
+    Auto: boolean;
+    Value: Windows.Foundation.TimeSpan | null;
+  }
+
+  class FrameFlashCapabilities implements Windows.Media.Devices.Core.IFrameFlashCapabilities {
+    readonly PowerSupported: boolean;
+    readonly RedEyeReductionSupported: boolean;
+    readonly Supported: boolean;
+  }
+
+  class FrameFlashControl implements Windows.Media.Devices.Core.IFrameFlashControl {
+    Auto: boolean;
+    Mode: number;
+    PowerPercent: number;
+    RedEyeReduction: boolean;
+  }
+
+  class FrameFocusCapabilities implements Windows.Media.Devices.Core.IFrameFocusCapabilities {
+    readonly Max: number;
+    readonly Min: number;
+    readonly Step: number;
+    readonly Supported: boolean;
+  }
+
+  class FrameFocusControl implements Windows.Media.Devices.Core.IFrameFocusControl {
+    Value: number | null;
+  }
+
+  class FrameIsoSpeedCapabilities implements Windows.Media.Devices.Core.IFrameIsoSpeedCapabilities {
+    readonly Max: number;
+    readonly Min: number;
+    readonly Step: number;
+    readonly Supported: boolean;
+  }
+
+  class FrameIsoSpeedControl implements Windows.Media.Devices.Core.IFrameIsoSpeedControl {
+    Auto: boolean;
+    Value: number | null;
+  }
+
+  class VariablePhotoSequenceController implements Windows.Media.Devices.Core.IVariablePhotoSequenceController {
+    GetCurrentFrameRate(): Windows.Media.MediaProperties.MediaRatio;
+    GetHighestConcurrentFrameRate(captureProperties: Windows.Media.MediaProperties.IMediaEncodingProperties): Windows.Media.MediaProperties.MediaRatio;
+    readonly DesiredFrameControllers: Windows.Foundation.Collections.IVector<Windows.Media.Devices.Core.FrameController> | Windows.Media.Devices.Core.FrameController[];
+    readonly FrameCapabilities: Windows.Media.Devices.Core.FrameControlCapabilities;
+    readonly MaxPhotosPerSecond: number;
+    PhotosPerSecondLimit: number;
+    readonly Supported: boolean;
+  }
+
+  enum FrameFlashMode {
+    Disable = 0,
+    Enable = 1,
+    Global = 2,
+  }
+
+  interface ICameraIntrinsics {
+    ProjectManyOntoFrame(coordinates: Windows.Foundation.Numerics.Vector3[], results: Windows.Foundation.Point[]): void;
+    ProjectOntoFrame(coordinate: Windows.Foundation.Numerics.Vector3): Windows.Foundation.Point;
+    UnprojectAtUnitDepth(pixelCoordinate: Windows.Foundation.Point): Windows.Foundation.Numerics.Vector2;
+    UnprojectPixelsAtUnitDepth(pixelCoordinates: Windows.Foundation.Point[], results: Windows.Foundation.Numerics.Vector2[]): void;
+    readonly FocalLength: Windows.Foundation.Numerics.Vector2;
+    readonly ImageHeight: number;
+    readonly ImageWidth: number;
+    readonly PrincipalPoint: Windows.Foundation.Numerics.Vector2;
+    readonly RadialDistortion: Windows.Foundation.Numerics.Vector3;
+    readonly TangentialDistortion: Windows.Foundation.Numerics.Vector2;
+  }
+  var ICameraIntrinsics: abstract new (...args: any[]) => ICameraIntrinsics;
+
+  interface ICameraIntrinsics2 {
+    DistortPoint(input: Windows.Foundation.Point): Windows.Foundation.Point;
+    DistortPoints(inputs: Windows.Foundation.Point[], results: Windows.Foundation.Point[]): void;
+    UndistortPoint(input: Windows.Foundation.Point): Windows.Foundation.Point;
+    UndistortPoints(inputs: Windows.Foundation.Point[], results: Windows.Foundation.Point[]): void;
+    readonly UndistortedProjectionTransform: Windows.Foundation.Numerics.Matrix4x4;
+  }
+  var ICameraIntrinsics2: abstract new (...args: any[]) => ICameraIntrinsics2;
+
+  interface ICameraIntrinsicsFactory {
+    Create(focalLength: Windows.Foundation.Numerics.Vector2, principalPoint: Windows.Foundation.Numerics.Vector2, radialDistortion: Windows.Foundation.Numerics.Vector3, tangentialDistortion: Windows.Foundation.Numerics.Vector2, imageWidth: number, imageHeight: number): Windows.Media.Devices.Core.CameraIntrinsics;
+  }
+  var ICameraIntrinsicsFactory: abstract new (...args: any[]) => ICameraIntrinsicsFactory;
+
+  interface IDepthCorrelatedCoordinateMapper extends Windows.Foundation.IClosable {
+    Close(): void;
+    MapPoint(sourcePoint: Windows.Foundation.Point, targetCoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, targetCameraIntrinsics: Windows.Media.Devices.Core.CameraIntrinsics): Windows.Foundation.Point;
+    MapPoints(sourcePoints: Windows.Foundation.Point[], targetCoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, targetCameraIntrinsics: Windows.Media.Devices.Core.CameraIntrinsics, results: Windows.Foundation.Point[]): void;
+    UnprojectPoint(sourcePoint: Windows.Foundation.Point, targetCoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Foundation.Numerics.Vector3;
+    UnprojectPoints(sourcePoints: Windows.Foundation.Point[], targetCoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, results: Windows.Foundation.Numerics.Vector3[]): void;
+  }
+  var IDepthCorrelatedCoordinateMapper: abstract new (...args: any[]) => IDepthCorrelatedCoordinateMapper;
+
+  interface IFrameControlCapabilities {
+    readonly Exposure: Windows.Media.Devices.Core.FrameExposureCapabilities;
+    readonly ExposureCompensation: Windows.Media.Devices.Core.FrameExposureCompensationCapabilities;
+    readonly Focus: Windows.Media.Devices.Core.FrameFocusCapabilities;
+    readonly IsoSpeed: Windows.Media.Devices.Core.FrameIsoSpeedCapabilities;
+    readonly PhotoConfirmationSupported: boolean;
+  }
+  var IFrameControlCapabilities: abstract new (...args: any[]) => IFrameControlCapabilities;
+
+  interface IFrameControlCapabilities2 {
+    readonly Flash: Windows.Media.Devices.Core.FrameFlashCapabilities;
+  }
+  var IFrameControlCapabilities2: abstract new (...args: any[]) => IFrameControlCapabilities2;
+
+  interface IFrameController {
+    readonly ExposureCompensationControl: Windows.Media.Devices.Core.FrameExposureCompensationControl;
+    readonly ExposureControl: Windows.Media.Devices.Core.FrameExposureControl;
+    readonly FocusControl: Windows.Media.Devices.Core.FrameFocusControl;
+    readonly IsoSpeedControl: Windows.Media.Devices.Core.FrameIsoSpeedControl;
+    PhotoConfirmationEnabled: boolean | null;
+  }
+  var IFrameController: abstract new (...args: any[]) => IFrameController;
+
+  interface IFrameController2 {
+    readonly FlashControl: Windows.Media.Devices.Core.FrameFlashControl;
+  }
+  var IFrameController2: abstract new (...args: any[]) => IFrameController2;
+
+  interface IFrameExposureCapabilities {
+    readonly Max: Windows.Foundation.TimeSpan;
+    readonly Min: Windows.Foundation.TimeSpan;
+    readonly Step: Windows.Foundation.TimeSpan;
+    readonly Supported: boolean;
+  }
+  var IFrameExposureCapabilities: abstract new (...args: any[]) => IFrameExposureCapabilities;
+
+  interface IFrameExposureCompensationCapabilities {
+    readonly Max: number;
+    readonly Min: number;
+    readonly Step: number;
+    readonly Supported: boolean;
+  }
+  var IFrameExposureCompensationCapabilities: abstract new (...args: any[]) => IFrameExposureCompensationCapabilities;
+
+  interface IFrameExposureCompensationControl {
+    Value: number | null;
+  }
+  var IFrameExposureCompensationControl: abstract new (...args: any[]) => IFrameExposureCompensationControl;
+
+  interface IFrameExposureControl {
+    Auto: boolean;
+    Value: Windows.Foundation.TimeSpan | null;
+  }
+  var IFrameExposureControl: abstract new (...args: any[]) => IFrameExposureControl;
+
+  interface IFrameFlashCapabilities {
+    readonly PowerSupported: boolean;
+    readonly RedEyeReductionSupported: boolean;
+    readonly Supported: boolean;
+  }
+  var IFrameFlashCapabilities: abstract new (...args: any[]) => IFrameFlashCapabilities;
+
+  interface IFrameFlashControl {
+    Auto: boolean;
+    Mode: number;
+    PowerPercent: number;
+    RedEyeReduction: boolean;
+  }
+  var IFrameFlashControl: abstract new (...args: any[]) => IFrameFlashControl;
+
+  interface IFrameFocusCapabilities {
+    readonly Max: number;
+    readonly Min: number;
+    readonly Step: number;
+    readonly Supported: boolean;
+  }
+  var IFrameFocusCapabilities: abstract new (...args: any[]) => IFrameFocusCapabilities;
+
+  interface IFrameFocusControl {
+    Value: number | null;
+  }
+  var IFrameFocusControl: abstract new (...args: any[]) => IFrameFocusControl;
+
+  interface IFrameIsoSpeedCapabilities {
+    readonly Max: number;
+    readonly Min: number;
+    readonly Step: number;
+    readonly Supported: boolean;
+  }
+  var IFrameIsoSpeedCapabilities: abstract new (...args: any[]) => IFrameIsoSpeedCapabilities;
+
+  interface IFrameIsoSpeedControl {
+    Auto: boolean;
+    Value: number | null;
+  }
+  var IFrameIsoSpeedControl: abstract new (...args: any[]) => IFrameIsoSpeedControl;
+
+  interface IVariablePhotoSequenceController {
+    GetCurrentFrameRate(): Windows.Media.MediaProperties.MediaRatio;
+    GetHighestConcurrentFrameRate(captureProperties: Windows.Media.MediaProperties.IMediaEncodingProperties): Windows.Media.MediaProperties.MediaRatio;
+    readonly DesiredFrameControllers: Windows.Foundation.Collections.IVector<Windows.Media.Devices.Core.FrameController> | Windows.Media.Devices.Core.FrameController[];
+    readonly FrameCapabilities: Windows.Media.Devices.Core.FrameControlCapabilities;
+    readonly MaxPhotosPerSecond: number;
+    PhotosPerSecondLimit: number;
+    readonly Supported: boolean;
+  }
+  var IVariablePhotoSequenceController: abstract new (...args: any[]) => IVariablePhotoSequenceController;
+
+}
+
+declare namespace Windows.Media.DialProtocol {
+  class DialApp implements Windows.Media.DialProtocol.IDialApp {
+    GetAppStateAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.DialProtocol.DialAppStateDetails>;
+    RequestLaunchAsync(appArgument: string): Windows.Foundation.IAsyncOperation<number>;
+    StopAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly AppName: string;
+  }
+
+  class DialAppStateDetails implements Windows.Media.DialProtocol.IDialAppStateDetails {
+    readonly FullXml: string;
+    readonly State: number;
+  }
+
+  class DialDevice implements Windows.Media.DialProtocol.IDialDevice, Windows.Media.DialProtocol.IDialDevice2 {
+    static DeviceInfoSupportsDialAsync(device: Windows.Devices.Enumeration.DeviceInformation): Windows.Foundation.IAsyncOperation<boolean>;
+    static FromIdAsync(value: string): Windows.Foundation.IAsyncOperation<Windows.Media.DialProtocol.DialDevice>;
+    static GetDeviceSelector(appName: string): string;
+    GetDialApp(appName: string): Windows.Media.DialProtocol.DialApp;
+    readonly FriendlyName: string;
+    readonly Id: string;
+    readonly Thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+  }
+
+  class DialDevicePicker implements Windows.Media.DialProtocol.IDialDevicePicker {
+    constructor();
+    Hide(): void;
+    PickSingleDialDeviceAsync(selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<Windows.Media.DialProtocol.DialDevice>;
+    PickSingleDialDeviceAsync(selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<Windows.Media.DialProtocol.DialDevice>;
+    SetDisplayStatus(device: Windows.Media.DialProtocol.DialDevice, status: number): void;
+    Show(selection: Windows.Foundation.Rect): void;
+    Show(selection: Windows.Foundation.Rect, preferredPlacement: number): void;
+    readonly Appearance: Windows.Devices.Enumeration.DevicePickerAppearance;
+    readonly Filter: Windows.Media.DialProtocol.DialDevicePickerFilter;
+    DialDevicePickerDismissed: Windows.Foundation.TypedEventHandler<Windows.Media.DialProtocol.DialDevicePicker, Object> | null;
+    DialDeviceSelected: Windows.Foundation.TypedEventHandler<Windows.Media.DialProtocol.DialDevicePicker, Windows.Media.DialProtocol.DialDeviceSelectedEventArgs> | null;
+    DisconnectButtonClicked: Windows.Foundation.TypedEventHandler<Windows.Media.DialProtocol.DialDevicePicker, Windows.Media.DialProtocol.DialDisconnectButtonClickedEventArgs> | null;
+  }
+
+  class DialDevicePickerFilter implements Windows.Media.DialProtocol.IDialDevicePickerFilter {
+    readonly SupportedAppNames: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+
+  class DialDeviceSelectedEventArgs implements Windows.Media.DialProtocol.IDialDeviceSelectedEventArgs {
+    readonly SelectedDialDevice: Windows.Media.DialProtocol.DialDevice;
+  }
+
+  class DialDisconnectButtonClickedEventArgs implements Windows.Media.DialProtocol.IDialDisconnectButtonClickedEventArgs {
+    readonly Device: Windows.Media.DialProtocol.DialDevice;
+  }
+
+  class DialReceiverApp implements Windows.Media.DialProtocol.IDialReceiverApp, Windows.Media.DialProtocol.IDialReceiverApp2 {
+    GetAdditionalDataAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMap<string, string> | Record<string, string>>;
+    GetUniqueDeviceNameAsync(): Windows.Foundation.IAsyncOperation<string>;
+    SetAdditionalDataAsync(additionalData: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, string>> | Windows.Foundation.Collections.IKeyValuePair<string, string>[]): Windows.Foundation.IAsyncAction;
+    static readonly Current: Windows.Media.DialProtocol.DialReceiverApp;
+  }
+
+  enum DialAppLaunchResult {
+    Launched = 0,
+    FailedToLaunch = 1,
+    NotFound = 2,
+    NetworkFailure = 3,
+  }
+
+  enum DialAppState {
+    Unknown = 0,
+    Stopped = 1,
+    Running = 2,
+    NetworkFailure = 3,
+  }
+
+  enum DialAppStopResult {
+    Stopped = 0,
+    StopFailed = 1,
+    OperationNotSupported = 2,
+    NetworkFailure = 3,
+  }
+
+  enum DialDeviceDisplayStatus {
+    None = 0,
+    Connecting = 1,
+    Connected = 2,
+    Disconnecting = 3,
+    Disconnected = 4,
+    Error = 5,
+  }
+
+  interface IDialApp {
+    GetAppStateAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.DialProtocol.DialAppStateDetails>;
+    RequestLaunchAsync(appArgument: string): Windows.Foundation.IAsyncOperation<number>;
+    StopAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly AppName: string;
+  }
+  var IDialApp: abstract new (...args: any[]) => IDialApp;
+
+  interface IDialAppStateDetails {
+    readonly FullXml: string;
+    readonly State: number;
+  }
+  var IDialAppStateDetails: abstract new (...args: any[]) => IDialAppStateDetails;
+
+  interface IDialDevice {
+    GetDialApp(appName: string): Windows.Media.DialProtocol.DialApp;
+    readonly Id: string;
+  }
+  var IDialDevice: abstract new (...args: any[]) => IDialDevice;
+
+  interface IDialDevice2 {
+    readonly FriendlyName: string;
+    readonly Thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+  }
+  var IDialDevice2: abstract new (...args: any[]) => IDialDevice2;
+
+  interface IDialDevicePicker {
+    Hide(): void;
+    PickSingleDialDeviceAsync(selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<Windows.Media.DialProtocol.DialDevice>;
+    PickSingleDialDeviceAsync(selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<Windows.Media.DialProtocol.DialDevice>;
+    SetDisplayStatus(device: Windows.Media.DialProtocol.DialDevice, status: number): void;
+    Show(selection: Windows.Foundation.Rect): void;
+    Show(selection: Windows.Foundation.Rect, preferredPlacement: number): void;
+    readonly Appearance: Windows.Devices.Enumeration.DevicePickerAppearance;
+    readonly Filter: Windows.Media.DialProtocol.DialDevicePickerFilter;
+    DialDevicePickerDismissed: Windows.Foundation.TypedEventHandler<Windows.Media.DialProtocol.DialDevicePicker, Object> | null;
+    DialDeviceSelected: Windows.Foundation.TypedEventHandler<Windows.Media.DialProtocol.DialDevicePicker, Windows.Media.DialProtocol.DialDeviceSelectedEventArgs> | null;
+    DisconnectButtonClicked: Windows.Foundation.TypedEventHandler<Windows.Media.DialProtocol.DialDevicePicker, Windows.Media.DialProtocol.DialDisconnectButtonClickedEventArgs> | null;
+  }
+  var IDialDevicePicker: abstract new (...args: any[]) => IDialDevicePicker;
+
+  interface IDialDevicePickerFilter {
+    readonly SupportedAppNames: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var IDialDevicePickerFilter: abstract new (...args: any[]) => IDialDevicePickerFilter;
+
+  interface IDialDeviceSelectedEventArgs {
+    readonly SelectedDialDevice: Windows.Media.DialProtocol.DialDevice;
+  }
+  var IDialDeviceSelectedEventArgs: abstract new (...args: any[]) => IDialDeviceSelectedEventArgs;
+
+  interface IDialDeviceStatics {
+    DeviceInfoSupportsDialAsync(device: Windows.Devices.Enumeration.DeviceInformation): Windows.Foundation.IAsyncOperation<boolean>;
+    FromIdAsync(value: string): Windows.Foundation.IAsyncOperation<Windows.Media.DialProtocol.DialDevice>;
+    GetDeviceSelector(appName: string): string;
+  }
+  var IDialDeviceStatics: abstract new (...args: any[]) => IDialDeviceStatics;
+
+  interface IDialDisconnectButtonClickedEventArgs {
+    readonly Device: Windows.Media.DialProtocol.DialDevice;
+  }
+  var IDialDisconnectButtonClickedEventArgs: abstract new (...args: any[]) => IDialDisconnectButtonClickedEventArgs;
+
+  interface IDialReceiverApp {
+    GetAdditionalDataAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMap<string, string> | Record<string, string>>;
+    SetAdditionalDataAsync(additionalData: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, string>> | Windows.Foundation.Collections.IKeyValuePair<string, string>[]): Windows.Foundation.IAsyncAction;
+  }
+  var IDialReceiverApp: abstract new (...args: any[]) => IDialReceiverApp;
+
+  interface IDialReceiverApp2 {
+    GetUniqueDeviceNameAsync(): Windows.Foundation.IAsyncOperation<string>;
+  }
+  var IDialReceiverApp2: abstract new (...args: any[]) => IDialReceiverApp2;
+
+  interface IDialReceiverAppStatics {
+    readonly Current: Windows.Media.DialProtocol.DialReceiverApp;
+  }
+  var IDialReceiverAppStatics: abstract new (...args: any[]) => IDialReceiverAppStatics;
+
+}
+
+declare namespace Windows.Media.Editing {
+  class BackgroundAudioTrack implements Windows.Media.Editing.IBackgroundAudioTrack {
+    Clone(): Windows.Media.Editing.BackgroundAudioTrack;
+    static CreateFromEmbeddedAudioTrack(embeddedAudioTrack: Windows.Media.Editing.EmbeddedAudioTrack): Windows.Media.Editing.BackgroundAudioTrack;
+    static CreateFromFileAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.Editing.BackgroundAudioTrack>;
+    GetAudioEncodingProperties(): Windows.Media.MediaProperties.AudioEncodingProperties;
+    readonly AudioEffectDefinitions: Windows.Foundation.Collections.IVector<Windows.Media.Effects.IAudioEffectDefinition> | Windows.Media.Effects.IAudioEffectDefinition[];
+    Delay: Windows.Foundation.TimeSpan;
+    readonly OriginalDuration: Windows.Foundation.TimeSpan;
+    TrimTimeFromEnd: Windows.Foundation.TimeSpan;
+    TrimTimeFromStart: Windows.Foundation.TimeSpan;
+    readonly TrimmedDuration: Windows.Foundation.TimeSpan;
+    readonly UserData: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    Volume: number;
+  }
+
+  class EmbeddedAudioTrack implements Windows.Media.Editing.IEmbeddedAudioTrack {
+    GetAudioEncodingProperties(): Windows.Media.MediaProperties.AudioEncodingProperties;
+  }
+
+  class MediaClip implements Windows.Media.Editing.IMediaClip {
+    Clone(): Windows.Media.Editing.MediaClip;
+    static CreateFromColor(color: Windows.UI.Color, originalDuration: Windows.Foundation.TimeSpan): Windows.Media.Editing.MediaClip;
+    static CreateFromFileAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.Editing.MediaClip>;
+    static CreateFromImageFileAsync(file: Windows.Storage.IStorageFile, originalDuration: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Media.Editing.MediaClip>;
+    static CreateFromSurface(surface: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface, originalDuration: Windows.Foundation.TimeSpan): Windows.Media.Editing.MediaClip;
+    GetVideoEncodingProperties(): Windows.Media.MediaProperties.VideoEncodingProperties;
+    readonly AudioEffectDefinitions: Windows.Foundation.Collections.IVector<Windows.Media.Effects.IAudioEffectDefinition> | Windows.Media.Effects.IAudioEffectDefinition[];
+    readonly EmbeddedAudioTracks: Windows.Foundation.Collections.IVectorView<Windows.Media.Editing.EmbeddedAudioTrack> | Windows.Media.Editing.EmbeddedAudioTrack[];
+    readonly EndTimeInComposition: Windows.Foundation.TimeSpan;
+    readonly OriginalDuration: Windows.Foundation.TimeSpan;
+    SelectedEmbeddedAudioTrackIndex: number;
+    readonly StartTimeInComposition: Windows.Foundation.TimeSpan;
+    TrimTimeFromEnd: Windows.Foundation.TimeSpan;
+    TrimTimeFromStart: Windows.Foundation.TimeSpan;
+    readonly TrimmedDuration: Windows.Foundation.TimeSpan;
+    readonly UserData: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    readonly VideoEffectDefinitions: Windows.Foundation.Collections.IVector<Windows.Media.Effects.IVideoEffectDefinition> | Windows.Media.Effects.IVideoEffectDefinition[];
+    Volume: number;
+  }
+
+  class MediaComposition implements Windows.Media.Editing.IMediaComposition, Windows.Media.Editing.IMediaComposition2 {
+    constructor();
+    Clone(): Windows.Media.Editing.MediaComposition;
+    CreateDefaultEncodingProfile(): Windows.Media.MediaProperties.MediaEncodingProfile;
+    GenerateMediaStreamSource(): Windows.Media.Core.MediaStreamSource;
+    GenerateMediaStreamSource(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile): Windows.Media.Core.MediaStreamSource;
+    GeneratePreviewMediaStreamSource(scaledWidth: number, scaledHeight: number): Windows.Media.Core.MediaStreamSource;
+    GetThumbnailAsync(timeFromStart: Windows.Foundation.TimeSpan, scaledWidth: number, scaledHeight: number, framePrecision: number): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.ImageStream>;
+    GetThumbnailsAsync(timesFromStart: Windows.Foundation.Collections.IIterable<Windows.Foundation.TimeSpan> | Windows.Foundation.TimeSpan[], scaledWidth: number, scaledHeight: number, framePrecision: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Graphics.Imaging.ImageStream> | Windows.Graphics.Imaging.ImageStream[]>;
+    static LoadAsync(file: Windows.Storage.StorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.Editing.MediaComposition>;
+    RenderToFileAsync(destination: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    RenderToFileAsync(destination: Windows.Storage.IStorageFile, trimmingPreference: number): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    RenderToFileAsync(destination: Windows.Storage.IStorageFile, trimmingPreference: number, encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    SaveAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncAction;
+    readonly BackgroundAudioTracks: Windows.Foundation.Collections.IVector<Windows.Media.Editing.BackgroundAudioTrack> | Windows.Media.Editing.BackgroundAudioTrack[];
+    readonly Clips: Windows.Foundation.Collections.IVector<Windows.Media.Editing.MediaClip> | Windows.Media.Editing.MediaClip[];
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly OverlayLayers: Windows.Foundation.Collections.IVector<Windows.Media.Editing.MediaOverlayLayer> | Windows.Media.Editing.MediaOverlayLayer[];
+    readonly UserData: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+  }
+
+  class MediaOverlay implements Windows.Media.Editing.IMediaOverlay {
+    constructor(clip: Windows.Media.Editing.MediaClip);
+    constructor(clip: Windows.Media.Editing.MediaClip, position: Windows.Foundation.Rect, opacity: number);
+    Clone(): Windows.Media.Editing.MediaOverlay;
+    AudioEnabled: boolean;
+    readonly Clip: Windows.Media.Editing.MediaClip;
+    Delay: Windows.Foundation.TimeSpan;
+    Opacity: number;
+    Position: Windows.Foundation.Rect;
+  }
+
+  class MediaOverlayLayer implements Windows.Media.Editing.IMediaOverlayLayer {
+    constructor(compositorDefinition: Windows.Media.Effects.IVideoCompositorDefinition);
+    constructor();
+    Clone(): Windows.Media.Editing.MediaOverlayLayer;
+    readonly CustomCompositorDefinition: Windows.Media.Effects.IVideoCompositorDefinition;
+    readonly Overlays: Windows.Foundation.Collections.IVector<Windows.Media.Editing.MediaOverlay> | Windows.Media.Editing.MediaOverlay[];
+  }
+
+  enum MediaTrimmingPreference {
+    Fast = 0,
+    Precise = 1,
+  }
+
+  enum VideoFramePrecision {
+    NearestFrame = 0,
+    NearestKeyFrame = 1,
+  }
+
+  interface IBackgroundAudioTrack {
+    Clone(): Windows.Media.Editing.BackgroundAudioTrack;
+    GetAudioEncodingProperties(): Windows.Media.MediaProperties.AudioEncodingProperties;
+    readonly AudioEffectDefinitions: Windows.Foundation.Collections.IVector<Windows.Media.Effects.IAudioEffectDefinition> | Windows.Media.Effects.IAudioEffectDefinition[];
+    Delay: Windows.Foundation.TimeSpan;
+    readonly OriginalDuration: Windows.Foundation.TimeSpan;
+    TrimTimeFromEnd: Windows.Foundation.TimeSpan;
+    TrimTimeFromStart: Windows.Foundation.TimeSpan;
+    readonly TrimmedDuration: Windows.Foundation.TimeSpan;
+    readonly UserData: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    Volume: number;
+  }
+  var IBackgroundAudioTrack: abstract new (...args: any[]) => IBackgroundAudioTrack;
+
+  interface IBackgroundAudioTrackStatics {
+    CreateFromEmbeddedAudioTrack(embeddedAudioTrack: Windows.Media.Editing.EmbeddedAudioTrack): Windows.Media.Editing.BackgroundAudioTrack;
+    CreateFromFileAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.Editing.BackgroundAudioTrack>;
+  }
+  var IBackgroundAudioTrackStatics: abstract new (...args: any[]) => IBackgroundAudioTrackStatics;
+
+  interface IEmbeddedAudioTrack {
+    GetAudioEncodingProperties(): Windows.Media.MediaProperties.AudioEncodingProperties;
+  }
+  var IEmbeddedAudioTrack: abstract new (...args: any[]) => IEmbeddedAudioTrack;
+
+  interface IMediaClip {
+    Clone(): Windows.Media.Editing.MediaClip;
+    GetVideoEncodingProperties(): Windows.Media.MediaProperties.VideoEncodingProperties;
+    readonly AudioEffectDefinitions: Windows.Foundation.Collections.IVector<Windows.Media.Effects.IAudioEffectDefinition> | Windows.Media.Effects.IAudioEffectDefinition[];
+    readonly EmbeddedAudioTracks: Windows.Foundation.Collections.IVectorView<Windows.Media.Editing.EmbeddedAudioTrack> | Windows.Media.Editing.EmbeddedAudioTrack[];
+    readonly EndTimeInComposition: Windows.Foundation.TimeSpan;
+    readonly OriginalDuration: Windows.Foundation.TimeSpan;
+    SelectedEmbeddedAudioTrackIndex: number;
+    readonly StartTimeInComposition: Windows.Foundation.TimeSpan;
+    TrimTimeFromEnd: Windows.Foundation.TimeSpan;
+    TrimTimeFromStart: Windows.Foundation.TimeSpan;
+    readonly TrimmedDuration: Windows.Foundation.TimeSpan;
+    readonly UserData: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    readonly VideoEffectDefinitions: Windows.Foundation.Collections.IVector<Windows.Media.Effects.IVideoEffectDefinition> | Windows.Media.Effects.IVideoEffectDefinition[];
+    Volume: number;
+  }
+  var IMediaClip: abstract new (...args: any[]) => IMediaClip;
+
+  interface IMediaClipStatics {
+    CreateFromColor(color: Windows.UI.Color, originalDuration: Windows.Foundation.TimeSpan): Windows.Media.Editing.MediaClip;
+    CreateFromFileAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.Editing.MediaClip>;
+    CreateFromImageFileAsync(file: Windows.Storage.IStorageFile, originalDuration: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<Windows.Media.Editing.MediaClip>;
+  }
+  var IMediaClipStatics: abstract new (...args: any[]) => IMediaClipStatics;
+
+  interface IMediaClipStatics2 {
+    CreateFromSurface(surface: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface, originalDuration: Windows.Foundation.TimeSpan): Windows.Media.Editing.MediaClip;
+  }
+  var IMediaClipStatics2: abstract new (...args: any[]) => IMediaClipStatics2;
+
+  interface IMediaComposition {
+    Clone(): Windows.Media.Editing.MediaComposition;
+    CreateDefaultEncodingProfile(): Windows.Media.MediaProperties.MediaEncodingProfile;
+    GenerateMediaStreamSource(): Windows.Media.Core.MediaStreamSource;
+    GenerateMediaStreamSource(encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile): Windows.Media.Core.MediaStreamSource;
+    GeneratePreviewMediaStreamSource(scaledWidth: number, scaledHeight: number): Windows.Media.Core.MediaStreamSource;
+    GetThumbnailAsync(timeFromStart: Windows.Foundation.TimeSpan, scaledWidth: number, scaledHeight: number, framePrecision: number): Windows.Foundation.IAsyncOperation<Windows.Graphics.Imaging.ImageStream>;
+    GetThumbnailsAsync(timesFromStart: Windows.Foundation.Collections.IIterable<Windows.Foundation.TimeSpan> | Windows.Foundation.TimeSpan[], scaledWidth: number, scaledHeight: number, framePrecision: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Graphics.Imaging.ImageStream> | Windows.Graphics.Imaging.ImageStream[]>;
+    RenderToFileAsync(destination: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    RenderToFileAsync(destination: Windows.Storage.IStorageFile, trimmingPreference: number): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    RenderToFileAsync(destination: Windows.Storage.IStorageFile, trimmingPreference: number, encodingProfile: Windows.Media.MediaProperties.MediaEncodingProfile): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    SaveAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncAction;
+    readonly BackgroundAudioTracks: Windows.Foundation.Collections.IVector<Windows.Media.Editing.BackgroundAudioTrack> | Windows.Media.Editing.BackgroundAudioTrack[];
+    readonly Clips: Windows.Foundation.Collections.IVector<Windows.Media.Editing.MediaClip> | Windows.Media.Editing.MediaClip[];
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly UserData: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+  }
+  var IMediaComposition: abstract new (...args: any[]) => IMediaComposition;
+
+  interface IMediaComposition2 {
+    readonly OverlayLayers: Windows.Foundation.Collections.IVector<Windows.Media.Editing.MediaOverlayLayer> | Windows.Media.Editing.MediaOverlayLayer[];
+  }
+  var IMediaComposition2: abstract new (...args: any[]) => IMediaComposition2;
+
+  interface IMediaCompositionStatics {
+    LoadAsync(file: Windows.Storage.StorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.Editing.MediaComposition>;
+  }
+  var IMediaCompositionStatics: abstract new (...args: any[]) => IMediaCompositionStatics;
+
+  interface IMediaOverlay {
+    Clone(): Windows.Media.Editing.MediaOverlay;
+    AudioEnabled: boolean;
+    readonly Clip: Windows.Media.Editing.MediaClip;
+    Delay: Windows.Foundation.TimeSpan;
+    Opacity: number;
+    Position: Windows.Foundation.Rect;
+  }
+  var IMediaOverlay: abstract new (...args: any[]) => IMediaOverlay;
+
+  interface IMediaOverlayFactory {
+    Create(clip: Windows.Media.Editing.MediaClip): Windows.Media.Editing.MediaOverlay;
+    CreateWithPositionAndOpacity(clip: Windows.Media.Editing.MediaClip, position: Windows.Foundation.Rect, opacity: number): Windows.Media.Editing.MediaOverlay;
+  }
+  var IMediaOverlayFactory: abstract new (...args: any[]) => IMediaOverlayFactory;
+
+  interface IMediaOverlayLayer {
+    Clone(): Windows.Media.Editing.MediaOverlayLayer;
+    readonly CustomCompositorDefinition: Windows.Media.Effects.IVideoCompositorDefinition;
+    readonly Overlays: Windows.Foundation.Collections.IVector<Windows.Media.Editing.MediaOverlay> | Windows.Media.Editing.MediaOverlay[];
+  }
+  var IMediaOverlayLayer: abstract new (...args: any[]) => IMediaOverlayLayer;
+
+  interface IMediaOverlayLayerFactory {
+    CreateWithCompositorDefinition(compositorDefinition: Windows.Media.Effects.IVideoCompositorDefinition): Windows.Media.Editing.MediaOverlayLayer;
+  }
+  var IMediaOverlayLayerFactory: abstract new (...args: any[]) => IMediaOverlayLayerFactory;
+
+}
+
+declare namespace Windows.Media.Effects {
+  class AcousticEchoCancellationConfiguration implements Windows.Media.Effects.IAcousticEchoCancellationConfiguration {
+    SetEchoCancellationRenderEndpoint(deviceId: string): void;
+  }
+
+  class AudioCaptureEffectsManager implements Windows.Media.Effects.IAudioCaptureEffectsManager {
+    GetAudioCaptureEffects(): Windows.Foundation.Collections.IVectorView<Windows.Media.Effects.AudioEffect> | Windows.Media.Effects.AudioEffect[];
+    AudioCaptureEffectsChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Effects.AudioCaptureEffectsManager, Object> | null;
+  }
+
+  class AudioEffect implements Windows.Media.Effects.IAudioEffect, Windows.Media.Effects.IAudioEffect2 {
+    SetState(newState: number): void;
+    readonly AcousticEchoCancellationConfiguration: Windows.Media.Effects.AcousticEchoCancellationConfiguration;
+    readonly AudioEffectType: number;
+    readonly CanSetState: boolean;
+    readonly State: number;
+  }
+
+  class AudioEffectDefinition implements Windows.Media.Effects.IAudioEffectDefinition {
+    constructor(activatableClassId: string);
+    constructor(activatableClassId: string, props: Windows.Foundation.Collections.IPropertySet);
+    readonly ActivatableClassId: string;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+  }
+
+  class AudioEffectsManager {
+    static CreateAudioCaptureEffectsManager(deviceId: string, category: number): Windows.Media.Effects.AudioCaptureEffectsManager;
+    static CreateAudioCaptureEffectsManager(deviceId: string, category: number, mode: number): Windows.Media.Effects.AudioCaptureEffectsManager;
+    static CreateAudioRenderEffectsManager(deviceId: string, category: number): Windows.Media.Effects.AudioRenderEffectsManager;
+    static CreateAudioRenderEffectsManager(deviceId: string, category: number, mode: number): Windows.Media.Effects.AudioRenderEffectsManager;
+  }
+
+  class AudioRenderEffectsManager implements Windows.Media.Effects.IAudioRenderEffectsManager, Windows.Media.Effects.IAudioRenderEffectsManager2 {
+    GetAudioRenderEffects(): Windows.Foundation.Collections.IVectorView<Windows.Media.Effects.AudioEffect> | Windows.Media.Effects.AudioEffect[];
+    ShowSettingsUI(): void;
+    readonly EffectsProviderSettingsLabel: string;
+    readonly EffectsProviderThumbnail: Windows.Storage.Streams.IRandomAccessStreamWithContentType;
+    AudioRenderEffectsChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Effects.AudioRenderEffectsManager, Object> | null;
+  }
+
+  class CompositeVideoFrameContext implements Windows.Media.Effects.ICompositeVideoFrameContext {
+    GetOverlayForSurface(surfaceToOverlay: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface): Windows.Media.Editing.MediaOverlay;
+    readonly BackgroundFrame: Windows.Media.VideoFrame;
+    readonly OutputFrame: Windows.Media.VideoFrame;
+    readonly SurfacesToOverlay: Windows.Foundation.Collections.IVectorView<Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface> | Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface[];
+  }
+
+  class ProcessAudioFrameContext implements Windows.Media.Effects.IProcessAudioFrameContext {
+    readonly InputFrame: Windows.Media.AudioFrame;
+    readonly OutputFrame: Windows.Media.AudioFrame;
+  }
+
+  class ProcessVideoFrameContext implements Windows.Media.Effects.IProcessVideoFrameContext {
+    readonly InputFrame: Windows.Media.VideoFrame;
+    readonly OutputFrame: Windows.Media.VideoFrame;
+  }
+
+  class VideoCompositorDefinition implements Windows.Media.Effects.IVideoCompositorDefinition {
+    constructor(activatableClassId: string);
+    constructor(activatableClassId: string, props: Windows.Foundation.Collections.IPropertySet);
+    readonly ActivatableClassId: string;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+  }
+
+  class VideoEffectDefinition implements Windows.Media.Effects.IVideoEffectDefinition {
+    constructor(activatableClassId: string);
+    constructor(activatableClassId: string, props: Windows.Foundation.Collections.IPropertySet);
+    readonly ActivatableClassId: string;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+  }
+
+  class VideoTransformEffectDefinition implements Windows.Media.Effects.IVideoEffectDefinition, Windows.Media.Effects.IVideoTransformEffectDefinition, Windows.Media.Effects.IVideoTransformEffectDefinition2 {
+    constructor();
+    readonly ActivatableClassId: string;
+    CropRectangle: Windows.Foundation.Rect;
+    Mirror: number;
+    OutputSize: Windows.Foundation.Size;
+    PaddingColor: Windows.UI.Color;
+    ProcessingAlgorithm: number;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+    Rotation: number;
+    readonly SphericalProjection: Windows.Media.Effects.VideoTransformSphericalProjection;
+  }
+
+  class VideoTransformSphericalProjection implements Windows.Media.Effects.IVideoTransformSphericalProjection {
+    FrameFormat: number;
+    HorizontalFieldOfViewInDegrees: number;
+    IsEnabled: boolean;
+    ProjectionMode: number;
+    ViewOrientation: Windows.Foundation.Numerics.Quaternion;
+  }
+
+  enum AudioEffectState {
+    Off = 0,
+    On = 1,
+  }
+
+  enum AudioEffectType {
+    Other = 0,
+    AcousticEchoCancellation = 1,
+    NoiseSuppression = 2,
+    AutomaticGainControl = 3,
+    BeamForming = 4,
+    ConstantToneRemoval = 5,
+    Equalizer = 6,
+    LoudnessEqualizer = 7,
+    BassBoost = 8,
+    VirtualSurround = 9,
+    VirtualHeadphones = 10,
+    SpeakerFill = 11,
+    RoomCorrection = 12,
+    BassManagement = 13,
+    EnvironmentalEffects = 14,
+    SpeakerProtection = 15,
+    SpeakerCompensation = 16,
+    DynamicRangeCompression = 17,
+    FarFieldBeamForming = 18,
+    DeepNoiseSuppression = 19,
+  }
+
+  enum MediaEffectClosedReason {
+    Done = 0,
+    UnknownError = 1,
+    UnsupportedEncodingFormat = 2,
+    EffectCurrentlyUnloaded = 3,
+  }
+
+  enum MediaMemoryTypes {
+    Gpu = 0,
+    Cpu = 1,
+    GpuAndCpu = 2,
+  }
+
+  interface IAcousticEchoCancellationConfiguration {
+    SetEchoCancellationRenderEndpoint(deviceId: string): void;
+  }
+  var IAcousticEchoCancellationConfiguration: abstract new (...args: any[]) => IAcousticEchoCancellationConfiguration;
+
+  interface IAudioCaptureEffectsManager {
+    GetAudioCaptureEffects(): Windows.Foundation.Collections.IVectorView<Windows.Media.Effects.AudioEffect> | Windows.Media.Effects.AudioEffect[];
+    AudioCaptureEffectsChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Effects.AudioCaptureEffectsManager, Object> | null;
+  }
+  var IAudioCaptureEffectsManager: abstract new (...args: any[]) => IAudioCaptureEffectsManager;
+
+  interface IAudioEffect {
+    readonly AudioEffectType: number;
+  }
+  var IAudioEffect: abstract new (...args: any[]) => IAudioEffect;
+
+  interface IAudioEffect2 {
+    SetState(newState: number): void;
+    readonly AcousticEchoCancellationConfiguration: Windows.Media.Effects.AcousticEchoCancellationConfiguration;
+    readonly CanSetState: boolean;
+    readonly State: number;
+  }
+  var IAudioEffect2: abstract new (...args: any[]) => IAudioEffect2;
+
+  interface IAudioEffectDefinition {
+    readonly ActivatableClassId: string;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+  }
+  var IAudioEffectDefinition: abstract new (...args: any[]) => IAudioEffectDefinition;
+
+  interface IAudioEffectDefinitionFactory {
+    Create(activatableClassId: string): Windows.Media.Effects.AudioEffectDefinition;
+    CreateWithProperties(activatableClassId: string, props: Windows.Foundation.Collections.IPropertySet): Windows.Media.Effects.AudioEffectDefinition;
+  }
+  var IAudioEffectDefinitionFactory: abstract new (...args: any[]) => IAudioEffectDefinitionFactory;
+
+  interface IAudioEffectsManagerStatics {
+    CreateAudioCaptureEffectsManager(deviceId: string, category: number): Windows.Media.Effects.AudioCaptureEffectsManager;
+    CreateAudioCaptureEffectsManager(deviceId: string, category: number, mode: number): Windows.Media.Effects.AudioCaptureEffectsManager;
+    CreateAudioRenderEffectsManager(deviceId: string, category: number): Windows.Media.Effects.AudioRenderEffectsManager;
+    CreateAudioRenderEffectsManager(deviceId: string, category: number, mode: number): Windows.Media.Effects.AudioRenderEffectsManager;
+  }
+  var IAudioEffectsManagerStatics: abstract new (...args: any[]) => IAudioEffectsManagerStatics;
+
+  interface IAudioRenderEffectsManager {
+    GetAudioRenderEffects(): Windows.Foundation.Collections.IVectorView<Windows.Media.Effects.AudioEffect> | Windows.Media.Effects.AudioEffect[];
+    AudioRenderEffectsChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Effects.AudioRenderEffectsManager, Object> | null;
+  }
+  var IAudioRenderEffectsManager: abstract new (...args: any[]) => IAudioRenderEffectsManager;
+
+  interface IAudioRenderEffectsManager2 {
+    ShowSettingsUI(): void;
+    readonly EffectsProviderSettingsLabel: string;
+    readonly EffectsProviderThumbnail: Windows.Storage.Streams.IRandomAccessStreamWithContentType;
+  }
+  var IAudioRenderEffectsManager2: abstract new (...args: any[]) => IAudioRenderEffectsManager2;
+
+  interface IBasicAudioEffect extends Windows.Media.IMediaExtension {
+    Close(reason: number): void;
+    DiscardQueuedFrames(): void;
+    ProcessFrame(context: Windows.Media.Effects.ProcessAudioFrameContext): void;
+    SetEncodingProperties(encodingProperties: Windows.Media.MediaProperties.AudioEncodingProperties): void;
+    SetProperties(configuration: Windows.Foundation.Collections.IPropertySet): void;
+    readonly SupportedEncodingProperties: Windows.Foundation.Collections.IVectorView<Windows.Media.MediaProperties.AudioEncodingProperties> | Windows.Media.MediaProperties.AudioEncodingProperties[];
+    readonly UseInputFrameForOutput: boolean;
+  }
+  var IBasicAudioEffect: abstract new (...args: any[]) => IBasicAudioEffect;
+
+  interface IBasicVideoEffect extends Windows.Media.IMediaExtension {
+    Close(reason: number): void;
+    DiscardQueuedFrames(): void;
+    ProcessFrame(context: Windows.Media.Effects.ProcessVideoFrameContext): void;
+    SetEncodingProperties(encodingProperties: Windows.Media.MediaProperties.VideoEncodingProperties, device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice): void;
+    SetProperties(configuration: Windows.Foundation.Collections.IPropertySet): void;
+    readonly IsReadOnly: boolean;
+    readonly SupportedEncodingProperties: Windows.Foundation.Collections.IVectorView<Windows.Media.MediaProperties.VideoEncodingProperties> | Windows.Media.MediaProperties.VideoEncodingProperties[];
+    readonly SupportedMemoryTypes: number;
+    readonly TimeIndependent: boolean;
+  }
+  var IBasicVideoEffect: abstract new (...args: any[]) => IBasicVideoEffect;
+
+  interface ICompositeVideoFrameContext {
+    GetOverlayForSurface(surfaceToOverlay: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface): Windows.Media.Editing.MediaOverlay;
+    readonly BackgroundFrame: Windows.Media.VideoFrame;
+    readonly OutputFrame: Windows.Media.VideoFrame;
+    readonly SurfacesToOverlay: Windows.Foundation.Collections.IVectorView<Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface> | Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface[];
+  }
+  var ICompositeVideoFrameContext: abstract new (...args: any[]) => ICompositeVideoFrameContext;
+
+  interface IProcessAudioFrameContext {
+    readonly InputFrame: Windows.Media.AudioFrame;
+    readonly OutputFrame: Windows.Media.AudioFrame;
+  }
+  var IProcessAudioFrameContext: abstract new (...args: any[]) => IProcessAudioFrameContext;
+
+  interface IProcessVideoFrameContext {
+    readonly InputFrame: Windows.Media.VideoFrame;
+    readonly OutputFrame: Windows.Media.VideoFrame;
+  }
+  var IProcessVideoFrameContext: abstract new (...args: any[]) => IProcessVideoFrameContext;
+
+  interface IVideoCompositor extends Windows.Media.IMediaExtension {
+    Close(reason: number): void;
+    CompositeFrame(context: Windows.Media.Effects.CompositeVideoFrameContext): void;
+    DiscardQueuedFrames(): void;
+    SetEncodingProperties(backgroundProperties: Windows.Media.MediaProperties.VideoEncodingProperties, device: Windows.Graphics.DirectX.Direct3D11.IDirect3DDevice): void;
+    SetProperties(configuration: Windows.Foundation.Collections.IPropertySet): void;
+    readonly TimeIndependent: boolean;
+  }
+  var IVideoCompositor: abstract new (...args: any[]) => IVideoCompositor;
+
+  interface IVideoCompositorDefinition {
+    readonly ActivatableClassId: string;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+  }
+  var IVideoCompositorDefinition: abstract new (...args: any[]) => IVideoCompositorDefinition;
+
+  interface IVideoCompositorDefinitionFactory {
+    Create(activatableClassId: string): Windows.Media.Effects.VideoCompositorDefinition;
+    CreateWithProperties(activatableClassId: string, props: Windows.Foundation.Collections.IPropertySet): Windows.Media.Effects.VideoCompositorDefinition;
+  }
+  var IVideoCompositorDefinitionFactory: abstract new (...args: any[]) => IVideoCompositorDefinitionFactory;
+
+  interface IVideoEffectDefinition {
+    readonly ActivatableClassId: string;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+  }
+  var IVideoEffectDefinition: abstract new (...args: any[]) => IVideoEffectDefinition;
+
+  interface IVideoEffectDefinitionFactory {
+    Create(activatableClassId: string): Windows.Media.Effects.VideoEffectDefinition;
+    CreateWithProperties(activatableClassId: string, props: Windows.Foundation.Collections.IPropertySet): Windows.Media.Effects.VideoEffectDefinition;
+  }
+  var IVideoEffectDefinitionFactory: abstract new (...args: any[]) => IVideoEffectDefinitionFactory;
+
+  interface IVideoTransformEffectDefinition extends Windows.Media.Effects.IVideoEffectDefinition {
+    CropRectangle: Windows.Foundation.Rect;
+    Mirror: number;
+    OutputSize: Windows.Foundation.Size;
+    PaddingColor: Windows.UI.Color;
+    ProcessingAlgorithm: number;
+    Rotation: number;
+  }
+  var IVideoTransformEffectDefinition: abstract new (...args: any[]) => IVideoTransformEffectDefinition;
+
+  interface IVideoTransformEffectDefinition2 {
+    readonly SphericalProjection: Windows.Media.Effects.VideoTransformSphericalProjection;
+  }
+  var IVideoTransformEffectDefinition2: abstract new (...args: any[]) => IVideoTransformEffectDefinition2;
+
+  interface IVideoTransformSphericalProjection {
+    FrameFormat: number;
+    HorizontalFieldOfViewInDegrees: number;
+    IsEnabled: boolean;
+    ProjectionMode: number;
+    ViewOrientation: Windows.Foundation.Numerics.Quaternion;
+  }
+  var IVideoTransformSphericalProjection: abstract new (...args: any[]) => IVideoTransformSphericalProjection;
+
+}
+
+declare namespace Windows.Media.FaceAnalysis {
+  class DetectedFace implements Windows.Media.FaceAnalysis.IDetectedFace {
+    readonly FaceBox: Windows.Graphics.Imaging.BitmapBounds;
+  }
+
+  class FaceDetector implements Windows.Media.FaceAnalysis.IFaceDetector {
+    static CreateAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.FaceAnalysis.FaceDetector>;
+    DetectFacesAsync(image: Windows.Graphics.Imaging.SoftwareBitmap): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.Media.FaceAnalysis.DetectedFace> | Windows.Media.FaceAnalysis.DetectedFace[]>;
+    DetectFacesAsync(image: Windows.Graphics.Imaging.SoftwareBitmap, searchArea: Windows.Graphics.Imaging.BitmapBounds): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.Media.FaceAnalysis.DetectedFace> | Windows.Media.FaceAnalysis.DetectedFace[]>;
+    static GetSupportedBitmapPixelFormats(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    static IsBitmapPixelFormatSupported(bitmapPixelFormat: number): boolean;
+    static readonly IsSupported: boolean;
+    MaxDetectableFaceSize: Windows.Graphics.Imaging.BitmapSize;
+    MinDetectableFaceSize: Windows.Graphics.Imaging.BitmapSize;
+  }
+
+  class FaceTracker implements Windows.Media.FaceAnalysis.IFaceTracker {
+    static CreateAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.FaceAnalysis.FaceTracker>;
+    static GetSupportedBitmapPixelFormats(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    static IsBitmapPixelFormatSupported(bitmapPixelFormat: number): boolean;
+    ProcessNextFrameAsync(videoFrame: Windows.Media.VideoFrame): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.Media.FaceAnalysis.DetectedFace> | Windows.Media.FaceAnalysis.DetectedFace[]>;
+    static readonly IsSupported: boolean;
+    MaxDetectableFaceSize: Windows.Graphics.Imaging.BitmapSize;
+    MinDetectableFaceSize: Windows.Graphics.Imaging.BitmapSize;
+  }
+
+  interface IDetectedFace {
+    readonly FaceBox: Windows.Graphics.Imaging.BitmapBounds;
+  }
+  var IDetectedFace: abstract new (...args: any[]) => IDetectedFace;
+
+  interface IFaceDetector {
+    DetectFacesAsync(image: Windows.Graphics.Imaging.SoftwareBitmap): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.Media.FaceAnalysis.DetectedFace> | Windows.Media.FaceAnalysis.DetectedFace[]>;
+    DetectFacesAsync(image: Windows.Graphics.Imaging.SoftwareBitmap, searchArea: Windows.Graphics.Imaging.BitmapBounds): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.Media.FaceAnalysis.DetectedFace> | Windows.Media.FaceAnalysis.DetectedFace[]>;
+    MaxDetectableFaceSize: Windows.Graphics.Imaging.BitmapSize;
+    MinDetectableFaceSize: Windows.Graphics.Imaging.BitmapSize;
+  }
+  var IFaceDetector: abstract new (...args: any[]) => IFaceDetector;
+
+  interface IFaceDetectorStatics {
+    CreateAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.FaceAnalysis.FaceDetector>;
+    GetSupportedBitmapPixelFormats(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    IsBitmapPixelFormatSupported(bitmapPixelFormat: number): boolean;
+    readonly IsSupported: boolean;
+  }
+  var IFaceDetectorStatics: abstract new (...args: any[]) => IFaceDetectorStatics;
+
+  interface IFaceTracker {
+    ProcessNextFrameAsync(videoFrame: Windows.Media.VideoFrame): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.Media.FaceAnalysis.DetectedFace> | Windows.Media.FaceAnalysis.DetectedFace[]>;
+    MaxDetectableFaceSize: Windows.Graphics.Imaging.BitmapSize;
+    MinDetectableFaceSize: Windows.Graphics.Imaging.BitmapSize;
+  }
+  var IFaceTracker: abstract new (...args: any[]) => IFaceTracker;
+
+  interface IFaceTrackerStatics {
+    CreateAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.FaceAnalysis.FaceTracker>;
+    GetSupportedBitmapPixelFormats(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    IsBitmapPixelFormatSupported(bitmapPixelFormat: number): boolean;
+    readonly IsSupported: boolean;
+  }
+  var IFaceTrackerStatics: abstract new (...args: any[]) => IFaceTrackerStatics;
+
+}
+
+declare namespace Windows.Media.Import {
+  class PhotoImportDeleteImportedItemsFromSourceResult implements Windows.Media.Import.IPhotoImportDeleteImportedItemsFromSourceResult {
+    readonly DeletedItems: Windows.Foundation.Collections.IVectorView<Windows.Media.Import.PhotoImportItem> | Windows.Media.Import.PhotoImportItem[];
+    readonly HasSucceeded: boolean;
+    readonly PhotosCount: number;
+    readonly PhotosSizeInBytes: number | bigint;
+    readonly Session: Windows.Media.Import.PhotoImportSession;
+    readonly SiblingsCount: number;
+    readonly SiblingsSizeInBytes: number | bigint;
+    readonly SidecarsCount: number;
+    readonly SidecarsSizeInBytes: number | bigint;
+    readonly TotalCount: number;
+    readonly TotalSizeInBytes: number | bigint;
+    readonly VideosCount: number;
+    readonly VideosSizeInBytes: number | bigint;
+  }
+
+  class PhotoImportFindItemsResult implements Windows.Media.Import.IPhotoImportFindItemsResult, Windows.Media.Import.IPhotoImportFindItemsResult2 {
+    AddItemsInDateRangeToSelection(rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan): void;
+    ImportItemsAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Media.Import.PhotoImportImportItemsResult, Windows.Media.Import.PhotoImportProgress>;
+    SelectAll(): void;
+    SelectNewAsync(): Windows.Foundation.IAsyncAction;
+    SelectNone(): void;
+    SetImportMode(value: number): void;
+    readonly FoundItems: Windows.Foundation.Collections.IVectorView<Windows.Media.Import.PhotoImportItem> | Windows.Media.Import.PhotoImportItem[];
+    readonly HasSucceeded: boolean;
+    readonly ImportMode: number;
+    readonly PhotosCount: number;
+    readonly PhotosSizeInBytes: number | bigint;
+    readonly SelectedPhotosCount: number;
+    readonly SelectedPhotosSizeInBytes: number | bigint;
+    readonly SelectedSiblingsCount: number;
+    readonly SelectedSiblingsSizeInBytes: number | bigint;
+    readonly SelectedSidecarsCount: number;
+    readonly SelectedSidecarsSizeInBytes: number | bigint;
+    readonly SelectedTotalCount: number;
+    readonly SelectedTotalSizeInBytes: number | bigint;
+    readonly SelectedVideosCount: number;
+    readonly SelectedVideosSizeInBytes: number | bigint;
+    readonly Session: Windows.Media.Import.PhotoImportSession;
+    readonly SiblingsCount: number;
+    readonly SiblingsSizeInBytes: number | bigint;
+    readonly SidecarsCount: number;
+    readonly SidecarsSizeInBytes: number | bigint;
+    readonly TotalCount: number;
+    readonly TotalSizeInBytes: number | bigint;
+    readonly VideosCount: number;
+    readonly VideosSizeInBytes: number | bigint;
+    ItemImported: Windows.Foundation.TypedEventHandler<Windows.Media.Import.PhotoImportFindItemsResult, Windows.Media.Import.PhotoImportItemImportedEventArgs> | null;
+    SelectionChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Import.PhotoImportFindItemsResult, Windows.Media.Import.PhotoImportSelectionChangedEventArgs> | null;
+  }
+
+  class PhotoImportImportItemsResult implements Windows.Media.Import.IPhotoImportImportItemsResult {
+    DeleteImportedItemsFromSourceAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Media.Import.PhotoImportDeleteImportedItemsFromSourceResult, number>;
+    readonly HasSucceeded: boolean;
+    readonly ImportedItems: Windows.Foundation.Collections.IVectorView<Windows.Media.Import.PhotoImportItem> | Windows.Media.Import.PhotoImportItem[];
+    readonly PhotosCount: number;
+    readonly PhotosSizeInBytes: number | bigint;
+    readonly Session: Windows.Media.Import.PhotoImportSession;
+    readonly SiblingsCount: number;
+    readonly SiblingsSizeInBytes: number | bigint;
+    readonly SidecarsCount: number;
+    readonly SidecarsSizeInBytes: number | bigint;
+    readonly TotalCount: number;
+    readonly TotalSizeInBytes: number | bigint;
+    readonly VideosCount: number;
+    readonly VideosSizeInBytes: number | bigint;
+  }
+
+  class PhotoImportItem implements Windows.Media.Import.IPhotoImportItem, Windows.Media.Import.IPhotoImportItem2 {
+    readonly ContentType: number;
+    readonly Date: Windows.Foundation.DateTime;
+    readonly DeletedFileNames: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly ImportedFileNames: Windows.Foundation.Collections.IVectorView<string> | string[];
+    IsSelected: boolean;
+    readonly ItemKey: number | bigint;
+    readonly Name: string;
+    readonly Path: string;
+    readonly Sibling: Windows.Media.Import.PhotoImportSidecar;
+    readonly Sidecars: Windows.Foundation.Collections.IVectorView<Windows.Media.Import.PhotoImportSidecar> | Windows.Media.Import.PhotoImportSidecar[];
+    readonly SizeInBytes: number | bigint;
+    readonly Thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly VideoSegments: Windows.Foundation.Collections.IVectorView<Windows.Media.Import.PhotoImportVideoSegment> | Windows.Media.Import.PhotoImportVideoSegment[];
+  }
+
+  class PhotoImportItemImportedEventArgs implements Windows.Media.Import.IPhotoImportItemImportedEventArgs {
+    readonly ImportedItem: Windows.Media.Import.PhotoImportItem;
+  }
+
+  class PhotoImportManager {
+    static FindAllSourcesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Media.Import.PhotoImportSource> | Windows.Media.Import.PhotoImportSource[]>;
+    static GetPendingOperations(): Windows.Foundation.Collections.IVectorView<Windows.Media.Import.PhotoImportOperation> | Windows.Media.Import.PhotoImportOperation[];
+    static IsSupportedAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+
+  class PhotoImportOperation implements Windows.Media.Import.IPhotoImportOperation {
+    readonly ContinueDeletingImportedItemsFromSourceAsync: Windows.Foundation.IAsyncOperationWithProgress<Windows.Media.Import.PhotoImportDeleteImportedItemsFromSourceResult, number>;
+    readonly ContinueFindingItemsAsync: Windows.Foundation.IAsyncOperationWithProgress<Windows.Media.Import.PhotoImportFindItemsResult, number>;
+    readonly ContinueImportingItemsAsync: Windows.Foundation.IAsyncOperationWithProgress<Windows.Media.Import.PhotoImportImportItemsResult, Windows.Media.Import.PhotoImportProgress>;
+    readonly Session: Windows.Media.Import.PhotoImportSession;
+    readonly Stage: number;
+  }
+
+  class PhotoImportSelectionChangedEventArgs implements Windows.Media.Import.IPhotoImportSelectionChangedEventArgs {
+    readonly IsSelectionEmpty: boolean;
+  }
+
+  class PhotoImportSession implements Windows.Foundation.IClosable, Windows.Media.Import.IPhotoImportSession, Windows.Media.Import.IPhotoImportSession2 {
+    Close(): void;
+    FindItemsAsync(contentTypeFilter: number, itemSelectionMode: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Media.Import.PhotoImportFindItemsResult, number>;
+    AppendSessionDateToDestinationFolder: boolean;
+    DestinationFileNamePrefix: string;
+    DestinationFolder: Windows.Storage.IStorageFolder;
+    RememberDeselectedItems: boolean;
+    readonly SessionId: Guid;
+    readonly Source: Windows.Media.Import.PhotoImportSource;
+    SubfolderCreationMode: number;
+    SubfolderDateFormat: number;
+  }
+
+  class PhotoImportSidecar implements Windows.Media.Import.IPhotoImportSidecar {
+    readonly Date: Windows.Foundation.DateTime;
+    readonly Name: string;
+    readonly SizeInBytes: number | bigint;
+  }
+
+  class PhotoImportSource implements Windows.Media.Import.IPhotoImportSource {
+    CreateImportSession(): Windows.Media.Import.PhotoImportSession;
+    static FromFolderAsync(sourceRootFolder: Windows.Storage.IStorageFolder): Windows.Foundation.IAsyncOperation<Windows.Media.Import.PhotoImportSource>;
+    static FromIdAsync(sourceId: string): Windows.Foundation.IAsyncOperation<Windows.Media.Import.PhotoImportSource>;
+    readonly BatteryLevelPercent: number | null;
+    readonly ConnectionProtocol: string;
+    readonly ConnectionTransport: number;
+    readonly DateTime: Windows.Foundation.DateTime | null;
+    readonly Description: string;
+    readonly DisplayName: string;
+    readonly Id: string;
+    readonly IsLocked: boolean | null;
+    readonly IsMassStorage: boolean;
+    readonly Manufacturer: string;
+    readonly Model: string;
+    readonly PowerSource: number;
+    readonly SerialNumber: string;
+    readonly StorageMedia: Windows.Foundation.Collections.IVectorView<Windows.Media.Import.PhotoImportStorageMedium> | Windows.Media.Import.PhotoImportStorageMedium[];
+    readonly Thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly Type: number;
+  }
+
+  class PhotoImportStorageMedium implements Windows.Media.Import.IPhotoImportStorageMedium {
+    Refresh(): void;
+    readonly AvailableSpaceInBytes: number | bigint;
+    readonly CapacityInBytes: number | bigint;
+    readonly Description: string;
+    readonly Name: string;
+    readonly SerialNumber: string;
+    readonly StorageMediumType: number;
+    readonly SupportedAccessMode: number;
+  }
+
+  class PhotoImportVideoSegment implements Windows.Media.Import.IPhotoImportVideoSegment {
+    readonly Date: Windows.Foundation.DateTime;
+    readonly Name: string;
+    readonly Sibling: Windows.Media.Import.PhotoImportSidecar;
+    readonly Sidecars: Windows.Foundation.Collections.IVectorView<Windows.Media.Import.PhotoImportSidecar> | Windows.Media.Import.PhotoImportSidecar[];
+    readonly SizeInBytes: number | bigint;
+  }
+
+  enum PhotoImportAccessMode {
+    ReadWrite = 0,
+    ReadOnly = 1,
+    ReadAndDelete = 2,
+  }
+
+  enum PhotoImportConnectionTransport {
+    Unknown = 0,
+    Usb = 1,
+    IP = 2,
+    Bluetooth = 3,
+  }
+
+  enum PhotoImportContentType {
+    Unknown = 0,
+    Image = 1,
+    Video = 2,
+  }
+
+  enum PhotoImportContentTypeFilter {
+    OnlyImages = 0,
+    OnlyVideos = 1,
+    ImagesAndVideos = 2,
+    ImagesAndVideosFromCameraRoll = 3,
+  }
+
+  enum PhotoImportImportMode {
+    ImportEverything = 0,
+    IgnoreSidecars = 1,
+    IgnoreSiblings = 2,
+    IgnoreSidecarsAndSiblings = 3,
+  }
+
+  enum PhotoImportItemSelectionMode {
+    SelectAll = 0,
+    SelectNone = 1,
+    SelectNew = 2,
+  }
+
+  enum PhotoImportPowerSource {
+    Unknown = 0,
+    Battery = 1,
+    External = 2,
+  }
+
+  enum PhotoImportSourceType {
+    Generic = 0,
+    Camera = 1,
+    MediaPlayer = 2,
+    Phone = 3,
+    Video = 4,
+    PersonalInfoManager = 5,
+    AudioRecorder = 6,
+  }
+
+  enum PhotoImportStage {
+    NotStarted = 0,
+    FindingItems = 1,
+    ImportingItems = 2,
+    DeletingImportedItemsFromSource = 3,
+  }
+
+  enum PhotoImportStorageMediumType {
+    Undefined = 0,
+    Fixed = 1,
+    Removable = 2,
+  }
+
+  enum PhotoImportSubfolderCreationMode {
+    DoNotCreateSubfolders = 0,
+    CreateSubfoldersFromFileDate = 1,
+    CreateSubfoldersFromExifDate = 2,
+    KeepOriginalFolderStructure = 3,
+  }
+
+  enum PhotoImportSubfolderDateFormat {
+    Year = 0,
+    YearMonth = 1,
+    YearMonthDay = 2,
+  }
+
+  interface IPhotoImportDeleteImportedItemsFromSourceResult {
+    readonly DeletedItems: Windows.Foundation.Collections.IVectorView<Windows.Media.Import.PhotoImportItem> | Windows.Media.Import.PhotoImportItem[];
+    readonly HasSucceeded: boolean;
+    readonly PhotosCount: number;
+    readonly PhotosSizeInBytes: number | bigint;
+    readonly Session: Windows.Media.Import.PhotoImportSession;
+    readonly SiblingsCount: number;
+    readonly SiblingsSizeInBytes: number | bigint;
+    readonly SidecarsCount: number;
+    readonly SidecarsSizeInBytes: number | bigint;
+    readonly TotalCount: number;
+    readonly TotalSizeInBytes: number | bigint;
+    readonly VideosCount: number;
+    readonly VideosSizeInBytes: number | bigint;
+  }
+  var IPhotoImportDeleteImportedItemsFromSourceResult: abstract new (...args: any[]) => IPhotoImportDeleteImportedItemsFromSourceResult;
+
+  interface IPhotoImportFindItemsResult {
+    ImportItemsAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Media.Import.PhotoImportImportItemsResult, Windows.Media.Import.PhotoImportProgress>;
+    SelectAll(): void;
+    SelectNewAsync(): Windows.Foundation.IAsyncAction;
+    SelectNone(): void;
+    SetImportMode(value: number): void;
+    readonly FoundItems: Windows.Foundation.Collections.IVectorView<Windows.Media.Import.PhotoImportItem> | Windows.Media.Import.PhotoImportItem[];
+    readonly HasSucceeded: boolean;
+    readonly ImportMode: number;
+    readonly PhotosCount: number;
+    readonly PhotosSizeInBytes: number | bigint;
+    readonly SelectedPhotosCount: number;
+    readonly SelectedPhotosSizeInBytes: number | bigint;
+    readonly SelectedSiblingsCount: number;
+    readonly SelectedSiblingsSizeInBytes: number | bigint;
+    readonly SelectedSidecarsCount: number;
+    readonly SelectedSidecarsSizeInBytes: number | bigint;
+    readonly SelectedTotalCount: number;
+    readonly SelectedTotalSizeInBytes: number | bigint;
+    readonly SelectedVideosCount: number;
+    readonly SelectedVideosSizeInBytes: number | bigint;
+    readonly Session: Windows.Media.Import.PhotoImportSession;
+    readonly SiblingsCount: number;
+    readonly SiblingsSizeInBytes: number | bigint;
+    readonly SidecarsCount: number;
+    readonly SidecarsSizeInBytes: number | bigint;
+    readonly TotalCount: number;
+    readonly TotalSizeInBytes: number | bigint;
+    readonly VideosCount: number;
+    readonly VideosSizeInBytes: number | bigint;
+    ItemImported: Windows.Foundation.TypedEventHandler<Windows.Media.Import.PhotoImportFindItemsResult, Windows.Media.Import.PhotoImportItemImportedEventArgs> | null;
+    SelectionChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Import.PhotoImportFindItemsResult, Windows.Media.Import.PhotoImportSelectionChangedEventArgs> | null;
+  }
+  var IPhotoImportFindItemsResult: abstract new (...args: any[]) => IPhotoImportFindItemsResult;
+
+  interface IPhotoImportFindItemsResult2 {
+    AddItemsInDateRangeToSelection(rangeStart: Windows.Foundation.DateTime, rangeLength: Windows.Foundation.TimeSpan): void;
+  }
+  var IPhotoImportFindItemsResult2: abstract new (...args: any[]) => IPhotoImportFindItemsResult2;
+
+  interface IPhotoImportImportItemsResult {
+    DeleteImportedItemsFromSourceAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Media.Import.PhotoImportDeleteImportedItemsFromSourceResult, number>;
+    readonly HasSucceeded: boolean;
+    readonly ImportedItems: Windows.Foundation.Collections.IVectorView<Windows.Media.Import.PhotoImportItem> | Windows.Media.Import.PhotoImportItem[];
+    readonly PhotosCount: number;
+    readonly PhotosSizeInBytes: number | bigint;
+    readonly Session: Windows.Media.Import.PhotoImportSession;
+    readonly SiblingsCount: number;
+    readonly SiblingsSizeInBytes: number | bigint;
+    readonly SidecarsCount: number;
+    readonly SidecarsSizeInBytes: number | bigint;
+    readonly TotalCount: number;
+    readonly TotalSizeInBytes: number | bigint;
+    readonly VideosCount: number;
+    readonly VideosSizeInBytes: number | bigint;
+  }
+  var IPhotoImportImportItemsResult: abstract new (...args: any[]) => IPhotoImportImportItemsResult;
+
+  interface IPhotoImportItem {
+    readonly ContentType: number;
+    readonly Date: Windows.Foundation.DateTime;
+    readonly DeletedFileNames: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly ImportedFileNames: Windows.Foundation.Collections.IVectorView<string> | string[];
+    IsSelected: boolean;
+    readonly ItemKey: number | bigint;
+    readonly Name: string;
+    readonly Sibling: Windows.Media.Import.PhotoImportSidecar;
+    readonly Sidecars: Windows.Foundation.Collections.IVectorView<Windows.Media.Import.PhotoImportSidecar> | Windows.Media.Import.PhotoImportSidecar[];
+    readonly SizeInBytes: number | bigint;
+    readonly Thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly VideoSegments: Windows.Foundation.Collections.IVectorView<Windows.Media.Import.PhotoImportVideoSegment> | Windows.Media.Import.PhotoImportVideoSegment[];
+  }
+  var IPhotoImportItem: abstract new (...args: any[]) => IPhotoImportItem;
+
+  interface IPhotoImportItem2 {
+    readonly Path: string;
+  }
+  var IPhotoImportItem2: abstract new (...args: any[]) => IPhotoImportItem2;
+
+  interface IPhotoImportItemImportedEventArgs {
+    readonly ImportedItem: Windows.Media.Import.PhotoImportItem;
+  }
+  var IPhotoImportItemImportedEventArgs: abstract new (...args: any[]) => IPhotoImportItemImportedEventArgs;
+
+  interface IPhotoImportManagerStatics {
+    FindAllSourcesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Media.Import.PhotoImportSource> | Windows.Media.Import.PhotoImportSource[]>;
+    GetPendingOperations(): Windows.Foundation.Collections.IVectorView<Windows.Media.Import.PhotoImportOperation> | Windows.Media.Import.PhotoImportOperation[];
+    IsSupportedAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IPhotoImportManagerStatics: abstract new (...args: any[]) => IPhotoImportManagerStatics;
+
+  interface IPhotoImportOperation {
+    readonly ContinueDeletingImportedItemsFromSourceAsync: Windows.Foundation.IAsyncOperationWithProgress<Windows.Media.Import.PhotoImportDeleteImportedItemsFromSourceResult, number>;
+    readonly ContinueFindingItemsAsync: Windows.Foundation.IAsyncOperationWithProgress<Windows.Media.Import.PhotoImportFindItemsResult, number>;
+    readonly ContinueImportingItemsAsync: Windows.Foundation.IAsyncOperationWithProgress<Windows.Media.Import.PhotoImportImportItemsResult, Windows.Media.Import.PhotoImportProgress>;
+    readonly Session: Windows.Media.Import.PhotoImportSession;
+    readonly Stage: number;
+  }
+  var IPhotoImportOperation: abstract new (...args: any[]) => IPhotoImportOperation;
+
+  interface IPhotoImportSelectionChangedEventArgs {
+    readonly IsSelectionEmpty: boolean;
+  }
+  var IPhotoImportSelectionChangedEventArgs: abstract new (...args: any[]) => IPhotoImportSelectionChangedEventArgs;
+
+  interface IPhotoImportSession extends Windows.Foundation.IClosable {
+    Close(): void;
+    FindItemsAsync(contentTypeFilter: number, itemSelectionMode: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Media.Import.PhotoImportFindItemsResult, number>;
+    AppendSessionDateToDestinationFolder: boolean;
+    DestinationFileNamePrefix: string;
+    DestinationFolder: Windows.Storage.IStorageFolder;
+    readonly SessionId: Guid;
+    readonly Source: Windows.Media.Import.PhotoImportSource;
+    SubfolderCreationMode: number;
+  }
+  var IPhotoImportSession: abstract new (...args: any[]) => IPhotoImportSession;
+
+  interface IPhotoImportSession2 {
+    RememberDeselectedItems: boolean;
+    SubfolderDateFormat: number;
+  }
+  var IPhotoImportSession2: abstract new (...args: any[]) => IPhotoImportSession2;
+
+  interface IPhotoImportSidecar {
+    readonly Date: Windows.Foundation.DateTime;
+    readonly Name: string;
+    readonly SizeInBytes: number | bigint;
+  }
+  var IPhotoImportSidecar: abstract new (...args: any[]) => IPhotoImportSidecar;
+
+  interface IPhotoImportSource {
+    CreateImportSession(): Windows.Media.Import.PhotoImportSession;
+    readonly BatteryLevelPercent: number | null;
+    readonly ConnectionProtocol: string;
+    readonly ConnectionTransport: number;
+    readonly DateTime: Windows.Foundation.DateTime | null;
+    readonly Description: string;
+    readonly DisplayName: string;
+    readonly Id: string;
+    readonly IsLocked: boolean | null;
+    readonly IsMassStorage: boolean;
+    readonly Manufacturer: string;
+    readonly Model: string;
+    readonly PowerSource: number;
+    readonly SerialNumber: string;
+    readonly StorageMedia: Windows.Foundation.Collections.IVectorView<Windows.Media.Import.PhotoImportStorageMedium> | Windows.Media.Import.PhotoImportStorageMedium[];
+    readonly Thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly Type: number;
+  }
+  var IPhotoImportSource: abstract new (...args: any[]) => IPhotoImportSource;
+
+  interface IPhotoImportSourceStatics {
+    FromFolderAsync(sourceRootFolder: Windows.Storage.IStorageFolder): Windows.Foundation.IAsyncOperation<Windows.Media.Import.PhotoImportSource>;
+    FromIdAsync(sourceId: string): Windows.Foundation.IAsyncOperation<Windows.Media.Import.PhotoImportSource>;
+  }
+  var IPhotoImportSourceStatics: abstract new (...args: any[]) => IPhotoImportSourceStatics;
+
+  interface IPhotoImportStorageMedium {
+    Refresh(): void;
+    readonly AvailableSpaceInBytes: number | bigint;
+    readonly CapacityInBytes: number | bigint;
+    readonly Description: string;
+    readonly Name: string;
+    readonly SerialNumber: string;
+    readonly StorageMediumType: number;
+    readonly SupportedAccessMode: number;
+  }
+  var IPhotoImportStorageMedium: abstract new (...args: any[]) => IPhotoImportStorageMedium;
+
+  interface IPhotoImportVideoSegment {
+    readonly Date: Windows.Foundation.DateTime;
+    readonly Name: string;
+    readonly Sibling: Windows.Media.Import.PhotoImportSidecar;
+    readonly Sidecars: Windows.Foundation.Collections.IVectorView<Windows.Media.Import.PhotoImportSidecar> | Windows.Media.Import.PhotoImportSidecar[];
+    readonly SizeInBytes: number | bigint;
+  }
+  var IPhotoImportVideoSegment: abstract new (...args: any[]) => IPhotoImportVideoSegment;
+
+  interface PhotoImportProgress {
+    ItemsImported: number;
+    TotalItemsToImport: number;
+    BytesImported: number | bigint;
+    TotalBytesToImport: number | bigint;
+    ImportProgress: number;
+  }
+  var PhotoImportProgress: {
+    new(itemsImported: number, totalItemsToImport: number, bytesImported: number | bigint, totalBytesToImport: number | bigint, importProgress: number): PhotoImportProgress;
+    new(fields: { ItemsImported?: number; TotalItemsToImport?: number; BytesImported?: number | bigint; TotalBytesToImport?: number | bigint; ImportProgress?: number }): PhotoImportProgress;
+  };
+
+}
+
+declare namespace Windows.Media.MediaProperties {
+  class AudioEncodingProperties implements Windows.Media.MediaProperties.IAudioEncodingProperties, Windows.Media.MediaProperties.IAudioEncodingProperties2, Windows.Media.MediaProperties.IAudioEncodingProperties3, Windows.Media.MediaProperties.IAudioEncodingPropertiesWithFormatUserData, Windows.Media.MediaProperties.IMediaEncodingProperties {
+    constructor();
+    Copy(): Windows.Media.MediaProperties.AudioEncodingProperties;
+    static CreateAac(sampleRate: number, channelCount: number, bitrate: number): Windows.Media.MediaProperties.AudioEncodingProperties;
+    static CreateAacAdts(sampleRate: number, channelCount: number, bitrate: number): Windows.Media.MediaProperties.AudioEncodingProperties;
+    static CreateAlac(sampleRate: number, channelCount: number, bitsPerSample: number): Windows.Media.MediaProperties.AudioEncodingProperties;
+    static CreateFlac(sampleRate: number, channelCount: number, bitsPerSample: number): Windows.Media.MediaProperties.AudioEncodingProperties;
+    static CreateMp3(sampleRate: number, channelCount: number, bitrate: number): Windows.Media.MediaProperties.AudioEncodingProperties;
+    static CreatePcm(sampleRate: number, channelCount: number, bitsPerSample: number): Windows.Media.MediaProperties.AudioEncodingProperties;
+    static CreateWma(sampleRate: number, channelCount: number, bitrate: number): Windows.Media.MediaProperties.AudioEncodingProperties;
+    GetFormatUserData(value: number[]): void;
+    SetFormatUserData(value: number[]): void;
+    Bitrate: number;
+    BitsPerSample: number;
+    ChannelCount: number;
+    readonly IsSpatial: boolean;
+    readonly Properties: Windows.Media.MediaProperties.MediaPropertySet;
+    SampleRate: number;
+    Subtype: string;
+    readonly Type: string;
+  }
+
+  class Av1ProfileIds {
+    static readonly HighChromaSubsampling444BitDepth10: number;
+    static readonly HighChromaSubsampling444BitDepth8: number;
+    static readonly MainChromaSubsampling400BitDepth10: number;
+    static readonly MainChromaSubsampling400BitDepth8: number;
+    static readonly MainChromaSubsampling420BitDepth10: number;
+    static readonly MainChromaSubsampling420BitDepth8: number;
+    static readonly ProfessionalChromaSubsampling400BitDepth12: number;
+    static readonly ProfessionalChromaSubsampling420BitDepth12: number;
+    static readonly ProfessionalChromaSubsampling422BitDepth10: number;
+    static readonly ProfessionalChromaSubsampling422BitDepth12: number;
+    static readonly ProfessionalChromaSubsampling422BitDepth8: number;
+    static readonly ProfessionalChromaSubsampling444BitDepth12: number;
+  }
+
+  class ContainerEncodingProperties implements Windows.Media.MediaProperties.IContainerEncodingProperties, Windows.Media.MediaProperties.IContainerEncodingProperties2, Windows.Media.MediaProperties.IMediaEncodingProperties {
+    constructor();
+    Copy(): Windows.Media.MediaProperties.ContainerEncodingProperties;
+    readonly Properties: Windows.Media.MediaProperties.MediaPropertySet;
+    Subtype: string;
+    readonly Type: string;
+  }
+
+  class H264ProfileIds {
+    static readonly Baseline: number;
+    static readonly ConstrainedBaseline: number;
+    static readonly Extended: number;
+    static readonly High: number;
+    static readonly High10: number;
+    static readonly High422: number;
+    static readonly High444: number;
+    static readonly Main: number;
+    static readonly MultiviewHigh: number;
+    static readonly StereoHigh: number;
+  }
+
+  class HevcProfileIds {
+    static readonly MainChromaSubsampling420BitDepth10: number;
+    static readonly MainChromaSubsampling420BitDepth12: number;
+    static readonly MainChromaSubsampling420BitDepth8: number;
+    static readonly MainChromaSubsampling422BitDepth10: number;
+    static readonly MainChromaSubsampling422BitDepth12: number;
+    static readonly MainChromaSubsampling444BitDepth10: number;
+    static readonly MainChromaSubsampling444BitDepth12: number;
+    static readonly MainChromaSubsampling444BitDepth8: number;
+    static readonly MainIntraChromaSubsampling420BitDepth10: number;
+    static readonly MainIntraChromaSubsampling420BitDepth12: number;
+    static readonly MainIntraChromaSubsampling420BitDepth8: number;
+    static readonly MainIntraChromaSubsampling422BitDepth10: number;
+    static readonly MainIntraChromaSubsampling422BitDepth12: number;
+    static readonly MainIntraChromaSubsampling444BitDepth10: number;
+    static readonly MainIntraChromaSubsampling444BitDepth12: number;
+    static readonly MainIntraChromaSubsampling444BitDepth16: number;
+    static readonly MainIntraChromaSubsampling444BitDepth8: number;
+    static readonly MainStillChromaSubsampling420BitDepth8: number;
+    static readonly MainStillChromaSubsampling444BitDepth16: number;
+    static readonly MainStillChromaSubsampling444BitDepth8: number;
+    static readonly MonochromeBitDepth12: number;
+    static readonly MonochromeBitDepth16: number;
+  }
+
+  class ImageEncodingProperties implements Windows.Media.MediaProperties.IImageEncodingProperties, Windows.Media.MediaProperties.IImageEncodingProperties2, Windows.Media.MediaProperties.IMediaEncodingProperties {
+    constructor();
+    Copy(): Windows.Media.MediaProperties.ImageEncodingProperties;
+    static CreateBmp(): Windows.Media.MediaProperties.ImageEncodingProperties;
+    static CreateHeif(): Windows.Media.MediaProperties.ImageEncodingProperties;
+    static CreateJpeg(): Windows.Media.MediaProperties.ImageEncodingProperties;
+    static CreateJpegXR(): Windows.Media.MediaProperties.ImageEncodingProperties;
+    static CreatePng(): Windows.Media.MediaProperties.ImageEncodingProperties;
+    static CreateUncompressed(format: number): Windows.Media.MediaProperties.ImageEncodingProperties;
+    Height: number;
+    readonly Properties: Windows.Media.MediaProperties.MediaPropertySet;
+    Subtype: string;
+    readonly Type: string;
+    Width: number;
+  }
+
+  class MediaEncodingProfile implements Windows.Media.MediaProperties.IMediaEncodingProfile, Windows.Media.MediaProperties.IMediaEncodingProfile2, Windows.Media.MediaProperties.IMediaEncodingProfile3 {
+    constructor();
+    static CreateAlac(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    static CreateAv1(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    static CreateAvi(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    static CreateFlac(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    static CreateFromFileAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.MediaProperties.MediaEncodingProfile>;
+    static CreateFromStreamAsync(stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<Windows.Media.MediaProperties.MediaEncodingProfile>;
+    static CreateHevc(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    static CreateM4a(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    static CreateMp3(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    static CreateMp4(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    static CreateVp9(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    static CreateWav(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    static CreateWma(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    static CreateWmv(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    GetAudioTracks(): Windows.Foundation.Collections.IVector<Windows.Media.Core.AudioStreamDescriptor> | Windows.Media.Core.AudioStreamDescriptor[];
+    GetTimedMetadataTracks(): Windows.Foundation.Collections.IVector<Windows.Media.Core.TimedMetadataStreamDescriptor> | Windows.Media.Core.TimedMetadataStreamDescriptor[];
+    GetVideoTracks(): Windows.Foundation.Collections.IVector<Windows.Media.Core.VideoStreamDescriptor> | Windows.Media.Core.VideoStreamDescriptor[];
+    SetAudioTracks(value: Windows.Foundation.Collections.IIterable<Windows.Media.Core.AudioStreamDescriptor> | Windows.Media.Core.AudioStreamDescriptor[]): void;
+    SetTimedMetadataTracks(value: Windows.Foundation.Collections.IIterable<Windows.Media.Core.TimedMetadataStreamDescriptor> | Windows.Media.Core.TimedMetadataStreamDescriptor[]): void;
+    SetVideoTracks(value: Windows.Foundation.Collections.IIterable<Windows.Media.Core.VideoStreamDescriptor> | Windows.Media.Core.VideoStreamDescriptor[]): void;
+    Audio: Windows.Media.MediaProperties.AudioEncodingProperties;
+    Container: Windows.Media.MediaProperties.ContainerEncodingProperties;
+    Video: Windows.Media.MediaProperties.VideoEncodingProperties;
+  }
+
+  class MediaEncodingSubtypes {
+    static readonly Aac: string;
+    static readonly AacAdts: string;
+    static readonly Ac3: string;
+    static readonly Alac: string;
+    static readonly AmrNb: string;
+    static readonly AmrWb: string;
+    static readonly Argb32: string;
+    static readonly Asf: string;
+    static readonly Av1: string;
+    static readonly Avi: string;
+    static readonly Bgra8: string;
+    static readonly Bmp: string;
+    static readonly D16: string;
+    static readonly Eac3: string;
+    static readonly Flac: string;
+    static readonly Float: string;
+    static readonly Gif: string;
+    static readonly H263: string;
+    static readonly H264: string;
+    static readonly H264Es: string;
+    static readonly Heif: string;
+    static readonly Hevc: string;
+    static readonly HevcEs: string;
+    static readonly Iyuv: string;
+    static readonly Jpeg: string;
+    static readonly JpegXr: string;
+    static readonly L16: string;
+    static readonly L8: string;
+    static readonly Mjpg: string;
+    static readonly Mp3: string;
+    static readonly Mpeg: string;
+    static readonly Mpeg1: string;
+    static readonly Mpeg2: string;
+    static readonly Mpeg4: string;
+    static readonly Nv12: string;
+    static readonly P010: string;
+    static readonly Pcm: string;
+    static readonly Pgs: string;
+    static readonly Png: string;
+    static readonly Rgb24: string;
+    static readonly Rgb32: string;
+    static readonly Srt: string;
+    static readonly Ssa: string;
+    static readonly Tiff: string;
+    static readonly VobSub: string;
+    static readonly Vp9: string;
+    static readonly Wave: string;
+    static readonly Wma8: string;
+    static readonly Wma9: string;
+    static readonly Wmv3: string;
+    static readonly Wvc1: string;
+    static readonly Yuy2: string;
+    static readonly Yv12: string;
+  }
+
+  class MediaPropertySet {
+    constructor();
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<Guid, Object>>;
+    GetView(): Windows.Foundation.Collections.IMapView<Guid, Object>;
+    HasKey(key: Guid): boolean;
+    Insert(key: Guid, value: Object): boolean;
+    Lookup(key: Guid): Object;
+    Remove(key: Guid): void;
+    readonly Size: number;
+  }
+
+  class MediaRatio implements Windows.Media.MediaProperties.IMediaRatio {
+    Denominator: number;
+    Numerator: number;
+  }
+
+  class Mpeg2ProfileIds {
+    static readonly High: number;
+    static readonly Main: number;
+    static readonly SignalNoiseRatioScalable: number;
+    static readonly Simple: number;
+    static readonly SpatiallyScalable: number;
+  }
+
+  class TimedMetadataEncodingProperties implements Windows.Media.MediaProperties.IMediaEncodingProperties, Windows.Media.MediaProperties.ITimedMetadataEncodingProperties {
+    constructor();
+    Copy(): Windows.Media.MediaProperties.TimedMetadataEncodingProperties;
+    static CreatePgs(): Windows.Media.MediaProperties.TimedMetadataEncodingProperties;
+    static CreateSrt(): Windows.Media.MediaProperties.TimedMetadataEncodingProperties;
+    static CreateSsa(formatUserData: number[]): Windows.Media.MediaProperties.TimedMetadataEncodingProperties;
+    static CreateVobSub(formatUserData: number[]): Windows.Media.MediaProperties.TimedMetadataEncodingProperties;
+    GetFormatUserData(value: number[]): void;
+    SetFormatUserData(value: number[]): void;
+    readonly Properties: Windows.Media.MediaProperties.MediaPropertySet;
+    Subtype: string;
+    readonly Type: string;
+  }
+
+  class VideoEncodingProperties implements Windows.Media.MediaProperties.IMediaEncodingProperties, Windows.Media.MediaProperties.IVideoEncodingProperties, Windows.Media.MediaProperties.IVideoEncodingProperties2, Windows.Media.MediaProperties.IVideoEncodingProperties3, Windows.Media.MediaProperties.IVideoEncodingProperties4, Windows.Media.MediaProperties.IVideoEncodingProperties5 {
+    constructor();
+    Copy(): Windows.Media.MediaProperties.VideoEncodingProperties;
+    static CreateAv1(): Windows.Media.MediaProperties.VideoEncodingProperties;
+    static CreateH264(): Windows.Media.MediaProperties.VideoEncodingProperties;
+    static CreateHevc(): Windows.Media.MediaProperties.VideoEncodingProperties;
+    static CreateMpeg2(): Windows.Media.MediaProperties.VideoEncodingProperties;
+    static CreateUncompressed(subtype: string, width: number, height: number): Windows.Media.MediaProperties.VideoEncodingProperties;
+    static CreateVp9(): Windows.Media.MediaProperties.VideoEncodingProperties;
+    GetFormatUserData(value: number[]): void;
+    SetFormatUserData(value: number[]): void;
+    Bitrate: number;
+    readonly FrameRate: Windows.Media.MediaProperties.MediaRatio;
+    Height: number;
+    readonly PixelAspectRatio: Windows.Media.MediaProperties.MediaRatio;
+    ProfileId: number;
+    readonly Properties: Windows.Media.MediaProperties.MediaPropertySet;
+    readonly SphericalVideoFrameFormat: number;
+    readonly StereoscopicVideoPackingMode: number;
+    Subtype: string;
+    readonly Type: string;
+    Width: number;
+  }
+
+  class Vp9ProfileIds {
+    static readonly Profile0ChromaSubsampling420BitDepth8: number;
+    static readonly Profile2ChromaSubsampling420BitDepth10: number;
+    static readonly Profile2ChromaSubsampling420BitDepth12: number;
+  }
+
+  enum AudioEncodingQuality {
+    Auto = 0,
+    High = 1,
+    Medium = 2,
+    Low = 3,
+  }
+
+  enum MediaMirroringOptions {
+    None = 0,
+    Horizontal = 1,
+    Vertical = 2,
+  }
+
+  enum MediaPixelFormat {
+    Nv12 = 0,
+    Bgra8 = 1,
+    P010 = 2,
+  }
+
+  enum MediaRotation {
+    None = 0,
+    Clockwise90Degrees = 1,
+    Clockwise180Degrees = 2,
+    Clockwise270Degrees = 3,
+  }
+
+  enum MediaThumbnailFormat {
+    Bmp = 0,
+    Bgra8 = 1,
+  }
+
+  enum SphericalVideoFrameFormat {
+    None = 0,
+    Unsupported = 1,
+    Equirectangular = 2,
+  }
+
+  enum StereoscopicVideoPackingMode {
+    None = 0,
+    SideBySide = 1,
+    TopBottom = 2,
+  }
+
+  enum VideoEncodingQuality {
+    Auto = 0,
+    HD1080p = 1,
+    HD720p = 2,
+    Wvga = 3,
+    Ntsc = 4,
+    Pal = 5,
+    Vga = 6,
+    Qvga = 7,
+    Uhd2160p = 8,
+    Uhd4320p = 9,
+  }
+
+  interface IAudioEncodingProperties extends Windows.Media.MediaProperties.IMediaEncodingProperties {
+    Bitrate: number;
+    BitsPerSample: number;
+    ChannelCount: number;
+    SampleRate: number;
+  }
+  var IAudioEncodingProperties: abstract new (...args: any[]) => IAudioEncodingProperties;
+
+  interface IAudioEncodingProperties2 {
+    readonly IsSpatial: boolean;
+  }
+  var IAudioEncodingProperties2: abstract new (...args: any[]) => IAudioEncodingProperties2;
+
+  interface IAudioEncodingProperties3 {
+    Copy(): Windows.Media.MediaProperties.AudioEncodingProperties;
+  }
+  var IAudioEncodingProperties3: abstract new (...args: any[]) => IAudioEncodingProperties3;
+
+  interface IAudioEncodingPropertiesStatics {
+    CreateAac(sampleRate: number, channelCount: number, bitrate: number): Windows.Media.MediaProperties.AudioEncodingProperties;
+    CreateAacAdts(sampleRate: number, channelCount: number, bitrate: number): Windows.Media.MediaProperties.AudioEncodingProperties;
+    CreateMp3(sampleRate: number, channelCount: number, bitrate: number): Windows.Media.MediaProperties.AudioEncodingProperties;
+    CreatePcm(sampleRate: number, channelCount: number, bitsPerSample: number): Windows.Media.MediaProperties.AudioEncodingProperties;
+    CreateWma(sampleRate: number, channelCount: number, bitrate: number): Windows.Media.MediaProperties.AudioEncodingProperties;
+  }
+  var IAudioEncodingPropertiesStatics: abstract new (...args: any[]) => IAudioEncodingPropertiesStatics;
+
+  interface IAudioEncodingPropertiesStatics2 {
+    CreateAlac(sampleRate: number, channelCount: number, bitsPerSample: number): Windows.Media.MediaProperties.AudioEncodingProperties;
+    CreateFlac(sampleRate: number, channelCount: number, bitsPerSample: number): Windows.Media.MediaProperties.AudioEncodingProperties;
+  }
+  var IAudioEncodingPropertiesStatics2: abstract new (...args: any[]) => IAudioEncodingPropertiesStatics2;
+
+  interface IAudioEncodingPropertiesWithFormatUserData {
+    GetFormatUserData(value: number[]): void;
+    SetFormatUserData(value: number[]): void;
+  }
+  var IAudioEncodingPropertiesWithFormatUserData: abstract new (...args: any[]) => IAudioEncodingPropertiesWithFormatUserData;
+
+  interface IAv1ProfileIdsStatics {
+    readonly HighChromaSubsampling444BitDepth10: number;
+    readonly HighChromaSubsampling444BitDepth8: number;
+    readonly MainChromaSubsampling400BitDepth10: number;
+    readonly MainChromaSubsampling400BitDepth8: number;
+    readonly MainChromaSubsampling420BitDepth10: number;
+    readonly MainChromaSubsampling420BitDepth8: number;
+    readonly ProfessionalChromaSubsampling400BitDepth12: number;
+    readonly ProfessionalChromaSubsampling420BitDepth12: number;
+    readonly ProfessionalChromaSubsampling422BitDepth10: number;
+    readonly ProfessionalChromaSubsampling422BitDepth12: number;
+    readonly ProfessionalChromaSubsampling422BitDepth8: number;
+    readonly ProfessionalChromaSubsampling444BitDepth12: number;
+  }
+  var IAv1ProfileIdsStatics: abstract new (...args: any[]) => IAv1ProfileIdsStatics;
+
+  interface IContainerEncodingProperties extends Windows.Media.MediaProperties.IMediaEncodingProperties {
+  }
+  var IContainerEncodingProperties: abstract new (...args: any[]) => IContainerEncodingProperties;
+
+  interface IContainerEncodingProperties2 {
+    Copy(): Windows.Media.MediaProperties.ContainerEncodingProperties;
+  }
+  var IContainerEncodingProperties2: abstract new (...args: any[]) => IContainerEncodingProperties2;
+
+  interface IH264ProfileIdsStatics {
+    readonly Baseline: number;
+    readonly ConstrainedBaseline: number;
+    readonly Extended: number;
+    readonly High: number;
+    readonly High10: number;
+    readonly High422: number;
+    readonly High444: number;
+    readonly Main: number;
+    readonly MultiviewHigh: number;
+    readonly StereoHigh: number;
+  }
+  var IH264ProfileIdsStatics: abstract new (...args: any[]) => IH264ProfileIdsStatics;
+
+  interface IHevcProfileIdsStatics {
+    readonly MainChromaSubsampling420BitDepth10: number;
+    readonly MainChromaSubsampling420BitDepth12: number;
+    readonly MainChromaSubsampling420BitDepth8: number;
+    readonly MainChromaSubsampling422BitDepth10: number;
+    readonly MainChromaSubsampling422BitDepth12: number;
+    readonly MainChromaSubsampling444BitDepth10: number;
+    readonly MainChromaSubsampling444BitDepth12: number;
+    readonly MainChromaSubsampling444BitDepth8: number;
+    readonly MainIntraChromaSubsampling420BitDepth10: number;
+    readonly MainIntraChromaSubsampling420BitDepth12: number;
+    readonly MainIntraChromaSubsampling420BitDepth8: number;
+    readonly MainIntraChromaSubsampling422BitDepth10: number;
+    readonly MainIntraChromaSubsampling422BitDepth12: number;
+    readonly MainIntraChromaSubsampling444BitDepth10: number;
+    readonly MainIntraChromaSubsampling444BitDepth12: number;
+    readonly MainIntraChromaSubsampling444BitDepth16: number;
+    readonly MainIntraChromaSubsampling444BitDepth8: number;
+    readonly MainStillChromaSubsampling420BitDepth8: number;
+    readonly MainStillChromaSubsampling444BitDepth16: number;
+    readonly MainStillChromaSubsampling444BitDepth8: number;
+    readonly MonochromeBitDepth12: number;
+    readonly MonochromeBitDepth16: number;
+  }
+  var IHevcProfileIdsStatics: abstract new (...args: any[]) => IHevcProfileIdsStatics;
+
+  interface IImageEncodingProperties extends Windows.Media.MediaProperties.IMediaEncodingProperties {
+    Height: number;
+    Width: number;
+  }
+  var IImageEncodingProperties: abstract new (...args: any[]) => IImageEncodingProperties;
+
+  interface IImageEncodingProperties2 {
+    Copy(): Windows.Media.MediaProperties.ImageEncodingProperties;
+  }
+  var IImageEncodingProperties2: abstract new (...args: any[]) => IImageEncodingProperties2;
+
+  interface IImageEncodingPropertiesStatics {
+    CreateJpeg(): Windows.Media.MediaProperties.ImageEncodingProperties;
+    CreateJpegXR(): Windows.Media.MediaProperties.ImageEncodingProperties;
+    CreatePng(): Windows.Media.MediaProperties.ImageEncodingProperties;
+  }
+  var IImageEncodingPropertiesStatics: abstract new (...args: any[]) => IImageEncodingPropertiesStatics;
+
+  interface IImageEncodingPropertiesStatics2 {
+    CreateBmp(): Windows.Media.MediaProperties.ImageEncodingProperties;
+    CreateUncompressed(format: number): Windows.Media.MediaProperties.ImageEncodingProperties;
+  }
+  var IImageEncodingPropertiesStatics2: abstract new (...args: any[]) => IImageEncodingPropertiesStatics2;
+
+  interface IImageEncodingPropertiesStatics3 {
+    CreateHeif(): Windows.Media.MediaProperties.ImageEncodingProperties;
+  }
+  var IImageEncodingPropertiesStatics3: abstract new (...args: any[]) => IImageEncodingPropertiesStatics3;
+
+  interface IMediaEncodingProfile {
+    Audio: Windows.Media.MediaProperties.AudioEncodingProperties;
+    Container: Windows.Media.MediaProperties.ContainerEncodingProperties;
+    Video: Windows.Media.MediaProperties.VideoEncodingProperties;
+  }
+  var IMediaEncodingProfile: abstract new (...args: any[]) => IMediaEncodingProfile;
+
+  interface IMediaEncodingProfile2 {
+    GetAudioTracks(): Windows.Foundation.Collections.IVector<Windows.Media.Core.AudioStreamDescriptor> | Windows.Media.Core.AudioStreamDescriptor[];
+    GetVideoTracks(): Windows.Foundation.Collections.IVector<Windows.Media.Core.VideoStreamDescriptor> | Windows.Media.Core.VideoStreamDescriptor[];
+    SetAudioTracks(value: Windows.Foundation.Collections.IIterable<Windows.Media.Core.AudioStreamDescriptor> | Windows.Media.Core.AudioStreamDescriptor[]): void;
+    SetVideoTracks(value: Windows.Foundation.Collections.IIterable<Windows.Media.Core.VideoStreamDescriptor> | Windows.Media.Core.VideoStreamDescriptor[]): void;
+  }
+  var IMediaEncodingProfile2: abstract new (...args: any[]) => IMediaEncodingProfile2;
+
+  interface IMediaEncodingProfile3 {
+    GetTimedMetadataTracks(): Windows.Foundation.Collections.IVector<Windows.Media.Core.TimedMetadataStreamDescriptor> | Windows.Media.Core.TimedMetadataStreamDescriptor[];
+    SetTimedMetadataTracks(value: Windows.Foundation.Collections.IIterable<Windows.Media.Core.TimedMetadataStreamDescriptor> | Windows.Media.Core.TimedMetadataStreamDescriptor[]): void;
+  }
+  var IMediaEncodingProfile3: abstract new (...args: any[]) => IMediaEncodingProfile3;
+
+  interface IMediaEncodingProfileStatics {
+    CreateFromFileAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.MediaProperties.MediaEncodingProfile>;
+    CreateFromStreamAsync(stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<Windows.Media.MediaProperties.MediaEncodingProfile>;
+    CreateM4a(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    CreateMp3(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    CreateMp4(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    CreateWma(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    CreateWmv(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+  }
+  var IMediaEncodingProfileStatics: abstract new (...args: any[]) => IMediaEncodingProfileStatics;
+
+  interface IMediaEncodingProfileStatics2 {
+    CreateAvi(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    CreateWav(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+  }
+  var IMediaEncodingProfileStatics2: abstract new (...args: any[]) => IMediaEncodingProfileStatics2;
+
+  interface IMediaEncodingProfileStatics3 {
+    CreateAlac(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    CreateFlac(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    CreateHevc(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+  }
+  var IMediaEncodingProfileStatics3: abstract new (...args: any[]) => IMediaEncodingProfileStatics3;
+
+  interface IMediaEncodingProfileStatics4 {
+    CreateAv1(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+    CreateVp9(quality: number): Windows.Media.MediaProperties.MediaEncodingProfile;
+  }
+  var IMediaEncodingProfileStatics4: abstract new (...args: any[]) => IMediaEncodingProfileStatics4;
+
+  interface IMediaEncodingProperties {
+    readonly Properties: Windows.Media.MediaProperties.MediaPropertySet;
+    Subtype: string;
+    readonly Type: string;
+  }
+  var IMediaEncodingProperties: abstract new (...args: any[]) => IMediaEncodingProperties;
+
+  interface IMediaEncodingSubtypesStatics {
+    readonly Aac: string;
+    readonly AacAdts: string;
+    readonly Ac3: string;
+    readonly AmrNb: string;
+    readonly AmrWb: string;
+    readonly Argb32: string;
+    readonly Asf: string;
+    readonly Avi: string;
+    readonly Bgra8: string;
+    readonly Bmp: string;
+    readonly Eac3: string;
+    readonly Float: string;
+    readonly Gif: string;
+    readonly H263: string;
+    readonly H264: string;
+    readonly H264Es: string;
+    readonly Hevc: string;
+    readonly HevcEs: string;
+    readonly Iyuv: string;
+    readonly Jpeg: string;
+    readonly JpegXr: string;
+    readonly Mjpg: string;
+    readonly Mp3: string;
+    readonly Mpeg: string;
+    readonly Mpeg1: string;
+    readonly Mpeg2: string;
+    readonly Mpeg4: string;
+    readonly Nv12: string;
+    readonly Pcm: string;
+    readonly Png: string;
+    readonly Rgb24: string;
+    readonly Rgb32: string;
+    readonly Tiff: string;
+    readonly Wave: string;
+    readonly Wma8: string;
+    readonly Wma9: string;
+    readonly Wmv3: string;
+    readonly Wvc1: string;
+    readonly Yuy2: string;
+    readonly Yv12: string;
+  }
+  var IMediaEncodingSubtypesStatics: abstract new (...args: any[]) => IMediaEncodingSubtypesStatics;
+
+  interface IMediaEncodingSubtypesStatics2 {
+    readonly D16: string;
+    readonly L16: string;
+    readonly L8: string;
+    readonly Vp9: string;
+  }
+  var IMediaEncodingSubtypesStatics2: abstract new (...args: any[]) => IMediaEncodingSubtypesStatics2;
+
+  interface IMediaEncodingSubtypesStatics3 {
+    readonly Alac: string;
+    readonly Flac: string;
+  }
+  var IMediaEncodingSubtypesStatics3: abstract new (...args: any[]) => IMediaEncodingSubtypesStatics3;
+
+  interface IMediaEncodingSubtypesStatics4 {
+    readonly P010: string;
+  }
+  var IMediaEncodingSubtypesStatics4: abstract new (...args: any[]) => IMediaEncodingSubtypesStatics4;
+
+  interface IMediaEncodingSubtypesStatics5 {
+    readonly Heif: string;
+  }
+  var IMediaEncodingSubtypesStatics5: abstract new (...args: any[]) => IMediaEncodingSubtypesStatics5;
+
+  interface IMediaEncodingSubtypesStatics6 {
+    readonly Pgs: string;
+    readonly Srt: string;
+    readonly Ssa: string;
+    readonly VobSub: string;
+  }
+  var IMediaEncodingSubtypesStatics6: abstract new (...args: any[]) => IMediaEncodingSubtypesStatics6;
+
+  interface IMediaEncodingSubtypesStatics7 {
+    readonly Av1: string;
+  }
+  var IMediaEncodingSubtypesStatics7: abstract new (...args: any[]) => IMediaEncodingSubtypesStatics7;
+
+  interface IMediaRatio {
+    Denominator: number;
+    Numerator: number;
+  }
+  var IMediaRatio: abstract new (...args: any[]) => IMediaRatio;
+
+  interface IMpeg2ProfileIdsStatics {
+    readonly High: number;
+    readonly Main: number;
+    readonly SignalNoiseRatioScalable: number;
+    readonly Simple: number;
+    readonly SpatiallyScalable: number;
+  }
+  var IMpeg2ProfileIdsStatics: abstract new (...args: any[]) => IMpeg2ProfileIdsStatics;
+
+  interface ITimedMetadataEncodingProperties {
+    Copy(): Windows.Media.MediaProperties.TimedMetadataEncodingProperties;
+    GetFormatUserData(value: number[]): void;
+    SetFormatUserData(value: number[]): void;
+  }
+  var ITimedMetadataEncodingProperties: abstract new (...args: any[]) => ITimedMetadataEncodingProperties;
+
+  interface ITimedMetadataEncodingPropertiesStatics {
+    CreatePgs(): Windows.Media.MediaProperties.TimedMetadataEncodingProperties;
+    CreateSrt(): Windows.Media.MediaProperties.TimedMetadataEncodingProperties;
+    CreateSsa(formatUserData: number[]): Windows.Media.MediaProperties.TimedMetadataEncodingProperties;
+    CreateVobSub(formatUserData: number[]): Windows.Media.MediaProperties.TimedMetadataEncodingProperties;
+  }
+  var ITimedMetadataEncodingPropertiesStatics: abstract new (...args: any[]) => ITimedMetadataEncodingPropertiesStatics;
+
+  interface IVideoEncodingProperties extends Windows.Media.MediaProperties.IMediaEncodingProperties {
+    Bitrate: number;
+    readonly FrameRate: Windows.Media.MediaProperties.MediaRatio;
+    Height: number;
+    readonly PixelAspectRatio: Windows.Media.MediaProperties.MediaRatio;
+    Width: number;
+  }
+  var IVideoEncodingProperties: abstract new (...args: any[]) => IVideoEncodingProperties;
+
+  interface IVideoEncodingProperties2 {
+    GetFormatUserData(value: number[]): void;
+    SetFormatUserData(value: number[]): void;
+    ProfileId: number;
+  }
+  var IVideoEncodingProperties2: abstract new (...args: any[]) => IVideoEncodingProperties2;
+
+  interface IVideoEncodingProperties3 {
+    readonly StereoscopicVideoPackingMode: number;
+  }
+  var IVideoEncodingProperties3: abstract new (...args: any[]) => IVideoEncodingProperties3;
+
+  interface IVideoEncodingProperties4 {
+    readonly SphericalVideoFrameFormat: number;
+  }
+  var IVideoEncodingProperties4: abstract new (...args: any[]) => IVideoEncodingProperties4;
+
+  interface IVideoEncodingProperties5 {
+    Copy(): Windows.Media.MediaProperties.VideoEncodingProperties;
+  }
+  var IVideoEncodingProperties5: abstract new (...args: any[]) => IVideoEncodingProperties5;
+
+  interface IVideoEncodingPropertiesStatics {
+    CreateH264(): Windows.Media.MediaProperties.VideoEncodingProperties;
+    CreateMpeg2(): Windows.Media.MediaProperties.VideoEncodingProperties;
+    CreateUncompressed(subtype: string, width: number, height: number): Windows.Media.MediaProperties.VideoEncodingProperties;
+  }
+  var IVideoEncodingPropertiesStatics: abstract new (...args: any[]) => IVideoEncodingPropertiesStatics;
+
+  interface IVideoEncodingPropertiesStatics2 {
+    CreateHevc(): Windows.Media.MediaProperties.VideoEncodingProperties;
+  }
+  var IVideoEncodingPropertiesStatics2: abstract new (...args: any[]) => IVideoEncodingPropertiesStatics2;
+
+  interface IVideoEncodingPropertiesStatics3 {
+    CreateAv1(): Windows.Media.MediaProperties.VideoEncodingProperties;
+    CreateVp9(): Windows.Media.MediaProperties.VideoEncodingProperties;
+  }
+  var IVideoEncodingPropertiesStatics3: abstract new (...args: any[]) => IVideoEncodingPropertiesStatics3;
+
+  interface IVp9ProfileIdsStatics {
+    readonly Profile0ChromaSubsampling420BitDepth8: number;
+    readonly Profile2ChromaSubsampling420BitDepth10: number;
+    readonly Profile2ChromaSubsampling420BitDepth12: number;
+  }
+  var IVp9ProfileIdsStatics: abstract new (...args: any[]) => IVp9ProfileIdsStatics;
+
+}
+
+declare namespace Windows.Media.Miracast {
+  class MiracastReceiver implements Windows.Media.Miracast.IMiracastReceiver {
+    constructor();
+    ClearKnownTransmitters(): void;
+    CreateSession(view: Windows.ApplicationModel.Core.CoreApplicationView): Windows.Media.Miracast.MiracastReceiverSession;
+    CreateSessionAsync(view: Windows.ApplicationModel.Core.CoreApplicationView): Windows.Foundation.IAsyncOperation<Windows.Media.Miracast.MiracastReceiverSession>;
+    DisconnectAllAndApplySettings(settings: Windows.Media.Miracast.MiracastReceiverSettings): Windows.Media.Miracast.MiracastReceiverApplySettingsResult;
+    DisconnectAllAndApplySettingsAsync(settings: Windows.Media.Miracast.MiracastReceiverSettings): Windows.Foundation.IAsyncOperation<Windows.Media.Miracast.MiracastReceiverApplySettingsResult>;
+    GetCurrentSettings(): Windows.Media.Miracast.MiracastReceiverSettings;
+    GetCurrentSettingsAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Miracast.MiracastReceiverSettings>;
+    GetDefaultSettings(): Windows.Media.Miracast.MiracastReceiverSettings;
+    GetStatus(): Windows.Media.Miracast.MiracastReceiverStatus;
+    GetStatusAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Miracast.MiracastReceiverStatus>;
+    RemoveKnownTransmitter(transmitter: Windows.Media.Miracast.MiracastTransmitter): void;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Miracast.MiracastReceiver, Object> | null;
+  }
+
+  class MiracastReceiverApplySettingsResult implements Windows.Media.Miracast.IMiracastReceiverApplySettingsResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+
+  class MiracastReceiverConnection implements Windows.Foundation.IClosable, Windows.Media.Miracast.IMiracastReceiverConnection {
+    Close(): void;
+    Disconnect(reason: number): void;
+    Disconnect(reason: number, message: string): void;
+    Pause(): void;
+    PauseAsync(): Windows.Foundation.IAsyncAction;
+    Resume(): void;
+    ResumeAsync(): Windows.Foundation.IAsyncAction;
+    readonly CursorImageChannel: Windows.Media.Miracast.MiracastReceiverCursorImageChannel;
+    readonly InputDevices: Windows.Media.Miracast.MiracastReceiverInputDevices;
+    readonly StreamControl: Windows.Media.Miracast.MiracastReceiverStreamControl;
+    readonly Transmitter: Windows.Media.Miracast.MiracastTransmitter;
+  }
+
+  class MiracastReceiverConnectionCreatedEventArgs implements Windows.Media.Miracast.IMiracastReceiverConnectionCreatedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Connection: Windows.Media.Miracast.MiracastReceiverConnection;
+    readonly Pin: string;
+  }
+
+  class MiracastReceiverCursorImageChannel implements Windows.Media.Miracast.IMiracastReceiverCursorImageChannel {
+    readonly ImageStream: Windows.Storage.Streams.IRandomAccessStreamWithContentType;
+    readonly IsEnabled: boolean;
+    readonly MaxImageSize: Windows.Graphics.SizeInt32;
+    readonly Position: Windows.Graphics.PointInt32;
+    ImageStreamChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Miracast.MiracastReceiverCursorImageChannel, Object> | null;
+    PositionChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Miracast.MiracastReceiverCursorImageChannel, Object> | null;
+  }
+
+  class MiracastReceiverCursorImageChannelSettings implements Windows.Media.Miracast.IMiracastReceiverCursorImageChannelSettings {
+    IsEnabled: boolean;
+    MaxImageSize: Windows.Graphics.SizeInt32;
+  }
+
+  class MiracastReceiverDisconnectedEventArgs implements Windows.Media.Miracast.IMiracastReceiverDisconnectedEventArgs {
+    readonly Connection: Windows.Media.Miracast.MiracastReceiverConnection;
+  }
+
+  class MiracastReceiverGameControllerDevice implements Windows.Media.Miracast.IMiracastReceiverGameControllerDevice {
+    readonly IsRequestedByTransmitter: boolean;
+    readonly IsTransmittingInput: boolean;
+    Mode: number;
+    TransmitInput: boolean;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.Media.Miracast.MiracastReceiverGameControllerDevice, Object> | null;
+  }
+
+  class MiracastReceiverInputDevices implements Windows.Media.Miracast.IMiracastReceiverInputDevices {
+    readonly GameController: Windows.Media.Miracast.MiracastReceiverGameControllerDevice;
+    readonly Keyboard: Windows.Media.Miracast.MiracastReceiverKeyboardDevice;
+  }
+
+  class MiracastReceiverKeyboardDevice implements Windows.Media.Miracast.IMiracastReceiverKeyboardDevice {
+    readonly IsRequestedByTransmitter: boolean;
+    readonly IsTransmittingInput: boolean;
+    TransmitInput: boolean;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.Media.Miracast.MiracastReceiverKeyboardDevice, Object> | null;
+  }
+
+  class MiracastReceiverMediaSourceCreatedEventArgs implements Windows.Media.Miracast.IMiracastReceiverMediaSourceCreatedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Connection: Windows.Media.Miracast.MiracastReceiverConnection;
+    readonly CursorImageChannelSettings: Windows.Media.Miracast.MiracastReceiverCursorImageChannelSettings;
+    readonly MediaSource: Windows.Media.Core.MediaSource;
+  }
+
+  class MiracastReceiverSession implements Windows.Foundation.IClosable, Windows.Media.Miracast.IMiracastReceiverSession {
+    Close(): void;
+    Start(): Windows.Media.Miracast.MiracastReceiverSessionStartResult;
+    StartAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Miracast.MiracastReceiverSessionStartResult>;
+    AllowConnectionTakeover: boolean;
+    MaxSimultaneousConnections: number;
+    ConnectionCreated: Windows.Foundation.TypedEventHandler<Windows.Media.Miracast.MiracastReceiverSession, Windows.Media.Miracast.MiracastReceiverConnectionCreatedEventArgs> | null;
+    Disconnected: Windows.Foundation.TypedEventHandler<Windows.Media.Miracast.MiracastReceiverSession, Windows.Media.Miracast.MiracastReceiverDisconnectedEventArgs> | null;
+    MediaSourceCreated: Windows.Foundation.TypedEventHandler<Windows.Media.Miracast.MiracastReceiverSession, Windows.Media.Miracast.MiracastReceiverMediaSourceCreatedEventArgs> | null;
+  }
+
+  class MiracastReceiverSessionStartResult implements Windows.Media.Miracast.IMiracastReceiverSessionStartResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+
+  class MiracastReceiverSettings implements Windows.Media.Miracast.IMiracastReceiverSettings {
+    AuthorizationMethod: number;
+    FriendlyName: string;
+    ModelName: string;
+    ModelNumber: string;
+    RequireAuthorizationFromKnownTransmitters: boolean;
+  }
+
+  class MiracastReceiverStatus implements Windows.Media.Miracast.IMiracastReceiverStatus {
+    readonly IsConnectionTakeoverSupported: boolean;
+    readonly KnownTransmitters: Windows.Foundation.Collections.IVectorView<Windows.Media.Miracast.MiracastTransmitter> | Windows.Media.Miracast.MiracastTransmitter[];
+    readonly ListeningStatus: number;
+    readonly MaxSimultaneousConnections: number;
+    readonly WiFiStatus: number;
+  }
+
+  class MiracastReceiverStreamControl implements Windows.Media.Miracast.IMiracastReceiverStreamControl {
+    GetVideoStreamSettings(): Windows.Media.Miracast.MiracastReceiverVideoStreamSettings;
+    GetVideoStreamSettingsAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Miracast.MiracastReceiverVideoStreamSettings>;
+    SuggestVideoStreamSettings(settings: Windows.Media.Miracast.MiracastReceiverVideoStreamSettings): void;
+    SuggestVideoStreamSettingsAsync(settings: Windows.Media.Miracast.MiracastReceiverVideoStreamSettings): Windows.Foundation.IAsyncAction;
+    MuteAudio: boolean;
+  }
+
+  class MiracastReceiverVideoStreamSettings implements Windows.Media.Miracast.IMiracastReceiverVideoStreamSettings {
+    Bitrate: number;
+    Size: Windows.Graphics.SizeInt32;
+  }
+
+  class MiracastTransmitter implements Windows.Media.Miracast.IMiracastTransmitter {
+    GetConnections(): Windows.Foundation.Collections.IVectorView<Windows.Media.Miracast.MiracastReceiverConnection> | Windows.Media.Miracast.MiracastReceiverConnection[];
+    AuthorizationStatus: number;
+    readonly LastConnectionTime: Windows.Foundation.DateTime;
+    readonly MacAddress: string;
+    Name: string;
+  }
+
+  enum MiracastReceiverApplySettingsStatus {
+    Success = 0,
+    UnknownFailure = 1,
+    MiracastNotSupported = 2,
+    AccessDenied = 3,
+    FriendlyNameTooLong = 4,
+    ModelNameTooLong = 5,
+    ModelNumberTooLong = 6,
+    InvalidSettings = 7,
+  }
+
+  enum MiracastReceiverAuthorizationMethod {
+    None = 0,
+    ConfirmConnection = 1,
+    PinDisplayIfRequested = 2,
+    PinDisplayRequired = 3,
+  }
+
+  enum MiracastReceiverDisconnectReason {
+    Finished = 0,
+    AppSpecificError = 1,
+    ConnectionNotAccepted = 2,
+    DisconnectedByUser = 3,
+    FailedToStartStreaming = 4,
+    MediaDecodingError = 5,
+    MediaStreamingError = 6,
+    MediaDecryptionError = 7,
+  }
+
+  enum MiracastReceiverGameControllerDeviceUsageMode {
+    AsGameController = 0,
+    AsMouseAndKeyboard = 1,
+  }
+
+  enum MiracastReceiverListeningStatus {
+    NotListening = 0,
+    Listening = 1,
+    ConnectionPending = 2,
+    Connected = 3,
+    DisabledByPolicy = 4,
+    TemporarilyDisabled = 5,
+  }
+
+  enum MiracastReceiverSessionStartStatus {
+    Success = 0,
+    UnknownFailure = 1,
+    MiracastNotSupported = 2,
+    AccessDenied = 3,
+  }
+
+  enum MiracastReceiverWiFiStatus {
+    MiracastSupportUndetermined = 0,
+    MiracastNotSupported = 1,
+    MiracastSupportNotOptimized = 2,
+    MiracastSupported = 3,
+  }
+
+  enum MiracastTransmitterAuthorizationStatus {
+    Undecided = 0,
+    Allowed = 1,
+    AlwaysPrompt = 2,
+    Blocked = 3,
+  }
+
+  interface IMiracastReceiver {
+    ClearKnownTransmitters(): void;
+    CreateSession(view: Windows.ApplicationModel.Core.CoreApplicationView): Windows.Media.Miracast.MiracastReceiverSession;
+    CreateSessionAsync(view: Windows.ApplicationModel.Core.CoreApplicationView): Windows.Foundation.IAsyncOperation<Windows.Media.Miracast.MiracastReceiverSession>;
+    DisconnectAllAndApplySettings(settings: Windows.Media.Miracast.MiracastReceiverSettings): Windows.Media.Miracast.MiracastReceiverApplySettingsResult;
+    DisconnectAllAndApplySettingsAsync(settings: Windows.Media.Miracast.MiracastReceiverSettings): Windows.Foundation.IAsyncOperation<Windows.Media.Miracast.MiracastReceiverApplySettingsResult>;
+    GetCurrentSettings(): Windows.Media.Miracast.MiracastReceiverSettings;
+    GetCurrentSettingsAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Miracast.MiracastReceiverSettings>;
+    GetDefaultSettings(): Windows.Media.Miracast.MiracastReceiverSettings;
+    GetStatus(): Windows.Media.Miracast.MiracastReceiverStatus;
+    GetStatusAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Miracast.MiracastReceiverStatus>;
+    RemoveKnownTransmitter(transmitter: Windows.Media.Miracast.MiracastTransmitter): void;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Miracast.MiracastReceiver, Object> | null;
+  }
+  var IMiracastReceiver: abstract new (...args: any[]) => IMiracastReceiver;
+
+  interface IMiracastReceiverApplySettingsResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+  var IMiracastReceiverApplySettingsResult: abstract new (...args: any[]) => IMiracastReceiverApplySettingsResult;
+
+  interface IMiracastReceiverConnection {
+    Disconnect(reason: number): void;
+    Disconnect(reason: number, message: string): void;
+    Pause(): void;
+    PauseAsync(): Windows.Foundation.IAsyncAction;
+    Resume(): void;
+    ResumeAsync(): Windows.Foundation.IAsyncAction;
+    readonly CursorImageChannel: Windows.Media.Miracast.MiracastReceiverCursorImageChannel;
+    readonly InputDevices: Windows.Media.Miracast.MiracastReceiverInputDevices;
+    readonly StreamControl: Windows.Media.Miracast.MiracastReceiverStreamControl;
+    readonly Transmitter: Windows.Media.Miracast.MiracastTransmitter;
+  }
+  var IMiracastReceiverConnection: abstract new (...args: any[]) => IMiracastReceiverConnection;
+
+  interface IMiracastReceiverConnectionCreatedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Connection: Windows.Media.Miracast.MiracastReceiverConnection;
+    readonly Pin: string;
+  }
+  var IMiracastReceiverConnectionCreatedEventArgs: abstract new (...args: any[]) => IMiracastReceiverConnectionCreatedEventArgs;
+
+  interface IMiracastReceiverCursorImageChannel {
+    readonly ImageStream: Windows.Storage.Streams.IRandomAccessStreamWithContentType;
+    readonly IsEnabled: boolean;
+    readonly MaxImageSize: Windows.Graphics.SizeInt32;
+    readonly Position: Windows.Graphics.PointInt32;
+    ImageStreamChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Miracast.MiracastReceiverCursorImageChannel, Object> | null;
+    PositionChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Miracast.MiracastReceiverCursorImageChannel, Object> | null;
+  }
+  var IMiracastReceiverCursorImageChannel: abstract new (...args: any[]) => IMiracastReceiverCursorImageChannel;
+
+  interface IMiracastReceiverCursorImageChannelSettings {
+    IsEnabled: boolean;
+    MaxImageSize: Windows.Graphics.SizeInt32;
+  }
+  var IMiracastReceiverCursorImageChannelSettings: abstract new (...args: any[]) => IMiracastReceiverCursorImageChannelSettings;
+
+  interface IMiracastReceiverDisconnectedEventArgs {
+    readonly Connection: Windows.Media.Miracast.MiracastReceiverConnection;
+  }
+  var IMiracastReceiverDisconnectedEventArgs: abstract new (...args: any[]) => IMiracastReceiverDisconnectedEventArgs;
+
+  interface IMiracastReceiverGameControllerDevice {
+    readonly IsRequestedByTransmitter: boolean;
+    readonly IsTransmittingInput: boolean;
+    Mode: number;
+    TransmitInput: boolean;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.Media.Miracast.MiracastReceiverGameControllerDevice, Object> | null;
+  }
+  var IMiracastReceiverGameControllerDevice: abstract new (...args: any[]) => IMiracastReceiverGameControllerDevice;
+
+  interface IMiracastReceiverInputDevices {
+    readonly GameController: Windows.Media.Miracast.MiracastReceiverGameControllerDevice;
+    readonly Keyboard: Windows.Media.Miracast.MiracastReceiverKeyboardDevice;
+  }
+  var IMiracastReceiverInputDevices: abstract new (...args: any[]) => IMiracastReceiverInputDevices;
+
+  interface IMiracastReceiverKeyboardDevice {
+    readonly IsRequestedByTransmitter: boolean;
+    readonly IsTransmittingInput: boolean;
+    TransmitInput: boolean;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.Media.Miracast.MiracastReceiverKeyboardDevice, Object> | null;
+  }
+  var IMiracastReceiverKeyboardDevice: abstract new (...args: any[]) => IMiracastReceiverKeyboardDevice;
+
+  interface IMiracastReceiverMediaSourceCreatedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Connection: Windows.Media.Miracast.MiracastReceiverConnection;
+    readonly CursorImageChannelSettings: Windows.Media.Miracast.MiracastReceiverCursorImageChannelSettings;
+    readonly MediaSource: Windows.Media.Core.MediaSource;
+  }
+  var IMiracastReceiverMediaSourceCreatedEventArgs: abstract new (...args: any[]) => IMiracastReceiverMediaSourceCreatedEventArgs;
+
+  interface IMiracastReceiverSession {
+    Start(): Windows.Media.Miracast.MiracastReceiverSessionStartResult;
+    StartAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Miracast.MiracastReceiverSessionStartResult>;
+    AllowConnectionTakeover: boolean;
+    MaxSimultaneousConnections: number;
+    ConnectionCreated: Windows.Foundation.TypedEventHandler<Windows.Media.Miracast.MiracastReceiverSession, Windows.Media.Miracast.MiracastReceiverConnectionCreatedEventArgs> | null;
+    Disconnected: Windows.Foundation.TypedEventHandler<Windows.Media.Miracast.MiracastReceiverSession, Windows.Media.Miracast.MiracastReceiverDisconnectedEventArgs> | null;
+    MediaSourceCreated: Windows.Foundation.TypedEventHandler<Windows.Media.Miracast.MiracastReceiverSession, Windows.Media.Miracast.MiracastReceiverMediaSourceCreatedEventArgs> | null;
+  }
+  var IMiracastReceiverSession: abstract new (...args: any[]) => IMiracastReceiverSession;
+
+  interface IMiracastReceiverSessionStartResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+  var IMiracastReceiverSessionStartResult: abstract new (...args: any[]) => IMiracastReceiverSessionStartResult;
+
+  interface IMiracastReceiverSettings {
+    AuthorizationMethod: number;
+    FriendlyName: string;
+    ModelName: string;
+    ModelNumber: string;
+    RequireAuthorizationFromKnownTransmitters: boolean;
+  }
+  var IMiracastReceiverSettings: abstract new (...args: any[]) => IMiracastReceiverSettings;
+
+  interface IMiracastReceiverStatus {
+    readonly IsConnectionTakeoverSupported: boolean;
+    readonly KnownTransmitters: Windows.Foundation.Collections.IVectorView<Windows.Media.Miracast.MiracastTransmitter> | Windows.Media.Miracast.MiracastTransmitter[];
+    readonly ListeningStatus: number;
+    readonly MaxSimultaneousConnections: number;
+    readonly WiFiStatus: number;
+  }
+  var IMiracastReceiverStatus: abstract new (...args: any[]) => IMiracastReceiverStatus;
+
+  interface IMiracastReceiverStreamControl {
+    GetVideoStreamSettings(): Windows.Media.Miracast.MiracastReceiverVideoStreamSettings;
+    GetVideoStreamSettingsAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.Miracast.MiracastReceiverVideoStreamSettings>;
+    SuggestVideoStreamSettings(settings: Windows.Media.Miracast.MiracastReceiverVideoStreamSettings): void;
+    SuggestVideoStreamSettingsAsync(settings: Windows.Media.Miracast.MiracastReceiverVideoStreamSettings): Windows.Foundation.IAsyncAction;
+    MuteAudio: boolean;
+  }
+  var IMiracastReceiverStreamControl: abstract new (...args: any[]) => IMiracastReceiverStreamControl;
+
+  interface IMiracastReceiverVideoStreamSettings {
+    Bitrate: number;
+    Size: Windows.Graphics.SizeInt32;
+  }
+  var IMiracastReceiverVideoStreamSettings: abstract new (...args: any[]) => IMiracastReceiverVideoStreamSettings;
+
+  interface IMiracastTransmitter {
+    GetConnections(): Windows.Foundation.Collections.IVectorView<Windows.Media.Miracast.MiracastReceiverConnection> | Windows.Media.Miracast.MiracastReceiverConnection[];
+    AuthorizationStatus: number;
+    readonly LastConnectionTime: Windows.Foundation.DateTime;
+    readonly MacAddress: string;
+    Name: string;
+  }
+  var IMiracastTransmitter: abstract new (...args: any[]) => IMiracastTransmitter;
+
+}
+
+declare namespace Windows.Media.Ocr {
+  class OcrEngine implements Windows.Media.Ocr.IOcrEngine {
+    static IsLanguageSupported(language: Windows.Globalization.Language): boolean;
+    RecognizeAsync(bitmap: Windows.Graphics.Imaging.SoftwareBitmap): Windows.Foundation.IAsyncOperation<Windows.Media.Ocr.OcrResult>;
+    static TryCreateFromLanguage(language: Windows.Globalization.Language): Windows.Media.Ocr.OcrEngine;
+    static TryCreateFromUserProfileLanguages(): Windows.Media.Ocr.OcrEngine;
+    static readonly AvailableRecognizerLanguages: Windows.Foundation.Collections.IVectorView<Windows.Globalization.Language> | Windows.Globalization.Language[];
+    static readonly MaxImageDimension: number;
+    readonly RecognizerLanguage: Windows.Globalization.Language;
+  }
+
+  class OcrLine implements Windows.Media.Ocr.IOcrLine {
+    readonly Text: string;
+    readonly Words: Windows.Foundation.Collections.IVectorView<Windows.Media.Ocr.OcrWord> | Windows.Media.Ocr.OcrWord[];
+  }
+
+  class OcrResult implements Windows.Media.Ocr.IOcrResult {
+    readonly Lines: Windows.Foundation.Collections.IVectorView<Windows.Media.Ocr.OcrLine> | Windows.Media.Ocr.OcrLine[];
+    readonly Text: string;
+    readonly TextAngle: number | null;
+  }
+
+  class OcrWord implements Windows.Media.Ocr.IOcrWord {
+    readonly BoundingRect: Windows.Foundation.Rect;
+    readonly Text: string;
+  }
+
+  interface IOcrEngine {
+    RecognizeAsync(bitmap: Windows.Graphics.Imaging.SoftwareBitmap): Windows.Foundation.IAsyncOperation<Windows.Media.Ocr.OcrResult>;
+    readonly RecognizerLanguage: Windows.Globalization.Language;
+  }
+  var IOcrEngine: abstract new (...args: any[]) => IOcrEngine;
+
+  interface IOcrEngineStatics {
+    IsLanguageSupported(language: Windows.Globalization.Language): boolean;
+    TryCreateFromLanguage(language: Windows.Globalization.Language): Windows.Media.Ocr.OcrEngine;
+    TryCreateFromUserProfileLanguages(): Windows.Media.Ocr.OcrEngine;
+    readonly AvailableRecognizerLanguages: Windows.Foundation.Collections.IVectorView<Windows.Globalization.Language> | Windows.Globalization.Language[];
+    readonly MaxImageDimension: number;
+  }
+  var IOcrEngineStatics: abstract new (...args: any[]) => IOcrEngineStatics;
+
+  interface IOcrLine {
+    readonly Text: string;
+    readonly Words: Windows.Foundation.Collections.IVectorView<Windows.Media.Ocr.OcrWord> | Windows.Media.Ocr.OcrWord[];
+  }
+  var IOcrLine: abstract new (...args: any[]) => IOcrLine;
+
+  interface IOcrResult {
+    readonly Lines: Windows.Foundation.Collections.IVectorView<Windows.Media.Ocr.OcrLine> | Windows.Media.Ocr.OcrLine[];
+    readonly Text: string;
+    readonly TextAngle: number | null;
+  }
+  var IOcrResult: abstract new (...args: any[]) => IOcrResult;
+
+  interface IOcrWord {
+    readonly BoundingRect: Windows.Foundation.Rect;
+    readonly Text: string;
+  }
+  var IOcrWord: abstract new (...args: any[]) => IOcrWord;
+
+}
+
+declare namespace Windows.Media.PlayTo {
+  class CurrentTimeChangeRequestedEventArgs implements Windows.Media.PlayTo.ICurrentTimeChangeRequestedEventArgs {
+    readonly Time: Windows.Foundation.TimeSpan;
+  }
+
+  class MuteChangeRequestedEventArgs implements Windows.Media.PlayTo.IMuteChangeRequestedEventArgs {
+    readonly Mute: boolean;
+  }
+
+  class PlayToConnection implements Windows.Media.PlayTo.IPlayToConnection {
+    readonly State: number;
+    Error: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToConnection, Windows.Media.PlayTo.PlayToConnectionErrorEventArgs> | null;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToConnection, Windows.Media.PlayTo.PlayToConnectionStateChangedEventArgs> | null;
+    Transferred: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToConnection, Windows.Media.PlayTo.PlayToConnectionTransferredEventArgs> | null;
+  }
+
+  class PlayToConnectionErrorEventArgs implements Windows.Media.PlayTo.IPlayToConnectionErrorEventArgs {
+    readonly Code: number;
+    readonly Message: string;
+  }
+
+  class PlayToConnectionStateChangedEventArgs implements Windows.Media.PlayTo.IPlayToConnectionStateChangedEventArgs {
+    readonly CurrentState: number;
+    readonly PreviousState: number;
+  }
+
+  class PlayToConnectionTransferredEventArgs implements Windows.Media.PlayTo.IPlayToConnectionTransferredEventArgs {
+    readonly CurrentSource: Windows.Media.PlayTo.PlayToSource;
+    readonly PreviousSource: Windows.Media.PlayTo.PlayToSource;
+  }
+
+  class PlayToManager implements Windows.Media.PlayTo.IPlayToManager {
+    static GetForCurrentView(): Windows.Media.PlayTo.PlayToManager;
+    static ShowPlayToUI(): void;
+    DefaultSourceSelection: boolean;
+    SourceRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToManager, Windows.Media.PlayTo.PlayToSourceRequestedEventArgs> | null;
+    SourceSelected: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToManager, Windows.Media.PlayTo.PlayToSourceSelectedEventArgs> | null;
+  }
+
+  class PlayToReceiver implements Windows.Media.PlayTo.IPlayToReceiver {
+    constructor();
+    NotifyDurationChange(duration: Windows.Foundation.TimeSpan): void;
+    NotifyEnded(): void;
+    NotifyError(): void;
+    NotifyLoadedMetadata(): void;
+    NotifyPaused(): void;
+    NotifyPlaying(): void;
+    NotifyRateChange(rate: number): void;
+    NotifySeeked(): void;
+    NotifySeeking(): void;
+    NotifyStopped(): void;
+    NotifyTimeUpdate(currentTime: Windows.Foundation.TimeSpan): void;
+    NotifyVolumeChange(volume: number, mute: boolean): void;
+    StartAsync(): Windows.Foundation.IAsyncAction;
+    StopAsync(): Windows.Foundation.IAsyncAction;
+    FriendlyName: string;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+    SupportsAudio: boolean;
+    SupportsImage: boolean;
+    SupportsVideo: boolean;
+    CurrentTimeChangeRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToReceiver, Windows.Media.PlayTo.CurrentTimeChangeRequestedEventArgs> | null;
+    MuteChangeRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToReceiver, Windows.Media.PlayTo.MuteChangeRequestedEventArgs> | null;
+    PauseRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToReceiver, Object> | null;
+    PlayRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToReceiver, Object> | null;
+    PlaybackRateChangeRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToReceiver, Windows.Media.PlayTo.PlaybackRateChangeRequestedEventArgs> | null;
+    SourceChangeRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToReceiver, Windows.Media.PlayTo.SourceChangeRequestedEventArgs> | null;
+    StopRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToReceiver, Object> | null;
+    TimeUpdateRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToReceiver, Object> | null;
+    VolumeChangeRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToReceiver, Windows.Media.PlayTo.VolumeChangeRequestedEventArgs> | null;
+  }
+
+  class PlayToSource implements Windows.Media.PlayTo.IPlayToSource, Windows.Media.PlayTo.IPlayToSourceWithPreferredSourceUri {
+    PlayNext(): void;
+    readonly Connection: Windows.Media.PlayTo.PlayToConnection;
+    Next: Windows.Media.PlayTo.PlayToSource;
+    PreferredSourceUri: Windows.Foundation.Uri;
+  }
+
+  class PlayToSourceDeferral implements Windows.Media.PlayTo.IPlayToSourceDeferral {
+    Complete(): void;
+  }
+
+  class PlayToSourceRequest implements Windows.Media.PlayTo.IPlayToSourceRequest {
+    DisplayErrorString(errorString: string): void;
+    GetDeferral(): Windows.Media.PlayTo.PlayToSourceDeferral;
+    SetSource(value: Windows.Media.PlayTo.PlayToSource): void;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+
+  class PlayToSourceRequestedEventArgs implements Windows.Media.PlayTo.IPlayToSourceRequestedEventArgs {
+    readonly SourceRequest: Windows.Media.PlayTo.PlayToSourceRequest;
+  }
+
+  class PlayToSourceSelectedEventArgs implements Windows.Media.PlayTo.IPlayToSourceSelectedEventArgs {
+    readonly FriendlyName: string;
+    readonly Icon: Windows.Storage.Streams.IRandomAccessStreamWithContentType;
+    readonly SupportsAudio: boolean;
+    readonly SupportsImage: boolean;
+    readonly SupportsVideo: boolean;
+  }
+
+  class PlaybackRateChangeRequestedEventArgs implements Windows.Media.PlayTo.IPlaybackRateChangeRequestedEventArgs {
+    readonly Rate: number;
+  }
+
+  class SourceChangeRequestedEventArgs implements Windows.Media.PlayTo.ISourceChangeRequestedEventArgs {
+    readonly Album: string;
+    readonly Author: string;
+    readonly Date: Windows.Foundation.DateTime | null;
+    readonly Description: string;
+    readonly Genre: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Rating: number | null;
+    readonly Stream: Windows.Storage.Streams.IRandomAccessStreamWithContentType;
+    readonly Thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly Title: string;
+  }
+
+  class VolumeChangeRequestedEventArgs implements Windows.Media.PlayTo.IVolumeChangeRequestedEventArgs {
+    readonly Volume: number;
+  }
+
+  enum PlayToConnectionError {
+    None = 0,
+    DeviceNotResponding = 1,
+    DeviceError = 2,
+    DeviceLocked = 3,
+    ProtectedPlaybackFailed = 4,
+  }
+
+  enum PlayToConnectionState {
+    Disconnected = 0,
+    Connected = 1,
+    Rendering = 2,
+  }
+
+  interface ICurrentTimeChangeRequestedEventArgs {
+    readonly Time: Windows.Foundation.TimeSpan;
+  }
+  var ICurrentTimeChangeRequestedEventArgs: abstract new (...args: any[]) => ICurrentTimeChangeRequestedEventArgs;
+
+  interface IMuteChangeRequestedEventArgs {
+    readonly Mute: boolean;
+  }
+  var IMuteChangeRequestedEventArgs: abstract new (...args: any[]) => IMuteChangeRequestedEventArgs;
+
+  interface IPlayToConnection {
+    readonly State: number;
+    Error: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToConnection, Windows.Media.PlayTo.PlayToConnectionErrorEventArgs> | null;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToConnection, Windows.Media.PlayTo.PlayToConnectionStateChangedEventArgs> | null;
+    Transferred: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToConnection, Windows.Media.PlayTo.PlayToConnectionTransferredEventArgs> | null;
+  }
+  var IPlayToConnection: abstract new (...args: any[]) => IPlayToConnection;
+
+  interface IPlayToConnectionErrorEventArgs {
+    readonly Code: number;
+    readonly Message: string;
+  }
+  var IPlayToConnectionErrorEventArgs: abstract new (...args: any[]) => IPlayToConnectionErrorEventArgs;
+
+  interface IPlayToConnectionStateChangedEventArgs {
+    readonly CurrentState: number;
+    readonly PreviousState: number;
+  }
+  var IPlayToConnectionStateChangedEventArgs: abstract new (...args: any[]) => IPlayToConnectionStateChangedEventArgs;
+
+  interface IPlayToConnectionTransferredEventArgs {
+    readonly CurrentSource: Windows.Media.PlayTo.PlayToSource;
+    readonly PreviousSource: Windows.Media.PlayTo.PlayToSource;
+  }
+  var IPlayToConnectionTransferredEventArgs: abstract new (...args: any[]) => IPlayToConnectionTransferredEventArgs;
+
+  interface IPlayToManager {
+    DefaultSourceSelection: boolean;
+    SourceRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToManager, Windows.Media.PlayTo.PlayToSourceRequestedEventArgs> | null;
+    SourceSelected: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToManager, Windows.Media.PlayTo.PlayToSourceSelectedEventArgs> | null;
+  }
+  var IPlayToManager: abstract new (...args: any[]) => IPlayToManager;
+
+  interface IPlayToManagerStatics {
+    GetForCurrentView(): Windows.Media.PlayTo.PlayToManager;
+    ShowPlayToUI(): void;
+  }
+  var IPlayToManagerStatics: abstract new (...args: any[]) => IPlayToManagerStatics;
+
+  interface IPlayToReceiver {
+    NotifyDurationChange(duration: Windows.Foundation.TimeSpan): void;
+    NotifyEnded(): void;
+    NotifyError(): void;
+    NotifyLoadedMetadata(): void;
+    NotifyPaused(): void;
+    NotifyPlaying(): void;
+    NotifyRateChange(rate: number): void;
+    NotifySeeked(): void;
+    NotifySeeking(): void;
+    NotifyStopped(): void;
+    NotifyTimeUpdate(currentTime: Windows.Foundation.TimeSpan): void;
+    NotifyVolumeChange(volume: number, mute: boolean): void;
+    StartAsync(): Windows.Foundation.IAsyncAction;
+    StopAsync(): Windows.Foundation.IAsyncAction;
+    FriendlyName: string;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+    SupportsAudio: boolean;
+    SupportsImage: boolean;
+    SupportsVideo: boolean;
+    CurrentTimeChangeRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToReceiver, Windows.Media.PlayTo.CurrentTimeChangeRequestedEventArgs> | null;
+    MuteChangeRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToReceiver, Windows.Media.PlayTo.MuteChangeRequestedEventArgs> | null;
+    PauseRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToReceiver, Object> | null;
+    PlayRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToReceiver, Object> | null;
+    PlaybackRateChangeRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToReceiver, Windows.Media.PlayTo.PlaybackRateChangeRequestedEventArgs> | null;
+    SourceChangeRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToReceiver, Windows.Media.PlayTo.SourceChangeRequestedEventArgs> | null;
+    StopRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToReceiver, Object> | null;
+    TimeUpdateRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToReceiver, Object> | null;
+    VolumeChangeRequested: Windows.Foundation.TypedEventHandler<Windows.Media.PlayTo.PlayToReceiver, Windows.Media.PlayTo.VolumeChangeRequestedEventArgs> | null;
+  }
+  var IPlayToReceiver: abstract new (...args: any[]) => IPlayToReceiver;
+
+  interface IPlayToSource {
+    PlayNext(): void;
+    readonly Connection: Windows.Media.PlayTo.PlayToConnection;
+    Next: Windows.Media.PlayTo.PlayToSource;
+  }
+  var IPlayToSource: abstract new (...args: any[]) => IPlayToSource;
+
+  interface IPlayToSourceDeferral {
+    Complete(): void;
+  }
+  var IPlayToSourceDeferral: abstract new (...args: any[]) => IPlayToSourceDeferral;
+
+  interface IPlayToSourceRequest {
+    DisplayErrorString(errorString: string): void;
+    GetDeferral(): Windows.Media.PlayTo.PlayToSourceDeferral;
+    SetSource(value: Windows.Media.PlayTo.PlayToSource): void;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+  var IPlayToSourceRequest: abstract new (...args: any[]) => IPlayToSourceRequest;
+
+  interface IPlayToSourceRequestedEventArgs {
+    readonly SourceRequest: Windows.Media.PlayTo.PlayToSourceRequest;
+  }
+  var IPlayToSourceRequestedEventArgs: abstract new (...args: any[]) => IPlayToSourceRequestedEventArgs;
+
+  interface IPlayToSourceSelectedEventArgs {
+    readonly FriendlyName: string;
+    readonly Icon: Windows.Storage.Streams.IRandomAccessStreamWithContentType;
+    readonly SupportsAudio: boolean;
+    readonly SupportsImage: boolean;
+    readonly SupportsVideo: boolean;
+  }
+  var IPlayToSourceSelectedEventArgs: abstract new (...args: any[]) => IPlayToSourceSelectedEventArgs;
+
+  interface IPlayToSourceWithPreferredSourceUri {
+    PreferredSourceUri: Windows.Foundation.Uri;
+  }
+  var IPlayToSourceWithPreferredSourceUri: abstract new (...args: any[]) => IPlayToSourceWithPreferredSourceUri;
+
+  interface IPlaybackRateChangeRequestedEventArgs {
+    readonly Rate: number;
+  }
+  var IPlaybackRateChangeRequestedEventArgs: abstract new (...args: any[]) => IPlaybackRateChangeRequestedEventArgs;
+
+  interface ISourceChangeRequestedEventArgs {
+    readonly Album: string;
+    readonly Author: string;
+    readonly Date: Windows.Foundation.DateTime | null;
+    readonly Description: string;
+    readonly Genre: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+    readonly Rating: number | null;
+    readonly Stream: Windows.Storage.Streams.IRandomAccessStreamWithContentType;
+    readonly Thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly Title: string;
+  }
+  var ISourceChangeRequestedEventArgs: abstract new (...args: any[]) => ISourceChangeRequestedEventArgs;
+
+  interface IVolumeChangeRequestedEventArgs {
+    readonly Volume: number;
+  }
+  var IVolumeChangeRequestedEventArgs: abstract new (...args: any[]) => IVolumeChangeRequestedEventArgs;
+
+}
+
+declare namespace Windows.Media.Playback {
+  class BackgroundMediaPlayer {
+    static IsMediaPlaying(): boolean;
+    static SendMessageToBackground(value: Windows.Foundation.Collections.ValueSet): void;
+    static SendMessageToForeground(value: Windows.Foundation.Collections.ValueSet): void;
+    static Shutdown(): void;
+    static readonly Current: Windows.Media.Playback.MediaPlayer;
+    static MessageReceivedFromBackground: Windows.Foundation.EventHandler<Windows.Media.Playback.MediaPlayerDataReceivedEventArgs> | null;
+    static MessageReceivedFromForeground: Windows.Foundation.EventHandler<Windows.Media.Playback.MediaPlayerDataReceivedEventArgs> | null;
+  }
+
+  class CurrentMediaPlaybackItemChangedEventArgs implements Windows.Media.Playback.ICurrentMediaPlaybackItemChangedEventArgs, Windows.Media.Playback.ICurrentMediaPlaybackItemChangedEventArgs2 {
+    readonly NewItem: Windows.Media.Playback.MediaPlaybackItem;
+    readonly OldItem: Windows.Media.Playback.MediaPlaybackItem;
+    readonly Reason: number;
+  }
+
+  class MediaBreak implements Windows.Media.Playback.IMediaBreak {
+    constructor(insertionMethod: number);
+    constructor(insertionMethod: number, presentationPosition: Windows.Foundation.TimeSpan);
+    CanStart: boolean;
+    readonly CustomProperties: Windows.Foundation.Collections.ValueSet;
+    readonly InsertionMethod: number;
+    readonly PlaybackList: Windows.Media.Playback.MediaPlaybackList;
+    readonly PresentationPosition: Windows.Foundation.TimeSpan | null;
+  }
+
+  class MediaBreakEndedEventArgs implements Windows.Media.Playback.IMediaBreakEndedEventArgs {
+    readonly MediaBreak: Windows.Media.Playback.MediaBreak;
+  }
+
+  class MediaBreakManager implements Windows.Media.Playback.IMediaBreakManager {
+    PlayBreak(value: Windows.Media.Playback.MediaBreak): void;
+    SkipCurrentBreak(): void;
+    readonly CurrentBreak: Windows.Media.Playback.MediaBreak;
+    readonly PlaybackSession: Windows.Media.Playback.MediaPlaybackSession;
+    BreakEnded: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaBreakManager, Windows.Media.Playback.MediaBreakEndedEventArgs> | null;
+    BreakSkipped: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaBreakManager, Windows.Media.Playback.MediaBreakSkippedEventArgs> | null;
+    BreakStarted: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaBreakManager, Windows.Media.Playback.MediaBreakStartedEventArgs> | null;
+    BreaksSeekedOver: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaBreakManager, Windows.Media.Playback.MediaBreakSeekedOverEventArgs> | null;
+  }
+
+  class MediaBreakSchedule implements Windows.Media.Playback.IMediaBreakSchedule {
+    InsertMidrollBreak(mediaBreak: Windows.Media.Playback.MediaBreak): void;
+    RemoveMidrollBreak(mediaBreak: Windows.Media.Playback.MediaBreak): void;
+    readonly MidrollBreaks: Windows.Foundation.Collections.IVectorView<Windows.Media.Playback.MediaBreak> | Windows.Media.Playback.MediaBreak[];
+    readonly PlaybackItem: Windows.Media.Playback.MediaPlaybackItem;
+    PostrollBreak: Windows.Media.Playback.MediaBreak;
+    PrerollBreak: Windows.Media.Playback.MediaBreak;
+    ScheduleChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaBreakSchedule, Object> | null;
+  }
+
+  class MediaBreakSeekedOverEventArgs implements Windows.Media.Playback.IMediaBreakSeekedOverEventArgs {
+    readonly NewPosition: Windows.Foundation.TimeSpan;
+    readonly OldPosition: Windows.Foundation.TimeSpan;
+    readonly SeekedOverBreaks: Windows.Foundation.Collections.IVectorView<Windows.Media.Playback.MediaBreak> | Windows.Media.Playback.MediaBreak[];
+  }
+
+  class MediaBreakSkippedEventArgs implements Windows.Media.Playback.IMediaBreakSkippedEventArgs {
+    readonly MediaBreak: Windows.Media.Playback.MediaBreak;
+  }
+
+  class MediaBreakStartedEventArgs implements Windows.Media.Playback.IMediaBreakStartedEventArgs {
+    readonly MediaBreak: Windows.Media.Playback.MediaBreak;
+  }
+
+  class MediaItemDisplayProperties implements Windows.Media.Playback.IMediaItemDisplayProperties {
+    ClearAll(): void;
+    readonly MusicProperties: Windows.Media.MusicDisplayProperties;
+    Thumbnail: Windows.Storage.Streams.RandomAccessStreamReference;
+    Type: number;
+    readonly VideoProperties: Windows.Media.VideoDisplayProperties;
+  }
+
+  class MediaPlaybackAudioTrackList implements Windows.Media.Core.ISingleSelectMediaTrackList {
+    First(): Windows.Foundation.Collections.IIterator<Windows.Media.Core.AudioTrack>;
+    GetAt(index: number): Windows.Media.Core.AudioTrack;
+    GetMany(startIndex: number, items: Windows.Media.Core.AudioTrack[]): number;
+    IndexOf(value: Windows.Media.Core.AudioTrack, index: number): boolean;
+    SelectedIndex: number;
+    readonly Size: number;
+    SelectedIndexChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Core.ISingleSelectMediaTrackList, Object> | null;
+  }
+
+  class MediaPlaybackCommandManager implements Windows.Media.Playback.IMediaPlaybackCommandManager {
+    readonly AutoRepeatModeBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    readonly FastForwardBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    IsEnabled: boolean;
+    readonly MediaPlayer: Windows.Media.Playback.MediaPlayer;
+    readonly NextBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    readonly PauseBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    readonly PlayBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    readonly PositionBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    readonly PreviousBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    readonly RateBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    readonly RewindBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    readonly ShuffleBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    AutoRepeatModeReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs> | null;
+    FastForwardReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs> | null;
+    NextReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs> | null;
+    PauseReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs> | null;
+    PlayReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs> | null;
+    PositionReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs> | null;
+    PreviousReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs> | null;
+    RateReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs> | null;
+    RewindReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs> | null;
+    ShuffleReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs> | null;
+  }
+
+  class MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs implements Windows.Media.Playback.IMediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly AutoRepeatMode: number;
+    Handled: boolean;
+  }
+
+  class MediaPlaybackCommandManagerCommandBehavior implements Windows.Media.Playback.IMediaPlaybackCommandManagerCommandBehavior {
+    readonly CommandManager: Windows.Media.Playback.MediaPlaybackCommandManager;
+    EnablingRule: number;
+    readonly IsEnabled: boolean;
+    IsEnabledChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior, Object> | null;
+  }
+
+  class MediaPlaybackCommandManagerFastForwardReceivedEventArgs implements Windows.Media.Playback.IMediaPlaybackCommandManagerFastForwardReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+
+  class MediaPlaybackCommandManagerNextReceivedEventArgs implements Windows.Media.Playback.IMediaPlaybackCommandManagerNextReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+
+  class MediaPlaybackCommandManagerPauseReceivedEventArgs implements Windows.Media.Playback.IMediaPlaybackCommandManagerPauseReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+
+  class MediaPlaybackCommandManagerPlayReceivedEventArgs implements Windows.Media.Playback.IMediaPlaybackCommandManagerPlayReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+
+  class MediaPlaybackCommandManagerPositionReceivedEventArgs implements Windows.Media.Playback.IMediaPlaybackCommandManagerPositionReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+    readonly Position: Windows.Foundation.TimeSpan;
+  }
+
+  class MediaPlaybackCommandManagerPreviousReceivedEventArgs implements Windows.Media.Playback.IMediaPlaybackCommandManagerPreviousReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+
+  class MediaPlaybackCommandManagerRateReceivedEventArgs implements Windows.Media.Playback.IMediaPlaybackCommandManagerRateReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+    readonly PlaybackRate: number;
+  }
+
+  class MediaPlaybackCommandManagerRewindReceivedEventArgs implements Windows.Media.Playback.IMediaPlaybackCommandManagerRewindReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+
+  class MediaPlaybackCommandManagerShuffleReceivedEventArgs implements Windows.Media.Playback.IMediaPlaybackCommandManagerShuffleReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+    readonly IsShuffleRequested: boolean;
+  }
+
+  class MediaPlaybackItem implements Windows.Media.Playback.IMediaPlaybackItem, Windows.Media.Playback.IMediaPlaybackItem2, Windows.Media.Playback.IMediaPlaybackItem3, Windows.Media.Playback.IMediaPlaybackSource {
+    constructor(source: Windows.Media.Core.MediaSource, startTime: Windows.Foundation.TimeSpan);
+    constructor(source: Windows.Media.Core.MediaSource, startTime: Windows.Foundation.TimeSpan, durationLimit: Windows.Foundation.TimeSpan);
+    constructor(source: Windows.Media.Core.MediaSource);
+    ApplyDisplayProperties(value: Windows.Media.Playback.MediaItemDisplayProperties): void;
+    static FindFromMediaSource(source: Windows.Media.Core.MediaSource): Windows.Media.Playback.MediaPlaybackItem;
+    GetDisplayProperties(): Windows.Media.Playback.MediaItemDisplayProperties;
+    readonly AudioTracks: Windows.Media.Playback.MediaPlaybackAudioTrackList;
+    AutoLoadedDisplayProperties: number;
+    readonly BreakSchedule: Windows.Media.Playback.MediaBreakSchedule;
+    CanSkip: boolean;
+    readonly DurationLimit: Windows.Foundation.TimeSpan | null;
+    IsDisabledInPlaybackList: boolean;
+    readonly Source: Windows.Media.Core.MediaSource;
+    readonly StartTime: Windows.Foundation.TimeSpan;
+    readonly TimedMetadataTracks: Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList;
+    readonly TotalDownloadProgress: number;
+    readonly VideoTracks: Windows.Media.Playback.MediaPlaybackVideoTrackList;
+    AudioTracksChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackItem, Windows.Foundation.Collections.IVectorChangedEventArgs> | null;
+    TimedMetadataTracksChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackItem, Windows.Foundation.Collections.IVectorChangedEventArgs> | null;
+    VideoTracksChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackItem, Windows.Foundation.Collections.IVectorChangedEventArgs> | null;
+  }
+
+  class MediaPlaybackItemError implements Windows.Media.Playback.IMediaPlaybackItemError {
+    readonly ErrorCode: number;
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+
+  class MediaPlaybackItemFailedEventArgs implements Windows.Media.Playback.IMediaPlaybackItemFailedEventArgs {
+    readonly Error: Windows.Media.Playback.MediaPlaybackItemError;
+    readonly Item: Windows.Media.Playback.MediaPlaybackItem;
+  }
+
+  class MediaPlaybackItemOpenedEventArgs implements Windows.Media.Playback.IMediaPlaybackItemOpenedEventArgs {
+    readonly Item: Windows.Media.Playback.MediaPlaybackItem;
+  }
+
+  class MediaPlaybackList implements Windows.Media.Playback.IMediaPlaybackList, Windows.Media.Playback.IMediaPlaybackList2, Windows.Media.Playback.IMediaPlaybackList3, Windows.Media.Playback.IMediaPlaybackSource {
+    constructor();
+    MoveNext(): Windows.Media.Playback.MediaPlaybackItem;
+    MovePrevious(): Windows.Media.Playback.MediaPlaybackItem;
+    MoveTo(itemIndex: number): Windows.Media.Playback.MediaPlaybackItem;
+    SetShuffledItems(value: Windows.Foundation.Collections.IIterable<Windows.Media.Playback.MediaPlaybackItem> | Windows.Media.Playback.MediaPlaybackItem[]): void;
+    AutoRepeatEnabled: boolean;
+    readonly CurrentItem: Windows.Media.Playback.MediaPlaybackItem;
+    readonly CurrentItemIndex: number;
+    readonly Items: Windows.Foundation.Collections.IObservableVector<Windows.Media.Playback.MediaPlaybackItem>;
+    MaxPlayedItemsToKeepOpen: number | null;
+    MaxPrefetchTime: Windows.Foundation.TimeSpan | null;
+    ShuffleEnabled: boolean;
+    readonly ShuffledItems: Windows.Foundation.Collections.IVectorView<Windows.Media.Playback.MediaPlaybackItem> | Windows.Media.Playback.MediaPlaybackItem[];
+    StartingItem: Windows.Media.Playback.MediaPlaybackItem;
+    CurrentItemChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackList, Windows.Media.Playback.CurrentMediaPlaybackItemChangedEventArgs> | null;
+    ItemFailed: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackList, Windows.Media.Playback.MediaPlaybackItemFailedEventArgs> | null;
+    ItemOpened: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackList, Windows.Media.Playback.MediaPlaybackItemOpenedEventArgs> | null;
+  }
+
+  class MediaPlaybackSession implements Windows.Media.Playback.IMediaPlaybackSession, Windows.Media.Playback.IMediaPlaybackSession2, Windows.Media.Playback.IMediaPlaybackSession3 {
+    GetBufferedRanges(): Windows.Foundation.Collections.IVectorView<Windows.Media.MediaTimeRange> | Windows.Media.MediaTimeRange[];
+    GetOutputDegradationPolicyState(): Windows.Media.Playback.MediaPlaybackSessionOutputDegradationPolicyState;
+    GetPlayedRanges(): Windows.Foundation.Collections.IVectorView<Windows.Media.MediaTimeRange> | Windows.Media.MediaTimeRange[];
+    GetSeekableRanges(): Windows.Foundation.Collections.IVectorView<Windows.Media.MediaTimeRange> | Windows.Media.MediaTimeRange[];
+    IsSupportedPlaybackRateRange(rate1: number, rate2: number): boolean;
+    readonly BufferingProgress: number;
+    readonly CanPause: boolean;
+    readonly CanSeek: boolean;
+    readonly DownloadProgress: number;
+    IsMirroring: boolean;
+    readonly IsProtected: boolean;
+    readonly MediaPlayer: Windows.Media.Playback.MediaPlayer;
+    readonly NaturalDuration: Windows.Foundation.TimeSpan;
+    readonly NaturalVideoHeight: number;
+    readonly NaturalVideoWidth: number;
+    NormalizedSourceRect: Windows.Foundation.Rect;
+    PlaybackRate: number;
+    PlaybackRotation: number;
+    readonly PlaybackState: number;
+    Position: Windows.Foundation.TimeSpan;
+    readonly SphericalVideoProjection: Windows.Media.Playback.MediaPlaybackSphericalVideoProjection;
+    StereoscopicVideoPackingMode: number;
+    BufferingEnded: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    BufferingProgressChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    BufferingStarted: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    DownloadProgressChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    NaturalDurationChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    NaturalVideoSizeChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    PlaybackRateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    PlaybackStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    PositionChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    SeekCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    BufferedRangesChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    PlayedRangesChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    SeekableRangesChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    SupportedPlaybackRatesChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+  }
+
+  class MediaPlaybackSessionBufferingStartedEventArgs implements Windows.Media.Playback.IMediaPlaybackSessionBufferingStartedEventArgs {
+    readonly IsPlaybackInterruption: boolean;
+  }
+
+  class MediaPlaybackSessionOutputDegradationPolicyState implements Windows.Media.Playback.IMediaPlaybackSessionOutputDegradationPolicyState {
+    readonly VideoConstrictionReason: number;
+  }
+
+  class MediaPlaybackSphericalVideoProjection implements Windows.Media.Playback.IMediaPlaybackSphericalVideoProjection {
+    FrameFormat: number;
+    HorizontalFieldOfViewInDegrees: number;
+    IsEnabled: boolean;
+    ProjectionMode: number;
+    ViewOrientation: Windows.Foundation.Numerics.Quaternion;
+  }
+
+  class MediaPlaybackTimedMetadataTrackList implements Windows.Media.Playback.IMediaPlaybackTimedMetadataTrackList {
+    First(): Windows.Foundation.Collections.IIterator<Windows.Media.Core.TimedMetadataTrack>;
+    GetAt(index: number): Windows.Media.Core.TimedMetadataTrack;
+    GetMany(startIndex: number, items: Windows.Media.Core.TimedMetadataTrack[]): number;
+    GetPresentationMode(index: number): number;
+    IndexOf(value: Windows.Media.Core.TimedMetadataTrack, index: number): boolean;
+    SetPresentationMode(index: number, value: number): void;
+    readonly Size: number;
+    PresentationModeChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList, Windows.Media.Playback.TimedMetadataPresentationModeChangedEventArgs> | null;
+  }
+
+  class MediaPlaybackVideoTrackList implements Windows.Media.Core.ISingleSelectMediaTrackList {
+    First(): Windows.Foundation.Collections.IIterator<Windows.Media.Core.VideoTrack>;
+    GetAt(index: number): Windows.Media.Core.VideoTrack;
+    GetMany(startIndex: number, items: Windows.Media.Core.VideoTrack[]): number;
+    IndexOf(value: Windows.Media.Core.VideoTrack, index: number): boolean;
+    SelectedIndex: number;
+    readonly Size: number;
+    SelectedIndexChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Core.ISingleSelectMediaTrackList, Object> | null;
+  }
+
+  class MediaPlayer implements Windows.Foundation.IClosable, Windows.Media.Playback.IMediaPlayer, Windows.Media.Playback.IMediaPlayer2, Windows.Media.Playback.IMediaPlayer3, Windows.Media.Playback.IMediaPlayer4, Windows.Media.Playback.IMediaPlayer5, Windows.Media.Playback.IMediaPlayer6, Windows.Media.Playback.IMediaPlayer7, Windows.Media.Playback.IMediaPlayerEffects, Windows.Media.Playback.IMediaPlayerEffects2, Windows.Media.Playback.IMediaPlayerSource, Windows.Media.Playback.IMediaPlayerSource2 {
+    constructor();
+    AddAudioEffect(activatableClassId: string, effectOptional: boolean, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    AddVideoEffect(activatableClassId: string, effectOptional: boolean, effectConfiguration: Windows.Foundation.Collections.IPropertySet): void;
+    Close(): void;
+    CopyFrameToStereoscopicVideoSurfaces(destinationLeftEye: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface, destinationRightEye: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface): void;
+    CopyFrameToVideoSurface(destination: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface): void;
+    CopyFrameToVideoSurface(destination: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface, targetRectangle: Windows.Foundation.Rect): void;
+    GetAsCastingSource(): Windows.Media.Casting.CastingSource;
+    GetSurface(compositor: Windows.UI.Composition.Compositor): Windows.Media.Playback.MediaPlayerSurface;
+    Pause(): void;
+    Play(): void;
+    RemoveAllEffects(): void;
+    RenderSubtitlesToSurface(destination: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface): boolean;
+    RenderSubtitlesToSurface(destination: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface, targetRectangle: Windows.Foundation.Rect): boolean;
+    SetFileSource(file: Windows.Storage.IStorageFile): void;
+    SetMediaSource(source: Windows.Media.Core.IMediaSource): void;
+    SetStreamSource(stream: Windows.Storage.Streams.IRandomAccessStream): void;
+    SetSurfaceSize(size: Windows.Foundation.Size): void;
+    SetUriSource(value: Windows.Foundation.Uri): void;
+    StepBackwardOneFrame(): void;
+    StepForwardOneFrame(): void;
+    AudioBalance: number;
+    AudioCategory: number;
+    AudioDevice: Windows.Devices.Enumeration.DeviceInformation;
+    AudioDeviceType: number;
+    readonly AudioStateMonitor: Windows.Media.Audio.AudioStateMonitor;
+    AutoPlay: boolean;
+    readonly BreakManager: Windows.Media.Playback.MediaBreakManager;
+    readonly BufferingProgress: number;
+    readonly CanPause: boolean;
+    readonly CanSeek: boolean;
+    readonly CommandManager: Windows.Media.Playback.MediaPlaybackCommandManager;
+    readonly CurrentState: number;
+    IsLoopingEnabled: boolean;
+    IsMuted: boolean;
+    readonly IsProtected: boolean;
+    IsVideoFrameServerEnabled: boolean;
+    readonly NaturalDuration: Windows.Foundation.TimeSpan;
+    readonly PlaybackMediaMarkers: Windows.Media.Playback.PlaybackMediaMarkerSequence;
+    PlaybackRate: number;
+    readonly PlaybackSession: Windows.Media.Playback.MediaPlaybackSession;
+    Position: Windows.Foundation.TimeSpan;
+    ProtectionManager: Windows.Media.Protection.MediaProtectionManager;
+    RealTimePlayback: boolean;
+    Source: Windows.Media.Playback.IMediaPlaybackSource;
+    StereoscopicVideoRenderMode: number;
+    readonly SystemMediaTransportControls: Windows.Media.SystemMediaTransportControls;
+    TimelineController: Windows.Media.MediaTimelineController;
+    TimelineControllerPositionOffset: Windows.Foundation.TimeSpan;
+    Volume: number;
+    BufferingEnded: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+    BufferingStarted: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+    CurrentStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+    MediaEnded: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+    MediaFailed: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Windows.Media.Playback.MediaPlayerFailedEventArgs> | null;
+    MediaOpened: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+    MediaPlayerRateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Windows.Media.Playback.MediaPlayerRateChangedEventArgs> | null;
+    PlaybackMediaMarkerReached: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Windows.Media.Playback.PlaybackMediaMarkerReachedEventArgs> | null;
+    SeekCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+    VolumeChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+    IsMutedChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+    SourceChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+    VideoFrameAvailable: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+    SubtitleFrameChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+  }
+
+  class MediaPlayerDataReceivedEventArgs implements Windows.Media.Playback.IMediaPlayerDataReceivedEventArgs {
+    readonly Data: Windows.Foundation.Collections.ValueSet;
+  }
+
+  class MediaPlayerFailedEventArgs implements Windows.Media.Playback.IMediaPlayerFailedEventArgs {
+    readonly Error: number;
+    readonly ErrorMessage: string;
+    readonly ExtendedErrorCode: Windows.Foundation.HResult;
+  }
+
+  class MediaPlayerRateChangedEventArgs implements Windows.Media.Playback.IMediaPlayerRateChangedEventArgs {
+    readonly NewRate: number;
+  }
+
+  class MediaPlayerSurface implements Windows.Foundation.IClosable, Windows.Media.Playback.IMediaPlayerSurface {
+    Close(): void;
+    readonly CompositionSurface: Windows.UI.Composition.ICompositionSurface;
+    readonly Compositor: Windows.UI.Composition.Compositor;
+    readonly MediaPlayer: Windows.Media.Playback.MediaPlayer;
+  }
+
+  class PlaybackMediaMarker implements Windows.Media.Playback.IPlaybackMediaMarker {
+    constructor(value: Windows.Foundation.TimeSpan);
+    constructor(value: Windows.Foundation.TimeSpan, mediaMarketType: string, text: string);
+    readonly MediaMarkerType: string;
+    readonly Text: string;
+    readonly Time: Windows.Foundation.TimeSpan;
+  }
+
+  class PlaybackMediaMarkerReachedEventArgs implements Windows.Media.Playback.IPlaybackMediaMarkerReachedEventArgs {
+    readonly PlaybackMediaMarker: Windows.Media.Playback.PlaybackMediaMarker;
+  }
+
+  class PlaybackMediaMarkerSequence implements Windows.Media.Playback.IPlaybackMediaMarkerSequence {
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Media.Playback.PlaybackMediaMarker>;
+    Insert(value: Windows.Media.Playback.PlaybackMediaMarker): void;
+    readonly Size: number;
+  }
+
+  class TimedMetadataPresentationModeChangedEventArgs implements Windows.Media.Playback.ITimedMetadataPresentationModeChangedEventArgs {
+    readonly NewPresentationMode: number;
+    readonly OldPresentationMode: number;
+    readonly Track: Windows.Media.Core.TimedMetadataTrack;
+  }
+
+  enum AutoLoadedDisplayPropertyKind {
+    None = 0,
+    MusicOrVideo = 1,
+    Music = 2,
+    Video = 3,
+  }
+
+  enum FailedMediaStreamKind {
+    Unknown = 0,
+    Audio = 1,
+    Video = 2,
+  }
+
+  enum MediaBreakInsertionMethod {
+    Interrupt = 0,
+    Replace = 1,
+  }
+
+  enum MediaCommandEnablingRule {
+    Auto = 0,
+    Always = 1,
+    Never = 2,
+  }
+
+  enum MediaPlaybackItemChangedReason {
+    InitialItem = 0,
+    EndOfStream = 1,
+    Error = 2,
+    AppRequested = 3,
+  }
+
+  enum MediaPlaybackItemErrorCode {
+    None = 0,
+    Aborted = 1,
+    NetworkError = 2,
+    DecodeError = 3,
+    SourceNotSupportedError = 4,
+    EncryptionError = 5,
+  }
+
+  enum MediaPlaybackSessionVideoConstrictionReason {
+    None = 0,
+    VirtualMachine = 1,
+    UnsupportedDisplayAdapter = 2,
+    UnsignedDriver = 3,
+    FrameServerEnabled = 4,
+    OutputProtectionFailed = 5,
+    Unknown = 6,
+  }
+
+  enum MediaPlaybackState {
+    None = 0,
+    Opening = 1,
+    Buffering = 2,
+    Playing = 3,
+    Paused = 4,
+  }
+
+  enum MediaPlayerAudioCategory {
+    Other = 0,
+    Communications = 3,
+    Alerts = 4,
+    SoundEffects = 5,
+    GameEffects = 6,
+    GameMedia = 7,
+    GameChat = 8,
+    Speech = 9,
+    Movie = 10,
+    Media = 11,
+  }
+
+  enum MediaPlayerAudioDeviceType {
+    Console = 0,
+    Multimedia = 1,
+    Communications = 2,
+  }
+
+  enum MediaPlayerError {
+    Unknown = 0,
+    Aborted = 1,
+    NetworkError = 2,
+    DecodingError = 3,
+    SourceNotSupported = 4,
+  }
+
+  enum MediaPlayerState {
+    Closed = 0,
+    Opening = 1,
+    Buffering = 2,
+    Playing = 3,
+    Paused = 4,
+    Stopped = 5,
+  }
+
+  enum SphericalVideoProjectionMode {
+    Spherical = 0,
+    Flat = 1,
+  }
+
+  enum StereoscopicVideoRenderMode {
+    Mono = 0,
+    Stereo = 1,
+  }
+
+  enum TimedMetadataTrackPresentationMode {
+    Disabled = 0,
+    Hidden = 1,
+    ApplicationPresented = 2,
+    PlatformPresented = 3,
+  }
+
+  interface IBackgroundMediaPlayerStatics {
+    IsMediaPlaying(): boolean;
+    SendMessageToBackground(value: Windows.Foundation.Collections.ValueSet): void;
+    SendMessageToForeground(value: Windows.Foundation.Collections.ValueSet): void;
+    Shutdown(): void;
+    readonly Current: Windows.Media.Playback.MediaPlayer;
+    MessageReceivedFromBackground: Windows.Foundation.EventHandler<Windows.Media.Playback.MediaPlayerDataReceivedEventArgs> | null;
+    MessageReceivedFromForeground: Windows.Foundation.EventHandler<Windows.Media.Playback.MediaPlayerDataReceivedEventArgs> | null;
+  }
+  var IBackgroundMediaPlayerStatics: abstract new (...args: any[]) => IBackgroundMediaPlayerStatics;
+
+  interface ICurrentMediaPlaybackItemChangedEventArgs {
+    readonly NewItem: Windows.Media.Playback.MediaPlaybackItem;
+    readonly OldItem: Windows.Media.Playback.MediaPlaybackItem;
+  }
+  var ICurrentMediaPlaybackItemChangedEventArgs: abstract new (...args: any[]) => ICurrentMediaPlaybackItemChangedEventArgs;
+
+  interface ICurrentMediaPlaybackItemChangedEventArgs2 extends Windows.Media.Playback.ICurrentMediaPlaybackItemChangedEventArgs {
+    readonly Reason: number;
+  }
+  var ICurrentMediaPlaybackItemChangedEventArgs2: abstract new (...args: any[]) => ICurrentMediaPlaybackItemChangedEventArgs2;
+
+  interface IMediaBreak {
+    CanStart: boolean;
+    readonly CustomProperties: Windows.Foundation.Collections.ValueSet;
+    readonly InsertionMethod: number;
+    readonly PlaybackList: Windows.Media.Playback.MediaPlaybackList;
+    readonly PresentationPosition: Windows.Foundation.TimeSpan | null;
+  }
+  var IMediaBreak: abstract new (...args: any[]) => IMediaBreak;
+
+  interface IMediaBreakEndedEventArgs {
+    readonly MediaBreak: Windows.Media.Playback.MediaBreak;
+  }
+  var IMediaBreakEndedEventArgs: abstract new (...args: any[]) => IMediaBreakEndedEventArgs;
+
+  interface IMediaBreakFactory {
+    Create(insertionMethod: number): Windows.Media.Playback.MediaBreak;
+    CreateWithPresentationPosition(insertionMethod: number, presentationPosition: Windows.Foundation.TimeSpan): Windows.Media.Playback.MediaBreak;
+  }
+  var IMediaBreakFactory: abstract new (...args: any[]) => IMediaBreakFactory;
+
+  interface IMediaBreakManager {
+    PlayBreak(value: Windows.Media.Playback.MediaBreak): void;
+    SkipCurrentBreak(): void;
+    readonly CurrentBreak: Windows.Media.Playback.MediaBreak;
+    readonly PlaybackSession: Windows.Media.Playback.MediaPlaybackSession;
+    BreakEnded: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaBreakManager, Windows.Media.Playback.MediaBreakEndedEventArgs> | null;
+    BreakSkipped: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaBreakManager, Windows.Media.Playback.MediaBreakSkippedEventArgs> | null;
+    BreakStarted: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaBreakManager, Windows.Media.Playback.MediaBreakStartedEventArgs> | null;
+    BreaksSeekedOver: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaBreakManager, Windows.Media.Playback.MediaBreakSeekedOverEventArgs> | null;
+  }
+  var IMediaBreakManager: abstract new (...args: any[]) => IMediaBreakManager;
+
+  interface IMediaBreakSchedule {
+    InsertMidrollBreak(mediaBreak: Windows.Media.Playback.MediaBreak): void;
+    RemoveMidrollBreak(mediaBreak: Windows.Media.Playback.MediaBreak): void;
+    readonly MidrollBreaks: Windows.Foundation.Collections.IVectorView<Windows.Media.Playback.MediaBreak> | Windows.Media.Playback.MediaBreak[];
+    readonly PlaybackItem: Windows.Media.Playback.MediaPlaybackItem;
+    PostrollBreak: Windows.Media.Playback.MediaBreak;
+    PrerollBreak: Windows.Media.Playback.MediaBreak;
+    ScheduleChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaBreakSchedule, Object> | null;
+  }
+  var IMediaBreakSchedule: abstract new (...args: any[]) => IMediaBreakSchedule;
+
+  interface IMediaBreakSeekedOverEventArgs {
+    readonly NewPosition: Windows.Foundation.TimeSpan;
+    readonly OldPosition: Windows.Foundation.TimeSpan;
+    readonly SeekedOverBreaks: Windows.Foundation.Collections.IVectorView<Windows.Media.Playback.MediaBreak> | Windows.Media.Playback.MediaBreak[];
+  }
+  var IMediaBreakSeekedOverEventArgs: abstract new (...args: any[]) => IMediaBreakSeekedOverEventArgs;
+
+  interface IMediaBreakSkippedEventArgs {
+    readonly MediaBreak: Windows.Media.Playback.MediaBreak;
+  }
+  var IMediaBreakSkippedEventArgs: abstract new (...args: any[]) => IMediaBreakSkippedEventArgs;
+
+  interface IMediaBreakStartedEventArgs {
+    readonly MediaBreak: Windows.Media.Playback.MediaBreak;
+  }
+  var IMediaBreakStartedEventArgs: abstract new (...args: any[]) => IMediaBreakStartedEventArgs;
+
+  interface IMediaEnginePlaybackSource {
+    SetPlaybackSource(source: Windows.Media.Playback.IMediaPlaybackSource): void;
+    readonly CurrentItem: Windows.Media.Playback.MediaPlaybackItem;
+  }
+  var IMediaEnginePlaybackSource: abstract new (...args: any[]) => IMediaEnginePlaybackSource;
+
+  interface IMediaItemDisplayProperties {
+    ClearAll(): void;
+    readonly MusicProperties: Windows.Media.MusicDisplayProperties;
+    Thumbnail: Windows.Storage.Streams.RandomAccessStreamReference;
+    Type: number;
+    readonly VideoProperties: Windows.Media.VideoDisplayProperties;
+  }
+  var IMediaItemDisplayProperties: abstract new (...args: any[]) => IMediaItemDisplayProperties;
+
+  interface IMediaPlaybackCommandManager {
+    readonly AutoRepeatModeBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    readonly FastForwardBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    IsEnabled: boolean;
+    readonly MediaPlayer: Windows.Media.Playback.MediaPlayer;
+    readonly NextBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    readonly PauseBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    readonly PlayBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    readonly PositionBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    readonly PreviousBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    readonly RateBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    readonly RewindBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    readonly ShuffleBehavior: Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior;
+    AutoRepeatModeReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs> | null;
+    FastForwardReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerFastForwardReceivedEventArgs> | null;
+    NextReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerNextReceivedEventArgs> | null;
+    PauseReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerPauseReceivedEventArgs> | null;
+    PlayReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerPlayReceivedEventArgs> | null;
+    PositionReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerPositionReceivedEventArgs> | null;
+    PreviousReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerPreviousReceivedEventArgs> | null;
+    RateReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerRateReceivedEventArgs> | null;
+    RewindReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerRewindReceivedEventArgs> | null;
+    ShuffleReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManager, Windows.Media.Playback.MediaPlaybackCommandManagerShuffleReceivedEventArgs> | null;
+  }
+  var IMediaPlaybackCommandManager: abstract new (...args: any[]) => IMediaPlaybackCommandManager;
+
+  interface IMediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly AutoRepeatMode: number;
+    Handled: boolean;
+  }
+  var IMediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs: abstract new (...args: any[]) => IMediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs;
+
+  interface IMediaPlaybackCommandManagerCommandBehavior {
+    readonly CommandManager: Windows.Media.Playback.MediaPlaybackCommandManager;
+    EnablingRule: number;
+    readonly IsEnabled: boolean;
+    IsEnabledChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackCommandManagerCommandBehavior, Object> | null;
+  }
+  var IMediaPlaybackCommandManagerCommandBehavior: abstract new (...args: any[]) => IMediaPlaybackCommandManagerCommandBehavior;
+
+  interface IMediaPlaybackCommandManagerFastForwardReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+  var IMediaPlaybackCommandManagerFastForwardReceivedEventArgs: abstract new (...args: any[]) => IMediaPlaybackCommandManagerFastForwardReceivedEventArgs;
+
+  interface IMediaPlaybackCommandManagerNextReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+  var IMediaPlaybackCommandManagerNextReceivedEventArgs: abstract new (...args: any[]) => IMediaPlaybackCommandManagerNextReceivedEventArgs;
+
+  interface IMediaPlaybackCommandManagerPauseReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+  var IMediaPlaybackCommandManagerPauseReceivedEventArgs: abstract new (...args: any[]) => IMediaPlaybackCommandManagerPauseReceivedEventArgs;
+
+  interface IMediaPlaybackCommandManagerPlayReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+  var IMediaPlaybackCommandManagerPlayReceivedEventArgs: abstract new (...args: any[]) => IMediaPlaybackCommandManagerPlayReceivedEventArgs;
+
+  interface IMediaPlaybackCommandManagerPositionReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+    readonly Position: Windows.Foundation.TimeSpan;
+  }
+  var IMediaPlaybackCommandManagerPositionReceivedEventArgs: abstract new (...args: any[]) => IMediaPlaybackCommandManagerPositionReceivedEventArgs;
+
+  interface IMediaPlaybackCommandManagerPreviousReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+  var IMediaPlaybackCommandManagerPreviousReceivedEventArgs: abstract new (...args: any[]) => IMediaPlaybackCommandManagerPreviousReceivedEventArgs;
+
+  interface IMediaPlaybackCommandManagerRateReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+    readonly PlaybackRate: number;
+  }
+  var IMediaPlaybackCommandManagerRateReceivedEventArgs: abstract new (...args: any[]) => IMediaPlaybackCommandManagerRateReceivedEventArgs;
+
+  interface IMediaPlaybackCommandManagerRewindReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+  var IMediaPlaybackCommandManagerRewindReceivedEventArgs: abstract new (...args: any[]) => IMediaPlaybackCommandManagerRewindReceivedEventArgs;
+
+  interface IMediaPlaybackCommandManagerShuffleReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+    readonly IsShuffleRequested: boolean;
+  }
+  var IMediaPlaybackCommandManagerShuffleReceivedEventArgs: abstract new (...args: any[]) => IMediaPlaybackCommandManagerShuffleReceivedEventArgs;
+
+  interface IMediaPlaybackItem extends Windows.Media.Playback.IMediaPlaybackSource {
+    readonly AudioTracks: Windows.Media.Playback.MediaPlaybackAudioTrackList;
+    readonly Source: Windows.Media.Core.MediaSource;
+    readonly TimedMetadataTracks: Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList;
+    readonly VideoTracks: Windows.Media.Playback.MediaPlaybackVideoTrackList;
+    AudioTracksChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackItem, Windows.Foundation.Collections.IVectorChangedEventArgs> | null;
+    TimedMetadataTracksChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackItem, Windows.Foundation.Collections.IVectorChangedEventArgs> | null;
+    VideoTracksChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackItem, Windows.Foundation.Collections.IVectorChangedEventArgs> | null;
+  }
+  var IMediaPlaybackItem: abstract new (...args: any[]) => IMediaPlaybackItem;
+
+  interface IMediaPlaybackItem2 extends Windows.Media.Playback.IMediaPlaybackItem, Windows.Media.Playback.IMediaPlaybackSource {
+    ApplyDisplayProperties(value: Windows.Media.Playback.MediaItemDisplayProperties): void;
+    GetDisplayProperties(): Windows.Media.Playback.MediaItemDisplayProperties;
+    readonly BreakSchedule: Windows.Media.Playback.MediaBreakSchedule;
+    CanSkip: boolean;
+    readonly DurationLimit: Windows.Foundation.TimeSpan | null;
+    readonly StartTime: Windows.Foundation.TimeSpan;
+  }
+  var IMediaPlaybackItem2: abstract new (...args: any[]) => IMediaPlaybackItem2;
+
+  interface IMediaPlaybackItem3 extends Windows.Media.Playback.IMediaPlaybackItem, Windows.Media.Playback.IMediaPlaybackItem2, Windows.Media.Playback.IMediaPlaybackSource {
+    ApplyDisplayProperties(value: Windows.Media.Playback.MediaItemDisplayProperties): void;
+    GetDisplayProperties(): Windows.Media.Playback.MediaItemDisplayProperties;
+    AutoLoadedDisplayProperties: number;
+    IsDisabledInPlaybackList: boolean;
+    readonly TotalDownloadProgress: number;
+  }
+  var IMediaPlaybackItem3: abstract new (...args: any[]) => IMediaPlaybackItem3;
+
+  interface IMediaPlaybackItemError {
+    readonly ErrorCode: number;
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+  var IMediaPlaybackItemError: abstract new (...args: any[]) => IMediaPlaybackItemError;
+
+  interface IMediaPlaybackItemFactory {
+    Create(source: Windows.Media.Core.MediaSource): Windows.Media.Playback.MediaPlaybackItem;
+  }
+  var IMediaPlaybackItemFactory: abstract new (...args: any[]) => IMediaPlaybackItemFactory;
+
+  interface IMediaPlaybackItemFactory2 extends Windows.Media.Playback.IMediaPlaybackItemFactory {
+    Create(source: Windows.Media.Core.MediaSource): Windows.Media.Playback.MediaPlaybackItem;
+    CreateWithStartTime(source: Windows.Media.Core.MediaSource, startTime: Windows.Foundation.TimeSpan): Windows.Media.Playback.MediaPlaybackItem;
+    CreateWithStartTimeAndDurationLimit(source: Windows.Media.Core.MediaSource, startTime: Windows.Foundation.TimeSpan, durationLimit: Windows.Foundation.TimeSpan): Windows.Media.Playback.MediaPlaybackItem;
+  }
+  var IMediaPlaybackItemFactory2: abstract new (...args: any[]) => IMediaPlaybackItemFactory2;
+
+  interface IMediaPlaybackItemFailedEventArgs {
+    readonly Error: Windows.Media.Playback.MediaPlaybackItemError;
+    readonly Item: Windows.Media.Playback.MediaPlaybackItem;
+  }
+  var IMediaPlaybackItemFailedEventArgs: abstract new (...args: any[]) => IMediaPlaybackItemFailedEventArgs;
+
+  interface IMediaPlaybackItemOpenedEventArgs {
+    readonly Item: Windows.Media.Playback.MediaPlaybackItem;
+  }
+  var IMediaPlaybackItemOpenedEventArgs: abstract new (...args: any[]) => IMediaPlaybackItemOpenedEventArgs;
+
+  interface IMediaPlaybackItemStatics {
+    FindFromMediaSource(source: Windows.Media.Core.MediaSource): Windows.Media.Playback.MediaPlaybackItem;
+  }
+  var IMediaPlaybackItemStatics: abstract new (...args: any[]) => IMediaPlaybackItemStatics;
+
+  interface IMediaPlaybackList extends Windows.Media.Playback.IMediaPlaybackSource {
+    MoveNext(): Windows.Media.Playback.MediaPlaybackItem;
+    MovePrevious(): Windows.Media.Playback.MediaPlaybackItem;
+    MoveTo(itemIndex: number): Windows.Media.Playback.MediaPlaybackItem;
+    AutoRepeatEnabled: boolean;
+    readonly CurrentItem: Windows.Media.Playback.MediaPlaybackItem;
+    readonly CurrentItemIndex: number;
+    readonly Items: Windows.Foundation.Collections.IObservableVector<Windows.Media.Playback.MediaPlaybackItem>;
+    ShuffleEnabled: boolean;
+    CurrentItemChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackList, Windows.Media.Playback.CurrentMediaPlaybackItemChangedEventArgs> | null;
+    ItemFailed: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackList, Windows.Media.Playback.MediaPlaybackItemFailedEventArgs> | null;
+    ItemOpened: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackList, Windows.Media.Playback.MediaPlaybackItemOpenedEventArgs> | null;
+  }
+  var IMediaPlaybackList: abstract new (...args: any[]) => IMediaPlaybackList;
+
+  interface IMediaPlaybackList2 extends Windows.Media.Playback.IMediaPlaybackList, Windows.Media.Playback.IMediaPlaybackSource {
+    MoveNext(): Windows.Media.Playback.MediaPlaybackItem;
+    MovePrevious(): Windows.Media.Playback.MediaPlaybackItem;
+    MoveTo(itemIndex: number): Windows.Media.Playback.MediaPlaybackItem;
+    SetShuffledItems(value: Windows.Foundation.Collections.IIterable<Windows.Media.Playback.MediaPlaybackItem> | Windows.Media.Playback.MediaPlaybackItem[]): void;
+    MaxPrefetchTime: Windows.Foundation.TimeSpan | null;
+    readonly ShuffledItems: Windows.Foundation.Collections.IVectorView<Windows.Media.Playback.MediaPlaybackItem> | Windows.Media.Playback.MediaPlaybackItem[];
+    StartingItem: Windows.Media.Playback.MediaPlaybackItem;
+  }
+  var IMediaPlaybackList2: abstract new (...args: any[]) => IMediaPlaybackList2;
+
+  interface IMediaPlaybackList3 extends Windows.Media.Playback.IMediaPlaybackList, Windows.Media.Playback.IMediaPlaybackList2, Windows.Media.Playback.IMediaPlaybackSource {
+    MoveNext(): Windows.Media.Playback.MediaPlaybackItem;
+    MovePrevious(): Windows.Media.Playback.MediaPlaybackItem;
+    MoveTo(itemIndex: number): Windows.Media.Playback.MediaPlaybackItem;
+    SetShuffledItems(value: Windows.Foundation.Collections.IIterable<Windows.Media.Playback.MediaPlaybackItem> | Windows.Media.Playback.MediaPlaybackItem[]): void;
+    MaxPlayedItemsToKeepOpen: number | null;
+  }
+  var IMediaPlaybackList3: abstract new (...args: any[]) => IMediaPlaybackList3;
+
+  interface IMediaPlaybackSession {
+    readonly BufferingProgress: number;
+    readonly CanPause: boolean;
+    readonly CanSeek: boolean;
+    readonly DownloadProgress: number;
+    readonly IsProtected: boolean;
+    readonly MediaPlayer: Windows.Media.Playback.MediaPlayer;
+    readonly NaturalDuration: Windows.Foundation.TimeSpan;
+    readonly NaturalVideoHeight: number;
+    readonly NaturalVideoWidth: number;
+    NormalizedSourceRect: Windows.Foundation.Rect;
+    PlaybackRate: number;
+    readonly PlaybackState: number;
+    Position: Windows.Foundation.TimeSpan;
+    StereoscopicVideoPackingMode: number;
+    BufferingEnded: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    BufferingProgressChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    BufferingStarted: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    DownloadProgressChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    NaturalDurationChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    NaturalVideoSizeChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    PlaybackRateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    PlaybackStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    PositionChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    SeekCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+  }
+  var IMediaPlaybackSession: abstract new (...args: any[]) => IMediaPlaybackSession;
+
+  interface IMediaPlaybackSession2 {
+    GetBufferedRanges(): Windows.Foundation.Collections.IVectorView<Windows.Media.MediaTimeRange> | Windows.Media.MediaTimeRange[];
+    GetPlayedRanges(): Windows.Foundation.Collections.IVectorView<Windows.Media.MediaTimeRange> | Windows.Media.MediaTimeRange[];
+    GetSeekableRanges(): Windows.Foundation.Collections.IVectorView<Windows.Media.MediaTimeRange> | Windows.Media.MediaTimeRange[];
+    IsSupportedPlaybackRateRange(rate1: number, rate2: number): boolean;
+    IsMirroring: boolean;
+    readonly SphericalVideoProjection: Windows.Media.Playback.MediaPlaybackSphericalVideoProjection;
+    BufferedRangesChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    PlayedRangesChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    SeekableRangesChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+    SupportedPlaybackRatesChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackSession, Object> | null;
+  }
+  var IMediaPlaybackSession2: abstract new (...args: any[]) => IMediaPlaybackSession2;
+
+  interface IMediaPlaybackSession3 {
+    GetOutputDegradationPolicyState(): Windows.Media.Playback.MediaPlaybackSessionOutputDegradationPolicyState;
+    PlaybackRotation: number;
+  }
+  var IMediaPlaybackSession3: abstract new (...args: any[]) => IMediaPlaybackSession3;
+
+  interface IMediaPlaybackSessionBufferingStartedEventArgs {
+    readonly IsPlaybackInterruption: boolean;
+  }
+  var IMediaPlaybackSessionBufferingStartedEventArgs: abstract new (...args: any[]) => IMediaPlaybackSessionBufferingStartedEventArgs;
+
+  interface IMediaPlaybackSessionOutputDegradationPolicyState {
+    readonly VideoConstrictionReason: number;
+  }
+  var IMediaPlaybackSessionOutputDegradationPolicyState: abstract new (...args: any[]) => IMediaPlaybackSessionOutputDegradationPolicyState;
+
+  interface IMediaPlaybackSource {
+  }
+  var IMediaPlaybackSource: abstract new (...args: any[]) => IMediaPlaybackSource;
+
+  interface IMediaPlaybackSphericalVideoProjection {
+    FrameFormat: number;
+    HorizontalFieldOfViewInDegrees: number;
+    IsEnabled: boolean;
+    ProjectionMode: number;
+    ViewOrientation: Windows.Foundation.Numerics.Quaternion;
+  }
+  var IMediaPlaybackSphericalVideoProjection: abstract new (...args: any[]) => IMediaPlaybackSphericalVideoProjection;
+
+  interface IMediaPlaybackTimedMetadataTrackList {
+    GetPresentationMode(index: number): number;
+    SetPresentationMode(index: number, value: number): void;
+    PresentationModeChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlaybackTimedMetadataTrackList, Windows.Media.Playback.TimedMetadataPresentationModeChangedEventArgs> | null;
+  }
+  var IMediaPlaybackTimedMetadataTrackList: abstract new (...args: any[]) => IMediaPlaybackTimedMetadataTrackList;
+
+  interface IMediaPlayer {
+    Pause(): void;
+    Play(): void;
+    SetUriSource(value: Windows.Foundation.Uri): void;
+    AutoPlay: boolean;
+    readonly BufferingProgress: number;
+    readonly CanPause: boolean;
+    readonly CanSeek: boolean;
+    readonly CurrentState: number;
+    IsLoopingEnabled: boolean;
+    IsMuted: boolean;
+    readonly IsProtected: boolean;
+    readonly NaturalDuration: Windows.Foundation.TimeSpan;
+    readonly PlaybackMediaMarkers: Windows.Media.Playback.PlaybackMediaMarkerSequence;
+    PlaybackRate: number;
+    Position: Windows.Foundation.TimeSpan;
+    Volume: number;
+    BufferingEnded: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+    BufferingStarted: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+    CurrentStateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+    MediaEnded: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+    MediaFailed: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Windows.Media.Playback.MediaPlayerFailedEventArgs> | null;
+    MediaOpened: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+    MediaPlayerRateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Windows.Media.Playback.MediaPlayerRateChangedEventArgs> | null;
+    PlaybackMediaMarkerReached: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Windows.Media.Playback.PlaybackMediaMarkerReachedEventArgs> | null;
+    SeekCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+    VolumeChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+  }
+  var IMediaPlayer: abstract new (...args: any[]) => IMediaPlayer;
+
+  interface IMediaPlayer2 {
+    AudioCategory: number;
+    AudioDeviceType: number;
+    readonly SystemMediaTransportControls: Windows.Media.SystemMediaTransportControls;
+  }
+  var IMediaPlayer2: abstract new (...args: any[]) => IMediaPlayer2;
+
+  interface IMediaPlayer3 {
+    GetAsCastingSource(): Windows.Media.Casting.CastingSource;
+    StepBackwardOneFrame(): void;
+    StepForwardOneFrame(): void;
+    AudioBalance: number;
+    AudioDevice: Windows.Devices.Enumeration.DeviceInformation;
+    readonly BreakManager: Windows.Media.Playback.MediaBreakManager;
+    readonly CommandManager: Windows.Media.Playback.MediaPlaybackCommandManager;
+    readonly PlaybackSession: Windows.Media.Playback.MediaPlaybackSession;
+    RealTimePlayback: boolean;
+    StereoscopicVideoRenderMode: number;
+    TimelineController: Windows.Media.MediaTimelineController;
+    TimelineControllerPositionOffset: Windows.Foundation.TimeSpan;
+    IsMutedChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+    SourceChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+  }
+  var IMediaPlayer3: abstract new (...args: any[]) => IMediaPlayer3;
+
+  interface IMediaPlayer4 {
+    GetSurface(compositor: Windows.UI.Composition.Compositor): Windows.Media.Playback.MediaPlayerSurface;
+    SetSurfaceSize(size: Windows.Foundation.Size): void;
+  }
+  var IMediaPlayer4: abstract new (...args: any[]) => IMediaPlayer4;
+
+  interface IMediaPlayer5 {
+    CopyFrameToStereoscopicVideoSurfaces(destinationLeftEye: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface, destinationRightEye: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface): void;
+    CopyFrameToVideoSurface(destination: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface): void;
+    CopyFrameToVideoSurface(destination: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface, targetRectangle: Windows.Foundation.Rect): void;
+    IsVideoFrameServerEnabled: boolean;
+    VideoFrameAvailable: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+  }
+  var IMediaPlayer5: abstract new (...args: any[]) => IMediaPlayer5;
+
+  interface IMediaPlayer6 {
+    RenderSubtitlesToSurface(destination: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface): boolean;
+    RenderSubtitlesToSurface(destination: Windows.Graphics.DirectX.Direct3D11.IDirect3DSurface, targetRectangle: Windows.Foundation.Rect): boolean;
+    SubtitleFrameChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Playback.MediaPlayer, Object> | null;
+  }
+  var IMediaPlayer6: abstract new (...args: any[]) => IMediaPlayer6;
+
+  interface IMediaPlayer7 {
+    readonly AudioStateMonitor: Windows.Media.Audio.AudioStateMonitor;
+  }
+  var IMediaPlayer7: abstract new (...args: any[]) => IMediaPlayer7;
+
+  interface IMediaPlayerDataReceivedEventArgs {
+    readonly Data: Windows.Foundation.Collections.ValueSet;
+  }
+  var IMediaPlayerDataReceivedEventArgs: abstract new (...args: any[]) => IMediaPlayerDataReceivedEventArgs;
+
+  interface IMediaPlayerEffects {
+    AddAudioEffect(activatableClassId: string, effectOptional: boolean, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    RemoveAllEffects(): void;
+  }
+  var IMediaPlayerEffects: abstract new (...args: any[]) => IMediaPlayerEffects;
+
+  interface IMediaPlayerEffects2 {
+    AddVideoEffect(activatableClassId: string, effectOptional: boolean, effectConfiguration: Windows.Foundation.Collections.IPropertySet): void;
+  }
+  var IMediaPlayerEffects2: abstract new (...args: any[]) => IMediaPlayerEffects2;
+
+  interface IMediaPlayerFailedEventArgs {
+    readonly Error: number;
+    readonly ErrorMessage: string;
+    readonly ExtendedErrorCode: Windows.Foundation.HResult;
+  }
+  var IMediaPlayerFailedEventArgs: abstract new (...args: any[]) => IMediaPlayerFailedEventArgs;
+
+  interface IMediaPlayerRateChangedEventArgs {
+    readonly NewRate: number;
+  }
+  var IMediaPlayerRateChangedEventArgs: abstract new (...args: any[]) => IMediaPlayerRateChangedEventArgs;
+
+  interface IMediaPlayerSource {
+    SetFileSource(file: Windows.Storage.IStorageFile): void;
+    SetMediaSource(source: Windows.Media.Core.IMediaSource): void;
+    SetStreamSource(stream: Windows.Storage.Streams.IRandomAccessStream): void;
+    ProtectionManager: Windows.Media.Protection.MediaProtectionManager;
+  }
+  var IMediaPlayerSource: abstract new (...args: any[]) => IMediaPlayerSource;
+
+  interface IMediaPlayerSource2 {
+    Source: Windows.Media.Playback.IMediaPlaybackSource;
+  }
+  var IMediaPlayerSource2: abstract new (...args: any[]) => IMediaPlayerSource2;
+
+  interface IMediaPlayerSurface {
+    readonly CompositionSurface: Windows.UI.Composition.ICompositionSurface;
+    readonly Compositor: Windows.UI.Composition.Compositor;
+    readonly MediaPlayer: Windows.Media.Playback.MediaPlayer;
+  }
+  var IMediaPlayerSurface: abstract new (...args: any[]) => IMediaPlayerSurface;
+
+  interface IPlaybackMediaMarker {
+    readonly MediaMarkerType: string;
+    readonly Text: string;
+    readonly Time: Windows.Foundation.TimeSpan;
+  }
+  var IPlaybackMediaMarker: abstract new (...args: any[]) => IPlaybackMediaMarker;
+
+  interface IPlaybackMediaMarkerFactory {
+    Create(value: Windows.Foundation.TimeSpan, mediaMarketType: string, text: string): Windows.Media.Playback.PlaybackMediaMarker;
+    CreateFromTime(value: Windows.Foundation.TimeSpan): Windows.Media.Playback.PlaybackMediaMarker;
+  }
+  var IPlaybackMediaMarkerFactory: abstract new (...args: any[]) => IPlaybackMediaMarkerFactory;
+
+  interface IPlaybackMediaMarkerReachedEventArgs {
+    readonly PlaybackMediaMarker: Windows.Media.Playback.PlaybackMediaMarker;
+  }
+  var IPlaybackMediaMarkerReachedEventArgs: abstract new (...args: any[]) => IPlaybackMediaMarkerReachedEventArgs;
+
+  interface IPlaybackMediaMarkerSequence {
+    Clear(): void;
+    Insert(value: Windows.Media.Playback.PlaybackMediaMarker): void;
+    readonly Size: number;
+  }
+  var IPlaybackMediaMarkerSequence: abstract new (...args: any[]) => IPlaybackMediaMarkerSequence;
+
+  interface ITimedMetadataPresentationModeChangedEventArgs {
+    readonly NewPresentationMode: number;
+    readonly OldPresentationMode: number;
+    readonly Track: Windows.Media.Core.TimedMetadataTrack;
+  }
+  var ITimedMetadataPresentationModeChangedEventArgs: abstract new (...args: any[]) => ITimedMetadataPresentationModeChangedEventArgs;
+
+}
+
+declare namespace Windows.Media.Playlists {
+  class Playlist implements Windows.Media.Playlists.IPlaylist {
+    constructor();
+    static LoadAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.Playlists.Playlist>;
+    SaveAsAsync(saveLocation: Windows.Storage.IStorageFolder, desiredName: string, option: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    SaveAsAsync(saveLocation: Windows.Storage.IStorageFolder, desiredName: string, option: number, playlistFormat: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    readonly Files: Windows.Foundation.Collections.IVector<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[];
+  }
+
+  enum PlaylistFormat {
+    WindowsMedia = 0,
+    Zune = 1,
+    M3u = 2,
+  }
+
+  interface IPlaylist {
+    SaveAsAsync(saveLocation: Windows.Storage.IStorageFolder, desiredName: string, option: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    SaveAsAsync(saveLocation: Windows.Storage.IStorageFolder, desiredName: string, option: number, playlistFormat: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    readonly Files: Windows.Foundation.Collections.IVector<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[];
+  }
+  var IPlaylist: abstract new (...args: any[]) => IPlaylist;
+
+  interface IPlaylistStatics {
+    LoadAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Media.Playlists.Playlist>;
+  }
+  var IPlaylistStatics: abstract new (...args: any[]) => IPlaylistStatics;
+
+  interface PlaylistsContract {
+  }
+  var PlaylistsContract: {
+    new(fields: {  }): PlaylistsContract;
+  };
+
+}
+
+declare namespace Windows.Media.Protection {
+  class ComponentLoadFailedEventArgs implements Windows.Media.Protection.IComponentLoadFailedEventArgs {
+    readonly Completion: Windows.Media.Protection.MediaProtectionServiceCompletion;
+    readonly Information: Windows.Media.Protection.RevocationAndRenewalInformation;
+  }
+
+  class ComponentRenewal {
+    static RenewSystemComponentsAsync(information: Windows.Media.Protection.RevocationAndRenewalInformation): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+  }
+
+  class HdcpSession implements Windows.Foundation.IClosable, Windows.Media.Protection.IHdcpSession {
+    constructor();
+    Close(): void;
+    GetEffectiveProtection(): number | null;
+    IsEffectiveProtectionAtLeast(protection: number): boolean;
+    SetDesiredMinProtectionAsync(protection: number): Windows.Foundation.IAsyncOperation<number>;
+    ProtectionChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Protection.HdcpSession, Object> | null;
+  }
+
+  class MediaProtectionManager implements Windows.Media.Protection.IMediaProtectionManager {
+    constructor();
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+    ComponentLoadFailed: Windows.Media.Protection.ComponentLoadFailedEventHandler | null;
+    RebootNeeded: Windows.Media.Protection.RebootNeededEventHandler | null;
+    ServiceRequested: Windows.Media.Protection.ServiceRequestedEventHandler | null;
+  }
+
+  class MediaProtectionPMPServer implements Windows.Media.Protection.IMediaProtectionPMPServer {
+    constructor(pProperties: Windows.Foundation.Collections.IPropertySet);
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+  }
+
+  class MediaProtectionServiceCompletion implements Windows.Media.Protection.IMediaProtectionServiceCompletion {
+    Complete(success: boolean): void;
+  }
+
+  class ProtectionCapabilities implements Windows.Media.Protection.IProtectionCapabilities {
+    constructor();
+    IsTypeSupported(type: string, keySystem: string): number;
+  }
+
+  class RevocationAndRenewalInformation implements Windows.Media.Protection.IRevocationAndRenewalInformation {
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.Media.Protection.RevocationAndRenewalItem> | Windows.Media.Protection.RevocationAndRenewalItem[];
+  }
+
+  class RevocationAndRenewalItem implements Windows.Media.Protection.IRevocationAndRenewalItem {
+    readonly HeaderHash: string;
+    readonly Name: string;
+    readonly PublicKeyHash: string;
+    readonly Reasons: number;
+    readonly RenewalId: string;
+  }
+
+  class ServiceRequestedEventArgs implements Windows.Media.Protection.IServiceRequestedEventArgs, Windows.Media.Protection.IServiceRequestedEventArgs2 {
+    readonly Completion: Windows.Media.Protection.MediaProtectionServiceCompletion;
+    readonly MediaPlaybackItem: Windows.Media.Playback.MediaPlaybackItem;
+    readonly Request: Windows.Media.Protection.IMediaProtectionServiceRequest;
+  }
+
+  enum GraphicsTrustStatus {
+    TrustNotRequired = 0,
+    TrustEstablished = 1,
+    EnvironmentNotSupported = 2,
+    DriverNotSupported = 3,
+    DriverSigningFailure = 4,
+    UnknownFailure = 5,
+  }
+
+  enum HdcpProtection {
+    Off = 0,
+    On = 1,
+    OnWithTypeEnforcement = 2,
+  }
+
+  enum HdcpSetProtectionResult {
+    Success = 0,
+    TimedOut = 1,
+    NotSupported = 2,
+    UnknownFailure = 3,
+  }
+
+  enum ProtectionCapabilityResult {
+    NotSupported = 0,
+    Maybe = 1,
+    Probably = 2,
+  }
+
+  enum RenewalStatus {
+    NotStarted = 0,
+    UpdatesInProgress = 1,
+    UserCancelled = 2,
+    AppComponentsMayNeedUpdating = 3,
+    NoComponentsFound = 4,
+  }
+
+  enum RevocationAndRenewalReasons {
+    UserModeComponentLoad = 1,
+    KernelModeComponentLoad = 2,
+    AppComponent = 4,
+    GlobalRevocationListLoadFailed = 16,
+    InvalidGlobalRevocationListSignature = 32,
+    GlobalRevocationListAbsent = 4096,
+    ComponentRevoked = 8192,
+    InvalidComponentCertificateExtendedKeyUse = 16384,
+    ComponentCertificateRevoked = 32768,
+    InvalidComponentCertificateRoot = 65536,
+    ComponentHighSecurityCertificateRevoked = 131072,
+    ComponentLowSecurityCertificateRevoked = 262144,
+    BootDriverVerificationFailed = 1048576,
+    ComponentSignedWithTestCertificate = 16777216,
+    EncryptionFailure = 268435456,
+  }
+
+  interface ComponentLoadFailedEventHandler {
+    (sender: Windows.Media.Protection.MediaProtectionManager, e: Windows.Media.Protection.ComponentLoadFailedEventArgs): void;
+  }
+  var ComponentLoadFailedEventHandler: {
+    new(callback: (sender: Windows.Media.Protection.MediaProtectionManager, e: Windows.Media.Protection.ComponentLoadFailedEventArgs) => void): ComponentLoadFailedEventHandler;
+  };
+
+  interface IComponentLoadFailedEventArgs {
+    readonly Completion: Windows.Media.Protection.MediaProtectionServiceCompletion;
+    readonly Information: Windows.Media.Protection.RevocationAndRenewalInformation;
+  }
+  var IComponentLoadFailedEventArgs: abstract new (...args: any[]) => IComponentLoadFailedEventArgs;
+
+  interface IComponentRenewalStatics {
+    RenewSystemComponentsAsync(information: Windows.Media.Protection.RevocationAndRenewalInformation): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+  }
+  var IComponentRenewalStatics: abstract new (...args: any[]) => IComponentRenewalStatics;
+
+  interface IHdcpSession extends Windows.Foundation.IClosable {
+    Close(): void;
+    GetEffectiveProtection(): number | null;
+    IsEffectiveProtectionAtLeast(protection: number): boolean;
+    SetDesiredMinProtectionAsync(protection: number): Windows.Foundation.IAsyncOperation<number>;
+    ProtectionChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Protection.HdcpSession, Object> | null;
+  }
+  var IHdcpSession: abstract new (...args: any[]) => IHdcpSession;
+
+  interface IMediaProtectionManager {
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+    ComponentLoadFailed: Windows.Media.Protection.ComponentLoadFailedEventHandler | null;
+    RebootNeeded: Windows.Media.Protection.RebootNeededEventHandler | null;
+    ServiceRequested: Windows.Media.Protection.ServiceRequestedEventHandler | null;
+  }
+  var IMediaProtectionManager: abstract new (...args: any[]) => IMediaProtectionManager;
+
+  interface IMediaProtectionPMPServer {
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+  }
+  var IMediaProtectionPMPServer: abstract new (...args: any[]) => IMediaProtectionPMPServer;
+
+  interface IMediaProtectionPMPServerFactory {
+    CreatePMPServer(pProperties: Windows.Foundation.Collections.IPropertySet): Windows.Media.Protection.MediaProtectionPMPServer;
+  }
+  var IMediaProtectionPMPServerFactory: abstract new (...args: any[]) => IMediaProtectionPMPServerFactory;
+
+  interface IMediaProtectionServiceCompletion {
+    Complete(success: boolean): void;
+  }
+  var IMediaProtectionServiceCompletion: abstract new (...args: any[]) => IMediaProtectionServiceCompletion;
+
+  interface IMediaProtectionServiceRequest {
+    readonly ProtectionSystem: Guid;
+    readonly Type: Guid;
+  }
+  var IMediaProtectionServiceRequest: abstract new (...args: any[]) => IMediaProtectionServiceRequest;
+
+  interface IProtectionCapabilities {
+    IsTypeSupported(type: string, keySystem: string): number;
+  }
+  var IProtectionCapabilities: abstract new (...args: any[]) => IProtectionCapabilities;
+
+  interface IRevocationAndRenewalInformation {
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.Media.Protection.RevocationAndRenewalItem> | Windows.Media.Protection.RevocationAndRenewalItem[];
+  }
+  var IRevocationAndRenewalInformation: abstract new (...args: any[]) => IRevocationAndRenewalInformation;
+
+  interface IRevocationAndRenewalItem {
+    readonly HeaderHash: string;
+    readonly Name: string;
+    readonly PublicKeyHash: string;
+    readonly Reasons: number;
+    readonly RenewalId: string;
+  }
+  var IRevocationAndRenewalItem: abstract new (...args: any[]) => IRevocationAndRenewalItem;
+
+  interface IServiceRequestedEventArgs {
+    readonly Completion: Windows.Media.Protection.MediaProtectionServiceCompletion;
+    readonly Request: Windows.Media.Protection.IMediaProtectionServiceRequest;
+  }
+  var IServiceRequestedEventArgs: abstract new (...args: any[]) => IServiceRequestedEventArgs;
+
+  interface IServiceRequestedEventArgs2 {
+    readonly MediaPlaybackItem: Windows.Media.Playback.MediaPlaybackItem;
+  }
+  var IServiceRequestedEventArgs2: abstract new (...args: any[]) => IServiceRequestedEventArgs2;
+
+  interface ProtectionRenewalContract {
+  }
+  var ProtectionRenewalContract: {
+    new(fields: {  }): ProtectionRenewalContract;
+  };
+
+  interface RebootNeededEventHandler {
+    (sender: Windows.Media.Protection.MediaProtectionManager): void;
+  }
+  var RebootNeededEventHandler: {
+    new(callback: (sender: Windows.Media.Protection.MediaProtectionManager) => void): RebootNeededEventHandler;
+  };
+
+  interface ServiceRequestedEventHandler {
+    (sender: Windows.Media.Protection.MediaProtectionManager, e: Windows.Media.Protection.ServiceRequestedEventArgs): void;
+  }
+  var ServiceRequestedEventHandler: {
+    new(callback: (sender: Windows.Media.Protection.MediaProtectionManager, e: Windows.Media.Protection.ServiceRequestedEventArgs) => void): ServiceRequestedEventHandler;
+  };
+
+}
+
+declare namespace Windows.Media.Protection.PlayReady {
+  class NDClient implements Windows.Media.Protection.PlayReady.INDClient {
+    constructor(downloadEngine: Windows.Media.Protection.PlayReady.INDDownloadEngine, streamParser: Windows.Media.Protection.PlayReady.INDStreamParser, pMessenger: Windows.Media.Protection.PlayReady.INDMessenger);
+    Close(): void;
+    LicenseFetchAsync(licenseFetchDescriptor: Windows.Media.Protection.PlayReady.INDLicenseFetchDescriptor): Windows.Foundation.IAsyncOperation<Windows.Media.Protection.PlayReady.INDLicenseFetchResult>;
+    ReRegistrationAsync(registrationCustomData: Windows.Media.Protection.PlayReady.INDCustomData): Windows.Foundation.IAsyncAction;
+    StartAsync(contentUrl: Windows.Foundation.Uri, startAsyncOptions: number, registrationCustomData: Windows.Media.Protection.PlayReady.INDCustomData, licenseFetchDescriptor: Windows.Media.Protection.PlayReady.INDLicenseFetchDescriptor): Windows.Foundation.IAsyncOperation<Windows.Media.Protection.PlayReady.INDStartResult>;
+    ClosedCaptionDataReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Protection.PlayReady.NDClient, Windows.Media.Protection.PlayReady.INDClosedCaptionDataReceivedEventArgs> | null;
+    LicenseFetchCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Protection.PlayReady.NDClient, Windows.Media.Protection.PlayReady.INDLicenseFetchCompletedEventArgs> | null;
+    ProximityDetectionCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Protection.PlayReady.NDClient, Windows.Media.Protection.PlayReady.INDProximityDetectionCompletedEventArgs> | null;
+    ReRegistrationNeeded: Windows.Foundation.TypedEventHandler<Windows.Media.Protection.PlayReady.NDClient, Object> | null;
+    RegistrationCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Protection.PlayReady.NDClient, Windows.Media.Protection.PlayReady.INDRegistrationCompletedEventArgs> | null;
+  }
+
+  class NDCustomData implements Windows.Media.Protection.PlayReady.INDCustomData {
+    constructor(customDataTypeIDBytes: number[], customDataBytes: number[]);
+    readonly CustomData: number[];
+    readonly CustomDataTypeID: number[];
+  }
+
+  class NDDownloadEngineNotifier implements Windows.Media.Protection.PlayReady.INDDownloadEngineNotifier {
+    constructor();
+    OnContentIDReceived(licenseFetchDescriptor: Windows.Media.Protection.PlayReady.INDLicenseFetchDescriptor): void;
+    OnDataReceived(dataBytes: number[], bytesReceived: number): void;
+    OnEndOfStream(): void;
+    OnNetworkError(): void;
+    OnPlayReadyObjectReceived(dataBytes: number[]): void;
+    OnStreamOpened(): void;
+  }
+
+  class NDLicenseFetchDescriptor implements Windows.Media.Protection.PlayReady.INDLicenseFetchDescriptor {
+    constructor(contentIDType: number, contentIDBytes: number[], licenseFetchChallengeCustomData: Windows.Media.Protection.PlayReady.INDCustomData);
+    readonly ContentID: number[];
+    readonly ContentIDType: number;
+    LicenseFetchChallengeCustomData: Windows.Media.Protection.PlayReady.INDCustomData;
+  }
+
+  class NDStorageFileHelper implements Windows.Media.Protection.PlayReady.INDStorageFileHelper {
+    constructor();
+    GetFileURLs(file: Windows.Storage.IStorageFile): Windows.Foundation.Collections.IVector<string> | string[];
+  }
+
+  class NDStreamParserNotifier implements Windows.Media.Protection.PlayReady.INDStreamParserNotifier {
+    constructor();
+    OnBeginSetupDecryptor(descriptor: Windows.Media.Core.IMediaStreamDescriptor, keyID: Guid, proBytes: number[]): void;
+    OnContentIDReceived(licenseFetchDescriptor: Windows.Media.Protection.PlayReady.INDLicenseFetchDescriptor): void;
+    OnMediaStreamDescriptorCreated(audioStreamDescriptors: Windows.Foundation.Collections.IVector<Windows.Media.Core.AudioStreamDescriptor> | Windows.Media.Core.AudioStreamDescriptor[], videoStreamDescriptors: Windows.Foundation.Collections.IVector<Windows.Media.Core.VideoStreamDescriptor> | Windows.Media.Core.VideoStreamDescriptor[]): void;
+    OnSampleParsed(streamID: number, streamType: number, streamSample: Windows.Media.Core.MediaStreamSample, pts: number | bigint, ccFormat: number, ccDataBytes: number[]): void;
+  }
+
+  class NDTCPMessenger implements Windows.Media.Protection.PlayReady.INDMessenger {
+    constructor(remoteHostName: string, remoteHostPort: number);
+    SendLicenseFetchRequestAsync(sessionIDBytes: number[], challengeDataBytes: number[]): Windows.Foundation.IAsyncOperation<Windows.Media.Protection.PlayReady.INDSendResult>;
+    SendProximityDetectionResponseAsync(pdType: number, transmitterChannelBytes: number[], sessionIDBytes: number[], responseDataBytes: number[]): Windows.Foundation.IAsyncOperation<Windows.Media.Protection.PlayReady.INDSendResult>;
+    SendProximityDetectionStartAsync(pdType: number, transmitterChannelBytes: number[], sessionIDBytes: number[], challengeDataBytes: number[]): Windows.Foundation.IAsyncOperation<Windows.Media.Protection.PlayReady.INDSendResult>;
+    SendRegistrationRequestAsync(sessionIDBytes: number[], challengeDataBytes: number[]): Windows.Foundation.IAsyncOperation<Windows.Media.Protection.PlayReady.INDSendResult>;
+  }
+
+  class PlayReadyContentHeader implements Windows.Media.Protection.PlayReady.IPlayReadyContentHeader, Windows.Media.Protection.PlayReady.IPlayReadyContentHeader2 {
+    constructor(dwFlags: number, contentKeyIds: Guid[], contentKeyIdStrings: string[], contentEncryptionAlgorithm: number, licenseAcquisitionUrl: Windows.Foundation.Uri, licenseAcquisitionUserInterfaceUrl: Windows.Foundation.Uri, customAttributes: string, domainServiceId: Guid);
+    constructor(headerBytes: number[], licenseAcquisitionUrl: Windows.Foundation.Uri, licenseAcquisitionUserInterfaceUrl: Windows.Foundation.Uri, customAttributes: string, domainServiceId: Guid);
+    constructor(contentKeyId: Guid, contentKeyIdString: string, contentEncryptionAlgorithm: number, licenseAcquisitionUrl: Windows.Foundation.Uri, licenseAcquisitionUserInterfaceUrl: Windows.Foundation.Uri, customAttributes: string, domainServiceId: Guid);
+    constructor(headerBytes: number[]);
+    GetSerializedHeader(): number[];
+    readonly CustomAttributes: string;
+    readonly DecryptorSetup: number;
+    readonly DomainServiceId: Guid;
+    readonly EncryptionType: number;
+    readonly HeaderWithEmbeddedUpdates: Windows.Media.Protection.PlayReady.PlayReadyContentHeader;
+    readonly KeyId: Guid;
+    readonly KeyIdString: string;
+    readonly KeyIdStrings: string[];
+    readonly KeyIds: Guid[];
+    readonly LicenseAcquisitionUrl: Windows.Foundation.Uri;
+    readonly LicenseAcquisitionUserInterfaceUrl: Windows.Foundation.Uri;
+  }
+
+  class PlayReadyContentResolver {
+    static ServiceRequest(contentHeader: Windows.Media.Protection.PlayReady.PlayReadyContentHeader): Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest;
+  }
+
+  class PlayReadyDomain implements Windows.Media.Protection.PlayReady.IPlayReadyDomain {
+    readonly AccountId: Guid;
+    readonly DomainJoinUrl: Windows.Foundation.Uri;
+    readonly FriendlyName: string;
+    readonly Revision: number;
+    readonly ServiceId: Guid;
+  }
+
+  class PlayReadyDomainIterable {
+    constructor(domainAccountId: Guid);
+    First(): Windows.Foundation.Collections.IIterator<Windows.Media.Protection.PlayReady.IPlayReadyDomain>;
+  }
+
+  class PlayReadyDomainIterator {
+    GetMany(items: Windows.Media.Protection.PlayReady.IPlayReadyDomain[]): number;
+    MoveNext(): boolean;
+    readonly Current: Windows.Media.Protection.PlayReady.IPlayReadyDomain;
+    readonly HasCurrent: boolean;
+  }
+
+  class PlayReadyDomainJoinServiceRequest implements Windows.Media.Protection.IMediaProtectionServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyDomainJoinServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest {
+    constructor();
+    BeginServiceRequest(): Windows.Foundation.IAsyncAction;
+    GenerateManualEnablingChallenge(): Windows.Media.Protection.PlayReady.PlayReadySoapMessage;
+    NextServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest;
+    ProcessManualEnablingResponse(responseBytes: number[]): Windows.Foundation.HResult;
+    ChallengeCustomData: string;
+    DomainAccountId: Guid;
+    DomainFriendlyName: string;
+    DomainServiceId: Guid;
+    readonly ProtectionSystem: Guid;
+    readonly ResponseCustomData: string;
+    readonly Type: Guid;
+    Uri: Windows.Foundation.Uri;
+  }
+
+  class PlayReadyDomainLeaveServiceRequest implements Windows.Media.Protection.IMediaProtectionServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyDomainLeaveServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest {
+    constructor();
+    BeginServiceRequest(): Windows.Foundation.IAsyncAction;
+    GenerateManualEnablingChallenge(): Windows.Media.Protection.PlayReady.PlayReadySoapMessage;
+    NextServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest;
+    ProcessManualEnablingResponse(responseBytes: number[]): Windows.Foundation.HResult;
+    ChallengeCustomData: string;
+    DomainAccountId: Guid;
+    DomainServiceId: Guid;
+    readonly ProtectionSystem: Guid;
+    readonly ResponseCustomData: string;
+    readonly Type: Guid;
+    Uri: Windows.Foundation.Uri;
+  }
+
+  class PlayReadyITADataGenerator implements Windows.Media.Protection.PlayReady.IPlayReadyITADataGenerator {
+    constructor();
+    GenerateData(guidCPSystemId: Guid, countOfStreams: number, configuration: Windows.Foundation.Collections.IPropertySet, format: number): number[];
+  }
+
+  class PlayReadyIndividualizationServiceRequest implements Windows.Media.Protection.IMediaProtectionServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyIndividualizationServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest {
+    constructor();
+    BeginServiceRequest(): Windows.Foundation.IAsyncAction;
+    GenerateManualEnablingChallenge(): Windows.Media.Protection.PlayReady.PlayReadySoapMessage;
+    NextServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest;
+    ProcessManualEnablingResponse(responseBytes: number[]): Windows.Foundation.HResult;
+    ChallengeCustomData: string;
+    readonly ProtectionSystem: Guid;
+    readonly ResponseCustomData: string;
+    readonly Type: Guid;
+    Uri: Windows.Foundation.Uri;
+  }
+
+  class PlayReadyLicense implements Windows.Media.Protection.PlayReady.IPlayReadyLicense, Windows.Media.Protection.PlayReady.IPlayReadyLicense2 {
+    GetKIDAtChainDepth(chainDepth: number): Guid;
+    readonly ChainDepth: number;
+    readonly DomainAccountID: Guid;
+    readonly ExpirationDate: Windows.Foundation.DateTime | null;
+    readonly ExpireAfterFirstPlay: number;
+    readonly ExpiresInRealTime: boolean;
+    readonly FullyEvaluated: boolean;
+    readonly InMemoryOnly: boolean;
+    readonly SecureStopId: Guid;
+    readonly SecurityLevel: number;
+    readonly UsableForPlay: boolean;
+  }
+
+  class PlayReadyLicenseAcquisitionServiceRequest implements Windows.Media.Protection.IMediaProtectionServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyLicenseAcquisitionServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyLicenseAcquisitionServiceRequest2, Windows.Media.Protection.PlayReady.IPlayReadyLicenseAcquisitionServiceRequest3, Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest {
+    constructor();
+    BeginServiceRequest(): Windows.Foundation.IAsyncAction;
+    CreateLicenseIterable(contentHeader: Windows.Media.Protection.PlayReady.PlayReadyContentHeader, fullyEvaluated: boolean): Windows.Media.Protection.PlayReady.PlayReadyLicenseIterable;
+    GenerateManualEnablingChallenge(): Windows.Media.Protection.PlayReady.PlayReadySoapMessage;
+    NextServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest;
+    ProcessManualEnablingResponse(responseBytes: number[]): Windows.Foundation.HResult;
+    ChallengeCustomData: string;
+    ContentHeader: Windows.Media.Protection.PlayReady.PlayReadyContentHeader;
+    DomainServiceId: Guid;
+    readonly ProtectionSystem: Guid;
+    readonly ResponseCustomData: string;
+    readonly SessionId: Guid;
+    readonly Type: Guid;
+    Uri: Windows.Foundation.Uri;
+  }
+
+  class PlayReadyLicenseIterable {
+    constructor();
+    constructor(contentHeader: Windows.Media.Protection.PlayReady.PlayReadyContentHeader, fullyEvaluated: boolean);
+    First(): Windows.Foundation.Collections.IIterator<Windows.Media.Protection.PlayReady.IPlayReadyLicense>;
+  }
+
+  class PlayReadyLicenseIterator {
+    GetMany(items: Windows.Media.Protection.PlayReady.IPlayReadyLicense[]): number;
+    MoveNext(): boolean;
+    readonly Current: Windows.Media.Protection.PlayReady.IPlayReadyLicense;
+    readonly HasCurrent: boolean;
+  }
+
+  class PlayReadyLicenseManagement {
+    static DeleteLicenses(contentHeader: Windows.Media.Protection.PlayReady.PlayReadyContentHeader): Windows.Foundation.IAsyncAction;
+  }
+
+  class PlayReadyLicenseSession implements Windows.Media.Protection.PlayReady.IPlayReadyLicenseSession, Windows.Media.Protection.PlayReady.IPlayReadyLicenseSession2 {
+    constructor(configuration: Windows.Foundation.Collections.IPropertySet);
+    ConfigureMediaProtectionManager(mpm: Windows.Media.Protection.MediaProtectionManager): void;
+    CreateLAServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyLicenseAcquisitionServiceRequest;
+    CreateLicenseIterable(contentHeader: Windows.Media.Protection.PlayReady.PlayReadyContentHeader, fullyEvaluated: boolean): Windows.Media.Protection.PlayReady.PlayReadyLicenseIterable;
+  }
+
+  class PlayReadyMeteringReportServiceRequest implements Windows.Media.Protection.IMediaProtectionServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyMeteringReportServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest {
+    constructor();
+    BeginServiceRequest(): Windows.Foundation.IAsyncAction;
+    GenerateManualEnablingChallenge(): Windows.Media.Protection.PlayReady.PlayReadySoapMessage;
+    NextServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest;
+    ProcessManualEnablingResponse(responseBytes: number[]): Windows.Foundation.HResult;
+    ChallengeCustomData: string;
+    MeteringCertificate: number[];
+    readonly ProtectionSystem: Guid;
+    readonly ResponseCustomData: string;
+    readonly Type: Guid;
+    Uri: Windows.Foundation.Uri;
+  }
+
+  class PlayReadyRevocationServiceRequest implements Windows.Media.Protection.IMediaProtectionServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyRevocationServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest {
+    constructor();
+    BeginServiceRequest(): Windows.Foundation.IAsyncAction;
+    GenerateManualEnablingChallenge(): Windows.Media.Protection.PlayReady.PlayReadySoapMessage;
+    NextServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest;
+    ProcessManualEnablingResponse(responseBytes: number[]): Windows.Foundation.HResult;
+    ChallengeCustomData: string;
+    readonly ProtectionSystem: Guid;
+    readonly ResponseCustomData: string;
+    readonly Type: Guid;
+    Uri: Windows.Foundation.Uri;
+  }
+
+  class PlayReadySecureStopIterable {
+    constructor(publisherCertBytes: number[]);
+    First(): Windows.Foundation.Collections.IIterator<Windows.Media.Protection.PlayReady.IPlayReadySecureStopServiceRequest>;
+  }
+
+  class PlayReadySecureStopIterator {
+    GetMany(items: Windows.Media.Protection.PlayReady.IPlayReadySecureStopServiceRequest[]): number;
+    MoveNext(): boolean;
+    readonly Current: Windows.Media.Protection.PlayReady.IPlayReadySecureStopServiceRequest;
+    readonly HasCurrent: boolean;
+  }
+
+  class PlayReadySecureStopServiceRequest implements Windows.Media.Protection.IMediaProtectionServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadySecureStopServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest {
+    constructor(publisherCertBytes: number[]);
+    constructor(sessionID: Guid, publisherCertBytes: number[]);
+    BeginServiceRequest(): Windows.Foundation.IAsyncAction;
+    GenerateManualEnablingChallenge(): Windows.Media.Protection.PlayReady.PlayReadySoapMessage;
+    NextServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest;
+    ProcessManualEnablingResponse(responseBytes: number[]): Windows.Foundation.HResult;
+    ChallengeCustomData: string;
+    readonly ProtectionSystem: Guid;
+    readonly PublisherCertificate: number[];
+    readonly ResponseCustomData: string;
+    readonly SessionID: Guid;
+    readonly StartTime: Windows.Foundation.DateTime;
+    readonly Stopped: boolean;
+    readonly Type: Guid;
+    readonly UpdateTime: Windows.Foundation.DateTime;
+    Uri: Windows.Foundation.Uri;
+  }
+
+  class PlayReadySoapMessage implements Windows.Media.Protection.PlayReady.IPlayReadySoapMessage {
+    GetMessageBody(): number[];
+    readonly MessageHeaders: Windows.Foundation.Collections.IPropertySet;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class PlayReadyStatics {
+    static CheckSupportedHardware(hwdrmFeature: number): boolean;
+    static ResetHardwareDRMDisabled(): void;
+    static readonly DomainJoinServiceRequestType: Guid;
+    static readonly DomainLeaveServiceRequestType: Guid;
+    static readonly HardwareDRMDisabledAtTime: Windows.Foundation.DateTime | null;
+    static readonly HardwareDRMDisabledUntilTime: Windows.Foundation.DateTime | null;
+    static readonly IndividualizationServiceRequestType: Guid;
+    static readonly InputTrustAuthorityToCreate: string;
+    static readonly LicenseAcquirerServiceRequestType: Guid;
+    static readonly MediaProtectionSystemId: Guid;
+    static readonly MeteringReportServiceRequestType: Guid;
+    static readonly PlayReadyCertificateSecurityLevel: number;
+    static readonly PlayReadySecurityVersion: number;
+    static readonly ProtectionSystemId: Guid;
+    static readonly RevocationServiceRequestType: Guid;
+    static readonly SecureStopServiceRequestType: Guid;
+  }
+
+  enum NDCertificateFeature {
+    Transmitter = 1,
+    Receiver = 2,
+    SharedCertificate = 3,
+    SecureClock = 4,
+    AntiRollBackClock = 5,
+    CRLS = 9,
+    PlayReady3Features = 13,
+  }
+
+  enum NDCertificatePlatformID {
+    Windows = 0,
+    OSX = 1,
+    WindowsOnARM = 2,
+    WindowsMobile7 = 5,
+    iOSOnARM = 6,
+    XBoxOnPPC = 7,
+    WindowsPhone8OnARM = 8,
+    WindowsPhone8OnX86 = 9,
+    XboxOne = 10,
+    AndroidOnARM = 11,
+    WindowsPhone81OnARM = 12,
+    WindowsPhone81OnX86 = 13,
+  }
+
+  enum NDCertificateType {
+    Unknown = 0,
+    PC = 1,
+    Device = 2,
+    Domain = 3,
+    Issuer = 4,
+    CrlSigner = 5,
+    Service = 6,
+    Silverlight = 7,
+    Application = 8,
+    Metering = 9,
+    KeyFileSigner = 10,
+    Server = 11,
+    LicenseSigner = 12,
+  }
+
+  enum NDClosedCaptionFormat {
+    ATSC = 0,
+    SCTE20 = 1,
+    Unknown = 2,
+  }
+
+  enum NDContentIDType {
+    KeyID = 1,
+    PlayReadyObject = 2,
+    Custom = 3,
+  }
+
+  enum NDMediaStreamType {
+    Audio = 1,
+    Video = 2,
+  }
+
+  enum NDProximityDetectionType {
+    UDP = 1,
+    TCP = 2,
+    TransportAgnostic = 4,
+  }
+
+  enum NDStartAsyncOptions {
+    MutualAuthentication = 1,
+    WaitForLicenseDescriptor = 2,
+  }
+
+  enum PlayReadyDecryptorSetup {
+    Uninitialized = 0,
+    OnDemand = 1,
+  }
+
+  enum PlayReadyEncryptionAlgorithm {
+    Unprotected = 0,
+    Aes128Ctr = 1,
+    Cocktail = 4,
+    Aes128Cbc = 5,
+    Unspecified = 65535,
+    Uninitialized = 2147483647,
+  }
+
+  enum PlayReadyHardwareDRMFeatures {
+    HardwareDRM = 1,
+    HEVC = 2,
+    Aes128Cbc = 3,
+  }
+
+  enum PlayReadyITADataFormat {
+    SerializedProperties = 0,
+    SerializedProperties_WithContentProtectionWrapper = 1,
+  }
+
+  interface INDClient {
+    Close(): void;
+    LicenseFetchAsync(licenseFetchDescriptor: Windows.Media.Protection.PlayReady.INDLicenseFetchDescriptor): Windows.Foundation.IAsyncOperation<Windows.Media.Protection.PlayReady.INDLicenseFetchResult>;
+    ReRegistrationAsync(registrationCustomData: Windows.Media.Protection.PlayReady.INDCustomData): Windows.Foundation.IAsyncAction;
+    StartAsync(contentUrl: Windows.Foundation.Uri, startAsyncOptions: number, registrationCustomData: Windows.Media.Protection.PlayReady.INDCustomData, licenseFetchDescriptor: Windows.Media.Protection.PlayReady.INDLicenseFetchDescriptor): Windows.Foundation.IAsyncOperation<Windows.Media.Protection.PlayReady.INDStartResult>;
+    ClosedCaptionDataReceived: Windows.Foundation.TypedEventHandler<Windows.Media.Protection.PlayReady.NDClient, Windows.Media.Protection.PlayReady.INDClosedCaptionDataReceivedEventArgs> | null;
+    LicenseFetchCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Protection.PlayReady.NDClient, Windows.Media.Protection.PlayReady.INDLicenseFetchCompletedEventArgs> | null;
+    ProximityDetectionCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Protection.PlayReady.NDClient, Windows.Media.Protection.PlayReady.INDProximityDetectionCompletedEventArgs> | null;
+    ReRegistrationNeeded: Windows.Foundation.TypedEventHandler<Windows.Media.Protection.PlayReady.NDClient, Object> | null;
+    RegistrationCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Protection.PlayReady.NDClient, Windows.Media.Protection.PlayReady.INDRegistrationCompletedEventArgs> | null;
+  }
+  var INDClient: abstract new (...args: any[]) => INDClient;
+
+  interface INDClientFactory {
+    CreateInstance(downloadEngine: Windows.Media.Protection.PlayReady.INDDownloadEngine, streamParser: Windows.Media.Protection.PlayReady.INDStreamParser, pMessenger: Windows.Media.Protection.PlayReady.INDMessenger): Windows.Media.Protection.PlayReady.NDClient;
+  }
+  var INDClientFactory: abstract new (...args: any[]) => INDClientFactory;
+
+  interface INDClosedCaptionDataReceivedEventArgs {
+    readonly ClosedCaptionData: number[];
+    readonly ClosedCaptionDataFormat: number;
+    readonly PresentationTimestamp: number | bigint;
+  }
+  var INDClosedCaptionDataReceivedEventArgs: abstract new (...args: any[]) => INDClosedCaptionDataReceivedEventArgs;
+
+  interface INDCustomData {
+    readonly CustomData: number[];
+    readonly CustomDataTypeID: number[];
+  }
+  var INDCustomData: abstract new (...args: any[]) => INDCustomData;
+
+  interface INDCustomDataFactory {
+    CreateInstance(customDataTypeIDBytes: number[], customDataBytes: number[]): Windows.Media.Protection.PlayReady.NDCustomData;
+  }
+  var INDCustomDataFactory: abstract new (...args: any[]) => INDCustomDataFactory;
+
+  interface INDDownloadEngine {
+    Close(): void;
+    Open(uri: Windows.Foundation.Uri, sessionIDBytes: number[]): void;
+    Pause(): void;
+    Resume(): void;
+    Seek(startPosition: Windows.Foundation.TimeSpan): void;
+    readonly BufferFullMaxThresholdInSamples: number;
+    readonly BufferFullMinThresholdInSamples: number;
+    readonly CanSeek: boolean;
+    readonly Notifier: Windows.Media.Protection.PlayReady.NDDownloadEngineNotifier;
+  }
+  var INDDownloadEngine: abstract new (...args: any[]) => INDDownloadEngine;
+
+  interface INDDownloadEngineNotifier {
+    OnContentIDReceived(licenseFetchDescriptor: Windows.Media.Protection.PlayReady.INDLicenseFetchDescriptor): void;
+    OnDataReceived(dataBytes: number[], bytesReceived: number): void;
+    OnEndOfStream(): void;
+    OnNetworkError(): void;
+    OnPlayReadyObjectReceived(dataBytes: number[]): void;
+    OnStreamOpened(): void;
+  }
+  var INDDownloadEngineNotifier: abstract new (...args: any[]) => INDDownloadEngineNotifier;
+
+  interface INDLicenseFetchCompletedEventArgs {
+    readonly ResponseCustomData: Windows.Media.Protection.PlayReady.INDCustomData;
+  }
+  var INDLicenseFetchCompletedEventArgs: abstract new (...args: any[]) => INDLicenseFetchCompletedEventArgs;
+
+  interface INDLicenseFetchDescriptor {
+    readonly ContentID: number[];
+    readonly ContentIDType: number;
+    LicenseFetchChallengeCustomData: Windows.Media.Protection.PlayReady.INDCustomData;
+  }
+  var INDLicenseFetchDescriptor: abstract new (...args: any[]) => INDLicenseFetchDescriptor;
+
+  interface INDLicenseFetchDescriptorFactory {
+    CreateInstance(contentIDType: number, contentIDBytes: number[], licenseFetchChallengeCustomData: Windows.Media.Protection.PlayReady.INDCustomData): Windows.Media.Protection.PlayReady.NDLicenseFetchDescriptor;
+  }
+  var INDLicenseFetchDescriptorFactory: abstract new (...args: any[]) => INDLicenseFetchDescriptorFactory;
+
+  interface INDLicenseFetchResult {
+    readonly ResponseCustomData: Windows.Media.Protection.PlayReady.INDCustomData;
+  }
+  var INDLicenseFetchResult: abstract new (...args: any[]) => INDLicenseFetchResult;
+
+  interface INDMessenger {
+    SendLicenseFetchRequestAsync(sessionIDBytes: number[], challengeDataBytes: number[]): Windows.Foundation.IAsyncOperation<Windows.Media.Protection.PlayReady.INDSendResult>;
+    SendProximityDetectionResponseAsync(pdType: number, transmitterChannelBytes: number[], sessionIDBytes: number[], responseDataBytes: number[]): Windows.Foundation.IAsyncOperation<Windows.Media.Protection.PlayReady.INDSendResult>;
+    SendProximityDetectionStartAsync(pdType: number, transmitterChannelBytes: number[], sessionIDBytes: number[], challengeDataBytes: number[]): Windows.Foundation.IAsyncOperation<Windows.Media.Protection.PlayReady.INDSendResult>;
+    SendRegistrationRequestAsync(sessionIDBytes: number[], challengeDataBytes: number[]): Windows.Foundation.IAsyncOperation<Windows.Media.Protection.PlayReady.INDSendResult>;
+  }
+  var INDMessenger: abstract new (...args: any[]) => INDMessenger;
+
+  interface INDProximityDetectionCompletedEventArgs {
+    readonly ProximityDetectionRetryCount: number;
+  }
+  var INDProximityDetectionCompletedEventArgs: abstract new (...args: any[]) => INDProximityDetectionCompletedEventArgs;
+
+  interface INDRegistrationCompletedEventArgs {
+    readonly ResponseCustomData: Windows.Media.Protection.PlayReady.INDCustomData;
+    TransmitterCertificateAccepted: boolean;
+    readonly TransmitterProperties: Windows.Media.Protection.PlayReady.INDTransmitterProperties;
+  }
+  var INDRegistrationCompletedEventArgs: abstract new (...args: any[]) => INDRegistrationCompletedEventArgs;
+
+  interface INDSendResult {
+    readonly Response: number[];
+  }
+  var INDSendResult: abstract new (...args: any[]) => INDSendResult;
+
+  interface INDStartResult {
+    readonly MediaStreamSource: Windows.Media.Core.MediaStreamSource;
+  }
+  var INDStartResult: abstract new (...args: any[]) => INDStartResult;
+
+  interface INDStorageFileHelper {
+    GetFileURLs(file: Windows.Storage.IStorageFile): Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var INDStorageFileHelper: abstract new (...args: any[]) => INDStorageFileHelper;
+
+  interface INDStreamParser {
+    BeginOfStream(): void;
+    EndOfStream(): void;
+    GetStreamInformation(descriptor: Windows.Media.Core.IMediaStreamDescriptor, streamType: number): number;
+    ParseData(dataBytes: number[]): void;
+    readonly Notifier: Windows.Media.Protection.PlayReady.NDStreamParserNotifier;
+  }
+  var INDStreamParser: abstract new (...args: any[]) => INDStreamParser;
+
+  interface INDStreamParserNotifier {
+    OnBeginSetupDecryptor(descriptor: Windows.Media.Core.IMediaStreamDescriptor, keyID: Guid, proBytes: number[]): void;
+    OnContentIDReceived(licenseFetchDescriptor: Windows.Media.Protection.PlayReady.INDLicenseFetchDescriptor): void;
+    OnMediaStreamDescriptorCreated(audioStreamDescriptors: Windows.Foundation.Collections.IVector<Windows.Media.Core.AudioStreamDescriptor> | Windows.Media.Core.AudioStreamDescriptor[], videoStreamDescriptors: Windows.Foundation.Collections.IVector<Windows.Media.Core.VideoStreamDescriptor> | Windows.Media.Core.VideoStreamDescriptor[]): void;
+    OnSampleParsed(streamID: number, streamType: number, streamSample: Windows.Media.Core.MediaStreamSample, pts: number | bigint, ccFormat: number, ccDataBytes: number[]): void;
+  }
+  var INDStreamParserNotifier: abstract new (...args: any[]) => INDStreamParserNotifier;
+
+  interface INDTCPMessengerFactory {
+    CreateInstance(remoteHostName: string, remoteHostPort: number): Windows.Media.Protection.PlayReady.NDTCPMessenger;
+  }
+  var INDTCPMessengerFactory: abstract new (...args: any[]) => INDTCPMessengerFactory;
+
+  interface INDTransmitterProperties {
+    readonly CertificateType: number;
+    readonly ClientID: number[];
+    readonly ExpirationDate: Windows.Foundation.DateTime;
+    readonly ModelDigest: number[];
+    readonly ModelManufacturerName: string;
+    readonly ModelName: string;
+    readonly ModelNumber: string;
+    readonly PlatformIdentifier: number;
+    readonly SecurityLevel: number;
+    readonly SecurityVersion: number;
+    readonly SupportedFeatures: number[];
+  }
+  var INDTransmitterProperties: abstract new (...args: any[]) => INDTransmitterProperties;
+
+  interface IPlayReadyContentHeader {
+    GetSerializedHeader(): number[];
+    readonly CustomAttributes: string;
+    readonly DecryptorSetup: number;
+    readonly DomainServiceId: Guid;
+    readonly EncryptionType: number;
+    readonly HeaderWithEmbeddedUpdates: Windows.Media.Protection.PlayReady.PlayReadyContentHeader;
+    readonly KeyId: Guid;
+    readonly KeyIdString: string;
+    readonly LicenseAcquisitionUrl: Windows.Foundation.Uri;
+    readonly LicenseAcquisitionUserInterfaceUrl: Windows.Foundation.Uri;
+  }
+  var IPlayReadyContentHeader: abstract new (...args: any[]) => IPlayReadyContentHeader;
+
+  interface IPlayReadyContentHeader2 extends Windows.Media.Protection.PlayReady.IPlayReadyContentHeader {
+    GetSerializedHeader(): number[];
+    readonly KeyIdStrings: string[];
+    readonly KeyIds: Guid[];
+  }
+  var IPlayReadyContentHeader2: abstract new (...args: any[]) => IPlayReadyContentHeader2;
+
+  interface IPlayReadyContentHeaderFactory {
+    CreateInstanceFromComponents(contentKeyId: Guid, contentKeyIdString: string, contentEncryptionAlgorithm: number, licenseAcquisitionUrl: Windows.Foundation.Uri, licenseAcquisitionUserInterfaceUrl: Windows.Foundation.Uri, customAttributes: string, domainServiceId: Guid): Windows.Media.Protection.PlayReady.PlayReadyContentHeader;
+    CreateInstanceFromPlayReadyHeader(headerBytes: number[]): Windows.Media.Protection.PlayReady.PlayReadyContentHeader;
+    CreateInstanceFromWindowsMediaDrmHeader(headerBytes: number[], licenseAcquisitionUrl: Windows.Foundation.Uri, licenseAcquisitionUserInterfaceUrl: Windows.Foundation.Uri, customAttributes: string, domainServiceId: Guid): Windows.Media.Protection.PlayReady.PlayReadyContentHeader;
+  }
+  var IPlayReadyContentHeaderFactory: abstract new (...args: any[]) => IPlayReadyContentHeaderFactory;
+
+  interface IPlayReadyContentHeaderFactory2 {
+    CreateInstanceFromComponents2(dwFlags: number, contentKeyIds: Guid[], contentKeyIdStrings: string[], contentEncryptionAlgorithm: number, licenseAcquisitionUrl: Windows.Foundation.Uri, licenseAcquisitionUserInterfaceUrl: Windows.Foundation.Uri, customAttributes: string, domainServiceId: Guid): Windows.Media.Protection.PlayReady.PlayReadyContentHeader;
+  }
+  var IPlayReadyContentHeaderFactory2: abstract new (...args: any[]) => IPlayReadyContentHeaderFactory2;
+
+  interface IPlayReadyContentResolver {
+    ServiceRequest(contentHeader: Windows.Media.Protection.PlayReady.PlayReadyContentHeader): Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest;
+  }
+  var IPlayReadyContentResolver: abstract new (...args: any[]) => IPlayReadyContentResolver;
+
+  interface IPlayReadyDomain {
+    readonly AccountId: Guid;
+    readonly DomainJoinUrl: Windows.Foundation.Uri;
+    readonly FriendlyName: string;
+    readonly Revision: number;
+    readonly ServiceId: Guid;
+  }
+  var IPlayReadyDomain: abstract new (...args: any[]) => IPlayReadyDomain;
+
+  interface IPlayReadyDomainIterableFactory {
+    CreateInstance(domainAccountId: Guid): Windows.Media.Protection.PlayReady.PlayReadyDomainIterable;
+  }
+  var IPlayReadyDomainIterableFactory: abstract new (...args: any[]) => IPlayReadyDomainIterableFactory;
+
+  interface IPlayReadyDomainJoinServiceRequest extends Windows.Media.Protection.IMediaProtectionServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest {
+    BeginServiceRequest(): Windows.Foundation.IAsyncAction;
+    GenerateManualEnablingChallenge(): Windows.Media.Protection.PlayReady.PlayReadySoapMessage;
+    NextServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest;
+    ProcessManualEnablingResponse(responseBytes: number[]): Windows.Foundation.HResult;
+    DomainAccountId: Guid;
+    DomainFriendlyName: string;
+    DomainServiceId: Guid;
+  }
+  var IPlayReadyDomainJoinServiceRequest: abstract new (...args: any[]) => IPlayReadyDomainJoinServiceRequest;
+
+  interface IPlayReadyDomainLeaveServiceRequest extends Windows.Media.Protection.IMediaProtectionServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest {
+    BeginServiceRequest(): Windows.Foundation.IAsyncAction;
+    GenerateManualEnablingChallenge(): Windows.Media.Protection.PlayReady.PlayReadySoapMessage;
+    NextServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest;
+    ProcessManualEnablingResponse(responseBytes: number[]): Windows.Foundation.HResult;
+    DomainAccountId: Guid;
+    DomainServiceId: Guid;
+  }
+  var IPlayReadyDomainLeaveServiceRequest: abstract new (...args: any[]) => IPlayReadyDomainLeaveServiceRequest;
+
+  interface IPlayReadyITADataGenerator {
+    GenerateData(guidCPSystemId: Guid, countOfStreams: number, configuration: Windows.Foundation.Collections.IPropertySet, format: number): number[];
+  }
+  var IPlayReadyITADataGenerator: abstract new (...args: any[]) => IPlayReadyITADataGenerator;
+
+  interface IPlayReadyIndividualizationServiceRequest extends Windows.Media.Protection.IMediaProtectionServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest {
+    BeginServiceRequest(): Windows.Foundation.IAsyncAction;
+    GenerateManualEnablingChallenge(): Windows.Media.Protection.PlayReady.PlayReadySoapMessage;
+    NextServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest;
+    ProcessManualEnablingResponse(responseBytes: number[]): Windows.Foundation.HResult;
+  }
+  var IPlayReadyIndividualizationServiceRequest: abstract new (...args: any[]) => IPlayReadyIndividualizationServiceRequest;
+
+  interface IPlayReadyLicense {
+    GetKIDAtChainDepth(chainDepth: number): Guid;
+    readonly ChainDepth: number;
+    readonly DomainAccountID: Guid;
+    readonly ExpirationDate: Windows.Foundation.DateTime | null;
+    readonly ExpireAfterFirstPlay: number;
+    readonly FullyEvaluated: boolean;
+    readonly UsableForPlay: boolean;
+  }
+  var IPlayReadyLicense: abstract new (...args: any[]) => IPlayReadyLicense;
+
+  interface IPlayReadyLicense2 extends Windows.Media.Protection.PlayReady.IPlayReadyLicense {
+    GetKIDAtChainDepth(chainDepth: number): Guid;
+    readonly ExpiresInRealTime: boolean;
+    readonly InMemoryOnly: boolean;
+    readonly SecureStopId: Guid;
+    readonly SecurityLevel: number;
+  }
+  var IPlayReadyLicense2: abstract new (...args: any[]) => IPlayReadyLicense2;
+
+  interface IPlayReadyLicenseAcquisitionServiceRequest extends Windows.Media.Protection.IMediaProtectionServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest {
+    BeginServiceRequest(): Windows.Foundation.IAsyncAction;
+    GenerateManualEnablingChallenge(): Windows.Media.Protection.PlayReady.PlayReadySoapMessage;
+    NextServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest;
+    ProcessManualEnablingResponse(responseBytes: number[]): Windows.Foundation.HResult;
+    ContentHeader: Windows.Media.Protection.PlayReady.PlayReadyContentHeader;
+    DomainServiceId: Guid;
+  }
+  var IPlayReadyLicenseAcquisitionServiceRequest: abstract new (...args: any[]) => IPlayReadyLicenseAcquisitionServiceRequest;
+
+  interface IPlayReadyLicenseAcquisitionServiceRequest2 extends Windows.Media.Protection.IMediaProtectionServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyLicenseAcquisitionServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest {
+    BeginServiceRequest(): Windows.Foundation.IAsyncAction;
+    GenerateManualEnablingChallenge(): Windows.Media.Protection.PlayReady.PlayReadySoapMessage;
+    NextServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest;
+    ProcessManualEnablingResponse(responseBytes: number[]): Windows.Foundation.HResult;
+    readonly SessionId: Guid;
+  }
+  var IPlayReadyLicenseAcquisitionServiceRequest2: abstract new (...args: any[]) => IPlayReadyLicenseAcquisitionServiceRequest2;
+
+  interface IPlayReadyLicenseAcquisitionServiceRequest3 extends Windows.Media.Protection.IMediaProtectionServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyLicenseAcquisitionServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyLicenseAcquisitionServiceRequest2, Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest {
+    BeginServiceRequest(): Windows.Foundation.IAsyncAction;
+    CreateLicenseIterable(contentHeader: Windows.Media.Protection.PlayReady.PlayReadyContentHeader, fullyEvaluated: boolean): Windows.Media.Protection.PlayReady.PlayReadyLicenseIterable;
+    GenerateManualEnablingChallenge(): Windows.Media.Protection.PlayReady.PlayReadySoapMessage;
+    NextServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest;
+    ProcessManualEnablingResponse(responseBytes: number[]): Windows.Foundation.HResult;
+  }
+  var IPlayReadyLicenseAcquisitionServiceRequest3: abstract new (...args: any[]) => IPlayReadyLicenseAcquisitionServiceRequest3;
+
+  interface IPlayReadyLicenseIterableFactory {
+    CreateInstance(contentHeader: Windows.Media.Protection.PlayReady.PlayReadyContentHeader, fullyEvaluated: boolean): Windows.Media.Protection.PlayReady.PlayReadyLicenseIterable;
+  }
+  var IPlayReadyLicenseIterableFactory: abstract new (...args: any[]) => IPlayReadyLicenseIterableFactory;
+
+  interface IPlayReadyLicenseManagement {
+    DeleteLicenses(contentHeader: Windows.Media.Protection.PlayReady.PlayReadyContentHeader): Windows.Foundation.IAsyncAction;
+  }
+  var IPlayReadyLicenseManagement: abstract new (...args: any[]) => IPlayReadyLicenseManagement;
+
+  interface IPlayReadyLicenseSession {
+    ConfigureMediaProtectionManager(mpm: Windows.Media.Protection.MediaProtectionManager): void;
+    CreateLAServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyLicenseAcquisitionServiceRequest;
+  }
+  var IPlayReadyLicenseSession: abstract new (...args: any[]) => IPlayReadyLicenseSession;
+
+  interface IPlayReadyLicenseSession2 extends Windows.Media.Protection.PlayReady.IPlayReadyLicenseSession {
+    ConfigureMediaProtectionManager(mpm: Windows.Media.Protection.MediaProtectionManager): void;
+    CreateLAServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyLicenseAcquisitionServiceRequest;
+    CreateLicenseIterable(contentHeader: Windows.Media.Protection.PlayReady.PlayReadyContentHeader, fullyEvaluated: boolean): Windows.Media.Protection.PlayReady.PlayReadyLicenseIterable;
+  }
+  var IPlayReadyLicenseSession2: abstract new (...args: any[]) => IPlayReadyLicenseSession2;
+
+  interface IPlayReadyLicenseSessionFactory {
+    CreateInstance(configuration: Windows.Foundation.Collections.IPropertySet): Windows.Media.Protection.PlayReady.PlayReadyLicenseSession;
+  }
+  var IPlayReadyLicenseSessionFactory: abstract new (...args: any[]) => IPlayReadyLicenseSessionFactory;
+
+  interface IPlayReadyMeteringReportServiceRequest extends Windows.Media.Protection.IMediaProtectionServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest {
+    BeginServiceRequest(): Windows.Foundation.IAsyncAction;
+    GenerateManualEnablingChallenge(): Windows.Media.Protection.PlayReady.PlayReadySoapMessage;
+    NextServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest;
+    ProcessManualEnablingResponse(responseBytes: number[]): Windows.Foundation.HResult;
+    MeteringCertificate: number[];
+  }
+  var IPlayReadyMeteringReportServiceRequest: abstract new (...args: any[]) => IPlayReadyMeteringReportServiceRequest;
+
+  interface IPlayReadyRevocationServiceRequest extends Windows.Media.Protection.IMediaProtectionServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest {
+    BeginServiceRequest(): Windows.Foundation.IAsyncAction;
+    GenerateManualEnablingChallenge(): Windows.Media.Protection.PlayReady.PlayReadySoapMessage;
+    NextServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest;
+    ProcessManualEnablingResponse(responseBytes: number[]): Windows.Foundation.HResult;
+  }
+  var IPlayReadyRevocationServiceRequest: abstract new (...args: any[]) => IPlayReadyRevocationServiceRequest;
+
+  interface IPlayReadySecureStopIterableFactory {
+    CreateInstance(publisherCertBytes: number[]): Windows.Media.Protection.PlayReady.PlayReadySecureStopIterable;
+  }
+  var IPlayReadySecureStopIterableFactory: abstract new (...args: any[]) => IPlayReadySecureStopIterableFactory;
+
+  interface IPlayReadySecureStopServiceRequest extends Windows.Media.Protection.IMediaProtectionServiceRequest, Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest {
+    BeginServiceRequest(): Windows.Foundation.IAsyncAction;
+    GenerateManualEnablingChallenge(): Windows.Media.Protection.PlayReady.PlayReadySoapMessage;
+    NextServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest;
+    ProcessManualEnablingResponse(responseBytes: number[]): Windows.Foundation.HResult;
+    readonly PublisherCertificate: number[];
+    readonly SessionID: Guid;
+    readonly StartTime: Windows.Foundation.DateTime;
+    readonly Stopped: boolean;
+    readonly UpdateTime: Windows.Foundation.DateTime;
+  }
+  var IPlayReadySecureStopServiceRequest: abstract new (...args: any[]) => IPlayReadySecureStopServiceRequest;
+
+  interface IPlayReadySecureStopServiceRequestFactory {
+    CreateInstance(publisherCertBytes: number[]): Windows.Media.Protection.PlayReady.PlayReadySecureStopServiceRequest;
+    CreateInstanceFromSessionID(sessionID: Guid, publisherCertBytes: number[]): Windows.Media.Protection.PlayReady.PlayReadySecureStopServiceRequest;
+  }
+  var IPlayReadySecureStopServiceRequestFactory: abstract new (...args: any[]) => IPlayReadySecureStopServiceRequestFactory;
+
+  interface IPlayReadyServiceRequest extends Windows.Media.Protection.IMediaProtectionServiceRequest {
+    BeginServiceRequest(): Windows.Foundation.IAsyncAction;
+    GenerateManualEnablingChallenge(): Windows.Media.Protection.PlayReady.PlayReadySoapMessage;
+    NextServiceRequest(): Windows.Media.Protection.PlayReady.IPlayReadyServiceRequest;
+    ProcessManualEnablingResponse(responseBytes: number[]): Windows.Foundation.HResult;
+    ChallengeCustomData: string;
+    readonly ResponseCustomData: string;
+    Uri: Windows.Foundation.Uri;
+  }
+  var IPlayReadyServiceRequest: abstract new (...args: any[]) => IPlayReadyServiceRequest;
+
+  interface IPlayReadySoapMessage {
+    GetMessageBody(): number[];
+    readonly MessageHeaders: Windows.Foundation.Collections.IPropertySet;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IPlayReadySoapMessage: abstract new (...args: any[]) => IPlayReadySoapMessage;
+
+  interface IPlayReadyStatics {
+    readonly DomainJoinServiceRequestType: Guid;
+    readonly DomainLeaveServiceRequestType: Guid;
+    readonly IndividualizationServiceRequestType: Guid;
+    readonly LicenseAcquirerServiceRequestType: Guid;
+    readonly MediaProtectionSystemId: Guid;
+    readonly MeteringReportServiceRequestType: Guid;
+    readonly PlayReadySecurityVersion: number;
+    readonly RevocationServiceRequestType: Guid;
+  }
+  var IPlayReadyStatics: abstract new (...args: any[]) => IPlayReadyStatics;
+
+  interface IPlayReadyStatics2 extends Windows.Media.Protection.PlayReady.IPlayReadyStatics {
+    readonly PlayReadyCertificateSecurityLevel: number;
+  }
+  var IPlayReadyStatics2: abstract new (...args: any[]) => IPlayReadyStatics2;
+
+  interface IPlayReadyStatics3 extends Windows.Media.Protection.PlayReady.IPlayReadyStatics, Windows.Media.Protection.PlayReady.IPlayReadyStatics2 {
+    CheckSupportedHardware(hwdrmFeature: number): boolean;
+    readonly SecureStopServiceRequestType: Guid;
+  }
+  var IPlayReadyStatics3: abstract new (...args: any[]) => IPlayReadyStatics3;
+
+  interface IPlayReadyStatics4 extends Windows.Media.Protection.PlayReady.IPlayReadyStatics, Windows.Media.Protection.PlayReady.IPlayReadyStatics2, Windows.Media.Protection.PlayReady.IPlayReadyStatics3 {
+    CheckSupportedHardware(hwdrmFeature: number): boolean;
+    readonly InputTrustAuthorityToCreate: string;
+    readonly ProtectionSystemId: Guid;
+  }
+  var IPlayReadyStatics4: abstract new (...args: any[]) => IPlayReadyStatics4;
+
+  interface IPlayReadyStatics5 extends Windows.Media.Protection.PlayReady.IPlayReadyStatics, Windows.Media.Protection.PlayReady.IPlayReadyStatics2, Windows.Media.Protection.PlayReady.IPlayReadyStatics3, Windows.Media.Protection.PlayReady.IPlayReadyStatics4 {
+    CheckSupportedHardware(hwdrmFeature: number): boolean;
+    ResetHardwareDRMDisabled(): void;
+    readonly HardwareDRMDisabledAtTime: Windows.Foundation.DateTime | null;
+    readonly HardwareDRMDisabledUntilTime: Windows.Foundation.DateTime | null;
+  }
+  var IPlayReadyStatics5: abstract new (...args: any[]) => IPlayReadyStatics5;
+
+}
+
+declare namespace Windows.Media.Render {
+  enum AudioRenderCategory {
+    Other = 0,
+    ForegroundOnlyMedia = 1,
+    BackgroundCapableMedia = 2,
+    Communications = 3,
+    Alerts = 4,
+    SoundEffects = 5,
+    GameEffects = 6,
+    GameMedia = 7,
+    GameChat = 8,
+    Speech = 9,
+    Movie = 10,
+    Media = 11,
+  }
+
+}
+
+declare namespace Windows.Media.SpeechRecognition {
+  class SpeechContinuousRecognitionCompletedEventArgs implements Windows.Media.SpeechRecognition.ISpeechContinuousRecognitionCompletedEventArgs {
+    readonly Status: number;
+  }
+
+  class SpeechContinuousRecognitionResultGeneratedEventArgs implements Windows.Media.SpeechRecognition.ISpeechContinuousRecognitionResultGeneratedEventArgs {
+    readonly Result: Windows.Media.SpeechRecognition.SpeechRecognitionResult;
+  }
+
+  class SpeechContinuousRecognitionSession implements Windows.Media.SpeechRecognition.ISpeechContinuousRecognitionSession {
+    CancelAsync(): Windows.Foundation.IAsyncAction;
+    PauseAsync(): Windows.Foundation.IAsyncAction;
+    Resume(): void;
+    StartAsync(): Windows.Foundation.IAsyncAction;
+    StartAsync(mode: number): Windows.Foundation.IAsyncAction;
+    StopAsync(): Windows.Foundation.IAsyncAction;
+    AutoStopSilenceTimeout: Windows.Foundation.TimeSpan;
+    Completed: Windows.Foundation.TypedEventHandler<Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession, Windows.Media.SpeechRecognition.SpeechContinuousRecognitionCompletedEventArgs> | null;
+    ResultGenerated: Windows.Foundation.TypedEventHandler<Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession, Windows.Media.SpeechRecognition.SpeechContinuousRecognitionResultGeneratedEventArgs> | null;
+  }
+
+  class SpeechRecognitionCompilationResult implements Windows.Media.SpeechRecognition.ISpeechRecognitionCompilationResult {
+    readonly Status: number;
+  }
+
+  class SpeechRecognitionGrammarFileConstraint implements Windows.Media.SpeechRecognition.ISpeechRecognitionConstraint, Windows.Media.SpeechRecognition.ISpeechRecognitionGrammarFileConstraint {
+    constructor(file: Windows.Storage.StorageFile);
+    constructor(file: Windows.Storage.StorageFile, tag: string);
+    readonly GrammarFile: Windows.Storage.StorageFile;
+    IsEnabled: boolean;
+    Probability: number;
+    Tag: string;
+    readonly Type: number;
+  }
+
+  class SpeechRecognitionHypothesis implements Windows.Media.SpeechRecognition.ISpeechRecognitionHypothesis {
+    readonly Text: string;
+  }
+
+  class SpeechRecognitionHypothesisGeneratedEventArgs implements Windows.Media.SpeechRecognition.ISpeechRecognitionHypothesisGeneratedEventArgs {
+    readonly Hypothesis: Windows.Media.SpeechRecognition.SpeechRecognitionHypothesis;
+  }
+
+  class SpeechRecognitionListConstraint implements Windows.Media.SpeechRecognition.ISpeechRecognitionConstraint, Windows.Media.SpeechRecognition.ISpeechRecognitionListConstraint {
+    constructor(commands: Windows.Foundation.Collections.IIterable<string> | string[]);
+    constructor(commands: Windows.Foundation.Collections.IIterable<string> | string[], tag: string);
+    readonly Commands: Windows.Foundation.Collections.IVector<string> | string[];
+    IsEnabled: boolean;
+    Probability: number;
+    Tag: string;
+    readonly Type: number;
+  }
+
+  class SpeechRecognitionQualityDegradingEventArgs implements Windows.Media.SpeechRecognition.ISpeechRecognitionQualityDegradingEventArgs {
+    readonly Problem: number;
+  }
+
+  class SpeechRecognitionResult implements Windows.Media.SpeechRecognition.ISpeechRecognitionResult, Windows.Media.SpeechRecognition.ISpeechRecognitionResult2 {
+    GetAlternates(maxAlternates: number): Windows.Foundation.Collections.IVectorView<Windows.Media.SpeechRecognition.SpeechRecognitionResult> | Windows.Media.SpeechRecognition.SpeechRecognitionResult[];
+    readonly Confidence: number;
+    readonly Constraint: Windows.Media.SpeechRecognition.ISpeechRecognitionConstraint;
+    readonly PhraseDuration: Windows.Foundation.TimeSpan;
+    readonly PhraseStartTime: Windows.Foundation.DateTime;
+    readonly RawConfidence: number;
+    readonly RulePath: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly SemanticInterpretation: Windows.Media.SpeechRecognition.SpeechRecognitionSemanticInterpretation;
+    readonly Status: number;
+    readonly Text: string;
+  }
+
+  class SpeechRecognitionSemanticInterpretation implements Windows.Media.SpeechRecognition.ISpeechRecognitionSemanticInterpretation {
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Windows.Foundation.Collections.IVectorView<string> | string[]>;
+  }
+
+  class SpeechRecognitionTopicConstraint implements Windows.Media.SpeechRecognition.ISpeechRecognitionConstraint, Windows.Media.SpeechRecognition.ISpeechRecognitionTopicConstraint {
+    constructor(scenario: number, topicHint: string);
+    constructor(scenario: number, topicHint: string, tag: string);
+    IsEnabled: boolean;
+    Probability: number;
+    readonly Scenario: number;
+    Tag: string;
+    readonly TopicHint: string;
+    readonly Type: number;
+  }
+
+  class SpeechRecognitionVoiceCommandDefinitionConstraint implements Windows.Media.SpeechRecognition.ISpeechRecognitionConstraint, Windows.Media.SpeechRecognition.ISpeechRecognitionVoiceCommandDefinitionConstraint {
+    IsEnabled: boolean;
+    Probability: number;
+    Tag: string;
+    readonly Type: number;
+  }
+
+  class SpeechRecognizer implements Windows.Foundation.IClosable, Windows.Media.SpeechRecognition.ISpeechRecognizer, Windows.Media.SpeechRecognition.ISpeechRecognizer2 {
+    constructor(language: Windows.Globalization.Language);
+    constructor();
+    Close(): void;
+    CompileConstraintsAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.SpeechRecognition.SpeechRecognitionCompilationResult>;
+    RecognizeAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.SpeechRecognition.SpeechRecognitionResult>;
+    RecognizeWithUIAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.SpeechRecognition.SpeechRecognitionResult>;
+    StopRecognitionAsync(): Windows.Foundation.IAsyncAction;
+    static TrySetSystemSpeechLanguageAsync(speechLanguage: Windows.Globalization.Language): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Constraints: Windows.Foundation.Collections.IVector<Windows.Media.SpeechRecognition.ISpeechRecognitionConstraint> | Windows.Media.SpeechRecognition.ISpeechRecognitionConstraint[];
+    readonly ContinuousRecognitionSession: Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession;
+    readonly CurrentLanguage: Windows.Globalization.Language;
+    readonly State: number;
+    static readonly SupportedGrammarLanguages: Windows.Foundation.Collections.IVectorView<Windows.Globalization.Language> | Windows.Globalization.Language[];
+    static readonly SupportedTopicLanguages: Windows.Foundation.Collections.IVectorView<Windows.Globalization.Language> | Windows.Globalization.Language[];
+    static readonly SystemSpeechLanguage: Windows.Globalization.Language;
+    readonly Timeouts: Windows.Media.SpeechRecognition.SpeechRecognizerTimeouts;
+    readonly UIOptions: Windows.Media.SpeechRecognition.SpeechRecognizerUIOptions;
+    RecognitionQualityDegrading: Windows.Foundation.TypedEventHandler<Windows.Media.SpeechRecognition.SpeechRecognizer, Windows.Media.SpeechRecognition.SpeechRecognitionQualityDegradingEventArgs> | null;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.SpeechRecognition.SpeechRecognizer, Windows.Media.SpeechRecognition.SpeechRecognizerStateChangedEventArgs> | null;
+    HypothesisGenerated: Windows.Foundation.TypedEventHandler<Windows.Media.SpeechRecognition.SpeechRecognizer, Windows.Media.SpeechRecognition.SpeechRecognitionHypothesisGeneratedEventArgs> | null;
+  }
+
+  class SpeechRecognizerStateChangedEventArgs implements Windows.Media.SpeechRecognition.ISpeechRecognizerStateChangedEventArgs {
+    readonly State: number;
+  }
+
+  class SpeechRecognizerTimeouts implements Windows.Media.SpeechRecognition.ISpeechRecognizerTimeouts {
+    BabbleTimeout: Windows.Foundation.TimeSpan;
+    EndSilenceTimeout: Windows.Foundation.TimeSpan;
+    InitialSilenceTimeout: Windows.Foundation.TimeSpan;
+  }
+
+  class SpeechRecognizerUIOptions implements Windows.Media.SpeechRecognition.ISpeechRecognizerUIOptions {
+    AudiblePrompt: string;
+    ExampleText: string;
+    IsReadBackEnabled: boolean;
+    ShowConfirmation: boolean;
+  }
+
+  enum SpeechContinuousRecognitionMode {
+    Default = 0,
+    PauseOnRecognition = 1,
+  }
+
+  enum SpeechRecognitionAudioProblem {
+    None = 0,
+    TooNoisy = 1,
+    NoSignal = 2,
+    TooLoud = 3,
+    TooQuiet = 4,
+    TooFast = 5,
+    TooSlow = 6,
+  }
+
+  enum SpeechRecognitionConfidence {
+    High = 0,
+    Medium = 1,
+    Low = 2,
+    Rejected = 3,
+  }
+
+  enum SpeechRecognitionConstraintProbability {
+    Default = 0,
+    Min = 1,
+    Max = 2,
+  }
+
+  enum SpeechRecognitionConstraintType {
+    Topic = 0,
+    List = 1,
+    Grammar = 2,
+    VoiceCommandDefinition = 3,
+  }
+
+  enum SpeechRecognitionResultStatus {
+    Success = 0,
+    TopicLanguageNotSupported = 1,
+    GrammarLanguageMismatch = 2,
+    GrammarCompilationFailure = 3,
+    AudioQualityFailure = 4,
+    UserCanceled = 5,
+    Unknown = 6,
+    TimeoutExceeded = 7,
+    PauseLimitExceeded = 8,
+    NetworkFailure = 9,
+    MicrophoneUnavailable = 10,
+  }
+
+  enum SpeechRecognitionScenario {
+    WebSearch = 0,
+    Dictation = 1,
+    FormFilling = 2,
+  }
+
+  enum SpeechRecognizerState {
+    Idle = 0,
+    Capturing = 1,
+    Processing = 2,
+    SoundStarted = 3,
+    SoundEnded = 4,
+    SpeechDetected = 5,
+    Paused = 6,
+  }
+
+  interface ISpeechContinuousRecognitionCompletedEventArgs {
+    readonly Status: number;
+  }
+  var ISpeechContinuousRecognitionCompletedEventArgs: abstract new (...args: any[]) => ISpeechContinuousRecognitionCompletedEventArgs;
+
+  interface ISpeechContinuousRecognitionResultGeneratedEventArgs {
+    readonly Result: Windows.Media.SpeechRecognition.SpeechRecognitionResult;
+  }
+  var ISpeechContinuousRecognitionResultGeneratedEventArgs: abstract new (...args: any[]) => ISpeechContinuousRecognitionResultGeneratedEventArgs;
+
+  interface ISpeechContinuousRecognitionSession {
+    CancelAsync(): Windows.Foundation.IAsyncAction;
+    PauseAsync(): Windows.Foundation.IAsyncAction;
+    Resume(): void;
+    StartAsync(): Windows.Foundation.IAsyncAction;
+    StartAsync(mode: number): Windows.Foundation.IAsyncAction;
+    StopAsync(): Windows.Foundation.IAsyncAction;
+    AutoStopSilenceTimeout: Windows.Foundation.TimeSpan;
+    Completed: Windows.Foundation.TypedEventHandler<Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession, Windows.Media.SpeechRecognition.SpeechContinuousRecognitionCompletedEventArgs> | null;
+    ResultGenerated: Windows.Foundation.TypedEventHandler<Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession, Windows.Media.SpeechRecognition.SpeechContinuousRecognitionResultGeneratedEventArgs> | null;
+  }
+  var ISpeechContinuousRecognitionSession: abstract new (...args: any[]) => ISpeechContinuousRecognitionSession;
+
+  interface ISpeechRecognitionCompilationResult {
+    readonly Status: number;
+  }
+  var ISpeechRecognitionCompilationResult: abstract new (...args: any[]) => ISpeechRecognitionCompilationResult;
+
+  interface ISpeechRecognitionConstraint {
+    IsEnabled: boolean;
+    Probability: number;
+    Tag: string;
+    readonly Type: number;
+  }
+  var ISpeechRecognitionConstraint: abstract new (...args: any[]) => ISpeechRecognitionConstraint;
+
+  interface ISpeechRecognitionGrammarFileConstraint extends Windows.Media.SpeechRecognition.ISpeechRecognitionConstraint {
+    readonly GrammarFile: Windows.Storage.StorageFile;
+  }
+  var ISpeechRecognitionGrammarFileConstraint: abstract new (...args: any[]) => ISpeechRecognitionGrammarFileConstraint;
+
+  interface ISpeechRecognitionGrammarFileConstraintFactory {
+    Create(file: Windows.Storage.StorageFile): Windows.Media.SpeechRecognition.SpeechRecognitionGrammarFileConstraint;
+    CreateWithTag(file: Windows.Storage.StorageFile, tag: string): Windows.Media.SpeechRecognition.SpeechRecognitionGrammarFileConstraint;
+  }
+  var ISpeechRecognitionGrammarFileConstraintFactory: abstract new (...args: any[]) => ISpeechRecognitionGrammarFileConstraintFactory;
+
+  interface ISpeechRecognitionHypothesis {
+    readonly Text: string;
+  }
+  var ISpeechRecognitionHypothesis: abstract new (...args: any[]) => ISpeechRecognitionHypothesis;
+
+  interface ISpeechRecognitionHypothesisGeneratedEventArgs {
+    readonly Hypothesis: Windows.Media.SpeechRecognition.SpeechRecognitionHypothesis;
+  }
+  var ISpeechRecognitionHypothesisGeneratedEventArgs: abstract new (...args: any[]) => ISpeechRecognitionHypothesisGeneratedEventArgs;
+
+  interface ISpeechRecognitionListConstraint extends Windows.Media.SpeechRecognition.ISpeechRecognitionConstraint {
+    readonly Commands: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var ISpeechRecognitionListConstraint: abstract new (...args: any[]) => ISpeechRecognitionListConstraint;
+
+  interface ISpeechRecognitionListConstraintFactory {
+    Create(commands: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Media.SpeechRecognition.SpeechRecognitionListConstraint;
+    CreateWithTag(commands: Windows.Foundation.Collections.IIterable<string> | string[], tag: string): Windows.Media.SpeechRecognition.SpeechRecognitionListConstraint;
+  }
+  var ISpeechRecognitionListConstraintFactory: abstract new (...args: any[]) => ISpeechRecognitionListConstraintFactory;
+
+  interface ISpeechRecognitionQualityDegradingEventArgs {
+    readonly Problem: number;
+  }
+  var ISpeechRecognitionQualityDegradingEventArgs: abstract new (...args: any[]) => ISpeechRecognitionQualityDegradingEventArgs;
+
+  interface ISpeechRecognitionResult {
+    GetAlternates(maxAlternates: number): Windows.Foundation.Collections.IVectorView<Windows.Media.SpeechRecognition.SpeechRecognitionResult> | Windows.Media.SpeechRecognition.SpeechRecognitionResult[];
+    readonly Confidence: number;
+    readonly Constraint: Windows.Media.SpeechRecognition.ISpeechRecognitionConstraint;
+    readonly RawConfidence: number;
+    readonly RulePath: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly SemanticInterpretation: Windows.Media.SpeechRecognition.SpeechRecognitionSemanticInterpretation;
+    readonly Status: number;
+    readonly Text: string;
+  }
+  var ISpeechRecognitionResult: abstract new (...args: any[]) => ISpeechRecognitionResult;
+
+  interface ISpeechRecognitionResult2 {
+    readonly PhraseDuration: Windows.Foundation.TimeSpan;
+    readonly PhraseStartTime: Windows.Foundation.DateTime;
+  }
+  var ISpeechRecognitionResult2: abstract new (...args: any[]) => ISpeechRecognitionResult2;
+
+  interface ISpeechRecognitionSemanticInterpretation {
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Windows.Foundation.Collections.IVectorView<string> | string[]>;
+  }
+  var ISpeechRecognitionSemanticInterpretation: abstract new (...args: any[]) => ISpeechRecognitionSemanticInterpretation;
+
+  interface ISpeechRecognitionTopicConstraint extends Windows.Media.SpeechRecognition.ISpeechRecognitionConstraint {
+    readonly Scenario: number;
+    readonly TopicHint: string;
+  }
+  var ISpeechRecognitionTopicConstraint: abstract new (...args: any[]) => ISpeechRecognitionTopicConstraint;
+
+  interface ISpeechRecognitionTopicConstraintFactory {
+    Create(scenario: number, topicHint: string): Windows.Media.SpeechRecognition.SpeechRecognitionTopicConstraint;
+    CreateWithTag(scenario: number, topicHint: string, tag: string): Windows.Media.SpeechRecognition.SpeechRecognitionTopicConstraint;
+  }
+  var ISpeechRecognitionTopicConstraintFactory: abstract new (...args: any[]) => ISpeechRecognitionTopicConstraintFactory;
+
+  interface ISpeechRecognitionVoiceCommandDefinitionConstraint extends Windows.Media.SpeechRecognition.ISpeechRecognitionConstraint {
+  }
+  var ISpeechRecognitionVoiceCommandDefinitionConstraint: abstract new (...args: any[]) => ISpeechRecognitionVoiceCommandDefinitionConstraint;
+
+  interface ISpeechRecognizer extends Windows.Foundation.IClosable {
+    Close(): void;
+    CompileConstraintsAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.SpeechRecognition.SpeechRecognitionCompilationResult>;
+    RecognizeAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.SpeechRecognition.SpeechRecognitionResult>;
+    RecognizeWithUIAsync(): Windows.Foundation.IAsyncOperation<Windows.Media.SpeechRecognition.SpeechRecognitionResult>;
+    readonly Constraints: Windows.Foundation.Collections.IVector<Windows.Media.SpeechRecognition.ISpeechRecognitionConstraint> | Windows.Media.SpeechRecognition.ISpeechRecognitionConstraint[];
+    readonly CurrentLanguage: Windows.Globalization.Language;
+    readonly Timeouts: Windows.Media.SpeechRecognition.SpeechRecognizerTimeouts;
+    readonly UIOptions: Windows.Media.SpeechRecognition.SpeechRecognizerUIOptions;
+    RecognitionQualityDegrading: Windows.Foundation.TypedEventHandler<Windows.Media.SpeechRecognition.SpeechRecognizer, Windows.Media.SpeechRecognition.SpeechRecognitionQualityDegradingEventArgs> | null;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.SpeechRecognition.SpeechRecognizer, Windows.Media.SpeechRecognition.SpeechRecognizerStateChangedEventArgs> | null;
+  }
+  var ISpeechRecognizer: abstract new (...args: any[]) => ISpeechRecognizer;
+
+  interface ISpeechRecognizer2 {
+    StopRecognitionAsync(): Windows.Foundation.IAsyncAction;
+    readonly ContinuousRecognitionSession: Windows.Media.SpeechRecognition.SpeechContinuousRecognitionSession;
+    readonly State: number;
+    HypothesisGenerated: Windows.Foundation.TypedEventHandler<Windows.Media.SpeechRecognition.SpeechRecognizer, Windows.Media.SpeechRecognition.SpeechRecognitionHypothesisGeneratedEventArgs> | null;
+  }
+  var ISpeechRecognizer2: abstract new (...args: any[]) => ISpeechRecognizer2;
+
+  interface ISpeechRecognizerFactory {
+    Create(language: Windows.Globalization.Language): Windows.Media.SpeechRecognition.SpeechRecognizer;
+  }
+  var ISpeechRecognizerFactory: abstract new (...args: any[]) => ISpeechRecognizerFactory;
+
+  interface ISpeechRecognizerStateChangedEventArgs {
+    readonly State: number;
+  }
+  var ISpeechRecognizerStateChangedEventArgs: abstract new (...args: any[]) => ISpeechRecognizerStateChangedEventArgs;
+
+  interface ISpeechRecognizerStatics {
+    readonly SupportedGrammarLanguages: Windows.Foundation.Collections.IVectorView<Windows.Globalization.Language> | Windows.Globalization.Language[];
+    readonly SupportedTopicLanguages: Windows.Foundation.Collections.IVectorView<Windows.Globalization.Language> | Windows.Globalization.Language[];
+    readonly SystemSpeechLanguage: Windows.Globalization.Language;
+  }
+  var ISpeechRecognizerStatics: abstract new (...args: any[]) => ISpeechRecognizerStatics;
+
+  interface ISpeechRecognizerStatics2 {
+    TrySetSystemSpeechLanguageAsync(speechLanguage: Windows.Globalization.Language): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var ISpeechRecognizerStatics2: abstract new (...args: any[]) => ISpeechRecognizerStatics2;
+
+  interface ISpeechRecognizerTimeouts {
+    BabbleTimeout: Windows.Foundation.TimeSpan;
+    EndSilenceTimeout: Windows.Foundation.TimeSpan;
+    InitialSilenceTimeout: Windows.Foundation.TimeSpan;
+  }
+  var ISpeechRecognizerTimeouts: abstract new (...args: any[]) => ISpeechRecognizerTimeouts;
+
+  interface ISpeechRecognizerUIOptions {
+    AudiblePrompt: string;
+    ExampleText: string;
+    IsReadBackEnabled: boolean;
+    ShowConfirmation: boolean;
+  }
+  var ISpeechRecognizerUIOptions: abstract new (...args: any[]) => ISpeechRecognizerUIOptions;
+
+}
+
+declare namespace Windows.Media.SpeechSynthesis {
+  class SpeechSynthesisStream implements Windows.Foundation.IClosable, Windows.Media.Core.ITimedMetadataTrackProvider, Windows.Media.SpeechSynthesis.ISpeechSynthesisStream, Windows.Storage.Streams.IContentTypeProvider, Windows.Storage.Streams.IInputStream, Windows.Storage.Streams.IOutputStream, Windows.Storage.Streams.IRandomAccessStream, Windows.Storage.Streams.IRandomAccessStreamWithContentType {
+    CloneStream(): Windows.Storage.Streams.IRandomAccessStream;
+    Close(): void;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    GetInputStreamAt(position: number | bigint): Windows.Storage.Streams.IInputStream;
+    GetOutputStreamAt(position: number | bigint): Windows.Storage.Streams.IOutputStream;
+    ReadAsync(buffer: Windows.Storage.Streams.IBuffer, count: number, options: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number>;
+    Seek(position: number | bigint): void;
+    WriteAsync(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    readonly CanRead: boolean;
+    readonly CanWrite: boolean;
+    readonly ContentType: string;
+    readonly Markers: Windows.Foundation.Collections.IVectorView<Windows.Media.IMediaMarker> | Windows.Media.IMediaMarker[];
+    readonly Position: number | bigint;
+    Size: number | bigint;
+    readonly TimedMetadataTracks: Windows.Foundation.Collections.IVectorView<Windows.Media.Core.TimedMetadataTrack> | Windows.Media.Core.TimedMetadataTrack[];
+  }
+
+  class SpeechSynthesizer implements Windows.Foundation.IClosable, Windows.Media.SpeechSynthesis.ISpeechSynthesizer, Windows.Media.SpeechSynthesis.ISpeechSynthesizer2 {
+    constructor();
+    Close(): void;
+    SynthesizeSsmlToStreamAsync(Ssml: string): Windows.Foundation.IAsyncOperation<Windows.Media.SpeechSynthesis.SpeechSynthesisStream>;
+    SynthesizeTextToStreamAsync(text: string): Windows.Foundation.IAsyncOperation<Windows.Media.SpeechSynthesis.SpeechSynthesisStream>;
+    static TrySetDefaultVoiceAsync(voice: Windows.Media.SpeechSynthesis.VoiceInformation): Windows.Foundation.IAsyncOperation<boolean>;
+    static readonly AllVoices: Windows.Foundation.Collections.IVectorView<Windows.Media.SpeechSynthesis.VoiceInformation> | Windows.Media.SpeechSynthesis.VoiceInformation[];
+    static readonly DefaultVoice: Windows.Media.SpeechSynthesis.VoiceInformation;
+    readonly Options: Windows.Media.SpeechSynthesis.SpeechSynthesizerOptions;
+    Voice: Windows.Media.SpeechSynthesis.VoiceInformation;
+  }
+
+  class SpeechSynthesizerOptions implements Windows.Media.SpeechSynthesis.ISpeechSynthesizerOptions, Windows.Media.SpeechSynthesis.ISpeechSynthesizerOptions2, Windows.Media.SpeechSynthesis.ISpeechSynthesizerOptions3 {
+    AppendedSilence: number;
+    AudioPitch: number;
+    AudioVolume: number;
+    IncludeSentenceBoundaryMetadata: boolean;
+    IncludeWordBoundaryMetadata: boolean;
+    PunctuationSilence: number;
+    SpeakingRate: number;
+  }
+
+  class VoiceInformation implements Windows.Media.SpeechSynthesis.IVoiceInformation {
+    readonly Description: string;
+    readonly DisplayName: string;
+    readonly Gender: number;
+    readonly Id: string;
+    readonly Language: string;
+  }
+
+  enum SpeechAppendedSilence {
+    Default = 0,
+    Min = 1,
+  }
+
+  enum SpeechPunctuationSilence {
+    Default = 0,
+    Min = 1,
+  }
+
+  enum VoiceGender {
+    Male = 0,
+    Female = 1,
+  }
+
+  interface IInstalledVoicesStatic {
+    readonly AllVoices: Windows.Foundation.Collections.IVectorView<Windows.Media.SpeechSynthesis.VoiceInformation> | Windows.Media.SpeechSynthesis.VoiceInformation[];
+    readonly DefaultVoice: Windows.Media.SpeechSynthesis.VoiceInformation;
+  }
+  var IInstalledVoicesStatic: abstract new (...args: any[]) => IInstalledVoicesStatic;
+
+  interface IInstalledVoicesStatic2 {
+    TrySetDefaultVoiceAsync(voice: Windows.Media.SpeechSynthesis.VoiceInformation): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IInstalledVoicesStatic2: abstract new (...args: any[]) => IInstalledVoicesStatic2;
+
+  interface ISpeechSynthesisStream extends Windows.Foundation.IClosable, Windows.Storage.Streams.IContentTypeProvider, Windows.Storage.Streams.IInputStream, Windows.Storage.Streams.IOutputStream, Windows.Storage.Streams.IRandomAccessStream, Windows.Storage.Streams.IRandomAccessStreamWithContentType {
+    CloneStream(): Windows.Storage.Streams.IRandomAccessStream;
+    Close(): void;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    GetInputStreamAt(position: number | bigint): Windows.Storage.Streams.IInputStream;
+    GetOutputStreamAt(position: number | bigint): Windows.Storage.Streams.IOutputStream;
+    ReadAsync(buffer: Windows.Storage.Streams.IBuffer, count: number, options: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number>;
+    Seek(position: number | bigint): void;
+    WriteAsync(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    readonly Markers: Windows.Foundation.Collections.IVectorView<Windows.Media.IMediaMarker> | Windows.Media.IMediaMarker[];
+  }
+  var ISpeechSynthesisStream: abstract new (...args: any[]) => ISpeechSynthesisStream;
+
+  interface ISpeechSynthesizer {
+    SynthesizeSsmlToStreamAsync(Ssml: string): Windows.Foundation.IAsyncOperation<Windows.Media.SpeechSynthesis.SpeechSynthesisStream>;
+    SynthesizeTextToStreamAsync(text: string): Windows.Foundation.IAsyncOperation<Windows.Media.SpeechSynthesis.SpeechSynthesisStream>;
+    Voice: Windows.Media.SpeechSynthesis.VoiceInformation;
+  }
+  var ISpeechSynthesizer: abstract new (...args: any[]) => ISpeechSynthesizer;
+
+  interface ISpeechSynthesizer2 {
+    readonly Options: Windows.Media.SpeechSynthesis.SpeechSynthesizerOptions;
+  }
+  var ISpeechSynthesizer2: abstract new (...args: any[]) => ISpeechSynthesizer2;
+
+  interface ISpeechSynthesizerOptions {
+    IncludeSentenceBoundaryMetadata: boolean;
+    IncludeWordBoundaryMetadata: boolean;
+  }
+  var ISpeechSynthesizerOptions: abstract new (...args: any[]) => ISpeechSynthesizerOptions;
+
+  interface ISpeechSynthesizerOptions2 {
+    AudioPitch: number;
+    AudioVolume: number;
+    SpeakingRate: number;
+  }
+  var ISpeechSynthesizerOptions2: abstract new (...args: any[]) => ISpeechSynthesizerOptions2;
+
+  interface ISpeechSynthesizerOptions3 {
+    AppendedSilence: number;
+    PunctuationSilence: number;
+  }
+  var ISpeechSynthesizerOptions3: abstract new (...args: any[]) => ISpeechSynthesizerOptions3;
+
+  interface IVoiceInformation {
+    readonly Description: string;
+    readonly DisplayName: string;
+    readonly Gender: number;
+    readonly Id: string;
+    readonly Language: string;
+  }
+  var IVoiceInformation: abstract new (...args: any[]) => IVoiceInformation;
+
+}
+
+declare namespace Windows.Media.Streaming.Adaptive {
+  class AdaptiveMediaSource implements Windows.Foundation.IClosable, Windows.Media.Core.IMediaSource, Windows.Media.Streaming.Adaptive.IAdaptiveMediaSource, Windows.Media.Streaming.Adaptive.IAdaptiveMediaSource2, Windows.Media.Streaming.Adaptive.IAdaptiveMediaSource3 {
+    Close(): void;
+    static CreateFromStreamAsync(stream: Windows.Storage.Streams.IInputStream, uri: Windows.Foundation.Uri, contentType: string): Windows.Foundation.IAsyncOperation<Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceCreationResult>;
+    static CreateFromStreamAsync(stream: Windows.Storage.Streams.IInputStream, uri: Windows.Foundation.Uri, contentType: string, httpClient: Windows.Web.Http.HttpClient): Windows.Foundation.IAsyncOperation<Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceCreationResult>;
+    static CreateFromUriAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceCreationResult>;
+    static CreateFromUriAsync(uri: Windows.Foundation.Uri, httpClient: Windows.Web.Http.HttpClient): Windows.Foundation.IAsyncOperation<Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceCreationResult>;
+    GetCorrelatedTimes(): Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceCorrelatedTimes;
+    static IsContentTypeSupported(contentType: string): boolean;
+    readonly AdvancedSettings: Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceAdvancedSettings;
+    readonly AudioOnlyPlayback: boolean;
+    readonly AvailableBitrates: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly CurrentDownloadBitrate: number;
+    readonly CurrentPlaybackBitrate: number;
+    DesiredLiveOffset: Windows.Foundation.TimeSpan;
+    DesiredMaxBitrate: number | null;
+    DesiredMinBitrate: number | null;
+    DesiredSeekableWindowSize: Windows.Foundation.TimeSpan | null;
+    readonly Diagnostics: Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics;
+    readonly InboundBitsPerSecond: number | bigint;
+    InboundBitsPerSecondWindow: Windows.Foundation.TimeSpan;
+    InitialBitrate: number;
+    readonly IsLive: boolean;
+    readonly MaxSeekableWindowSize: Windows.Foundation.TimeSpan | null;
+    readonly MinLiveOffset: Windows.Foundation.TimeSpan | null;
+    DownloadBitrateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Streaming.Adaptive.AdaptiveMediaSource, Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadBitrateChangedEventArgs> | null;
+    DownloadCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Streaming.Adaptive.AdaptiveMediaSource, Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadCompletedEventArgs> | null;
+    DownloadFailed: Windows.Foundation.TypedEventHandler<Windows.Media.Streaming.Adaptive.AdaptiveMediaSource, Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadFailedEventArgs> | null;
+    DownloadRequested: Windows.Foundation.TypedEventHandler<Windows.Media.Streaming.Adaptive.AdaptiveMediaSource, Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedEventArgs> | null;
+    PlaybackBitrateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Streaming.Adaptive.AdaptiveMediaSource, Windows.Media.Streaming.Adaptive.AdaptiveMediaSourcePlaybackBitrateChangedEventArgs> | null;
+  }
+
+  class AdaptiveMediaSourceAdvancedSettings implements Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceAdvancedSettings {
+    AllSegmentsIndependent: boolean;
+    BitrateDowngradeTriggerRatio: number | null;
+    DesiredBitrateHeadroomRatio: number | null;
+  }
+
+  class AdaptiveMediaSourceCorrelatedTimes implements Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceCorrelatedTimes {
+    readonly Position: Windows.Foundation.TimeSpan | null;
+    readonly PresentationTimeStamp: Windows.Foundation.TimeSpan | null;
+    readonly ProgramDateTime: Windows.Foundation.DateTime | null;
+  }
+
+  class AdaptiveMediaSourceCreationResult implements Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceCreationResult, Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceCreationResult2 {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly HttpResponseMessage: Windows.Web.Http.HttpResponseMessage;
+    readonly MediaSource: Windows.Media.Streaming.Adaptive.AdaptiveMediaSource;
+    readonly Status: number;
+  }
+
+  class AdaptiveMediaSourceDiagnosticAvailableEventArgs implements Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceDiagnosticAvailableEventArgs, Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceDiagnosticAvailableEventArgs2, Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceDiagnosticAvailableEventArgs3 {
+    readonly Bitrate: number | null;
+    readonly DiagnosticType: number;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Position: Windows.Foundation.TimeSpan | null;
+    readonly RequestId: number | null;
+    readonly ResourceByteRangeLength: number | bigint | null;
+    readonly ResourceByteRangeOffset: number | bigint | null;
+    readonly ResourceContentType: string;
+    readonly ResourceDuration: Windows.Foundation.TimeSpan | null;
+    readonly ResourceType: number | null;
+    readonly ResourceUri: Windows.Foundation.Uri;
+    readonly SegmentId: number | bigint | null;
+  }
+
+  class AdaptiveMediaSourceDiagnostics implements Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceDiagnostics {
+    DiagnosticAvailable: Windows.Foundation.TypedEventHandler<Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics, Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnosticAvailableEventArgs> | null;
+  }
+
+  class AdaptiveMediaSourceDownloadBitrateChangedEventArgs implements Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceDownloadBitrateChangedEventArgs, Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceDownloadBitrateChangedEventArgs2 {
+    readonly NewValue: number;
+    readonly OldValue: number;
+    readonly Reason: number;
+  }
+
+  class AdaptiveMediaSourceDownloadCompletedEventArgs implements Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceDownloadCompletedEventArgs, Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceDownloadCompletedEventArgs2, Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceDownloadCompletedEventArgs3 {
+    readonly HttpResponseMessage: Windows.Web.Http.HttpResponseMessage;
+    readonly Position: Windows.Foundation.TimeSpan | null;
+    readonly RequestId: number;
+    readonly ResourceByteRangeLength: number | bigint | null;
+    readonly ResourceByteRangeOffset: number | bigint | null;
+    readonly ResourceContentType: string;
+    readonly ResourceDuration: Windows.Foundation.TimeSpan | null;
+    readonly ResourceType: number;
+    readonly ResourceUri: Windows.Foundation.Uri;
+    readonly Statistics: Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadStatistics;
+  }
+
+  class AdaptiveMediaSourceDownloadFailedEventArgs implements Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceDownloadFailedEventArgs, Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceDownloadFailedEventArgs2, Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceDownloadFailedEventArgs3 {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly HttpResponseMessage: Windows.Web.Http.HttpResponseMessage;
+    readonly Position: Windows.Foundation.TimeSpan | null;
+    readonly RequestId: number;
+    readonly ResourceByteRangeLength: number | bigint | null;
+    readonly ResourceByteRangeOffset: number | bigint | null;
+    readonly ResourceContentType: string;
+    readonly ResourceDuration: Windows.Foundation.TimeSpan | null;
+    readonly ResourceType: number;
+    readonly ResourceUri: Windows.Foundation.Uri;
+    readonly Statistics: Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadStatistics;
+  }
+
+  class AdaptiveMediaSourceDownloadRequestedDeferral implements Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceDownloadRequestedDeferral {
+    Complete(): void;
+  }
+
+  class AdaptiveMediaSourceDownloadRequestedEventArgs implements Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceDownloadRequestedEventArgs, Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceDownloadRequestedEventArgs2, Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceDownloadRequestedEventArgs3 {
+    GetDeferral(): Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedDeferral;
+    readonly Position: Windows.Foundation.TimeSpan | null;
+    readonly RequestId: number;
+    readonly ResourceByteRangeLength: number | bigint | null;
+    readonly ResourceByteRangeOffset: number | bigint | null;
+    readonly ResourceContentType: string;
+    readonly ResourceDuration: Windows.Foundation.TimeSpan | null;
+    readonly ResourceType: number;
+    readonly ResourceUri: Windows.Foundation.Uri;
+    readonly Result: Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadResult;
+  }
+
+  class AdaptiveMediaSourceDownloadResult implements Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceDownloadResult, Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceDownloadResult2 {
+    Buffer: Windows.Storage.Streams.IBuffer;
+    ContentType: string;
+    ExtendedStatus: number;
+    InputStream: Windows.Storage.Streams.IInputStream;
+    ResourceByteRangeLength: number | bigint | null;
+    ResourceByteRangeOffset: number | bigint | null;
+    ResourceUri: Windows.Foundation.Uri;
+  }
+
+  class AdaptiveMediaSourceDownloadStatistics implements Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourceDownloadStatistics {
+    readonly ContentBytesReceivedCount: number | bigint;
+    readonly TimeToFirstByteReceived: Windows.Foundation.TimeSpan | null;
+    readonly TimeToHeadersReceived: Windows.Foundation.TimeSpan | null;
+    readonly TimeToLastByteReceived: Windows.Foundation.TimeSpan | null;
+  }
+
+  class AdaptiveMediaSourcePlaybackBitrateChangedEventArgs implements Windows.Media.Streaming.Adaptive.IAdaptiveMediaSourcePlaybackBitrateChangedEventArgs {
+    readonly AudioOnly: boolean;
+    readonly NewValue: number;
+    readonly OldValue: number;
+  }
+
+  enum AdaptiveMediaSourceCreationStatus {
+    Success = 0,
+    ManifestDownloadFailure = 1,
+    ManifestParseFailure = 2,
+    UnsupportedManifestContentType = 3,
+    UnsupportedManifestVersion = 4,
+    UnsupportedManifestProfile = 5,
+    UnknownFailure = 6,
+  }
+
+  enum AdaptiveMediaSourceDiagnosticType {
+    ManifestUnchangedUponReload = 0,
+    ManifestMismatchUponReload = 1,
+    ManifestSignaledEndOfLiveEventUponReload = 2,
+    MediaSegmentSkipped = 3,
+    ResourceNotFound = 4,
+    ResourceTimedOut = 5,
+    ResourceParsingError = 6,
+    BitrateDisabled = 7,
+    FatalMediaSourceError = 8,
+  }
+
+  enum AdaptiveMediaSourceDownloadBitrateChangedReason {
+    SufficientInboundBitsPerSecond = 0,
+    InsufficientInboundBitsPerSecond = 1,
+    LowBufferLevel = 2,
+    PositionChanged = 3,
+    TrackSelectionChanged = 4,
+    DesiredBitratesChanged = 5,
+    ErrorInPreviousBitrate = 6,
+  }
+
+  enum AdaptiveMediaSourceResourceType {
+    Manifest = 0,
+    InitializationSegment = 1,
+    MediaSegment = 2,
+    Key = 3,
+    InitializationVector = 4,
+    MediaSegmentIndex = 5,
+  }
+
+  interface IAdaptiveMediaSource extends Windows.Media.Core.IMediaSource {
+    readonly AudioOnlyPlayback: boolean;
+    readonly AvailableBitrates: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly CurrentDownloadBitrate: number;
+    readonly CurrentPlaybackBitrate: number;
+    DesiredLiveOffset: Windows.Foundation.TimeSpan;
+    DesiredMaxBitrate: number | null;
+    DesiredMinBitrate: number | null;
+    readonly InboundBitsPerSecond: number | bigint;
+    InboundBitsPerSecondWindow: Windows.Foundation.TimeSpan;
+    InitialBitrate: number;
+    readonly IsLive: boolean;
+    DownloadBitrateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Streaming.Adaptive.AdaptiveMediaSource, Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadBitrateChangedEventArgs> | null;
+    DownloadCompleted: Windows.Foundation.TypedEventHandler<Windows.Media.Streaming.Adaptive.AdaptiveMediaSource, Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadCompletedEventArgs> | null;
+    DownloadFailed: Windows.Foundation.TypedEventHandler<Windows.Media.Streaming.Adaptive.AdaptiveMediaSource, Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadFailedEventArgs> | null;
+    DownloadRequested: Windows.Foundation.TypedEventHandler<Windows.Media.Streaming.Adaptive.AdaptiveMediaSource, Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedEventArgs> | null;
+    PlaybackBitrateChanged: Windows.Foundation.TypedEventHandler<Windows.Media.Streaming.Adaptive.AdaptiveMediaSource, Windows.Media.Streaming.Adaptive.AdaptiveMediaSourcePlaybackBitrateChangedEventArgs> | null;
+  }
+  var IAdaptiveMediaSource: abstract new (...args: any[]) => IAdaptiveMediaSource;
+
+  interface IAdaptiveMediaSource2 {
+    readonly AdvancedSettings: Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceAdvancedSettings;
+  }
+  var IAdaptiveMediaSource2: abstract new (...args: any[]) => IAdaptiveMediaSource2;
+
+  interface IAdaptiveMediaSource3 {
+    GetCorrelatedTimes(): Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceCorrelatedTimes;
+    DesiredSeekableWindowSize: Windows.Foundation.TimeSpan | null;
+    readonly Diagnostics: Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics;
+    readonly MaxSeekableWindowSize: Windows.Foundation.TimeSpan | null;
+    readonly MinLiveOffset: Windows.Foundation.TimeSpan | null;
+  }
+  var IAdaptiveMediaSource3: abstract new (...args: any[]) => IAdaptiveMediaSource3;
+
+  interface IAdaptiveMediaSourceAdvancedSettings {
+    AllSegmentsIndependent: boolean;
+    BitrateDowngradeTriggerRatio: number | null;
+    DesiredBitrateHeadroomRatio: number | null;
+  }
+  var IAdaptiveMediaSourceAdvancedSettings: abstract new (...args: any[]) => IAdaptiveMediaSourceAdvancedSettings;
+
+  interface IAdaptiveMediaSourceCorrelatedTimes {
+    readonly Position: Windows.Foundation.TimeSpan | null;
+    readonly PresentationTimeStamp: Windows.Foundation.TimeSpan | null;
+    readonly ProgramDateTime: Windows.Foundation.DateTime | null;
+  }
+  var IAdaptiveMediaSourceCorrelatedTimes: abstract new (...args: any[]) => IAdaptiveMediaSourceCorrelatedTimes;
+
+  interface IAdaptiveMediaSourceCreationResult {
+    readonly HttpResponseMessage: Windows.Web.Http.HttpResponseMessage;
+    readonly MediaSource: Windows.Media.Streaming.Adaptive.AdaptiveMediaSource;
+    readonly Status: number;
+  }
+  var IAdaptiveMediaSourceCreationResult: abstract new (...args: any[]) => IAdaptiveMediaSourceCreationResult;
+
+  interface IAdaptiveMediaSourceCreationResult2 {
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+  var IAdaptiveMediaSourceCreationResult2: abstract new (...args: any[]) => IAdaptiveMediaSourceCreationResult2;
+
+  interface IAdaptiveMediaSourceDiagnosticAvailableEventArgs {
+    readonly Bitrate: number | null;
+    readonly DiagnosticType: number;
+    readonly Position: Windows.Foundation.TimeSpan | null;
+    readonly RequestId: number | null;
+    readonly ResourceByteRangeLength: number | bigint | null;
+    readonly ResourceByteRangeOffset: number | bigint | null;
+    readonly ResourceType: number | null;
+    readonly ResourceUri: Windows.Foundation.Uri;
+    readonly SegmentId: number | bigint | null;
+  }
+  var IAdaptiveMediaSourceDiagnosticAvailableEventArgs: abstract new (...args: any[]) => IAdaptiveMediaSourceDiagnosticAvailableEventArgs;
+
+  interface IAdaptiveMediaSourceDiagnosticAvailableEventArgs2 {
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+  var IAdaptiveMediaSourceDiagnosticAvailableEventArgs2: abstract new (...args: any[]) => IAdaptiveMediaSourceDiagnosticAvailableEventArgs2;
+
+  interface IAdaptiveMediaSourceDiagnosticAvailableEventArgs3 {
+    readonly ResourceContentType: string;
+    readonly ResourceDuration: Windows.Foundation.TimeSpan | null;
+  }
+  var IAdaptiveMediaSourceDiagnosticAvailableEventArgs3: abstract new (...args: any[]) => IAdaptiveMediaSourceDiagnosticAvailableEventArgs3;
+
+  interface IAdaptiveMediaSourceDiagnostics {
+    DiagnosticAvailable: Windows.Foundation.TypedEventHandler<Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnostics, Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDiagnosticAvailableEventArgs> | null;
+  }
+  var IAdaptiveMediaSourceDiagnostics: abstract new (...args: any[]) => IAdaptiveMediaSourceDiagnostics;
+
+  interface IAdaptiveMediaSourceDownloadBitrateChangedEventArgs {
+    readonly NewValue: number;
+    readonly OldValue: number;
+  }
+  var IAdaptiveMediaSourceDownloadBitrateChangedEventArgs: abstract new (...args: any[]) => IAdaptiveMediaSourceDownloadBitrateChangedEventArgs;
+
+  interface IAdaptiveMediaSourceDownloadBitrateChangedEventArgs2 {
+    readonly Reason: number;
+  }
+  var IAdaptiveMediaSourceDownloadBitrateChangedEventArgs2: abstract new (...args: any[]) => IAdaptiveMediaSourceDownloadBitrateChangedEventArgs2;
+
+  interface IAdaptiveMediaSourceDownloadCompletedEventArgs {
+    readonly HttpResponseMessage: Windows.Web.Http.HttpResponseMessage;
+    readonly ResourceByteRangeLength: number | bigint | null;
+    readonly ResourceByteRangeOffset: number | bigint | null;
+    readonly ResourceType: number;
+    readonly ResourceUri: Windows.Foundation.Uri;
+  }
+  var IAdaptiveMediaSourceDownloadCompletedEventArgs: abstract new (...args: any[]) => IAdaptiveMediaSourceDownloadCompletedEventArgs;
+
+  interface IAdaptiveMediaSourceDownloadCompletedEventArgs2 {
+    readonly Position: Windows.Foundation.TimeSpan | null;
+    readonly RequestId: number;
+    readonly Statistics: Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadStatistics;
+  }
+  var IAdaptiveMediaSourceDownloadCompletedEventArgs2: abstract new (...args: any[]) => IAdaptiveMediaSourceDownloadCompletedEventArgs2;
+
+  interface IAdaptiveMediaSourceDownloadCompletedEventArgs3 {
+    readonly ResourceContentType: string;
+    readonly ResourceDuration: Windows.Foundation.TimeSpan | null;
+  }
+  var IAdaptiveMediaSourceDownloadCompletedEventArgs3: abstract new (...args: any[]) => IAdaptiveMediaSourceDownloadCompletedEventArgs3;
+
+  interface IAdaptiveMediaSourceDownloadFailedEventArgs {
+    readonly HttpResponseMessage: Windows.Web.Http.HttpResponseMessage;
+    readonly ResourceByteRangeLength: number | bigint | null;
+    readonly ResourceByteRangeOffset: number | bigint | null;
+    readonly ResourceType: number;
+    readonly ResourceUri: Windows.Foundation.Uri;
+  }
+  var IAdaptiveMediaSourceDownloadFailedEventArgs: abstract new (...args: any[]) => IAdaptiveMediaSourceDownloadFailedEventArgs;
+
+  interface IAdaptiveMediaSourceDownloadFailedEventArgs2 {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Position: Windows.Foundation.TimeSpan | null;
+    readonly RequestId: number;
+    readonly Statistics: Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadStatistics;
+  }
+  var IAdaptiveMediaSourceDownloadFailedEventArgs2: abstract new (...args: any[]) => IAdaptiveMediaSourceDownloadFailedEventArgs2;
+
+  interface IAdaptiveMediaSourceDownloadFailedEventArgs3 {
+    readonly ResourceContentType: string;
+    readonly ResourceDuration: Windows.Foundation.TimeSpan | null;
+  }
+  var IAdaptiveMediaSourceDownloadFailedEventArgs3: abstract new (...args: any[]) => IAdaptiveMediaSourceDownloadFailedEventArgs3;
+
+  interface IAdaptiveMediaSourceDownloadRequestedDeferral {
+    Complete(): void;
+  }
+  var IAdaptiveMediaSourceDownloadRequestedDeferral: abstract new (...args: any[]) => IAdaptiveMediaSourceDownloadRequestedDeferral;
+
+  interface IAdaptiveMediaSourceDownloadRequestedEventArgs {
+    GetDeferral(): Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadRequestedDeferral;
+    readonly ResourceByteRangeLength: number | bigint | null;
+    readonly ResourceByteRangeOffset: number | bigint | null;
+    readonly ResourceType: number;
+    readonly ResourceUri: Windows.Foundation.Uri;
+    readonly Result: Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceDownloadResult;
+  }
+  var IAdaptiveMediaSourceDownloadRequestedEventArgs: abstract new (...args: any[]) => IAdaptiveMediaSourceDownloadRequestedEventArgs;
+
+  interface IAdaptiveMediaSourceDownloadRequestedEventArgs2 {
+    readonly Position: Windows.Foundation.TimeSpan | null;
+    readonly RequestId: number;
+  }
+  var IAdaptiveMediaSourceDownloadRequestedEventArgs2: abstract new (...args: any[]) => IAdaptiveMediaSourceDownloadRequestedEventArgs2;
+
+  interface IAdaptiveMediaSourceDownloadRequestedEventArgs3 {
+    readonly ResourceContentType: string;
+    readonly ResourceDuration: Windows.Foundation.TimeSpan | null;
+  }
+  var IAdaptiveMediaSourceDownloadRequestedEventArgs3: abstract new (...args: any[]) => IAdaptiveMediaSourceDownloadRequestedEventArgs3;
+
+  interface IAdaptiveMediaSourceDownloadResult {
+    Buffer: Windows.Storage.Streams.IBuffer;
+    ContentType: string;
+    ExtendedStatus: number;
+    InputStream: Windows.Storage.Streams.IInputStream;
+    ResourceUri: Windows.Foundation.Uri;
+  }
+  var IAdaptiveMediaSourceDownloadResult: abstract new (...args: any[]) => IAdaptiveMediaSourceDownloadResult;
+
+  interface IAdaptiveMediaSourceDownloadResult2 {
+    ResourceByteRangeLength: number | bigint | null;
+    ResourceByteRangeOffset: number | bigint | null;
+  }
+  var IAdaptiveMediaSourceDownloadResult2: abstract new (...args: any[]) => IAdaptiveMediaSourceDownloadResult2;
+
+  interface IAdaptiveMediaSourceDownloadStatistics {
+    readonly ContentBytesReceivedCount: number | bigint;
+    readonly TimeToFirstByteReceived: Windows.Foundation.TimeSpan | null;
+    readonly TimeToHeadersReceived: Windows.Foundation.TimeSpan | null;
+    readonly TimeToLastByteReceived: Windows.Foundation.TimeSpan | null;
+  }
+  var IAdaptiveMediaSourceDownloadStatistics: abstract new (...args: any[]) => IAdaptiveMediaSourceDownloadStatistics;
+
+  interface IAdaptiveMediaSourcePlaybackBitrateChangedEventArgs {
+    readonly AudioOnly: boolean;
+    readonly NewValue: number;
+    readonly OldValue: number;
+  }
+  var IAdaptiveMediaSourcePlaybackBitrateChangedEventArgs: abstract new (...args: any[]) => IAdaptiveMediaSourcePlaybackBitrateChangedEventArgs;
+
+  interface IAdaptiveMediaSourceStatics {
+    CreateFromStreamAsync(stream: Windows.Storage.Streams.IInputStream, uri: Windows.Foundation.Uri, contentType: string): Windows.Foundation.IAsyncOperation<Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceCreationResult>;
+    CreateFromStreamAsync(stream: Windows.Storage.Streams.IInputStream, uri: Windows.Foundation.Uri, contentType: string, httpClient: Windows.Web.Http.HttpClient): Windows.Foundation.IAsyncOperation<Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceCreationResult>;
+    CreateFromUriAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceCreationResult>;
+    CreateFromUriAsync(uri: Windows.Foundation.Uri, httpClient: Windows.Web.Http.HttpClient): Windows.Foundation.IAsyncOperation<Windows.Media.Streaming.Adaptive.AdaptiveMediaSourceCreationResult>;
+    IsContentTypeSupported(contentType: string): boolean;
+  }
+  var IAdaptiveMediaSourceStatics: abstract new (...args: any[]) => IAdaptiveMediaSourceStatics;
+
+}
+
+declare namespace Windows.Media.Transcoding {
+  class MediaTranscoder implements Windows.Media.Transcoding.IMediaTranscoder, Windows.Media.Transcoding.IMediaTranscoder2 {
+    constructor();
+    AddAudioEffect(activatableClassId: string): void;
+    AddAudioEffect(activatableClassId: string, effectRequired: boolean, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    AddVideoEffect(activatableClassId: string): void;
+    AddVideoEffect(activatableClassId: string, effectRequired: boolean, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    ClearEffects(): void;
+    PrepareFileTranscodeAsync(source: Windows.Storage.IStorageFile, destination: Windows.Storage.IStorageFile, profile: Windows.Media.MediaProperties.MediaEncodingProfile): Windows.Foundation.IAsyncOperation<Windows.Media.Transcoding.PrepareTranscodeResult>;
+    PrepareMediaStreamSourceTranscodeAsync(source: Windows.Media.Core.IMediaSource, destination: Windows.Storage.Streams.IRandomAccessStream, profile: Windows.Media.MediaProperties.MediaEncodingProfile): Windows.Foundation.IAsyncOperation<Windows.Media.Transcoding.PrepareTranscodeResult>;
+    PrepareStreamTranscodeAsync(source: Windows.Storage.Streams.IRandomAccessStream, destination: Windows.Storage.Streams.IRandomAccessStream, profile: Windows.Media.MediaProperties.MediaEncodingProfile): Windows.Foundation.IAsyncOperation<Windows.Media.Transcoding.PrepareTranscodeResult>;
+    AlwaysReencode: boolean;
+    HardwareAccelerationEnabled: boolean;
+    TrimStartTime: Windows.Foundation.TimeSpan;
+    TrimStopTime: Windows.Foundation.TimeSpan;
+    VideoProcessingAlgorithm: number;
+  }
+
+  class PrepareTranscodeResult implements Windows.Media.Transcoding.IPrepareTranscodeResult {
+    TranscodeAsync(): Windows.Foundation.IAsyncActionWithProgress<number>;
+    readonly CanTranscode: boolean;
+    readonly FailureReason: number;
+  }
+
+  enum MediaVideoProcessingAlgorithm {
+    Default = 0,
+    MrfCrf444 = 1,
+  }
+
+  enum TranscodeFailureReason {
+    None = 0,
+    Unknown = 1,
+    InvalidProfile = 2,
+    CodecNotFound = 3,
+  }
+
+  interface IMediaTranscoder {
+    AddAudioEffect(activatableClassId: string): void;
+    AddAudioEffect(activatableClassId: string, effectRequired: boolean, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    AddVideoEffect(activatableClassId: string): void;
+    AddVideoEffect(activatableClassId: string, effectRequired: boolean, configuration: Windows.Foundation.Collections.IPropertySet): void;
+    ClearEffects(): void;
+    PrepareFileTranscodeAsync(source: Windows.Storage.IStorageFile, destination: Windows.Storage.IStorageFile, profile: Windows.Media.MediaProperties.MediaEncodingProfile): Windows.Foundation.IAsyncOperation<Windows.Media.Transcoding.PrepareTranscodeResult>;
+    PrepareStreamTranscodeAsync(source: Windows.Storage.Streams.IRandomAccessStream, destination: Windows.Storage.Streams.IRandomAccessStream, profile: Windows.Media.MediaProperties.MediaEncodingProfile): Windows.Foundation.IAsyncOperation<Windows.Media.Transcoding.PrepareTranscodeResult>;
+    AlwaysReencode: boolean;
+    HardwareAccelerationEnabled: boolean;
+    TrimStartTime: Windows.Foundation.TimeSpan;
+    TrimStopTime: Windows.Foundation.TimeSpan;
+  }
+  var IMediaTranscoder: abstract new (...args: any[]) => IMediaTranscoder;
+
+  interface IMediaTranscoder2 {
+    PrepareMediaStreamSourceTranscodeAsync(source: Windows.Media.Core.IMediaSource, destination: Windows.Storage.Streams.IRandomAccessStream, profile: Windows.Media.MediaProperties.MediaEncodingProfile): Windows.Foundation.IAsyncOperation<Windows.Media.Transcoding.PrepareTranscodeResult>;
+    VideoProcessingAlgorithm: number;
+  }
+  var IMediaTranscoder2: abstract new (...args: any[]) => IMediaTranscoder2;
+
+  interface IPrepareTranscodeResult {
+    TranscodeAsync(): Windows.Foundation.IAsyncActionWithProgress<number>;
+    readonly CanTranscode: boolean;
+    readonly FailureReason: number;
+  }
+  var IPrepareTranscodeResult: abstract new (...args: any[]) => IPrepareTranscodeResult;
+
+}
+
+declare namespace Windows.Networking {
+  class EndpointPair implements Windows.Networking.IEndpointPair {
+    constructor(localHostName: Windows.Networking.HostName, localServiceName: string, remoteHostName: Windows.Networking.HostName, remoteServiceName: string);
+    LocalHostName: Windows.Networking.HostName;
+    LocalServiceName: string;
+    RemoteHostName: Windows.Networking.HostName;
+    RemoteServiceName: string;
+  }
+
+  class HostName implements Windows.Foundation.IStringable, Windows.Networking.IHostName {
+    constructor(hostName: string);
+    static Compare(value1: string, value2: string): number;
+    IsEqual(hostName: Windows.Networking.HostName): boolean;
+    ToString(): string;
+    readonly CanonicalName: string;
+    readonly DisplayName: string;
+    readonly IPInformation: Windows.Networking.Connectivity.IPInformation;
+    readonly RawName: string;
+    readonly Type: number;
+  }
+
+  enum DomainNameType {
+    Suffix = 0,
+    FullyQualified = 1,
+  }
+
+  enum HostNameSortOptions {
+    None = 0,
+    OptimizeForLongConnections = 2,
+  }
+
+  enum HostNameType {
+    DomainName = 0,
+    Ipv4 = 1,
+    Ipv6 = 2,
+    Bluetooth = 3,
+  }
+
+  interface IEndpointPair {
+    LocalHostName: Windows.Networking.HostName;
+    LocalServiceName: string;
+    RemoteHostName: Windows.Networking.HostName;
+    RemoteServiceName: string;
+  }
+  var IEndpointPair: abstract new (...args: any[]) => IEndpointPair;
+
+  interface IEndpointPairFactory {
+    CreateEndpointPair(localHostName: Windows.Networking.HostName, localServiceName: string, remoteHostName: Windows.Networking.HostName, remoteServiceName: string): Windows.Networking.EndpointPair;
+  }
+  var IEndpointPairFactory: abstract new (...args: any[]) => IEndpointPairFactory;
+
+  interface IHostName {
+    IsEqual(hostName: Windows.Networking.HostName): boolean;
+    readonly CanonicalName: string;
+    readonly DisplayName: string;
+    readonly IPInformation: Windows.Networking.Connectivity.IPInformation;
+    readonly RawName: string;
+    readonly Type: number;
+  }
+  var IHostName: abstract new (...args: any[]) => IHostName;
+
+  interface IHostNameFactory {
+    CreateHostName(hostName: string): Windows.Networking.HostName;
+  }
+  var IHostNameFactory: abstract new (...args: any[]) => IHostNameFactory;
+
+  interface IHostNameStatics {
+    Compare(value1: string, value2: string): number;
+  }
+  var IHostNameStatics: abstract new (...args: any[]) => IHostNameStatics;
+
+}
+
+declare namespace Windows.Networking.BackgroundTransfer {
+  class BackgroundDownloader implements Windows.Networking.BackgroundTransfer.IBackgroundDownloader, Windows.Networking.BackgroundTransfer.IBackgroundDownloader2, Windows.Networking.BackgroundTransfer.IBackgroundDownloader3, Windows.Networking.BackgroundTransfer.IBackgroundTransferBase {
+    constructor(completionGroup: Windows.Networking.BackgroundTransfer.BackgroundTransferCompletionGroup);
+    constructor();
+    CreateDownload(uri: Windows.Foundation.Uri, resultFile: Windows.Storage.IStorageFile): Windows.Networking.BackgroundTransfer.DownloadOperation;
+    CreateDownload(uri: Windows.Foundation.Uri, resultFile: Windows.Storage.IStorageFile, requestBodyFile: Windows.Storage.IStorageFile): Windows.Networking.BackgroundTransfer.DownloadOperation;
+    CreateDownloadAsync(uri: Windows.Foundation.Uri, resultFile: Windows.Storage.IStorageFile, requestBodyStream: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncOperation<Windows.Networking.BackgroundTransfer.DownloadOperation>;
+    static GetCurrentDownloadsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.BackgroundTransfer.DownloadOperation> | Windows.Networking.BackgroundTransfer.DownloadOperation[]>;
+    static GetCurrentDownloadsAsync(group: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.BackgroundTransfer.DownloadOperation> | Windows.Networking.BackgroundTransfer.DownloadOperation[]>;
+    static GetCurrentDownloadsForTransferGroupAsync(group: Windows.Networking.BackgroundTransfer.BackgroundTransferGroup): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.BackgroundTransfer.DownloadOperation> | Windows.Networking.BackgroundTransfer.DownloadOperation[]>;
+    static RequestUnconstrainedDownloadsAsync(operations: Windows.Foundation.Collections.IIterable<Windows.Networking.BackgroundTransfer.DownloadOperation> | Windows.Networking.BackgroundTransfer.DownloadOperation[]): Windows.Foundation.IAsyncOperation<Windows.Networking.BackgroundTransfer.UnconstrainedTransferRequestResult>;
+    SetRequestHeader(headerName: string, headerValue: string): void;
+    readonly CompletionGroup: Windows.Networking.BackgroundTransfer.BackgroundTransferCompletionGroup;
+    CostPolicy: number;
+    FailureTileNotification: Windows.UI.Notifications.TileNotification;
+    FailureToastNotification: Windows.UI.Notifications.ToastNotification;
+    Group: string;
+    Method: string;
+    ProxyCredential: Windows.Security.Credentials.PasswordCredential;
+    ServerCredential: Windows.Security.Credentials.PasswordCredential;
+    SuccessTileNotification: Windows.UI.Notifications.TileNotification;
+    SuccessToastNotification: Windows.UI.Notifications.ToastNotification;
+    TransferGroup: Windows.Networking.BackgroundTransfer.BackgroundTransferGroup;
+  }
+
+  class BackgroundTransferCompletionGroup implements Windows.Networking.BackgroundTransfer.IBackgroundTransferCompletionGroup {
+    constructor();
+    Enable(): void;
+    readonly IsEnabled: boolean;
+    readonly Trigger: Windows.ApplicationModel.Background.IBackgroundTrigger;
+  }
+
+  class BackgroundTransferCompletionGroupTriggerDetails implements Windows.Networking.BackgroundTransfer.IBackgroundTransferCompletionGroupTriggerDetails {
+    readonly Downloads: Windows.Foundation.Collections.IVectorView<Windows.Networking.BackgroundTransfer.DownloadOperation> | Windows.Networking.BackgroundTransfer.DownloadOperation[];
+    readonly Uploads: Windows.Foundation.Collections.IVectorView<Windows.Networking.BackgroundTransfer.UploadOperation> | Windows.Networking.BackgroundTransfer.UploadOperation[];
+  }
+
+  class BackgroundTransferContentPart implements Windows.Networking.BackgroundTransfer.IBackgroundTransferContentPart {
+    constructor(name: string);
+    constructor(name: string, fileName: string);
+    constructor();
+    SetFile(value: Windows.Storage.IStorageFile): void;
+    SetHeader(headerName: string, headerValue: string): void;
+    SetText(value: string): void;
+  }
+
+  class BackgroundTransferError {
+    static GetStatus(hresult: number): number;
+  }
+
+  class BackgroundTransferGroup implements Windows.Networking.BackgroundTransfer.IBackgroundTransferGroup {
+    static CreateGroup(name: string): Windows.Networking.BackgroundTransfer.BackgroundTransferGroup;
+    readonly Name: string;
+    TransferBehavior: number;
+  }
+
+  class BackgroundTransferRangesDownloadedEventArgs implements Windows.Networking.BackgroundTransfer.IBackgroundTransferRangesDownloadedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly AddedRanges: Windows.Foundation.Collections.IVector<Windows.Networking.BackgroundTransfer.BackgroundTransferFileRange> | Windows.Networking.BackgroundTransfer.BackgroundTransferFileRange[];
+    readonly WasDownloadRestarted: boolean;
+  }
+
+  class BackgroundUploader implements Windows.Networking.BackgroundTransfer.IBackgroundTransferBase, Windows.Networking.BackgroundTransfer.IBackgroundUploader, Windows.Networking.BackgroundTransfer.IBackgroundUploader2, Windows.Networking.BackgroundTransfer.IBackgroundUploader3 {
+    constructor(completionGroup: Windows.Networking.BackgroundTransfer.BackgroundTransferCompletionGroup);
+    constructor();
+    CreateUpload(uri: Windows.Foundation.Uri, sourceFile: Windows.Storage.IStorageFile): Windows.Networking.BackgroundTransfer.UploadOperation;
+    CreateUploadAsync(uri: Windows.Foundation.Uri, parts: Windows.Foundation.Collections.IIterable<Windows.Networking.BackgroundTransfer.BackgroundTransferContentPart> | Windows.Networking.BackgroundTransfer.BackgroundTransferContentPart[]): Windows.Foundation.IAsyncOperation<Windows.Networking.BackgroundTransfer.UploadOperation>;
+    CreateUploadAsync(uri: Windows.Foundation.Uri, parts: Windows.Foundation.Collections.IIterable<Windows.Networking.BackgroundTransfer.BackgroundTransferContentPart> | Windows.Networking.BackgroundTransfer.BackgroundTransferContentPart[], subType: string): Windows.Foundation.IAsyncOperation<Windows.Networking.BackgroundTransfer.UploadOperation>;
+    CreateUploadAsync(uri: Windows.Foundation.Uri, parts: Windows.Foundation.Collections.IIterable<Windows.Networking.BackgroundTransfer.BackgroundTransferContentPart> | Windows.Networking.BackgroundTransfer.BackgroundTransferContentPart[], subType: string, boundary: string): Windows.Foundation.IAsyncOperation<Windows.Networking.BackgroundTransfer.UploadOperation>;
+    CreateUploadFromStreamAsync(uri: Windows.Foundation.Uri, sourceStream: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncOperation<Windows.Networking.BackgroundTransfer.UploadOperation>;
+    static GetCurrentUploadsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.BackgroundTransfer.UploadOperation> | Windows.Networking.BackgroundTransfer.UploadOperation[]>;
+    static GetCurrentUploadsAsync(group: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.BackgroundTransfer.UploadOperation> | Windows.Networking.BackgroundTransfer.UploadOperation[]>;
+    static GetCurrentUploadsForTransferGroupAsync(group: Windows.Networking.BackgroundTransfer.BackgroundTransferGroup): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.BackgroundTransfer.UploadOperation> | Windows.Networking.BackgroundTransfer.UploadOperation[]>;
+    static RequestUnconstrainedUploadsAsync(operations: Windows.Foundation.Collections.IIterable<Windows.Networking.BackgroundTransfer.UploadOperation> | Windows.Networking.BackgroundTransfer.UploadOperation[]): Windows.Foundation.IAsyncOperation<Windows.Networking.BackgroundTransfer.UnconstrainedTransferRequestResult>;
+    SetRequestHeader(headerName: string, headerValue: string): void;
+    readonly CompletionGroup: Windows.Networking.BackgroundTransfer.BackgroundTransferCompletionGroup;
+    CostPolicy: number;
+    FailureTileNotification: Windows.UI.Notifications.TileNotification;
+    FailureToastNotification: Windows.UI.Notifications.ToastNotification;
+    Group: string;
+    Method: string;
+    ProxyCredential: Windows.Security.Credentials.PasswordCredential;
+    ServerCredential: Windows.Security.Credentials.PasswordCredential;
+    SuccessTileNotification: Windows.UI.Notifications.TileNotification;
+    SuccessToastNotification: Windows.UI.Notifications.ToastNotification;
+    TransferGroup: Windows.Networking.BackgroundTransfer.BackgroundTransferGroup;
+  }
+
+  class ContentPrefetcher {
+    static readonly ContentUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    static IndirectContentUri: Windows.Foundation.Uri;
+    static readonly LastSuccessfulPrefetchTime: Windows.Foundation.DateTime | null;
+  }
+
+  class DownloadOperation implements Windows.Networking.BackgroundTransfer.IBackgroundTransferOperation, Windows.Networking.BackgroundTransfer.IBackgroundTransferOperationPriority, Windows.Networking.BackgroundTransfer.IDownloadOperation, Windows.Networking.BackgroundTransfer.IDownloadOperation2, Windows.Networking.BackgroundTransfer.IDownloadOperation3, Windows.Networking.BackgroundTransfer.IDownloadOperation4, Windows.Networking.BackgroundTransfer.IDownloadOperation5 {
+    AttachAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Networking.BackgroundTransfer.DownloadOperation, Windows.Networking.BackgroundTransfer.DownloadOperation>;
+    GetDownloadedRanges(): Windows.Foundation.Collections.IVector<Windows.Networking.BackgroundTransfer.BackgroundTransferFileRange> | Windows.Networking.BackgroundTransfer.BackgroundTransferFileRange[];
+    GetResponseInformation(): Windows.Networking.BackgroundTransfer.ResponseInformation;
+    GetResultRandomAccessStreamReference(): Windows.Storage.Streams.IRandomAccessStreamReference;
+    GetResultStreamAt(position: number | bigint): Windows.Storage.Streams.IInputStream;
+    MakeCurrentInTransferGroup(): void;
+    Pause(): void;
+    RemoveRequestHeader(headerName: string): void;
+    Resume(): void;
+    SetRequestHeader(headerName: string, headerValue: string): void;
+    StartAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Networking.BackgroundTransfer.DownloadOperation, Windows.Networking.BackgroundTransfer.DownloadOperation>;
+    CostPolicy: number;
+    readonly CurrentWebErrorStatus: number | null;
+    readonly Group: string;
+    readonly Guid: Guid;
+    IsRandomAccessRequired: boolean;
+    readonly Method: string;
+    Priority: number;
+    readonly Progress: Windows.Networking.BackgroundTransfer.BackgroundDownloadProgress;
+    readonly RecoverableWebErrorStatuses: Windows.Foundation.Collections.IVector<number> | number[];
+    RequestedUri: Windows.Foundation.Uri;
+    readonly ResultFile: Windows.Storage.IStorageFile;
+    readonly TransferGroup: Windows.Networking.BackgroundTransfer.BackgroundTransferGroup;
+    RangesDownloaded: Windows.Foundation.TypedEventHandler<Windows.Networking.BackgroundTransfer.DownloadOperation, Windows.Networking.BackgroundTransfer.BackgroundTransferRangesDownloadedEventArgs> | null;
+  }
+
+  class ResponseInformation implements Windows.Networking.BackgroundTransfer.IResponseInformation {
+    readonly ActualUri: Windows.Foundation.Uri;
+    readonly Headers: Windows.Foundation.Collections.IMapView<string, string>;
+    readonly IsResumable: boolean;
+    readonly StatusCode: number;
+  }
+
+  class UnconstrainedTransferRequestResult implements Windows.Networking.BackgroundTransfer.IUnconstrainedTransferRequestResult {
+    readonly IsUnconstrained: boolean;
+  }
+
+  class UploadOperation implements Windows.Networking.BackgroundTransfer.IBackgroundTransferOperation, Windows.Networking.BackgroundTransfer.IBackgroundTransferOperationPriority, Windows.Networking.BackgroundTransfer.IUploadOperation, Windows.Networking.BackgroundTransfer.IUploadOperation2, Windows.Networking.BackgroundTransfer.IUploadOperation3, Windows.Networking.BackgroundTransfer.IUploadOperation4 {
+    AttachAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Networking.BackgroundTransfer.UploadOperation, Windows.Networking.BackgroundTransfer.UploadOperation>;
+    GetResponseInformation(): Windows.Networking.BackgroundTransfer.ResponseInformation;
+    GetResultStreamAt(position: number | bigint): Windows.Storage.Streams.IInputStream;
+    MakeCurrentInTransferGroup(): void;
+    RemoveRequestHeader(headerName: string): void;
+    SetRequestHeader(headerName: string, headerValue: string): void;
+    StartAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Networking.BackgroundTransfer.UploadOperation, Windows.Networking.BackgroundTransfer.UploadOperation>;
+    CostPolicy: number;
+    readonly Group: string;
+    readonly Guid: Guid;
+    readonly Method: string;
+    Priority: number;
+    readonly Progress: Windows.Networking.BackgroundTransfer.BackgroundUploadProgress;
+    readonly RequestedUri: Windows.Foundation.Uri;
+    readonly SourceFile: Windows.Storage.IStorageFile;
+    readonly TransferGroup: Windows.Networking.BackgroundTransfer.BackgroundTransferGroup;
+  }
+
+  enum BackgroundTransferBehavior {
+    Parallel = 0,
+    Serialized = 1,
+  }
+
+  enum BackgroundTransferCostPolicy {
+    Default = 0,
+    UnrestrictedOnly = 1,
+    Always = 2,
+  }
+
+  enum BackgroundTransferPriority {
+    Default = 0,
+    High = 1,
+    Low = 2,
+  }
+
+  enum BackgroundTransferStatus {
+    Idle = 0,
+    Running = 1,
+    PausedByApplication = 2,
+    PausedCostedNetwork = 3,
+    PausedNoNetwork = 4,
+    Completed = 5,
+    Canceled = 6,
+    Error = 7,
+    PausedRecoverableWebErrorStatus = 8,
+    PausedSystemPolicy = 32,
+  }
+
+  interface BackgroundDownloadProgress {
+    BytesReceived: number | bigint;
+    TotalBytesToReceive: number | bigint;
+    Status: number;
+    HasResponseChanged: boolean;
+    HasRestarted: boolean;
+  }
+  var BackgroundDownloadProgress: {
+    new(bytesReceived: number | bigint, totalBytesToReceive: number | bigint, status: number, hasResponseChanged: boolean, hasRestarted: boolean): BackgroundDownloadProgress;
+    new(fields: { BytesReceived?: number | bigint; TotalBytesToReceive?: number | bigint; Status?: number; HasResponseChanged?: boolean; HasRestarted?: boolean }): BackgroundDownloadProgress;
+  };
+
+  interface BackgroundTransferFileRange {
+    Offset: number | bigint;
+    Length: number | bigint;
+  }
+  var BackgroundTransferFileRange: {
+    new(offset: number | bigint, length: number | bigint): BackgroundTransferFileRange;
+    new(fields: { Offset?: number | bigint; Length?: number | bigint }): BackgroundTransferFileRange;
+  };
+
+  interface BackgroundUploadProgress {
+    BytesReceived: number | bigint;
+    BytesSent: number | bigint;
+    TotalBytesToReceive: number | bigint;
+    TotalBytesToSend: number | bigint;
+    Status: number;
+    HasResponseChanged: boolean;
+    HasRestarted: boolean;
+  }
+  var BackgroundUploadProgress: {
+    new(bytesReceived: number | bigint, bytesSent: number | bigint, totalBytesToReceive: number | bigint, totalBytesToSend: number | bigint, status: number, hasResponseChanged: boolean, hasRestarted: boolean): BackgroundUploadProgress;
+    new(fields: { BytesReceived?: number | bigint; BytesSent?: number | bigint; TotalBytesToReceive?: number | bigint; TotalBytesToSend?: number | bigint; Status?: number; HasResponseChanged?: boolean; HasRestarted?: boolean }): BackgroundUploadProgress;
+  };
+
+  interface IBackgroundDownloader extends Windows.Networking.BackgroundTransfer.IBackgroundTransferBase {
+    CreateDownload(uri: Windows.Foundation.Uri, resultFile: Windows.Storage.IStorageFile): Windows.Networking.BackgroundTransfer.DownloadOperation;
+    CreateDownload(uri: Windows.Foundation.Uri, resultFile: Windows.Storage.IStorageFile, requestBodyFile: Windows.Storage.IStorageFile): Windows.Networking.BackgroundTransfer.DownloadOperation;
+    CreateDownloadAsync(uri: Windows.Foundation.Uri, resultFile: Windows.Storage.IStorageFile, requestBodyStream: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncOperation<Windows.Networking.BackgroundTransfer.DownloadOperation>;
+    SetRequestHeader(headerName: string, headerValue: string): void;
+  }
+  var IBackgroundDownloader: abstract new (...args: any[]) => IBackgroundDownloader;
+
+  interface IBackgroundDownloader2 {
+    FailureTileNotification: Windows.UI.Notifications.TileNotification;
+    FailureToastNotification: Windows.UI.Notifications.ToastNotification;
+    SuccessTileNotification: Windows.UI.Notifications.TileNotification;
+    SuccessToastNotification: Windows.UI.Notifications.ToastNotification;
+    TransferGroup: Windows.Networking.BackgroundTransfer.BackgroundTransferGroup;
+  }
+  var IBackgroundDownloader2: abstract new (...args: any[]) => IBackgroundDownloader2;
+
+  interface IBackgroundDownloader3 {
+    readonly CompletionGroup: Windows.Networking.BackgroundTransfer.BackgroundTransferCompletionGroup;
+  }
+  var IBackgroundDownloader3: abstract new (...args: any[]) => IBackgroundDownloader3;
+
+  interface IBackgroundDownloaderFactory {
+    CreateWithCompletionGroup(completionGroup: Windows.Networking.BackgroundTransfer.BackgroundTransferCompletionGroup): Windows.Networking.BackgroundTransfer.BackgroundDownloader;
+  }
+  var IBackgroundDownloaderFactory: abstract new (...args: any[]) => IBackgroundDownloaderFactory;
+
+  interface IBackgroundDownloaderStaticMethods {
+    GetCurrentDownloadsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.BackgroundTransfer.DownloadOperation> | Windows.Networking.BackgroundTransfer.DownloadOperation[]>;
+    GetCurrentDownloadsAsync(group: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.BackgroundTransfer.DownloadOperation> | Windows.Networking.BackgroundTransfer.DownloadOperation[]>;
+  }
+  var IBackgroundDownloaderStaticMethods: abstract new (...args: any[]) => IBackgroundDownloaderStaticMethods;
+
+  interface IBackgroundDownloaderStaticMethods2 {
+    GetCurrentDownloadsForTransferGroupAsync(group: Windows.Networking.BackgroundTransfer.BackgroundTransferGroup): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.BackgroundTransfer.DownloadOperation> | Windows.Networking.BackgroundTransfer.DownloadOperation[]>;
+  }
+  var IBackgroundDownloaderStaticMethods2: abstract new (...args: any[]) => IBackgroundDownloaderStaticMethods2;
+
+  interface IBackgroundDownloaderUserConsent {
+    RequestUnconstrainedDownloadsAsync(operations: Windows.Foundation.Collections.IIterable<Windows.Networking.BackgroundTransfer.DownloadOperation> | Windows.Networking.BackgroundTransfer.DownloadOperation[]): Windows.Foundation.IAsyncOperation<Windows.Networking.BackgroundTransfer.UnconstrainedTransferRequestResult>;
+  }
+  var IBackgroundDownloaderUserConsent: abstract new (...args: any[]) => IBackgroundDownloaderUserConsent;
+
+  interface IBackgroundTransferBase {
+    SetRequestHeader(headerName: string, headerValue: string): void;
+    CostPolicy: number;
+    Group: string;
+    Method: string;
+    ProxyCredential: Windows.Security.Credentials.PasswordCredential;
+    ServerCredential: Windows.Security.Credentials.PasswordCredential;
+  }
+  var IBackgroundTransferBase: abstract new (...args: any[]) => IBackgroundTransferBase;
+
+  interface IBackgroundTransferCompletionGroup {
+    Enable(): void;
+    readonly IsEnabled: boolean;
+    readonly Trigger: Windows.ApplicationModel.Background.IBackgroundTrigger;
+  }
+  var IBackgroundTransferCompletionGroup: abstract new (...args: any[]) => IBackgroundTransferCompletionGroup;
+
+  interface IBackgroundTransferCompletionGroupTriggerDetails {
+    readonly Downloads: Windows.Foundation.Collections.IVectorView<Windows.Networking.BackgroundTransfer.DownloadOperation> | Windows.Networking.BackgroundTransfer.DownloadOperation[];
+    readonly Uploads: Windows.Foundation.Collections.IVectorView<Windows.Networking.BackgroundTransfer.UploadOperation> | Windows.Networking.BackgroundTransfer.UploadOperation[];
+  }
+  var IBackgroundTransferCompletionGroupTriggerDetails: abstract new (...args: any[]) => IBackgroundTransferCompletionGroupTriggerDetails;
+
+  interface IBackgroundTransferContentPart {
+    SetFile(value: Windows.Storage.IStorageFile): void;
+    SetHeader(headerName: string, headerValue: string): void;
+    SetText(value: string): void;
+  }
+  var IBackgroundTransferContentPart: abstract new (...args: any[]) => IBackgroundTransferContentPart;
+
+  interface IBackgroundTransferContentPartFactory {
+    CreateWithName(name: string): Windows.Networking.BackgroundTransfer.BackgroundTransferContentPart;
+    CreateWithNameAndFileName(name: string, fileName: string): Windows.Networking.BackgroundTransfer.BackgroundTransferContentPart;
+  }
+  var IBackgroundTransferContentPartFactory: abstract new (...args: any[]) => IBackgroundTransferContentPartFactory;
+
+  interface IBackgroundTransferErrorStaticMethods {
+    GetStatus(hresult: number): number;
+  }
+  var IBackgroundTransferErrorStaticMethods: abstract new (...args: any[]) => IBackgroundTransferErrorStaticMethods;
+
+  interface IBackgroundTransferGroup {
+    readonly Name: string;
+    TransferBehavior: number;
+  }
+  var IBackgroundTransferGroup: abstract new (...args: any[]) => IBackgroundTransferGroup;
+
+  interface IBackgroundTransferGroupStatics {
+    CreateGroup(name: string): Windows.Networking.BackgroundTransfer.BackgroundTransferGroup;
+  }
+  var IBackgroundTransferGroupStatics: abstract new (...args: any[]) => IBackgroundTransferGroupStatics;
+
+  interface IBackgroundTransferOperation {
+    GetResponseInformation(): Windows.Networking.BackgroundTransfer.ResponseInformation;
+    GetResultStreamAt(position: number | bigint): Windows.Storage.Streams.IInputStream;
+    CostPolicy: number;
+    readonly Group: string;
+    readonly Guid: Guid;
+    readonly Method: string;
+    readonly RequestedUri: Windows.Foundation.Uri;
+  }
+  var IBackgroundTransferOperation: abstract new (...args: any[]) => IBackgroundTransferOperation;
+
+  interface IBackgroundTransferOperationPriority {
+    Priority: number;
+  }
+  var IBackgroundTransferOperationPriority: abstract new (...args: any[]) => IBackgroundTransferOperationPriority;
+
+  interface IBackgroundTransferRangesDownloadedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly AddedRanges: Windows.Foundation.Collections.IVector<Windows.Networking.BackgroundTransfer.BackgroundTransferFileRange> | Windows.Networking.BackgroundTransfer.BackgroundTransferFileRange[];
+    readonly WasDownloadRestarted: boolean;
+  }
+  var IBackgroundTransferRangesDownloadedEventArgs: abstract new (...args: any[]) => IBackgroundTransferRangesDownloadedEventArgs;
+
+  interface IBackgroundUploader extends Windows.Networking.BackgroundTransfer.IBackgroundTransferBase {
+    CreateUpload(uri: Windows.Foundation.Uri, sourceFile: Windows.Storage.IStorageFile): Windows.Networking.BackgroundTransfer.UploadOperation;
+    CreateUploadAsync(uri: Windows.Foundation.Uri, parts: Windows.Foundation.Collections.IIterable<Windows.Networking.BackgroundTransfer.BackgroundTransferContentPart> | Windows.Networking.BackgroundTransfer.BackgroundTransferContentPart[]): Windows.Foundation.IAsyncOperation<Windows.Networking.BackgroundTransfer.UploadOperation>;
+    CreateUploadAsync(uri: Windows.Foundation.Uri, parts: Windows.Foundation.Collections.IIterable<Windows.Networking.BackgroundTransfer.BackgroundTransferContentPart> | Windows.Networking.BackgroundTransfer.BackgroundTransferContentPart[], subType: string): Windows.Foundation.IAsyncOperation<Windows.Networking.BackgroundTransfer.UploadOperation>;
+    CreateUploadAsync(uri: Windows.Foundation.Uri, parts: Windows.Foundation.Collections.IIterable<Windows.Networking.BackgroundTransfer.BackgroundTransferContentPart> | Windows.Networking.BackgroundTransfer.BackgroundTransferContentPart[], subType: string, boundary: string): Windows.Foundation.IAsyncOperation<Windows.Networking.BackgroundTransfer.UploadOperation>;
+    CreateUploadFromStreamAsync(uri: Windows.Foundation.Uri, sourceStream: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncOperation<Windows.Networking.BackgroundTransfer.UploadOperation>;
+    SetRequestHeader(headerName: string, headerValue: string): void;
+  }
+  var IBackgroundUploader: abstract new (...args: any[]) => IBackgroundUploader;
+
+  interface IBackgroundUploader2 {
+    FailureTileNotification: Windows.UI.Notifications.TileNotification;
+    FailureToastNotification: Windows.UI.Notifications.ToastNotification;
+    SuccessTileNotification: Windows.UI.Notifications.TileNotification;
+    SuccessToastNotification: Windows.UI.Notifications.ToastNotification;
+    TransferGroup: Windows.Networking.BackgroundTransfer.BackgroundTransferGroup;
+  }
+  var IBackgroundUploader2: abstract new (...args: any[]) => IBackgroundUploader2;
+
+  interface IBackgroundUploader3 {
+    readonly CompletionGroup: Windows.Networking.BackgroundTransfer.BackgroundTransferCompletionGroup;
+  }
+  var IBackgroundUploader3: abstract new (...args: any[]) => IBackgroundUploader3;
+
+  interface IBackgroundUploaderFactory {
+    CreateWithCompletionGroup(completionGroup: Windows.Networking.BackgroundTransfer.BackgroundTransferCompletionGroup): Windows.Networking.BackgroundTransfer.BackgroundUploader;
+  }
+  var IBackgroundUploaderFactory: abstract new (...args: any[]) => IBackgroundUploaderFactory;
+
+  interface IBackgroundUploaderStaticMethods {
+    GetCurrentUploadsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.BackgroundTransfer.UploadOperation> | Windows.Networking.BackgroundTransfer.UploadOperation[]>;
+    GetCurrentUploadsAsync(group: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.BackgroundTransfer.UploadOperation> | Windows.Networking.BackgroundTransfer.UploadOperation[]>;
+  }
+  var IBackgroundUploaderStaticMethods: abstract new (...args: any[]) => IBackgroundUploaderStaticMethods;
+
+  interface IBackgroundUploaderStaticMethods2 {
+    GetCurrentUploadsForTransferGroupAsync(group: Windows.Networking.BackgroundTransfer.BackgroundTransferGroup): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.BackgroundTransfer.UploadOperation> | Windows.Networking.BackgroundTransfer.UploadOperation[]>;
+  }
+  var IBackgroundUploaderStaticMethods2: abstract new (...args: any[]) => IBackgroundUploaderStaticMethods2;
+
+  interface IBackgroundUploaderUserConsent {
+    RequestUnconstrainedUploadsAsync(operations: Windows.Foundation.Collections.IIterable<Windows.Networking.BackgroundTransfer.UploadOperation> | Windows.Networking.BackgroundTransfer.UploadOperation[]): Windows.Foundation.IAsyncOperation<Windows.Networking.BackgroundTransfer.UnconstrainedTransferRequestResult>;
+  }
+  var IBackgroundUploaderUserConsent: abstract new (...args: any[]) => IBackgroundUploaderUserConsent;
+
+  interface IContentPrefetcher {
+    readonly ContentUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    IndirectContentUri: Windows.Foundation.Uri;
+  }
+  var IContentPrefetcher: abstract new (...args: any[]) => IContentPrefetcher;
+
+  interface IContentPrefetcherTime {
+    readonly LastSuccessfulPrefetchTime: Windows.Foundation.DateTime | null;
+  }
+  var IContentPrefetcherTime: abstract new (...args: any[]) => IContentPrefetcherTime;
+
+  interface IDownloadOperation extends Windows.Networking.BackgroundTransfer.IBackgroundTransferOperation {
+    AttachAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Networking.BackgroundTransfer.DownloadOperation, Windows.Networking.BackgroundTransfer.DownloadOperation>;
+    GetResponseInformation(): Windows.Networking.BackgroundTransfer.ResponseInformation;
+    GetResultStreamAt(position: number | bigint): Windows.Storage.Streams.IInputStream;
+    Pause(): void;
+    Resume(): void;
+    StartAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Networking.BackgroundTransfer.DownloadOperation, Windows.Networking.BackgroundTransfer.DownloadOperation>;
+    readonly Progress: Windows.Networking.BackgroundTransfer.BackgroundDownloadProgress;
+    readonly ResultFile: Windows.Storage.IStorageFile;
+  }
+  var IDownloadOperation: abstract new (...args: any[]) => IDownloadOperation;
+
+  interface IDownloadOperation2 {
+    readonly TransferGroup: Windows.Networking.BackgroundTransfer.BackgroundTransferGroup;
+  }
+  var IDownloadOperation2: abstract new (...args: any[]) => IDownloadOperation2;
+
+  interface IDownloadOperation3 {
+    GetDownloadedRanges(): Windows.Foundation.Collections.IVector<Windows.Networking.BackgroundTransfer.BackgroundTransferFileRange> | Windows.Networking.BackgroundTransfer.BackgroundTransferFileRange[];
+    GetResultRandomAccessStreamReference(): Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly CurrentWebErrorStatus: number | null;
+    IsRandomAccessRequired: boolean;
+    readonly RecoverableWebErrorStatuses: Windows.Foundation.Collections.IVector<number> | number[];
+    RequestedUri: Object;
+    RangesDownloaded: Windows.Foundation.TypedEventHandler<Windows.Networking.BackgroundTransfer.DownloadOperation, Windows.Networking.BackgroundTransfer.BackgroundTransferRangesDownloadedEventArgs> | null;
+  }
+  var IDownloadOperation3: abstract new (...args: any[]) => IDownloadOperation3;
+
+  interface IDownloadOperation4 {
+    MakeCurrentInTransferGroup(): void;
+  }
+  var IDownloadOperation4: abstract new (...args: any[]) => IDownloadOperation4;
+
+  interface IDownloadOperation5 {
+    RemoveRequestHeader(headerName: string): void;
+    SetRequestHeader(headerName: string, headerValue: string): void;
+  }
+  var IDownloadOperation5: abstract new (...args: any[]) => IDownloadOperation5;
+
+  interface IResponseInformation {
+    readonly ActualUri: Windows.Foundation.Uri;
+    readonly Headers: Windows.Foundation.Collections.IMapView<string, string>;
+    readonly IsResumable: boolean;
+    readonly StatusCode: number;
+  }
+  var IResponseInformation: abstract new (...args: any[]) => IResponseInformation;
+
+  interface IUnconstrainedTransferRequestResult {
+    readonly IsUnconstrained: boolean;
+  }
+  var IUnconstrainedTransferRequestResult: abstract new (...args: any[]) => IUnconstrainedTransferRequestResult;
+
+  interface IUploadOperation extends Windows.Networking.BackgroundTransfer.IBackgroundTransferOperation {
+    AttachAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Networking.BackgroundTransfer.UploadOperation, Windows.Networking.BackgroundTransfer.UploadOperation>;
+    GetResponseInformation(): Windows.Networking.BackgroundTransfer.ResponseInformation;
+    GetResultStreamAt(position: number | bigint): Windows.Storage.Streams.IInputStream;
+    StartAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Networking.BackgroundTransfer.UploadOperation, Windows.Networking.BackgroundTransfer.UploadOperation>;
+    readonly Progress: Windows.Networking.BackgroundTransfer.BackgroundUploadProgress;
+    readonly SourceFile: Windows.Storage.IStorageFile;
+  }
+  var IUploadOperation: abstract new (...args: any[]) => IUploadOperation;
+
+  interface IUploadOperation2 {
+    readonly TransferGroup: Windows.Networking.BackgroundTransfer.BackgroundTransferGroup;
+  }
+  var IUploadOperation2: abstract new (...args: any[]) => IUploadOperation2;
+
+  interface IUploadOperation3 {
+    MakeCurrentInTransferGroup(): void;
+  }
+  var IUploadOperation3: abstract new (...args: any[]) => IUploadOperation3;
+
+  interface IUploadOperation4 {
+    RemoveRequestHeader(headerName: string): void;
+    SetRequestHeader(headerName: string, headerValue: string): void;
+  }
+  var IUploadOperation4: abstract new (...args: any[]) => IUploadOperation4;
+
+}
+
+declare namespace Windows.Networking.Connectivity {
+  class AttributedNetworkUsage implements Windows.Networking.Connectivity.IAttributedNetworkUsage {
+    readonly AttributionId: string;
+    readonly AttributionName: string;
+    readonly AttributionThumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly BytesReceived: number | bigint;
+    readonly BytesSent: number | bigint;
+  }
+
+  class CellularApnContext implements Windows.Networking.Connectivity.ICellularApnContext, Windows.Networking.Connectivity.ICellularApnContext2 {
+    constructor();
+    AccessPointName: string;
+    AuthenticationType: number;
+    IsCompressionEnabled: boolean;
+    Password: string;
+    ProfileName: string;
+    ProviderId: string;
+    UserName: string;
+  }
+
+  class ConnectionCost implements Windows.Networking.Connectivity.IConnectionCost, Windows.Networking.Connectivity.IConnectionCost2 {
+    readonly ApproachingDataLimit: boolean;
+    readonly BackgroundDataUsageRestricted: boolean;
+    readonly NetworkCostType: number;
+    readonly OverDataLimit: boolean;
+    readonly Roaming: boolean;
+  }
+
+  class ConnectionProfile implements Windows.Networking.Connectivity.IConnectionProfile, Windows.Networking.Connectivity.IConnectionProfile2, Windows.Networking.Connectivity.IConnectionProfile3, Windows.Networking.Connectivity.IConnectionProfile4, Windows.Networking.Connectivity.IConnectionProfile5, Windows.Networking.Connectivity.IConnectionProfile6 {
+    GetAttributedNetworkUsageAsync(startTime: Windows.Foundation.DateTime, endTime: Windows.Foundation.DateTime, states: Windows.Networking.Connectivity.NetworkUsageStates): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.Connectivity.AttributedNetworkUsage> | Windows.Networking.Connectivity.AttributedNetworkUsage[]>;
+    GetConnectionCost(): Windows.Networking.Connectivity.ConnectionCost;
+    GetConnectivityIntervalsAsync(startTime: Windows.Foundation.DateTime, endTime: Windows.Foundation.DateTime, states: Windows.Networking.Connectivity.NetworkUsageStates): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.Connectivity.ConnectivityInterval> | Windows.Networking.Connectivity.ConnectivityInterval[]>;
+    GetDataPlanStatus(): Windows.Networking.Connectivity.DataPlanStatus;
+    GetDomainConnectivityLevel(): number;
+    GetLocalUsage(StartTime: Windows.Foundation.DateTime, EndTime: Windows.Foundation.DateTime): Windows.Networking.Connectivity.DataUsage;
+    GetLocalUsage(StartTime: Windows.Foundation.DateTime, EndTime: Windows.Foundation.DateTime, States: number): Windows.Networking.Connectivity.DataUsage;
+    GetNetworkConnectivityLevel(): number;
+    GetNetworkNames(): Windows.Foundation.Collections.IVectorView<string> | string[];
+    GetNetworkUsageAsync(startTime: Windows.Foundation.DateTime, endTime: Windows.Foundation.DateTime, granularity: number, states: Windows.Networking.Connectivity.NetworkUsageStates): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.Connectivity.NetworkUsage> | Windows.Networking.Connectivity.NetworkUsage[]>;
+    GetProviderNetworkUsageAsync(startTime: Windows.Foundation.DateTime, endTime: Windows.Foundation.DateTime, states: Windows.Networking.Connectivity.NetworkUsageStates): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.Connectivity.ProviderNetworkUsage> | Windows.Networking.Connectivity.ProviderNetworkUsage[]>;
+    GetSignalBars(): number | null;
+    IsDomainAuthenticatedBy(kind: number): boolean;
+    TryDeleteAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly CanDelete: boolean;
+    readonly IsWlanConnectionProfile: boolean;
+    readonly IsWwanConnectionProfile: boolean;
+    readonly NetworkAdapter: Windows.Networking.Connectivity.NetworkAdapter;
+    readonly NetworkSecuritySettings: Windows.Networking.Connectivity.NetworkSecuritySettings;
+    readonly ProfileName: string;
+    readonly ServiceProviderGuid: Guid | null;
+    readonly WlanConnectionProfileDetails: Windows.Networking.Connectivity.WlanConnectionProfileDetails;
+    readonly WwanConnectionProfileDetails: Windows.Networking.Connectivity.WwanConnectionProfileDetails;
+  }
+
+  class ConnectionProfileFilter implements Windows.Networking.Connectivity.IConnectionProfileFilter, Windows.Networking.Connectivity.IConnectionProfileFilter2, Windows.Networking.Connectivity.IConnectionProfileFilter3 {
+    constructor();
+    IsBackgroundDataUsageRestricted: boolean | null;
+    IsConnected: boolean;
+    IsOverDataLimit: boolean | null;
+    IsRoaming: boolean | null;
+    IsWlanConnectionProfile: boolean;
+    IsWwanConnectionProfile: boolean;
+    NetworkCostType: number;
+    PurposeGuid: Guid | null;
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+    ServiceProviderGuid: Guid | null;
+  }
+
+  class ConnectionSession implements Windows.Foundation.IClosable, Windows.Networking.Connectivity.IConnectionSession {
+    Close(): void;
+    readonly ConnectionProfile: Windows.Networking.Connectivity.ConnectionProfile;
+  }
+
+  class ConnectivityInterval implements Windows.Networking.Connectivity.IConnectivityInterval {
+    readonly ConnectionDuration: Windows.Foundation.TimeSpan;
+    readonly StartTime: Windows.Foundation.DateTime;
+  }
+
+  class ConnectivityManager {
+    static AcquireConnectionAsync(cellularApnContext: Windows.Networking.Connectivity.CellularApnContext): Windows.Foundation.IAsyncOperation<Windows.Networking.Connectivity.ConnectionSession>;
+    static AddHttpRoutePolicy(routePolicy: Windows.Networking.Connectivity.RoutePolicy): void;
+    static RemoveHttpRoutePolicy(routePolicy: Windows.Networking.Connectivity.RoutePolicy): void;
+  }
+
+  class DataPlanStatus implements Windows.Networking.Connectivity.IDataPlanStatus {
+    readonly DataLimitInMegabytes: number | null;
+    readonly DataPlanUsage: Windows.Networking.Connectivity.DataPlanUsage;
+    readonly InboundBitsPerSecond: number | bigint | null;
+    readonly MaxTransferSizeInMegabytes: number | null;
+    readonly NextBillingCycle: Windows.Foundation.DateTime | null;
+    readonly OutboundBitsPerSecond: number | bigint | null;
+  }
+
+  class DataPlanUsage implements Windows.Networking.Connectivity.IDataPlanUsage {
+    readonly LastSyncTime: Windows.Foundation.DateTime;
+    readonly MegabytesUsed: number;
+  }
+
+  class DataUsage implements Windows.Networking.Connectivity.IDataUsage {
+    readonly BytesReceived: number | bigint;
+    readonly BytesSent: number | bigint;
+  }
+
+  class IPInformation implements Windows.Networking.Connectivity.IIPInformation {
+    readonly NetworkAdapter: Windows.Networking.Connectivity.NetworkAdapter;
+    readonly PrefixLength: number | null;
+  }
+
+  class LanIdentifier implements Windows.Networking.Connectivity.ILanIdentifier {
+    readonly InfrastructureId: Windows.Networking.Connectivity.LanIdentifierData;
+    readonly NetworkAdapterId: Guid;
+    readonly PortId: Windows.Networking.Connectivity.LanIdentifierData;
+  }
+
+  class LanIdentifierData implements Windows.Networking.Connectivity.ILanIdentifierData {
+    readonly Type: number;
+    readonly Value: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class NetworkAdapter implements Windows.Networking.Connectivity.INetworkAdapter {
+    GetConnectedProfileAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.Connectivity.ConnectionProfile>;
+    readonly IanaInterfaceType: number;
+    readonly InboundMaxBitsPerSecond: number | bigint;
+    readonly NetworkAdapterId: Guid;
+    readonly NetworkItem: Windows.Networking.Connectivity.NetworkItem;
+    readonly OutboundMaxBitsPerSecond: number | bigint;
+  }
+
+  class NetworkInformation {
+    static FindConnectionProfilesAsync(pProfileFilter: Windows.Networking.Connectivity.ConnectionProfileFilter): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.Connectivity.ConnectionProfile> | Windows.Networking.Connectivity.ConnectionProfile[]>;
+    static GetConnectionProfiles(): Windows.Foundation.Collections.IVectorView<Windows.Networking.Connectivity.ConnectionProfile> | Windows.Networking.Connectivity.ConnectionProfile[];
+    static GetHostNames(): Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[];
+    static GetInternetConnectionProfile(): Windows.Networking.Connectivity.ConnectionProfile;
+    static GetLanIdentifiers(): Windows.Foundation.Collections.IVectorView<Windows.Networking.Connectivity.LanIdentifier> | Windows.Networking.Connectivity.LanIdentifier[];
+    static GetProxyConfigurationAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Networking.Connectivity.ProxyConfiguration>;
+    static GetSortedEndpointPairs(destinationList: Windows.Foundation.Collections.IIterable<Windows.Networking.EndpointPair> | Windows.Networking.EndpointPair[], sortOptions: number): Windows.Foundation.Collections.IVectorView<Windows.Networking.EndpointPair> | Windows.Networking.EndpointPair[];
+    static NetworkStatusChanged: Windows.Networking.Connectivity.NetworkStatusChangedEventHandler | null;
+  }
+
+  class NetworkItem implements Windows.Networking.Connectivity.INetworkItem {
+    GetNetworkTypes(): number;
+    readonly NetworkId: Guid;
+  }
+
+  class NetworkSecuritySettings implements Windows.Networking.Connectivity.INetworkSecuritySettings {
+    readonly NetworkAuthenticationType: number;
+    readonly NetworkEncryptionType: number;
+  }
+
+  class NetworkStateChangeEventDetails implements Windows.Networking.Connectivity.INetworkStateChangeEventDetails, Windows.Networking.Connectivity.INetworkStateChangeEventDetails2 {
+    readonly HasNewConnectionCost: boolean;
+    readonly HasNewDomainConnectivityLevel: boolean;
+    readonly HasNewHostNameList: boolean;
+    readonly HasNewInternetConnectionProfile: boolean;
+    readonly HasNewNetworkConnectivityLevel: boolean;
+    readonly HasNewTetheringClientCount: boolean;
+    readonly HasNewTetheringOperationalState: boolean;
+    readonly HasNewWwanRegistrationState: boolean;
+  }
+
+  class NetworkUsage implements Windows.Networking.Connectivity.INetworkUsage {
+    readonly BytesReceived: number | bigint;
+    readonly BytesSent: number | bigint;
+    readonly ConnectionDuration: Windows.Foundation.TimeSpan;
+  }
+
+  class ProviderNetworkUsage implements Windows.Networking.Connectivity.IProviderNetworkUsage {
+    readonly BytesReceived: number | bigint;
+    readonly BytesSent: number | bigint;
+    readonly ProviderId: string;
+  }
+
+  class ProxyConfiguration implements Windows.Networking.Connectivity.IProxyConfiguration {
+    readonly CanConnectDirectly: boolean;
+    readonly ProxyUris: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+  }
+
+  class RoutePolicy implements Windows.Networking.Connectivity.IRoutePolicy {
+    constructor(connectionProfile: Windows.Networking.Connectivity.ConnectionProfile, hostName: Windows.Networking.HostName, type: number);
+    readonly ConnectionProfile: Windows.Networking.Connectivity.ConnectionProfile;
+    readonly HostName: Windows.Networking.HostName;
+    readonly HostNameType: number;
+  }
+
+  class WlanConnectionProfileDetails implements Windows.Networking.Connectivity.IWlanConnectionProfileDetails {
+    GetConnectedSsid(): string;
+  }
+
+  class WwanConnectionProfileDetails implements Windows.Networking.Connectivity.IWwanConnectionProfileDetails, Windows.Networking.Connectivity.IWwanConnectionProfileDetails2 {
+    GetCurrentDataClass(): number;
+    GetNetworkRegistrationState(): number;
+    readonly AccessPointName: string;
+    readonly HomeProviderId: string;
+    readonly IPKind: number;
+    readonly PurposeGuids: Windows.Foundation.Collections.IVectorView<Guid> | Guid[];
+  }
+
+  enum CellularApnAuthenticationType {
+    None = 0,
+    Pap = 1,
+    Chap = 2,
+    Mschapv2 = 3,
+  }
+
+  enum ConnectionProfileDeleteStatus {
+    Success = 0,
+    DeniedByUser = 1,
+    DeniedBySystem = 2,
+    UnknownError = 3,
+  }
+
+  enum DataUsageGranularity {
+    PerMinute = 0,
+    PerHour = 1,
+    PerDay = 2,
+    Total = 3,
+  }
+
+  enum DomainAuthenticationKind {
+    None = 0,
+    Ldap = 1,
+    Tls = 2,
+  }
+
+  enum DomainConnectivityLevel {
+    None = 0,
+    Unauthenticated = 1,
+    Authenticated = 2,
+  }
+
+  enum NetworkAuthenticationType {
+    None = 0,
+    Unknown = 1,
+    Open80211 = 2,
+    SharedKey80211 = 3,
+    Wpa = 4,
+    WpaPsk = 5,
+    WpaNone = 6,
+    Rsna = 7,
+    RsnaPsk = 8,
+    Ihv = 9,
+    Wpa3 = 10,
+    Wpa3Enterprise192Bits = 10,
+    Wpa3Sae = 11,
+    Owe = 12,
+    Wpa3Enterprise = 13,
+  }
+
+  enum NetworkConnectivityLevel {
+    None = 0,
+    LocalAccess = 1,
+    ConstrainedInternetAccess = 2,
+    InternetAccess = 3,
+  }
+
+  enum NetworkCostType {
+    Unknown = 0,
+    Unrestricted = 1,
+    Fixed = 2,
+    Variable = 3,
+  }
+
+  enum NetworkEncryptionType {
+    None = 0,
+    Unknown = 1,
+    Wep = 2,
+    Wep40 = 3,
+    Wep104 = 4,
+    Tkip = 5,
+    Ccmp = 6,
+    WpaUseGroup = 7,
+    RsnUseGroup = 8,
+    Ihv = 9,
+    Gcmp = 10,
+    Gcmp256 = 11,
+  }
+
+  enum NetworkTypes {
+    None = 0,
+    Internet = 1,
+    PrivateNetwork = 2,
+  }
+
+  enum RoamingStates {
+    None = 0,
+    NotRoaming = 1,
+    Roaming = 2,
+  }
+
+  enum TriStates {
+    DoNotCare = 0,
+    No = 1,
+    Yes = 2,
+  }
+
+  enum WwanDataClass {
+    None = 0,
+    Gprs = 1,
+    Edge = 2,
+    Umts = 4,
+    Hsdpa = 8,
+    Hsupa = 16,
+    LteAdvanced = 32,
+    NewRadioNonStandalone = 64,
+    NewRadioStandalone = 128,
+    Cdma1xRtt = 65536,
+    Cdma1xEvdo = 131072,
+    Cdma1xEvdoRevA = 262144,
+    Cdma1xEvdv = 524288,
+    Cdma3xRtt = 1048576,
+    Cdma1xEvdoRevB = 2097152,
+    CdmaUmb = 4194304,
+    Custom = 2147483648,
+  }
+
+  enum WwanNetworkIPKind {
+    None = 0,
+    Ipv4 = 1,
+    Ipv6 = 2,
+    Ipv4v6 = 3,
+    Ipv4v6v4Xlat = 4,
+  }
+
+  enum WwanNetworkRegistrationState {
+    None = 0,
+    Deregistered = 1,
+    Searching = 2,
+    Home = 3,
+    Roaming = 4,
+    Partner = 5,
+    Denied = 6,
+  }
+
+  interface IAttributedNetworkUsage {
+    readonly AttributionId: string;
+    readonly AttributionName: string;
+    readonly AttributionThumbnail: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly BytesReceived: number | bigint;
+    readonly BytesSent: number | bigint;
+  }
+  var IAttributedNetworkUsage: abstract new (...args: any[]) => IAttributedNetworkUsage;
+
+  interface ICellularApnContext {
+    AccessPointName: string;
+    AuthenticationType: number;
+    IsCompressionEnabled: boolean;
+    Password: string;
+    ProviderId: string;
+    UserName: string;
+  }
+  var ICellularApnContext: abstract new (...args: any[]) => ICellularApnContext;
+
+  interface ICellularApnContext2 {
+    ProfileName: string;
+  }
+  var ICellularApnContext2: abstract new (...args: any[]) => ICellularApnContext2;
+
+  interface IConnectionCost {
+    readonly ApproachingDataLimit: boolean;
+    readonly NetworkCostType: number;
+    readonly OverDataLimit: boolean;
+    readonly Roaming: boolean;
+  }
+  var IConnectionCost: abstract new (...args: any[]) => IConnectionCost;
+
+  interface IConnectionCost2 {
+    readonly BackgroundDataUsageRestricted: boolean;
+  }
+  var IConnectionCost2: abstract new (...args: any[]) => IConnectionCost2;
+
+  interface IConnectionProfile {
+    GetConnectionCost(): Windows.Networking.Connectivity.ConnectionCost;
+    GetDataPlanStatus(): Windows.Networking.Connectivity.DataPlanStatus;
+    GetLocalUsage(StartTime: Windows.Foundation.DateTime, EndTime: Windows.Foundation.DateTime): Windows.Networking.Connectivity.DataUsage;
+    GetLocalUsage(StartTime: Windows.Foundation.DateTime, EndTime: Windows.Foundation.DateTime, States: number): Windows.Networking.Connectivity.DataUsage;
+    GetNetworkConnectivityLevel(): number;
+    GetNetworkNames(): Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly NetworkAdapter: Windows.Networking.Connectivity.NetworkAdapter;
+    readonly NetworkSecuritySettings: Windows.Networking.Connectivity.NetworkSecuritySettings;
+    readonly ProfileName: string;
+  }
+  var IConnectionProfile: abstract new (...args: any[]) => IConnectionProfile;
+
+  interface IConnectionProfile2 {
+    GetConnectivityIntervalsAsync(startTime: Windows.Foundation.DateTime, endTime: Windows.Foundation.DateTime, states: Windows.Networking.Connectivity.NetworkUsageStates): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.Connectivity.ConnectivityInterval> | Windows.Networking.Connectivity.ConnectivityInterval[]>;
+    GetDomainConnectivityLevel(): number;
+    GetNetworkUsageAsync(startTime: Windows.Foundation.DateTime, endTime: Windows.Foundation.DateTime, granularity: number, states: Windows.Networking.Connectivity.NetworkUsageStates): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.Connectivity.NetworkUsage> | Windows.Networking.Connectivity.NetworkUsage[]>;
+    GetSignalBars(): number | null;
+    readonly IsWlanConnectionProfile: boolean;
+    readonly IsWwanConnectionProfile: boolean;
+    readonly ServiceProviderGuid: Guid | null;
+    readonly WlanConnectionProfileDetails: Windows.Networking.Connectivity.WlanConnectionProfileDetails;
+    readonly WwanConnectionProfileDetails: Windows.Networking.Connectivity.WwanConnectionProfileDetails;
+  }
+  var IConnectionProfile2: abstract new (...args: any[]) => IConnectionProfile2;
+
+  interface IConnectionProfile3 {
+    GetAttributedNetworkUsageAsync(startTime: Windows.Foundation.DateTime, endTime: Windows.Foundation.DateTime, states: Windows.Networking.Connectivity.NetworkUsageStates): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.Connectivity.AttributedNetworkUsage> | Windows.Networking.Connectivity.AttributedNetworkUsage[]>;
+  }
+  var IConnectionProfile3: abstract new (...args: any[]) => IConnectionProfile3;
+
+  interface IConnectionProfile4 {
+    GetProviderNetworkUsageAsync(startTime: Windows.Foundation.DateTime, endTime: Windows.Foundation.DateTime, states: Windows.Networking.Connectivity.NetworkUsageStates): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.Connectivity.ProviderNetworkUsage> | Windows.Networking.Connectivity.ProviderNetworkUsage[]>;
+  }
+  var IConnectionProfile4: abstract new (...args: any[]) => IConnectionProfile4;
+
+  interface IConnectionProfile5 {
+    TryDeleteAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly CanDelete: boolean;
+  }
+  var IConnectionProfile5: abstract new (...args: any[]) => IConnectionProfile5;
+
+  interface IConnectionProfile6 {
+    IsDomainAuthenticatedBy(kind: number): boolean;
+  }
+  var IConnectionProfile6: abstract new (...args: any[]) => IConnectionProfile6;
+
+  interface IConnectionProfileFilter {
+    IsConnected: boolean;
+    IsWlanConnectionProfile: boolean;
+    IsWwanConnectionProfile: boolean;
+    NetworkCostType: number;
+    ServiceProviderGuid: Guid | null;
+  }
+  var IConnectionProfileFilter: abstract new (...args: any[]) => IConnectionProfileFilter;
+
+  interface IConnectionProfileFilter2 {
+    IsBackgroundDataUsageRestricted: boolean | null;
+    IsOverDataLimit: boolean | null;
+    IsRoaming: boolean | null;
+    readonly RawData: Windows.Storage.Streams.IBuffer;
+  }
+  var IConnectionProfileFilter2: abstract new (...args: any[]) => IConnectionProfileFilter2;
+
+  interface IConnectionProfileFilter3 {
+    PurposeGuid: Guid | null;
+  }
+  var IConnectionProfileFilter3: abstract new (...args: any[]) => IConnectionProfileFilter3;
+
+  interface IConnectionSession extends Windows.Foundation.IClosable {
+    Close(): void;
+    readonly ConnectionProfile: Windows.Networking.Connectivity.ConnectionProfile;
+  }
+  var IConnectionSession: abstract new (...args: any[]) => IConnectionSession;
+
+  interface IConnectivityInterval {
+    readonly ConnectionDuration: Windows.Foundation.TimeSpan;
+    readonly StartTime: Windows.Foundation.DateTime;
+  }
+  var IConnectivityInterval: abstract new (...args: any[]) => IConnectivityInterval;
+
+  interface IConnectivityManagerStatics {
+    AcquireConnectionAsync(cellularApnContext: Windows.Networking.Connectivity.CellularApnContext): Windows.Foundation.IAsyncOperation<Windows.Networking.Connectivity.ConnectionSession>;
+    AddHttpRoutePolicy(routePolicy: Windows.Networking.Connectivity.RoutePolicy): void;
+    RemoveHttpRoutePolicy(routePolicy: Windows.Networking.Connectivity.RoutePolicy): void;
+  }
+  var IConnectivityManagerStatics: abstract new (...args: any[]) => IConnectivityManagerStatics;
+
+  interface IDataPlanStatus {
+    readonly DataLimitInMegabytes: number | null;
+    readonly DataPlanUsage: Windows.Networking.Connectivity.DataPlanUsage;
+    readonly InboundBitsPerSecond: number | bigint | null;
+    readonly MaxTransferSizeInMegabytes: number | null;
+    readonly NextBillingCycle: Windows.Foundation.DateTime | null;
+    readonly OutboundBitsPerSecond: number | bigint | null;
+  }
+  var IDataPlanStatus: abstract new (...args: any[]) => IDataPlanStatus;
+
+  interface IDataPlanUsage {
+    readonly LastSyncTime: Windows.Foundation.DateTime;
+    readonly MegabytesUsed: number;
+  }
+  var IDataPlanUsage: abstract new (...args: any[]) => IDataPlanUsage;
+
+  interface IDataUsage {
+    readonly BytesReceived: number | bigint;
+    readonly BytesSent: number | bigint;
+  }
+  var IDataUsage: abstract new (...args: any[]) => IDataUsage;
+
+  interface IIPInformation {
+    readonly NetworkAdapter: Windows.Networking.Connectivity.NetworkAdapter;
+    readonly PrefixLength: number | null;
+  }
+  var IIPInformation: abstract new (...args: any[]) => IIPInformation;
+
+  interface ILanIdentifier {
+    readonly InfrastructureId: Windows.Networking.Connectivity.LanIdentifierData;
+    readonly NetworkAdapterId: Guid;
+    readonly PortId: Windows.Networking.Connectivity.LanIdentifierData;
+  }
+  var ILanIdentifier: abstract new (...args: any[]) => ILanIdentifier;
+
+  interface ILanIdentifierData {
+    readonly Type: number;
+    readonly Value: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var ILanIdentifierData: abstract new (...args: any[]) => ILanIdentifierData;
+
+  interface INetworkAdapter {
+    GetConnectedProfileAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.Connectivity.ConnectionProfile>;
+    readonly IanaInterfaceType: number;
+    readonly InboundMaxBitsPerSecond: number | bigint;
+    readonly NetworkAdapterId: Guid;
+    readonly NetworkItem: Windows.Networking.Connectivity.NetworkItem;
+    readonly OutboundMaxBitsPerSecond: number | bigint;
+  }
+  var INetworkAdapter: abstract new (...args: any[]) => INetworkAdapter;
+
+  interface INetworkInformationStatics {
+    GetConnectionProfiles(): Windows.Foundation.Collections.IVectorView<Windows.Networking.Connectivity.ConnectionProfile> | Windows.Networking.Connectivity.ConnectionProfile[];
+    GetHostNames(): Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[];
+    GetInternetConnectionProfile(): Windows.Networking.Connectivity.ConnectionProfile;
+    GetLanIdentifiers(): Windows.Foundation.Collections.IVectorView<Windows.Networking.Connectivity.LanIdentifier> | Windows.Networking.Connectivity.LanIdentifier[];
+    GetProxyConfigurationAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Networking.Connectivity.ProxyConfiguration>;
+    GetSortedEndpointPairs(destinationList: Windows.Foundation.Collections.IIterable<Windows.Networking.EndpointPair> | Windows.Networking.EndpointPair[], sortOptions: number): Windows.Foundation.Collections.IVectorView<Windows.Networking.EndpointPair> | Windows.Networking.EndpointPair[];
+    NetworkStatusChanged: Windows.Networking.Connectivity.NetworkStatusChangedEventHandler | null;
+  }
+  var INetworkInformationStatics: abstract new (...args: any[]) => INetworkInformationStatics;
+
+  interface INetworkInformationStatics2 {
+    FindConnectionProfilesAsync(pProfileFilter: Windows.Networking.Connectivity.ConnectionProfileFilter): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.Connectivity.ConnectionProfile> | Windows.Networking.Connectivity.ConnectionProfile[]>;
+  }
+  var INetworkInformationStatics2: abstract new (...args: any[]) => INetworkInformationStatics2;
+
+  interface INetworkItem {
+    GetNetworkTypes(): number;
+    readonly NetworkId: Guid;
+  }
+  var INetworkItem: abstract new (...args: any[]) => INetworkItem;
+
+  interface INetworkSecuritySettings {
+    readonly NetworkAuthenticationType: number;
+    readonly NetworkEncryptionType: number;
+  }
+  var INetworkSecuritySettings: abstract new (...args: any[]) => INetworkSecuritySettings;
+
+  interface INetworkStateChangeEventDetails {
+    readonly HasNewConnectionCost: boolean;
+    readonly HasNewDomainConnectivityLevel: boolean;
+    readonly HasNewHostNameList: boolean;
+    readonly HasNewInternetConnectionProfile: boolean;
+    readonly HasNewNetworkConnectivityLevel: boolean;
+    readonly HasNewWwanRegistrationState: boolean;
+  }
+  var INetworkStateChangeEventDetails: abstract new (...args: any[]) => INetworkStateChangeEventDetails;
+
+  interface INetworkStateChangeEventDetails2 {
+    readonly HasNewTetheringClientCount: boolean;
+    readonly HasNewTetheringOperationalState: boolean;
+  }
+  var INetworkStateChangeEventDetails2: abstract new (...args: any[]) => INetworkStateChangeEventDetails2;
+
+  interface INetworkUsage {
+    readonly BytesReceived: number | bigint;
+    readonly BytesSent: number | bigint;
+    readonly ConnectionDuration: Windows.Foundation.TimeSpan;
+  }
+  var INetworkUsage: abstract new (...args: any[]) => INetworkUsage;
+
+  interface IProviderNetworkUsage {
+    readonly BytesReceived: number | bigint;
+    readonly BytesSent: number | bigint;
+    readonly ProviderId: string;
+  }
+  var IProviderNetworkUsage: abstract new (...args: any[]) => IProviderNetworkUsage;
+
+  interface IProxyConfiguration {
+    readonly CanConnectDirectly: boolean;
+    readonly ProxyUris: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+  }
+  var IProxyConfiguration: abstract new (...args: any[]) => IProxyConfiguration;
+
+  interface IRoutePolicy {
+    readonly ConnectionProfile: Windows.Networking.Connectivity.ConnectionProfile;
+    readonly HostName: Windows.Networking.HostName;
+    readonly HostNameType: number;
+  }
+  var IRoutePolicy: abstract new (...args: any[]) => IRoutePolicy;
+
+  interface IRoutePolicyFactory {
+    CreateRoutePolicy(connectionProfile: Windows.Networking.Connectivity.ConnectionProfile, hostName: Windows.Networking.HostName, type: number): Windows.Networking.Connectivity.RoutePolicy;
+  }
+  var IRoutePolicyFactory: abstract new (...args: any[]) => IRoutePolicyFactory;
+
+  interface IWlanConnectionProfileDetails {
+    GetConnectedSsid(): string;
+  }
+  var IWlanConnectionProfileDetails: abstract new (...args: any[]) => IWlanConnectionProfileDetails;
+
+  interface IWwanConnectionProfileDetails {
+    GetCurrentDataClass(): number;
+    GetNetworkRegistrationState(): number;
+    readonly AccessPointName: string;
+    readonly HomeProviderId: string;
+  }
+  var IWwanConnectionProfileDetails: abstract new (...args: any[]) => IWwanConnectionProfileDetails;
+
+  interface IWwanConnectionProfileDetails2 {
+    readonly IPKind: number;
+    readonly PurposeGuids: Windows.Foundation.Collections.IVectorView<Guid> | Guid[];
+  }
+  var IWwanConnectionProfileDetails2: abstract new (...args: any[]) => IWwanConnectionProfileDetails2;
+
+  interface NetworkStatusChangedEventHandler {
+    (sender: Object): void;
+  }
+  var NetworkStatusChangedEventHandler: {
+    new(callback: (sender: Object) => void): NetworkStatusChangedEventHandler;
+  };
+
+  interface NetworkUsageStates {
+    Roaming: number;
+    Shared: number;
+  }
+  var NetworkUsageStates: {
+    new(roaming: number, shared: number): NetworkUsageStates;
+    new(fields: { Roaming?: number; Shared?: number }): NetworkUsageStates;
+  };
+
+  interface WwanContract {
+  }
+  var WwanContract: {
+    new(fields: {  }): WwanContract;
+  };
+
+}
+
+declare namespace Windows.Networking.NetworkOperators {
+  class ESim implements Windows.Networking.NetworkOperators.IESim, Windows.Networking.NetworkOperators.IESim2, Windows.Networking.NetworkOperators.IESim3 {
+    DeleteProfileAsync(profileId: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimOperationResult>;
+    Discover(): Windows.Networking.NetworkOperators.ESimDiscoverResult;
+    Discover(serverAddress: string, matchingId: string): Windows.Networking.NetworkOperators.ESimDiscoverResult;
+    DiscoverAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimDiscoverResult>;
+    DiscoverAsync(serverAddress: string, matchingId: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimDiscoverResult>;
+    DownloadProfileMetadataAsync(activationCode: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimDownloadProfileMetadataResult>;
+    GetProfiles(): Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.ESimProfile> | Windows.Networking.NetworkOperators.ESimProfile[];
+    ResetAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimOperationResult>;
+    readonly AvailableMemoryInBytes: number | null;
+    readonly Eid: string;
+    readonly FirmwareVersion: string;
+    readonly MobileBroadbandModemDeviceId: string;
+    readonly Policy: Windows.Networking.NetworkOperators.ESimPolicy;
+    readonly SlotIndex: number | null;
+    readonly State: number;
+    ProfileChanged: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.ESim, Object> | null;
+  }
+
+  class ESimAddedEventArgs implements Windows.Networking.NetworkOperators.IESimAddedEventArgs {
+    readonly ESim: Windows.Networking.NetworkOperators.ESim;
+  }
+
+  class ESimDiscoverEvent implements Windows.Networking.NetworkOperators.IESimDiscoverEvent {
+    readonly MatchingId: string;
+    readonly RspServerAddress: string;
+  }
+
+  class ESimDiscoverResult implements Windows.Networking.NetworkOperators.IESimDiscoverResult {
+    readonly Events: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.ESimDiscoverEvent> | Windows.Networking.NetworkOperators.ESimDiscoverEvent[];
+    readonly Kind: number;
+    readonly ProfileMetadata: Windows.Networking.NetworkOperators.ESimProfileMetadata;
+    readonly Result: Windows.Networking.NetworkOperators.ESimOperationResult;
+  }
+
+  class ESimDownloadProfileMetadataResult implements Windows.Networking.NetworkOperators.IESimDownloadProfileMetadataResult {
+    readonly ProfileMetadata: Windows.Networking.NetworkOperators.ESimProfileMetadata;
+    readonly Result: Windows.Networking.NetworkOperators.ESimOperationResult;
+  }
+
+  class ESimManager {
+    static TryCreateESimWatcher(): Windows.Networking.NetworkOperators.ESimWatcher;
+    static readonly ServiceInfo: Windows.Networking.NetworkOperators.ESimServiceInfo;
+    static ServiceInfoChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class ESimOperationResult implements Windows.Networking.NetworkOperators.IESimOperationResult {
+    readonly Status: number;
+  }
+
+  class ESimPolicy implements Windows.Networking.NetworkOperators.IESimPolicy {
+    readonly ShouldEnableManagingUi: boolean;
+  }
+
+  class ESimProfile implements Windows.Networking.NetworkOperators.IESimProfile {
+    DisableAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimOperationResult>;
+    EnableAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimOperationResult>;
+    SetNicknameAsync(newNickname: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimOperationResult>;
+    readonly Class: number;
+    readonly Id: string;
+    readonly Nickname: string;
+    readonly Policy: Windows.Networking.NetworkOperators.ESimProfilePolicy;
+    readonly ProviderIcon: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly ProviderId: string;
+    readonly ProviderName: string;
+    readonly State: number;
+  }
+
+  class ESimProfileMetadata implements Windows.Networking.NetworkOperators.IESimProfileMetadata {
+    ConfirmInstallAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Networking.NetworkOperators.ESimOperationResult, Windows.Networking.NetworkOperators.ESimProfileInstallProgress>;
+    ConfirmInstallAsync(confirmationCode: string): Windows.Foundation.IAsyncOperationWithProgress<Windows.Networking.NetworkOperators.ESimOperationResult, Windows.Networking.NetworkOperators.ESimProfileInstallProgress>;
+    DenyInstallAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimOperationResult>;
+    PostponeInstallAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimOperationResult>;
+    readonly Id: string;
+    readonly IsConfirmationCodeRequired: boolean;
+    readonly Policy: Windows.Networking.NetworkOperators.ESimProfilePolicy;
+    readonly ProviderIcon: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly ProviderId: string;
+    readonly ProviderName: string;
+    readonly State: number;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.ESimProfileMetadata, Object> | null;
+  }
+
+  class ESimProfilePolicy implements Windows.Networking.NetworkOperators.IESimProfilePolicy {
+    readonly CanDelete: boolean;
+    readonly CanDisable: boolean;
+    readonly IsManagedByEnterprise: boolean;
+  }
+
+  class ESimRemovedEventArgs implements Windows.Networking.NetworkOperators.IESimRemovedEventArgs {
+    readonly ESim: Windows.Networking.NetworkOperators.ESim;
+  }
+
+  class ESimServiceInfo implements Windows.Networking.NetworkOperators.IESimServiceInfo {
+    readonly AuthenticationPreference: number;
+    readonly IsESimUiEnabled: boolean;
+  }
+
+  class ESimUpdatedEventArgs implements Windows.Networking.NetworkOperators.IESimUpdatedEventArgs {
+    readonly ESim: Windows.Networking.NetworkOperators.ESim;
+  }
+
+  class ESimWatcher implements Windows.Networking.NetworkOperators.IESimWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.ESimWatcher, Windows.Networking.NetworkOperators.ESimAddedEventArgs> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.ESimWatcher, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.ESimWatcher, Windows.Networking.NetworkOperators.ESimRemovedEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.ESimWatcher, Object> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.ESimWatcher, Windows.Networking.NetworkOperators.ESimUpdatedEventArgs> | null;
+  }
+
+  class HotspotAuthenticationContext implements Windows.Networking.NetworkOperators.IHotspotAuthenticationContext, Windows.Networking.NetworkOperators.IHotspotAuthenticationContext2 {
+    AbortAuthentication(markAsManual: boolean): void;
+    IssueCredentials(userName: string, password: string, extraParameters: string, markAsManualConnectOnFailure: boolean): void;
+    IssueCredentialsAsync(userName: string, password: string, extraParameters: string, markAsManualConnectOnFailure: boolean): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.HotspotCredentialsAuthenticationResult>;
+    SkipAuthentication(): void;
+    TriggerAttentionRequired(packageRelativeApplicationId: string, applicationParameters: string): void;
+    static TryGetAuthenticationContext(evenToken: string, context: Windows.Networking.NetworkOperators.HotspotAuthenticationContext): boolean;
+    readonly AuthenticationUrl: Windows.Foundation.Uri;
+    readonly NetworkAdapter: Windows.Networking.Connectivity.NetworkAdapter;
+    readonly RedirectMessageUrl: Windows.Foundation.Uri;
+    readonly RedirectMessageXml: Windows.Data.Xml.Dom.XmlDocument;
+    readonly WirelessNetworkId: number[];
+  }
+
+  class HotspotAuthenticationEventDetails implements Windows.Networking.NetworkOperators.IHotspotAuthenticationEventDetails {
+    readonly EventToken: string;
+  }
+
+  class HotspotCredentialsAuthenticationResult implements Windows.Networking.NetworkOperators.IHotspotCredentialsAuthenticationResult {
+    readonly AuthenticationReplyXml: Windows.Data.Xml.Dom.XmlDocument;
+    readonly HasNetworkErrorOccurred: boolean;
+    readonly LogoffUrl: Windows.Foundation.Uri;
+    readonly ResponseCode: number;
+  }
+
+  class KnownCSimFilePaths {
+    static readonly EFSpn: Windows.Foundation.Collections.IVectorView<number> | number[];
+    static readonly Gid1: Windows.Foundation.Collections.IVectorView<number> | number[];
+    static readonly Gid2: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class KnownRuimFilePaths {
+    static readonly EFSpn: Windows.Foundation.Collections.IVectorView<number> | number[];
+    static readonly Gid1: Windows.Foundation.Collections.IVectorView<number> | number[];
+    static readonly Gid2: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class KnownSimFilePaths {
+    static readonly EFOns: Windows.Foundation.Collections.IVectorView<number> | number[];
+    static readonly EFSpn: Windows.Foundation.Collections.IVectorView<number> | number[];
+    static readonly Gid1: Windows.Foundation.Collections.IVectorView<number> | number[];
+    static readonly Gid2: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class KnownUSimFilePaths {
+    static readonly EFOpl: Windows.Foundation.Collections.IVectorView<number> | number[];
+    static readonly EFPnn: Windows.Foundation.Collections.IVectorView<number> | number[];
+    static readonly EFSpn: Windows.Foundation.Collections.IVectorView<number> | number[];
+    static readonly Gid1: Windows.Foundation.Collections.IVectorView<number> | number[];
+    static readonly Gid2: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class MobileBroadbandAccount implements Windows.Networking.NetworkOperators.IMobileBroadbandAccount, Windows.Networking.NetworkOperators.IMobileBroadbandAccount2, Windows.Networking.NetworkOperators.IMobileBroadbandAccount3 {
+    static CreateFromNetworkAccountId(networkAccountId: string): Windows.Networking.NetworkOperators.MobileBroadbandAccount;
+    GetConnectionProfiles(): Windows.Foundation.Collections.IVectorView<Windows.Networking.Connectivity.ConnectionProfile> | Windows.Networking.Connectivity.ConnectionProfile[];
+    readonly AccountExperienceUrl: Windows.Foundation.Uri;
+    static readonly AvailableNetworkAccountIds: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly CurrentDeviceInformation: Windows.Networking.NetworkOperators.MobileBroadbandDeviceInformation;
+    readonly CurrentNetwork: Windows.Networking.NetworkOperators.MobileBroadbandNetwork;
+    readonly NetworkAccountId: string;
+    readonly ServiceProviderGuid: Guid;
+    readonly ServiceProviderName: string;
+  }
+
+  class MobileBroadbandAccountEventArgs implements Windows.Networking.NetworkOperators.IMobileBroadbandAccountEventArgs {
+    readonly NetworkAccountId: string;
+  }
+
+  class MobileBroadbandAccountUpdatedEventArgs implements Windows.Networking.NetworkOperators.IMobileBroadbandAccountUpdatedEventArgs {
+    readonly HasDeviceInformationChanged: boolean;
+    readonly HasNetworkChanged: boolean;
+    readonly NetworkAccountId: string;
+  }
+
+  class MobileBroadbandAccountWatcher implements Windows.Networking.NetworkOperators.IMobileBroadbandAccountWatcher {
+    constructor();
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    AccountAdded: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher, Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs> | null;
+    AccountRemoved: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher, Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs> | null;
+    AccountUpdated: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher, Windows.Networking.NetworkOperators.MobileBroadbandAccountUpdatedEventArgs> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher, Object> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher, Object> | null;
+  }
+
+  class MobileBroadbandAntennaSar implements Windows.Networking.NetworkOperators.IMobileBroadbandAntennaSar {
+    constructor(antennaIndex: number, sarBackoffIndex: number);
+    readonly AntennaIndex: number;
+    readonly SarBackoffIndex: number;
+  }
+
+  class MobileBroadbandCellCdma implements Windows.Networking.NetworkOperators.IMobileBroadbandCellCdma {
+    readonly BaseStationId: number | null;
+    readonly BaseStationLastBroadcastGpsTime: Windows.Foundation.TimeSpan | null;
+    readonly BaseStationLatitude: number | null;
+    readonly BaseStationLongitude: number | null;
+    readonly BaseStationPNCode: number | null;
+    readonly NetworkId: number | null;
+    readonly PilotSignalStrengthInDB: number | null;
+    readonly SystemId: number | null;
+  }
+
+  class MobileBroadbandCellGsm implements Windows.Networking.NetworkOperators.IMobileBroadbandCellGsm {
+    readonly BaseStationId: number | null;
+    readonly CellId: number | null;
+    readonly ChannelNumber: number | null;
+    readonly LocationAreaCode: number | null;
+    readonly ProviderId: string;
+    readonly ReceivedSignalStrengthInDBm: number | null;
+    readonly TimingAdvanceInBitPeriods: number | null;
+  }
+
+  class MobileBroadbandCellLte implements Windows.Networking.NetworkOperators.IMobileBroadbandCellLte {
+    readonly CellId: number | null;
+    readonly ChannelNumber: number | null;
+    readonly PhysicalCellId: number | null;
+    readonly ProviderId: string;
+    readonly ReferenceSignalReceivedPowerInDBm: number | null;
+    readonly ReferenceSignalReceivedQualityInDBm: number | null;
+    readonly TimingAdvanceInBitPeriods: number | null;
+    readonly TrackingAreaCode: number | null;
+  }
+
+  class MobileBroadbandCellNR implements Windows.Networking.NetworkOperators.IMobileBroadbandCellNR {
+    readonly CellId: number | bigint | null;
+    readonly ChannelNumber: number | null;
+    readonly PhysicalCellId: number | null;
+    readonly ProviderId: string;
+    readonly ReferenceSignalReceivedPowerInDBm: number | null;
+    readonly ReferenceSignalReceivedQualityInDBm: number | null;
+    readonly SignalToNoiseRatioInDB: number | null;
+    readonly TimingAdvanceInNanoseconds: number | null;
+    readonly TrackingAreaCode: number | null;
+  }
+
+  class MobileBroadbandCellTdscdma implements Windows.Networking.NetworkOperators.IMobileBroadbandCellTdscdma {
+    readonly CellId: number | null;
+    readonly CellParameterId: number | null;
+    readonly ChannelNumber: number | null;
+    readonly LocationAreaCode: number | null;
+    readonly PathLossInDB: number | null;
+    readonly ProviderId: string;
+    readonly ReceivedSignalCodePowerInDBm: number | null;
+    readonly TimingAdvanceInBitPeriods: number | null;
+  }
+
+  class MobileBroadbandCellUmts implements Windows.Networking.NetworkOperators.IMobileBroadbandCellUmts {
+    readonly CellId: number | null;
+    readonly ChannelNumber: number | null;
+    readonly LocationAreaCode: number | null;
+    readonly PathLossInDB: number | null;
+    readonly PrimaryScramblingCode: number | null;
+    readonly ProviderId: string;
+    readonly ReceivedSignalCodePowerInDBm: number | null;
+    readonly SignalToNoiseRatioInDB: number | null;
+  }
+
+  class MobileBroadbandCellsInfo implements Windows.Networking.NetworkOperators.IMobileBroadbandCellsInfo, Windows.Networking.NetworkOperators.IMobileBroadbandCellsInfo2 {
+    readonly NeighboringCellsCdma: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellCdma> | Windows.Networking.NetworkOperators.MobileBroadbandCellCdma[];
+    readonly NeighboringCellsGsm: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellGsm> | Windows.Networking.NetworkOperators.MobileBroadbandCellGsm[];
+    readonly NeighboringCellsLte: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellLte> | Windows.Networking.NetworkOperators.MobileBroadbandCellLte[];
+    readonly NeighboringCellsNR: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellNR> | Windows.Networking.NetworkOperators.MobileBroadbandCellNR[];
+    readonly NeighboringCellsTdscdma: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellTdscdma> | Windows.Networking.NetworkOperators.MobileBroadbandCellTdscdma[];
+    readonly NeighboringCellsUmts: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellUmts> | Windows.Networking.NetworkOperators.MobileBroadbandCellUmts[];
+    readonly ServingCellsCdma: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellCdma> | Windows.Networking.NetworkOperators.MobileBroadbandCellCdma[];
+    readonly ServingCellsGsm: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellGsm> | Windows.Networking.NetworkOperators.MobileBroadbandCellGsm[];
+    readonly ServingCellsLte: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellLte> | Windows.Networking.NetworkOperators.MobileBroadbandCellLte[];
+    readonly ServingCellsNR: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellNR> | Windows.Networking.NetworkOperators.MobileBroadbandCellNR[];
+    readonly ServingCellsTdscdma: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellTdscdma> | Windows.Networking.NetworkOperators.MobileBroadbandCellTdscdma[];
+    readonly ServingCellsUmts: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellUmts> | Windows.Networking.NetworkOperators.MobileBroadbandCellUmts[];
+  }
+
+  class MobileBroadbandCurrentSlotIndexChangedEventArgs implements Windows.Networking.NetworkOperators.IMobileBroadbandCurrentSlotIndexChangedEventArgs {
+    readonly CurrentSlotIndex: number;
+  }
+
+  class MobileBroadbandDeviceInformation implements Windows.Networking.NetworkOperators.IMobileBroadbandDeviceInformation, Windows.Networking.NetworkOperators.IMobileBroadbandDeviceInformation2, Windows.Networking.NetworkOperators.IMobileBroadbandDeviceInformation3, Windows.Networking.NetworkOperators.IMobileBroadbandDeviceInformation4 {
+    readonly CellularClass: number;
+    readonly CurrentRadioState: number;
+    readonly CustomDataClass: string;
+    readonly DataClasses: number;
+    readonly DeviceId: string;
+    readonly DeviceType: number;
+    readonly FirmwareInformation: string;
+    readonly Manufacturer: string;
+    readonly MobileEquipmentId: string;
+    readonly Model: string;
+    readonly NetworkDeviceStatus: number;
+    readonly PinManager: Windows.Networking.NetworkOperators.MobileBroadbandPinManager;
+    readonly Revision: string;
+    readonly SerialNumber: string;
+    readonly SimGid1: string;
+    readonly SimIccId: string;
+    readonly SimPnn: string;
+    readonly SimSpn: string;
+    readonly SlotManager: Windows.Networking.NetworkOperators.MobileBroadbandSlotManager;
+    readonly SubscriberId: string;
+    readonly TelephoneNumbers: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+
+  class MobileBroadbandDeviceService implements Windows.Networking.NetworkOperators.IMobileBroadbandDeviceService {
+    OpenCommandSession(): Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceCommandSession;
+    OpenDataSession(): Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession;
+    readonly DeviceServiceId: Guid;
+    readonly SupportedCommands: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class MobileBroadbandDeviceServiceCommandEventArgs implements Windows.Networking.NetworkOperators.IMobileBroadbandDeviceServiceCommandEventArgs {
+    readonly DeviceId: string;
+    readonly DeviceServiceId: Guid;
+    readonly EventId: number;
+    readonly ReceivedData: Windows.Storage.Streams.IBuffer;
+  }
+
+  class MobileBroadbandDeviceServiceCommandResult implements Windows.Networking.NetworkOperators.IMobileBroadbandDeviceServiceCommandResult {
+    readonly ResponseData: Windows.Storage.Streams.IBuffer;
+    readonly StatusCode: number;
+  }
+
+  class MobileBroadbandDeviceServiceCommandSession implements Windows.Networking.NetworkOperators.IMobileBroadbandDeviceServiceCommandSession, Windows.Networking.NetworkOperators.IMobileBroadbandDeviceServiceCommandSession2 {
+    CloseSession(): void;
+    SendQueryCommandAsync(commandId: number, data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceCommandResult>;
+    SendSetCommandAsync(commandId: number, data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceCommandResult>;
+    CommandReceived: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceCommandSession, Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceCommandEventArgs> | null;
+  }
+
+  class MobileBroadbandDeviceServiceDataReceivedEventArgs implements Windows.Networking.NetworkOperators.IMobileBroadbandDeviceServiceDataReceivedEventArgs {
+    readonly ReceivedData: Windows.Storage.Streams.IBuffer;
+  }
+
+  class MobileBroadbandDeviceServiceDataSession implements Windows.Networking.NetworkOperators.IMobileBroadbandDeviceServiceDataSession {
+    CloseSession(): void;
+    WriteDataAsync(value: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncAction;
+    DataReceived: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession, Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataReceivedEventArgs> | null;
+  }
+
+  class MobileBroadbandDeviceServiceInformation implements Windows.Networking.NetworkOperators.IMobileBroadbandDeviceServiceInformation {
+    readonly DeviceServiceId: Guid;
+    readonly IsDataReadSupported: boolean;
+    readonly IsDataWriteSupported: boolean;
+  }
+
+  class MobileBroadbandDeviceServiceTriggerDetails implements Windows.Networking.NetworkOperators.IMobileBroadbandDeviceServiceTriggerDetails, Windows.Networking.NetworkOperators.IMobileBroadbandDeviceServiceTriggerDetails2 {
+    readonly DeviceId: string;
+    readonly DeviceServiceId: Guid;
+    readonly EventId: number;
+    readonly ReceivedData: Windows.Storage.Streams.IBuffer;
+  }
+
+  class MobileBroadbandModem implements Windows.Networking.NetworkOperators.IMobileBroadbandModem, Windows.Networking.NetworkOperators.IMobileBroadbandModem2, Windows.Networking.NetworkOperators.IMobileBroadbandModem3, Windows.Networking.NetworkOperators.IMobileBroadbandModem4 {
+    static FromId(deviceId: string): Windows.Networking.NetworkOperators.MobileBroadbandModem;
+    GetCurrentConfigurationAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandModemConfiguration>;
+    static GetDefault(): Windows.Networking.NetworkOperators.MobileBroadbandModem;
+    static GetDeviceSelector(): string;
+    GetDeviceService(deviceServiceId: Guid): Windows.Networking.NetworkOperators.MobileBroadbandDeviceService;
+    GetIsPassthroughEnabled(slotindex: number): boolean;
+    GetIsPassthroughEnabledAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    GetIsPassthroughEnabledAsync(slotindex: number): Windows.Foundation.IAsyncOperation<boolean>;
+    ResetAsync(): Windows.Foundation.IAsyncAction;
+    SetIsPassthroughEnabled(value: boolean, slotindex: number): number;
+    SetIsPassthroughEnabledAsync(value: boolean): Windows.Foundation.IAsyncOperation<number>;
+    SetIsPassthroughEnabledAsync(value: boolean, slotindex: number): Windows.Foundation.IAsyncOperation<number>;
+    TryGetPcoAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandPco>;
+    readonly CurrentAccount: Windows.Networking.NetworkOperators.MobileBroadbandAccount;
+    readonly CurrentNetwork: Windows.Networking.NetworkOperators.MobileBroadbandNetwork;
+    readonly DeviceInformation: Windows.Networking.NetworkOperators.MobileBroadbandDeviceInformation;
+    readonly DeviceServices: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceInformation> | Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceInformation[];
+    readonly IsInEmergencyCallMode: boolean;
+    readonly IsResetSupported: boolean;
+    readonly MaxDeviceServiceCommandSizeInBytes: number;
+    readonly MaxDeviceServiceDataSizeInBytes: number;
+    IsInEmergencyCallModeChanged: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandModem, Object> | null;
+  }
+
+  class MobileBroadbandModemConfiguration implements Windows.Networking.NetworkOperators.IMobileBroadbandModemConfiguration, Windows.Networking.NetworkOperators.IMobileBroadbandModemConfiguration2 {
+    readonly HomeProviderId: string;
+    readonly HomeProviderName: string;
+    readonly SarManager: Windows.Networking.NetworkOperators.MobileBroadbandSarManager;
+    readonly Uicc: Windows.Networking.NetworkOperators.MobileBroadbandUicc;
+  }
+
+  class MobileBroadbandModemIsolation implements Windows.Networking.NetworkOperators.IMobileBroadbandModemIsolation {
+    constructor(modemDeviceId: string, ruleGroupId: string);
+    AddAllowedHost(host: Windows.Networking.HostName): void;
+    AddAllowedHostRange(first: Windows.Networking.HostName, last: Windows.Networking.HostName): void;
+    ApplyConfigurationAsync(): Windows.Foundation.IAsyncAction;
+    ClearConfigurationAsync(): Windows.Foundation.IAsyncAction;
+  }
+
+  class MobileBroadbandNetwork implements Windows.Networking.NetworkOperators.IMobileBroadbandNetwork, Windows.Networking.NetworkOperators.IMobileBroadbandNetwork2, Windows.Networking.NetworkOperators.IMobileBroadbandNetwork3 {
+    GetCellsInfoAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandCellsInfo>;
+    GetVoiceCallSupportAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowConnectionUI(): void;
+    readonly AccessPointName: string;
+    readonly ActivationNetworkError: number;
+    readonly NetworkAdapter: Windows.Networking.Connectivity.NetworkAdapter;
+    readonly NetworkRegistrationState: number;
+    readonly PacketAttachNetworkError: number;
+    readonly RegisteredDataClass: number;
+    readonly RegisteredProviderId: string;
+    readonly RegisteredProviderName: string;
+    readonly RegistrationNetworkError: number;
+    readonly RegistrationUiccApps: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandUiccApp> | Windows.Networking.NetworkOperators.MobileBroadbandUiccApp[];
+  }
+
+  class MobileBroadbandNetworkRegistrationStateChange implements Windows.Networking.NetworkOperators.IMobileBroadbandNetworkRegistrationStateChange {
+    readonly DeviceId: string;
+    readonly Network: Windows.Networking.NetworkOperators.MobileBroadbandNetwork;
+  }
+
+  class MobileBroadbandNetworkRegistrationStateChangeTriggerDetails implements Windows.Networking.NetworkOperators.IMobileBroadbandNetworkRegistrationStateChangeTriggerDetails {
+    readonly NetworkRegistrationStateChanges: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandNetworkRegistrationStateChange> | Windows.Networking.NetworkOperators.MobileBroadbandNetworkRegistrationStateChange[];
+  }
+
+  class MobileBroadbandPco implements Windows.Networking.NetworkOperators.IMobileBroadbandPco {
+    readonly Data: Windows.Storage.Streams.IBuffer;
+    readonly DeviceId: string;
+    readonly IsComplete: boolean;
+  }
+
+  class MobileBroadbandPcoDataChangeTriggerDetails implements Windows.Networking.NetworkOperators.IMobileBroadbandPcoDataChangeTriggerDetails {
+    readonly UpdatedData: Windows.Networking.NetworkOperators.MobileBroadbandPco;
+  }
+
+  class MobileBroadbandPin implements Windows.Networking.NetworkOperators.IMobileBroadbandPin {
+    ChangeAsync(currentPin: string, newPin: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandPinOperationResult>;
+    DisableAsync(currentPin: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandPinOperationResult>;
+    EnableAsync(currentPin: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandPinOperationResult>;
+    EnterAsync(currentPin: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandPinOperationResult>;
+    UnblockAsync(pinUnblockKey: string, newPin: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandPinOperationResult>;
+    readonly AttemptsRemaining: number;
+    readonly Enabled: boolean;
+    readonly Format: number;
+    readonly LockState: number;
+    readonly MaxLength: number;
+    readonly MinLength: number;
+    readonly Type: number;
+  }
+
+  class MobileBroadbandPinLockStateChange implements Windows.Networking.NetworkOperators.IMobileBroadbandPinLockStateChange {
+    readonly DeviceId: string;
+    readonly PinLockState: number;
+    readonly PinType: number;
+  }
+
+  class MobileBroadbandPinLockStateChangeTriggerDetails implements Windows.Networking.NetworkOperators.IMobileBroadbandPinLockStateChangeTriggerDetails {
+    readonly PinLockStateChanges: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandPinLockStateChange> | Windows.Networking.NetworkOperators.MobileBroadbandPinLockStateChange[];
+  }
+
+  class MobileBroadbandPinManager implements Windows.Networking.NetworkOperators.IMobileBroadbandPinManager {
+    GetPin(pinType: number): Windows.Networking.NetworkOperators.MobileBroadbandPin;
+    readonly SupportedPins: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+
+  class MobileBroadbandPinOperationResult implements Windows.Networking.NetworkOperators.IMobileBroadbandPinOperationResult {
+    readonly AttemptsRemaining: number;
+    readonly IsSuccessful: boolean;
+  }
+
+  class MobileBroadbandRadioStateChange implements Windows.Networking.NetworkOperators.IMobileBroadbandRadioStateChange {
+    readonly DeviceId: string;
+    readonly RadioState: number;
+  }
+
+  class MobileBroadbandRadioStateChangeTriggerDetails implements Windows.Networking.NetworkOperators.IMobileBroadbandRadioStateChangeTriggerDetails {
+    readonly RadioStateChanges: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandRadioStateChange> | Windows.Networking.NetworkOperators.MobileBroadbandRadioStateChange[];
+  }
+
+  class MobileBroadbandSarManager implements Windows.Networking.NetworkOperators.IMobileBroadbandSarManager {
+    DisableBackoffAsync(): Windows.Foundation.IAsyncAction;
+    EnableBackoffAsync(): Windows.Foundation.IAsyncAction;
+    GetIsTransmittingAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    RevertSarToHardwareControlAsync(): Windows.Foundation.IAsyncAction;
+    SetConfigurationAsync(antennas: Windows.Foundation.Collections.IIterable<Windows.Networking.NetworkOperators.MobileBroadbandAntennaSar> | Windows.Networking.NetworkOperators.MobileBroadbandAntennaSar[]): Windows.Foundation.IAsyncAction;
+    SetTransmissionStateChangedHysteresisAsync(timerPeriod: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncAction;
+    StartTransmissionStateMonitoring(): void;
+    StopTransmissionStateMonitoring(): void;
+    readonly Antennas: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandAntennaSar> | Windows.Networking.NetworkOperators.MobileBroadbandAntennaSar[];
+    readonly HysteresisTimerPeriod: Windows.Foundation.TimeSpan;
+    readonly IsBackoffEnabled: boolean;
+    readonly IsSarControlledByHardware: boolean;
+    readonly IsWiFiHardwareIntegrated: boolean;
+    TransmissionStateChanged: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandSarManager, Windows.Networking.NetworkOperators.MobileBroadbandTransmissionStateChangedEventArgs> | null;
+  }
+
+  class MobileBroadbandSlotInfo implements Windows.Networking.NetworkOperators.IMobileBroadbandSlotInfo, Windows.Networking.NetworkOperators.IMobileBroadbandSlotInfo2 {
+    readonly IccId: string;
+    readonly Index: number;
+    readonly State: number;
+  }
+
+  class MobileBroadbandSlotInfoChangedEventArgs implements Windows.Networking.NetworkOperators.IMobileBroadbandSlotInfoChangedEventArgs {
+    readonly SlotInfo: Windows.Networking.NetworkOperators.MobileBroadbandSlotInfo;
+  }
+
+  class MobileBroadbandSlotManager implements Windows.Networking.NetworkOperators.IMobileBroadbandSlotManager {
+    SetCurrentSlot(slotIndex: number): number;
+    SetCurrentSlotAsync(slotIndex: number): Windows.Foundation.IAsyncOperation<number>;
+    readonly CurrentSlotIndex: number;
+    readonly SlotInfos: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandSlotInfo> | Windows.Networking.NetworkOperators.MobileBroadbandSlotInfo[];
+    CurrentSlotIndexChanged: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandSlotManager, Windows.Networking.NetworkOperators.MobileBroadbandCurrentSlotIndexChangedEventArgs> | null;
+    SlotInfoChanged: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandSlotManager, Windows.Networking.NetworkOperators.MobileBroadbandSlotInfoChangedEventArgs> | null;
+  }
+
+  class MobileBroadbandTransmissionStateChangedEventArgs implements Windows.Networking.NetworkOperators.IMobileBroadbandTransmissionStateChangedEventArgs {
+    readonly IsTransmitting: boolean;
+  }
+
+  class MobileBroadbandUicc implements Windows.Networking.NetworkOperators.IMobileBroadbandUicc {
+    GetUiccAppsAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandUiccAppsResult>;
+    readonly SimIccId: string;
+  }
+
+  class MobileBroadbandUiccApp implements Windows.Networking.NetworkOperators.IMobileBroadbandUiccApp {
+    GetRecordDetailsAsync(uiccFilePath: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandUiccAppRecordDetailsResult>;
+    ReadRecordAsync(uiccFilePath: Windows.Foundation.Collections.IIterable<number> | number[], recordIndex: number): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandUiccAppReadRecordResult>;
+    readonly Id: Windows.Storage.Streams.IBuffer;
+    readonly Kind: number;
+  }
+
+  class MobileBroadbandUiccAppReadRecordResult implements Windows.Networking.NetworkOperators.IMobileBroadbandUiccAppReadRecordResult {
+    readonly Data: Windows.Storage.Streams.IBuffer;
+    readonly Status: number;
+  }
+
+  class MobileBroadbandUiccAppRecordDetailsResult implements Windows.Networking.NetworkOperators.IMobileBroadbandUiccAppRecordDetailsResult {
+    readonly Kind: number;
+    readonly ReadAccessCondition: number;
+    readonly RecordCount: number;
+    readonly RecordSize: number;
+    readonly Status: number;
+    readonly WriteAccessCondition: number;
+  }
+
+  class MobileBroadbandUiccAppsResult implements Windows.Networking.NetworkOperators.IMobileBroadbandUiccAppsResult {
+    readonly Status: number;
+    readonly UiccApps: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandUiccApp> | Windows.Networking.NetworkOperators.MobileBroadbandUiccApp[];
+  }
+
+  class NetworkOperatorDataUsageTriggerDetails implements Windows.Networking.NetworkOperators.INetworkOperatorDataUsageTriggerDetails {
+    readonly NotificationKind: number;
+  }
+
+  class NetworkOperatorNotificationEventDetails implements Windows.Networking.NetworkOperators.INetworkOperatorNotificationEventDetails, Windows.Networking.NetworkOperators.INetworkOperatorTetheringEntitlementCheck {
+    AuthorizeTethering(allow: boolean, entitlementFailureReason: string): void;
+    readonly EncodingType: number;
+    readonly Message: string;
+    readonly NetworkAccountId: string;
+    readonly NotificationType: number;
+    readonly RuleId: string;
+    readonly SmsMessage: Windows.Devices.Sms.ISmsMessage;
+  }
+
+  class NetworkOperatorTetheringAccessPointConfiguration implements Windows.Networking.NetworkOperators.INetworkOperatorTetheringAccessPointConfiguration, Windows.Networking.NetworkOperators.INetworkOperatorTetheringAccessPointConfiguration2, Windows.Networking.NetworkOperators.INetworkOperatorTetheringAccessPointConfiguration3 {
+    constructor();
+    IsAuthenticationKindSupported(authenticationKind: number): boolean;
+    IsAuthenticationKindSupportedAsync(authenticationKind: number): Windows.Foundation.IAsyncOperation<boolean>;
+    IsBandSupported(band: number): boolean;
+    IsBandSupportedAsync(band: number): Windows.Foundation.IAsyncOperation<boolean>;
+    AuthenticationKind: number;
+    Band: number;
+    Passphrase: string;
+    Ssid: string;
+  }
+
+  class NetworkOperatorTetheringClient implements Windows.Networking.NetworkOperators.INetworkOperatorTetheringClient {
+    readonly HostNames: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[];
+    readonly MacAddress: string;
+  }
+
+  class NetworkOperatorTetheringManager implements Windows.Networking.NetworkOperators.INetworkOperatorTetheringClientManager, Windows.Networking.NetworkOperators.INetworkOperatorTetheringManager, Windows.Networking.NetworkOperators.INetworkOperatorTetheringManager2 {
+    ConfigureAccessPointAsync(configuration: Windows.Networking.NetworkOperators.NetworkOperatorTetheringAccessPointConfiguration): Windows.Foundation.IAsyncAction;
+    static CreateFromConnectionProfile(profile: Windows.Networking.Connectivity.ConnectionProfile, adapter: Windows.Networking.Connectivity.NetworkAdapter): Windows.Networking.NetworkOperators.NetworkOperatorTetheringManager;
+    static CreateFromConnectionProfile(profile: Windows.Networking.Connectivity.ConnectionProfile): Windows.Networking.NetworkOperators.NetworkOperatorTetheringManager;
+    static CreateFromNetworkAccountId(networkAccountId: string): Windows.Networking.NetworkOperators.NetworkOperatorTetheringManager;
+    static DisableNoConnectionsTimeout(): void;
+    static DisableNoConnectionsTimeoutAsync(): Windows.Foundation.IAsyncAction;
+    static EnableNoConnectionsTimeout(): void;
+    static EnableNoConnectionsTimeoutAsync(): Windows.Foundation.IAsyncAction;
+    GetCurrentAccessPointConfiguration(): Windows.Networking.NetworkOperators.NetworkOperatorTetheringAccessPointConfiguration;
+    static GetTetheringCapability(networkAccountId: string): number;
+    static GetTetheringCapabilityFromConnectionProfile(profile: Windows.Networking.Connectivity.ConnectionProfile): number;
+    GetTetheringClients(): Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.NetworkOperatorTetheringClient> | Windows.Networking.NetworkOperators.NetworkOperatorTetheringClient[];
+    static IsNoConnectionsTimeoutEnabled(): boolean;
+    StartTetheringAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.NetworkOperatorTetheringOperationResult>;
+    StartTetheringAsync(configuration: Windows.Networking.NetworkOperators.NetworkOperatorTetheringSessionAccessPointConfiguration): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.NetworkOperatorTetheringOperationResult>;
+    StopTetheringAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.NetworkOperatorTetheringOperationResult>;
+    readonly ClientCount: number;
+    readonly MaxClientCount: number;
+    readonly TetheringOperationalState: number;
+  }
+
+  class NetworkOperatorTetheringOperationResult implements Windows.Networking.NetworkOperators.INetworkOperatorTetheringOperationResult {
+    readonly AdditionalErrorMessage: string;
+    readonly Status: number;
+  }
+
+  class NetworkOperatorTetheringSessionAccessPointConfiguration implements Windows.Networking.NetworkOperators.INetworkOperatorTetheringSessionAccessPointConfiguration {
+    constructor();
+    IsAuthenticationKindSupported(authenticationKind: number): boolean;
+    IsAuthenticationKindSupportedAsync(authenticationKind: number): Windows.Foundation.IAsyncOperation<boolean>;
+    IsBandSupported(band: number): boolean;
+    IsBandSupportedAsync(band: number): Windows.Foundation.IAsyncOperation<boolean>;
+    AuthenticationKind: number;
+    Band: number;
+    Passphrase: string;
+    PerformancePriority: number;
+    Ssid: string;
+  }
+
+  class ProvisionFromXmlDocumentResults implements Windows.Networking.NetworkOperators.IProvisionFromXmlDocumentResults {
+    readonly AllElementsProvisioned: boolean;
+    readonly ProvisionResultsXml: string;
+  }
+
+  class ProvisionedProfile implements Windows.Networking.NetworkOperators.IProvisionedProfile {
+    UpdateCost(value: number): void;
+    UpdateUsage(value: Windows.Networking.NetworkOperators.ProfileUsage): void;
+  }
+
+  class ProvisioningAgent implements Windows.Networking.NetworkOperators.IProvisioningAgent {
+    constructor();
+    static CreateFromNetworkAccountId(networkAccountId: string): Windows.Networking.NetworkOperators.ProvisioningAgent;
+    GetProvisionedProfile(mediaType: number, profileName: string): Windows.Networking.NetworkOperators.ProvisionedProfile;
+    ProvisionFromXmlDocumentAsync(provisioningXmlDocument: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ProvisionFromXmlDocumentResults>;
+  }
+
+  class TetheringEntitlementCheckTriggerDetails implements Windows.Networking.NetworkOperators.ITetheringEntitlementCheckTriggerDetails {
+    AllowTethering(): void;
+    DenyTethering(entitlementFailureReason: string): void;
+    readonly NetworkAccountId: string;
+  }
+
+  class UssdMessage implements Windows.Networking.NetworkOperators.IUssdMessage {
+    constructor(messageText: string);
+    GetPayload(): number[];
+    SetPayload(value: number[]): void;
+    DataCodingScheme: number;
+    PayloadAsText: string;
+  }
+
+  class UssdReply implements Windows.Networking.NetworkOperators.IUssdReply {
+    readonly Message: Windows.Networking.NetworkOperators.UssdMessage;
+    readonly ResultCode: number;
+  }
+
+  class UssdSession implements Windows.Networking.NetworkOperators.IUssdSession {
+    Close(): void;
+    static CreateFromNetworkAccountId(networkAccountId: string): Windows.Networking.NetworkOperators.UssdSession;
+    static CreateFromNetworkInterfaceId(networkInterfaceId: string): Windows.Networking.NetworkOperators.UssdSession;
+    SendMessageAndGetReplyAsync(message: Windows.Networking.NetworkOperators.UssdMessage): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.UssdReply>;
+  }
+
+  enum DataClasses {
+    None = 0,
+    Gprs = 1,
+    Edge = 2,
+    Umts = 4,
+    Hsdpa = 8,
+    Hsupa = 16,
+    LteAdvanced = 32,
+    NewRadioNonStandalone = 64,
+    NewRadioStandalone = 128,
+    Cdma1xRtt = 65536,
+    Cdma1xEvdo = 131072,
+    Cdma1xEvdoRevA = 262144,
+    Cdma1xEvdv = 524288,
+    Cdma3xRtt = 1048576,
+    Cdma1xEvdoRevB = 2097152,
+    CdmaUmb = 4194304,
+    Custom = 2147483648,
+  }
+
+  enum ESimAuthenticationPreference {
+    OnEntry = 0,
+    OnAction = 1,
+    Never = 2,
+  }
+
+  enum ESimDiscoverResultKind {
+    None = 0,
+    Events = 1,
+    ProfileMetadata = 2,
+  }
+
+  enum ESimOperationStatus {
+    Success = 0,
+    NotAuthorized = 1,
+    NotFound = 2,
+    PolicyViolation = 3,
+    InsufficientSpaceOnCard = 4,
+    ServerFailure = 5,
+    ServerNotReachable = 6,
+    TimeoutWaitingForUserConsent = 7,
+    IncorrectConfirmationCode = 8,
+    ConfirmationCodeMaxRetriesExceeded = 9,
+    CardRemoved = 10,
+    CardBusy = 11,
+    Other = 12,
+    CardGeneralFailure = 13,
+    ConfirmationCodeMissing = 14,
+    InvalidMatchingId = 15,
+    NoEligibleProfileForThisDevice = 16,
+    OperationAborted = 17,
+    EidMismatch = 18,
+    ProfileNotAvailableForNewBinding = 19,
+    ProfileNotReleasedByOperator = 20,
+    OperationProhibitedByProfileClass = 21,
+    ProfileNotPresent = 22,
+    NoCorrespondingRequest = 23,
+    TimeoutWaitingForResponse = 24,
+    IccidAlreadyExists = 25,
+    ProfileProcessingError = 26,
+    ServerNotTrusted = 27,
+    ProfileDownloadMaxRetriesExceeded = 28,
+  }
+
+  enum ESimProfileClass {
+    Operational = 0,
+    Test = 1,
+    Provisioning = 2,
+  }
+
+  enum ESimProfileMetadataState {
+    Unknown = 0,
+    WaitingForInstall = 1,
+    Downloading = 2,
+    Installing = 3,
+    Expired = 4,
+    RejectingDownload = 5,
+    NoLongerAvailable = 6,
+    DeniedByPolicy = 7,
+  }
+
+  enum ESimProfileState {
+    Unknown = 0,
+    Disabled = 1,
+    Enabled = 2,
+    Deleted = 3,
+  }
+
+  enum ESimState {
+    Unknown = 0,
+    Idle = 1,
+    Removed = 2,
+    Busy = 3,
+  }
+
+  enum ESimWatcherStatus {
+    Created = 0,
+    Started = 1,
+    EnumerationCompleted = 2,
+    Stopping = 3,
+    Stopped = 4,
+  }
+
+  enum HotspotAuthenticationResponseCode {
+    NoError = 0,
+    LoginSucceeded = 50,
+    LoginFailed = 100,
+    RadiusServerError = 102,
+    NetworkAdministratorError = 105,
+    LoginAborted = 151,
+    AccessGatewayInternalError = 255,
+  }
+
+  enum MobileBroadbandAccountWatcherStatus {
+    Created = 0,
+    Started = 1,
+    EnumerationCompleted = 2,
+    Stopped = 3,
+    Aborted = 4,
+  }
+
+  enum MobileBroadbandDeviceType {
+    Unknown = 0,
+    Embedded = 1,
+    Removable = 2,
+    Remote = 3,
+  }
+
+  enum MobileBroadbandModemStatus {
+    Success = 0,
+    OtherFailure = 1,
+    Busy = 2,
+    NoDeviceSupport = 3,
+  }
+
+  enum MobileBroadbandPinFormat {
+    Unknown = 0,
+    Numeric = 1,
+    Alphanumeric = 2,
+  }
+
+  enum MobileBroadbandPinLockState {
+    Unknown = 0,
+    Unlocked = 1,
+    PinRequired = 2,
+    PinUnblockKeyRequired = 3,
+  }
+
+  enum MobileBroadbandPinType {
+    None = 0,
+    Custom = 1,
+    Pin1 = 2,
+    Pin2 = 3,
+    SimPin = 4,
+    FirstSimPin = 5,
+    NetworkPin = 6,
+    NetworkSubsetPin = 7,
+    ServiceProviderPin = 8,
+    CorporatePin = 9,
+    SubsidyLock = 10,
+  }
+
+  enum MobileBroadbandRadioState {
+    Off = 0,
+    On = 1,
+  }
+
+  enum MobileBroadbandSlotState {
+    Unmanaged = 0,
+    Unknown = 1,
+    OffEmpty = 2,
+    Off = 3,
+    Empty = 4,
+    NotReady = 5,
+    Active = 6,
+    Error = 7,
+    ActiveEsim = 8,
+    ActiveEsimNoProfile = 9,
+  }
+
+  enum MobileBroadbandUiccAppOperationStatus {
+    Success = 0,
+    InvalidUiccFilePath = 1,
+    AccessConditionNotHeld = 2,
+    UiccBusy = 3,
+  }
+
+  enum NetworkDeviceStatus {
+    DeviceNotReady = 0,
+    DeviceReady = 1,
+    SimNotInserted = 2,
+    BadSim = 3,
+    DeviceHardwareFailure = 4,
+    AccountNotActivated = 5,
+    DeviceLocked = 6,
+    DeviceBlocked = 7,
+  }
+
+  enum NetworkOperatorDataUsageNotificationKind {
+    DataUsageProgress = 0,
+  }
+
+  enum NetworkOperatorEventMessageType {
+    Gsm = 0,
+    Cdma = 1,
+    Ussd = 2,
+    DataPlanThresholdReached = 3,
+    DataPlanReset = 4,
+    DataPlanDeleted = 5,
+    ProfileConnected = 6,
+    ProfileDisconnected = 7,
+    RegisteredRoaming = 8,
+    RegisteredHome = 9,
+    TetheringEntitlementCheck = 10,
+    TetheringOperationalStateChanged = 11,
+    TetheringNumberOfClientsChanged = 12,
+  }
+
+  enum NetworkRegistrationState {
+    None = 0,
+    Deregistered = 1,
+    Searching = 2,
+    Home = 3,
+    Roaming = 4,
+    Partner = 5,
+    Denied = 6,
+  }
+
+  enum ProfileMediaType {
+    Wlan = 0,
+    Wwan = 1,
+  }
+
+  enum TetheringCapability {
+    Enabled = 0,
+    DisabledByGroupPolicy = 1,
+    DisabledByHardwareLimitation = 2,
+    DisabledByOperator = 3,
+    DisabledBySku = 4,
+    DisabledByRequiredAppNotInstalled = 5,
+    DisabledDueToUnknownCause = 6,
+    DisabledBySystemCapability = 7,
+  }
+
+  enum TetheringOperationStatus {
+    Success = 0,
+    Unknown = 1,
+    MobileBroadbandDeviceOff = 2,
+    WiFiDeviceOff = 3,
+    EntitlementCheckTimeout = 4,
+    EntitlementCheckFailure = 5,
+    OperationInProgress = 6,
+    BluetoothDeviceOff = 7,
+    NetworkLimitedConnectivity = 8,
+    AlreadyOn = 9,
+    RadioRestriction = 10,
+    BandInterference = 11,
+  }
+
+  enum TetheringOperationalState {
+    Unknown = 0,
+    On = 1,
+    Off = 2,
+    InTransition = 3,
+  }
+
+  enum TetheringWiFiAuthenticationKind {
+    Wpa2 = 0,
+    Wpa3TransitionMode = 1,
+    Wpa3 = 2,
+  }
+
+  enum TetheringWiFiBand {
+    Auto = 0,
+    TwoPointFourGigahertz = 1,
+    FiveGigahertz = 2,
+    SixGigahertz = 3,
+  }
+
+  enum TetheringWiFiPerformancePriority {
+    Default = 0,
+    TetheringOverStation = 1,
+  }
+
+  enum UiccAccessCondition {
+    AlwaysAllowed = 0,
+    Pin1 = 1,
+    Pin2 = 2,
+    Pin3 = 3,
+    Pin4 = 4,
+    Administrative5 = 5,
+    Administrative6 = 6,
+    NeverAllowed = 7,
+  }
+
+  enum UiccAppKind {
+    Unknown = 0,
+    MF = 1,
+    MFSim = 2,
+    MFRuim = 3,
+    USim = 4,
+    CSim = 5,
+    ISim = 6,
+  }
+
+  enum UiccAppRecordKind {
+    Unknown = 0,
+    Transparent = 1,
+    RecordOriented = 2,
+  }
+
+  enum UssdResultCode {
+    NoActionRequired = 0,
+    ActionRequired = 1,
+    Terminated = 2,
+    OtherLocalClient = 3,
+    OperationNotSupported = 4,
+    NetworkTimeout = 5,
+  }
+
+  interface ESimProfileInstallProgress {
+    TotalSizeInBytes: number;
+    InstalledSizeInBytes: number;
+  }
+  var ESimProfileInstallProgress: {
+    new(totalSizeInBytes: number, installedSizeInBytes: number): ESimProfileInstallProgress;
+    new(fields: { TotalSizeInBytes?: number; InstalledSizeInBytes?: number }): ESimProfileInstallProgress;
+  };
+
+  interface IESim {
+    DeleteProfileAsync(profileId: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimOperationResult>;
+    DownloadProfileMetadataAsync(activationCode: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimDownloadProfileMetadataResult>;
+    GetProfiles(): Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.ESimProfile> | Windows.Networking.NetworkOperators.ESimProfile[];
+    ResetAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimOperationResult>;
+    readonly AvailableMemoryInBytes: number | null;
+    readonly Eid: string;
+    readonly FirmwareVersion: string;
+    readonly MobileBroadbandModemDeviceId: string;
+    readonly Policy: Windows.Networking.NetworkOperators.ESimPolicy;
+    readonly State: number;
+    ProfileChanged: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.ESim, Object> | null;
+  }
+  var IESim: abstract new (...args: any[]) => IESim;
+
+  interface IESim2 {
+    Discover(): Windows.Networking.NetworkOperators.ESimDiscoverResult;
+    Discover(serverAddress: string, matchingId: string): Windows.Networking.NetworkOperators.ESimDiscoverResult;
+    DiscoverAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimDiscoverResult>;
+    DiscoverAsync(serverAddress: string, matchingId: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimDiscoverResult>;
+  }
+  var IESim2: abstract new (...args: any[]) => IESim2;
+
+  interface IESim3 {
+    readonly SlotIndex: number | null;
+  }
+  var IESim3: abstract new (...args: any[]) => IESim3;
+
+  interface IESimAddedEventArgs {
+    readonly ESim: Windows.Networking.NetworkOperators.ESim;
+  }
+  var IESimAddedEventArgs: abstract new (...args: any[]) => IESimAddedEventArgs;
+
+  interface IESimDiscoverEvent {
+    readonly MatchingId: string;
+    readonly RspServerAddress: string;
+  }
+  var IESimDiscoverEvent: abstract new (...args: any[]) => IESimDiscoverEvent;
+
+  interface IESimDiscoverResult {
+    readonly Events: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.ESimDiscoverEvent> | Windows.Networking.NetworkOperators.ESimDiscoverEvent[];
+    readonly Kind: number;
+    readonly ProfileMetadata: Windows.Networking.NetworkOperators.ESimProfileMetadata;
+    readonly Result: Windows.Networking.NetworkOperators.ESimOperationResult;
+  }
+  var IESimDiscoverResult: abstract new (...args: any[]) => IESimDiscoverResult;
+
+  interface IESimDownloadProfileMetadataResult {
+    readonly ProfileMetadata: Windows.Networking.NetworkOperators.ESimProfileMetadata;
+    readonly Result: Windows.Networking.NetworkOperators.ESimOperationResult;
+  }
+  var IESimDownloadProfileMetadataResult: abstract new (...args: any[]) => IESimDownloadProfileMetadataResult;
+
+  interface IESimManagerStatics {
+    TryCreateESimWatcher(): Windows.Networking.NetworkOperators.ESimWatcher;
+    readonly ServiceInfo: Windows.Networking.NetworkOperators.ESimServiceInfo;
+    ServiceInfoChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IESimManagerStatics: abstract new (...args: any[]) => IESimManagerStatics;
+
+  interface IESimOperationResult {
+    readonly Status: number;
+  }
+  var IESimOperationResult: abstract new (...args: any[]) => IESimOperationResult;
+
+  interface IESimPolicy {
+    readonly ShouldEnableManagingUi: boolean;
+  }
+  var IESimPolicy: abstract new (...args: any[]) => IESimPolicy;
+
+  interface IESimProfile {
+    DisableAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimOperationResult>;
+    EnableAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimOperationResult>;
+    SetNicknameAsync(newNickname: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimOperationResult>;
+    readonly Class: number;
+    readonly Id: string;
+    readonly Nickname: string;
+    readonly Policy: Windows.Networking.NetworkOperators.ESimProfilePolicy;
+    readonly ProviderIcon: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly ProviderId: string;
+    readonly ProviderName: string;
+    readonly State: number;
+  }
+  var IESimProfile: abstract new (...args: any[]) => IESimProfile;
+
+  interface IESimProfileMetadata {
+    ConfirmInstallAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Networking.NetworkOperators.ESimOperationResult, Windows.Networking.NetworkOperators.ESimProfileInstallProgress>;
+    ConfirmInstallAsync(confirmationCode: string): Windows.Foundation.IAsyncOperationWithProgress<Windows.Networking.NetworkOperators.ESimOperationResult, Windows.Networking.NetworkOperators.ESimProfileInstallProgress>;
+    DenyInstallAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimOperationResult>;
+    PostponeInstallAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ESimOperationResult>;
+    readonly Id: string;
+    readonly IsConfirmationCodeRequired: boolean;
+    readonly Policy: Windows.Networking.NetworkOperators.ESimProfilePolicy;
+    readonly ProviderIcon: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly ProviderId: string;
+    readonly ProviderName: string;
+    readonly State: number;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.ESimProfileMetadata, Object> | null;
+  }
+  var IESimProfileMetadata: abstract new (...args: any[]) => IESimProfileMetadata;
+
+  interface IESimProfilePolicy {
+    readonly CanDelete: boolean;
+    readonly CanDisable: boolean;
+    readonly IsManagedByEnterprise: boolean;
+  }
+  var IESimProfilePolicy: abstract new (...args: any[]) => IESimProfilePolicy;
+
+  interface IESimRemovedEventArgs {
+    readonly ESim: Windows.Networking.NetworkOperators.ESim;
+  }
+  var IESimRemovedEventArgs: abstract new (...args: any[]) => IESimRemovedEventArgs;
+
+  interface IESimServiceInfo {
+    readonly AuthenticationPreference: number;
+    readonly IsESimUiEnabled: boolean;
+  }
+  var IESimServiceInfo: abstract new (...args: any[]) => IESimServiceInfo;
+
+  interface IESimUpdatedEventArgs {
+    readonly ESim: Windows.Networking.NetworkOperators.ESim;
+  }
+  var IESimUpdatedEventArgs: abstract new (...args: any[]) => IESimUpdatedEventArgs;
+
+  interface IESimWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.ESimWatcher, Windows.Networking.NetworkOperators.ESimAddedEventArgs> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.ESimWatcher, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.ESimWatcher, Windows.Networking.NetworkOperators.ESimRemovedEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.ESimWatcher, Object> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.ESimWatcher, Windows.Networking.NetworkOperators.ESimUpdatedEventArgs> | null;
+  }
+  var IESimWatcher: abstract new (...args: any[]) => IESimWatcher;
+
+  interface IHotspotAuthenticationContext {
+    AbortAuthentication(markAsManual: boolean): void;
+    IssueCredentials(userName: string, password: string, extraParameters: string, markAsManualConnectOnFailure: boolean): void;
+    SkipAuthentication(): void;
+    TriggerAttentionRequired(packageRelativeApplicationId: string, applicationParameters: string): void;
+    readonly AuthenticationUrl: Windows.Foundation.Uri;
+    readonly NetworkAdapter: Windows.Networking.Connectivity.NetworkAdapter;
+    readonly RedirectMessageUrl: Windows.Foundation.Uri;
+    readonly RedirectMessageXml: Windows.Data.Xml.Dom.XmlDocument;
+    readonly WirelessNetworkId: number[];
+  }
+  var IHotspotAuthenticationContext: abstract new (...args: any[]) => IHotspotAuthenticationContext;
+
+  interface IHotspotAuthenticationContext2 {
+    IssueCredentialsAsync(userName: string, password: string, extraParameters: string, markAsManualConnectOnFailure: boolean): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.HotspotCredentialsAuthenticationResult>;
+  }
+  var IHotspotAuthenticationContext2: abstract new (...args: any[]) => IHotspotAuthenticationContext2;
+
+  interface IHotspotAuthenticationContextStatics {
+    TryGetAuthenticationContext(evenToken: string, context: Windows.Networking.NetworkOperators.HotspotAuthenticationContext): boolean;
+  }
+  var IHotspotAuthenticationContextStatics: abstract new (...args: any[]) => IHotspotAuthenticationContextStatics;
+
+  interface IHotspotAuthenticationEventDetails {
+    readonly EventToken: string;
+  }
+  var IHotspotAuthenticationEventDetails: abstract new (...args: any[]) => IHotspotAuthenticationEventDetails;
+
+  interface IHotspotCredentialsAuthenticationResult {
+    readonly AuthenticationReplyXml: Windows.Data.Xml.Dom.XmlDocument;
+    readonly HasNetworkErrorOccurred: boolean;
+    readonly LogoffUrl: Windows.Foundation.Uri;
+    readonly ResponseCode: number;
+  }
+  var IHotspotCredentialsAuthenticationResult: abstract new (...args: any[]) => IHotspotCredentialsAuthenticationResult;
+
+  interface IKnownCSimFilePathsStatics {
+    readonly EFSpn: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Gid1: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Gid2: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IKnownCSimFilePathsStatics: abstract new (...args: any[]) => IKnownCSimFilePathsStatics;
+
+  interface IKnownRuimFilePathsStatics {
+    readonly EFSpn: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Gid1: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Gid2: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IKnownRuimFilePathsStatics: abstract new (...args: any[]) => IKnownRuimFilePathsStatics;
+
+  interface IKnownSimFilePathsStatics {
+    readonly EFOns: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly EFSpn: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Gid1: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Gid2: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IKnownSimFilePathsStatics: abstract new (...args: any[]) => IKnownSimFilePathsStatics;
+
+  interface IKnownUSimFilePathsStatics {
+    readonly EFOpl: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly EFPnn: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly EFSpn: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Gid1: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Gid2: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IKnownUSimFilePathsStatics: abstract new (...args: any[]) => IKnownUSimFilePathsStatics;
+
+  interface IMobileBroadbandAccount {
+    readonly CurrentDeviceInformation: Windows.Networking.NetworkOperators.MobileBroadbandDeviceInformation;
+    readonly CurrentNetwork: Windows.Networking.NetworkOperators.MobileBroadbandNetwork;
+    readonly NetworkAccountId: string;
+    readonly ServiceProviderGuid: Guid;
+    readonly ServiceProviderName: string;
+  }
+  var IMobileBroadbandAccount: abstract new (...args: any[]) => IMobileBroadbandAccount;
+
+  interface IMobileBroadbandAccount2 {
+    GetConnectionProfiles(): Windows.Foundation.Collections.IVectorView<Windows.Networking.Connectivity.ConnectionProfile> | Windows.Networking.Connectivity.ConnectionProfile[];
+  }
+  var IMobileBroadbandAccount2: abstract new (...args: any[]) => IMobileBroadbandAccount2;
+
+  interface IMobileBroadbandAccount3 {
+    readonly AccountExperienceUrl: Windows.Foundation.Uri;
+  }
+  var IMobileBroadbandAccount3: abstract new (...args: any[]) => IMobileBroadbandAccount3;
+
+  interface IMobileBroadbandAccountEventArgs {
+    readonly NetworkAccountId: string;
+  }
+  var IMobileBroadbandAccountEventArgs: abstract new (...args: any[]) => IMobileBroadbandAccountEventArgs;
+
+  interface IMobileBroadbandAccountStatics {
+    CreateFromNetworkAccountId(networkAccountId: string): Windows.Networking.NetworkOperators.MobileBroadbandAccount;
+    readonly AvailableNetworkAccountIds: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var IMobileBroadbandAccountStatics: abstract new (...args: any[]) => IMobileBroadbandAccountStatics;
+
+  interface IMobileBroadbandAccountUpdatedEventArgs {
+    readonly HasDeviceInformationChanged: boolean;
+    readonly HasNetworkChanged: boolean;
+    readonly NetworkAccountId: string;
+  }
+  var IMobileBroadbandAccountUpdatedEventArgs: abstract new (...args: any[]) => IMobileBroadbandAccountUpdatedEventArgs;
+
+  interface IMobileBroadbandAccountWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    AccountAdded: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher, Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs> | null;
+    AccountRemoved: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher, Windows.Networking.NetworkOperators.MobileBroadbandAccountEventArgs> | null;
+    AccountUpdated: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher, Windows.Networking.NetworkOperators.MobileBroadbandAccountUpdatedEventArgs> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher, Object> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandAccountWatcher, Object> | null;
+  }
+  var IMobileBroadbandAccountWatcher: abstract new (...args: any[]) => IMobileBroadbandAccountWatcher;
+
+  interface IMobileBroadbandAntennaSar {
+    readonly AntennaIndex: number;
+    readonly SarBackoffIndex: number;
+  }
+  var IMobileBroadbandAntennaSar: abstract new (...args: any[]) => IMobileBroadbandAntennaSar;
+
+  interface IMobileBroadbandAntennaSarFactory {
+    CreateWithIndex(antennaIndex: number, sarBackoffIndex: number): Windows.Networking.NetworkOperators.MobileBroadbandAntennaSar;
+  }
+  var IMobileBroadbandAntennaSarFactory: abstract new (...args: any[]) => IMobileBroadbandAntennaSarFactory;
+
+  interface IMobileBroadbandCellCdma {
+    readonly BaseStationId: number | null;
+    readonly BaseStationLastBroadcastGpsTime: Windows.Foundation.TimeSpan | null;
+    readonly BaseStationLatitude: number | null;
+    readonly BaseStationLongitude: number | null;
+    readonly BaseStationPNCode: number | null;
+    readonly NetworkId: number | null;
+    readonly PilotSignalStrengthInDB: number | null;
+    readonly SystemId: number | null;
+  }
+  var IMobileBroadbandCellCdma: abstract new (...args: any[]) => IMobileBroadbandCellCdma;
+
+  interface IMobileBroadbandCellGsm {
+    readonly BaseStationId: number | null;
+    readonly CellId: number | null;
+    readonly ChannelNumber: number | null;
+    readonly LocationAreaCode: number | null;
+    readonly ProviderId: string;
+    readonly ReceivedSignalStrengthInDBm: number | null;
+    readonly TimingAdvanceInBitPeriods: number | null;
+  }
+  var IMobileBroadbandCellGsm: abstract new (...args: any[]) => IMobileBroadbandCellGsm;
+
+  interface IMobileBroadbandCellLte {
+    readonly CellId: number | null;
+    readonly ChannelNumber: number | null;
+    readonly PhysicalCellId: number | null;
+    readonly ProviderId: string;
+    readonly ReferenceSignalReceivedPowerInDBm: number | null;
+    readonly ReferenceSignalReceivedQualityInDBm: number | null;
+    readonly TimingAdvanceInBitPeriods: number | null;
+    readonly TrackingAreaCode: number | null;
+  }
+  var IMobileBroadbandCellLte: abstract new (...args: any[]) => IMobileBroadbandCellLte;
+
+  interface IMobileBroadbandCellNR {
+    readonly CellId: number | bigint | null;
+    readonly ChannelNumber: number | null;
+    readonly PhysicalCellId: number | null;
+    readonly ProviderId: string;
+    readonly ReferenceSignalReceivedPowerInDBm: number | null;
+    readonly ReferenceSignalReceivedQualityInDBm: number | null;
+    readonly SignalToNoiseRatioInDB: number | null;
+    readonly TimingAdvanceInNanoseconds: number | null;
+    readonly TrackingAreaCode: number | null;
+  }
+  var IMobileBroadbandCellNR: abstract new (...args: any[]) => IMobileBroadbandCellNR;
+
+  interface IMobileBroadbandCellTdscdma {
+    readonly CellId: number | null;
+    readonly CellParameterId: number | null;
+    readonly ChannelNumber: number | null;
+    readonly LocationAreaCode: number | null;
+    readonly PathLossInDB: number | null;
+    readonly ProviderId: string;
+    readonly ReceivedSignalCodePowerInDBm: number | null;
+    readonly TimingAdvanceInBitPeriods: number | null;
+  }
+  var IMobileBroadbandCellTdscdma: abstract new (...args: any[]) => IMobileBroadbandCellTdscdma;
+
+  interface IMobileBroadbandCellUmts {
+    readonly CellId: number | null;
+    readonly ChannelNumber: number | null;
+    readonly LocationAreaCode: number | null;
+    readonly PathLossInDB: number | null;
+    readonly PrimaryScramblingCode: number | null;
+    readonly ProviderId: string;
+    readonly ReceivedSignalCodePowerInDBm: number | null;
+    readonly SignalToNoiseRatioInDB: number | null;
+  }
+  var IMobileBroadbandCellUmts: abstract new (...args: any[]) => IMobileBroadbandCellUmts;
+
+  interface IMobileBroadbandCellsInfo {
+    readonly NeighboringCellsCdma: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellCdma> | Windows.Networking.NetworkOperators.MobileBroadbandCellCdma[];
+    readonly NeighboringCellsGsm: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellGsm> | Windows.Networking.NetworkOperators.MobileBroadbandCellGsm[];
+    readonly NeighboringCellsLte: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellLte> | Windows.Networking.NetworkOperators.MobileBroadbandCellLte[];
+    readonly NeighboringCellsTdscdma: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellTdscdma> | Windows.Networking.NetworkOperators.MobileBroadbandCellTdscdma[];
+    readonly NeighboringCellsUmts: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellUmts> | Windows.Networking.NetworkOperators.MobileBroadbandCellUmts[];
+    readonly ServingCellsCdma: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellCdma> | Windows.Networking.NetworkOperators.MobileBroadbandCellCdma[];
+    readonly ServingCellsGsm: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellGsm> | Windows.Networking.NetworkOperators.MobileBroadbandCellGsm[];
+    readonly ServingCellsLte: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellLte> | Windows.Networking.NetworkOperators.MobileBroadbandCellLte[];
+    readonly ServingCellsTdscdma: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellTdscdma> | Windows.Networking.NetworkOperators.MobileBroadbandCellTdscdma[];
+    readonly ServingCellsUmts: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellUmts> | Windows.Networking.NetworkOperators.MobileBroadbandCellUmts[];
+  }
+  var IMobileBroadbandCellsInfo: abstract new (...args: any[]) => IMobileBroadbandCellsInfo;
+
+  interface IMobileBroadbandCellsInfo2 {
+    readonly NeighboringCellsNR: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellNR> | Windows.Networking.NetworkOperators.MobileBroadbandCellNR[];
+    readonly ServingCellsNR: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandCellNR> | Windows.Networking.NetworkOperators.MobileBroadbandCellNR[];
+  }
+  var IMobileBroadbandCellsInfo2: abstract new (...args: any[]) => IMobileBroadbandCellsInfo2;
+
+  interface IMobileBroadbandCurrentSlotIndexChangedEventArgs {
+    readonly CurrentSlotIndex: number;
+  }
+  var IMobileBroadbandCurrentSlotIndexChangedEventArgs: abstract new (...args: any[]) => IMobileBroadbandCurrentSlotIndexChangedEventArgs;
+
+  interface IMobileBroadbandDeviceInformation {
+    readonly CellularClass: number;
+    readonly CurrentRadioState: number;
+    readonly CustomDataClass: string;
+    readonly DataClasses: number;
+    readonly DeviceId: string;
+    readonly DeviceType: number;
+    readonly FirmwareInformation: string;
+    readonly Manufacturer: string;
+    readonly MobileEquipmentId: string;
+    readonly Model: string;
+    readonly NetworkDeviceStatus: number;
+    readonly SimIccId: string;
+    readonly SubscriberId: string;
+    readonly TelephoneNumbers: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var IMobileBroadbandDeviceInformation: abstract new (...args: any[]) => IMobileBroadbandDeviceInformation;
+
+  interface IMobileBroadbandDeviceInformation2 {
+    readonly PinManager: Windows.Networking.NetworkOperators.MobileBroadbandPinManager;
+    readonly Revision: string;
+    readonly SerialNumber: string;
+  }
+  var IMobileBroadbandDeviceInformation2: abstract new (...args: any[]) => IMobileBroadbandDeviceInformation2;
+
+  interface IMobileBroadbandDeviceInformation3 {
+    readonly SimGid1: string;
+    readonly SimPnn: string;
+    readonly SimSpn: string;
+  }
+  var IMobileBroadbandDeviceInformation3: abstract new (...args: any[]) => IMobileBroadbandDeviceInformation3;
+
+  interface IMobileBroadbandDeviceInformation4 {
+    readonly SlotManager: Windows.Networking.NetworkOperators.MobileBroadbandSlotManager;
+  }
+  var IMobileBroadbandDeviceInformation4: abstract new (...args: any[]) => IMobileBroadbandDeviceInformation4;
+
+  interface IMobileBroadbandDeviceService {
+    OpenCommandSession(): Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceCommandSession;
+    OpenDataSession(): Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession;
+    readonly DeviceServiceId: Guid;
+    readonly SupportedCommands: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IMobileBroadbandDeviceService: abstract new (...args: any[]) => IMobileBroadbandDeviceService;
+
+  interface IMobileBroadbandDeviceServiceCommandEventArgs {
+    readonly DeviceId: string;
+    readonly DeviceServiceId: Guid;
+    readonly EventId: number;
+    readonly ReceivedData: Windows.Storage.Streams.IBuffer;
+  }
+  var IMobileBroadbandDeviceServiceCommandEventArgs: abstract new (...args: any[]) => IMobileBroadbandDeviceServiceCommandEventArgs;
+
+  interface IMobileBroadbandDeviceServiceCommandResult {
+    readonly ResponseData: Windows.Storage.Streams.IBuffer;
+    readonly StatusCode: number;
+  }
+  var IMobileBroadbandDeviceServiceCommandResult: abstract new (...args: any[]) => IMobileBroadbandDeviceServiceCommandResult;
+
+  interface IMobileBroadbandDeviceServiceCommandSession {
+    CloseSession(): void;
+    SendQueryCommandAsync(commandId: number, data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceCommandResult>;
+    SendSetCommandAsync(commandId: number, data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceCommandResult>;
+  }
+  var IMobileBroadbandDeviceServiceCommandSession: abstract new (...args: any[]) => IMobileBroadbandDeviceServiceCommandSession;
+
+  interface IMobileBroadbandDeviceServiceCommandSession2 {
+    CommandReceived: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceCommandSession, Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceCommandEventArgs> | null;
+  }
+  var IMobileBroadbandDeviceServiceCommandSession2: abstract new (...args: any[]) => IMobileBroadbandDeviceServiceCommandSession2;
+
+  interface IMobileBroadbandDeviceServiceDataReceivedEventArgs {
+    readonly ReceivedData: Windows.Storage.Streams.IBuffer;
+  }
+  var IMobileBroadbandDeviceServiceDataReceivedEventArgs: abstract new (...args: any[]) => IMobileBroadbandDeviceServiceDataReceivedEventArgs;
+
+  interface IMobileBroadbandDeviceServiceDataSession {
+    CloseSession(): void;
+    WriteDataAsync(value: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncAction;
+    DataReceived: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataSession, Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceDataReceivedEventArgs> | null;
+  }
+  var IMobileBroadbandDeviceServiceDataSession: abstract new (...args: any[]) => IMobileBroadbandDeviceServiceDataSession;
+
+  interface IMobileBroadbandDeviceServiceInformation {
+    readonly DeviceServiceId: Guid;
+    readonly IsDataReadSupported: boolean;
+    readonly IsDataWriteSupported: boolean;
+  }
+  var IMobileBroadbandDeviceServiceInformation: abstract new (...args: any[]) => IMobileBroadbandDeviceServiceInformation;
+
+  interface IMobileBroadbandDeviceServiceTriggerDetails {
+    readonly DeviceId: string;
+    readonly DeviceServiceId: Guid;
+    readonly ReceivedData: Windows.Storage.Streams.IBuffer;
+  }
+  var IMobileBroadbandDeviceServiceTriggerDetails: abstract new (...args: any[]) => IMobileBroadbandDeviceServiceTriggerDetails;
+
+  interface IMobileBroadbandDeviceServiceTriggerDetails2 {
+    readonly EventId: number;
+  }
+  var IMobileBroadbandDeviceServiceTriggerDetails2: abstract new (...args: any[]) => IMobileBroadbandDeviceServiceTriggerDetails2;
+
+  interface IMobileBroadbandModem {
+    GetCurrentConfigurationAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandModemConfiguration>;
+    GetDeviceService(deviceServiceId: Guid): Windows.Networking.NetworkOperators.MobileBroadbandDeviceService;
+    ResetAsync(): Windows.Foundation.IAsyncAction;
+    readonly CurrentAccount: Windows.Networking.NetworkOperators.MobileBroadbandAccount;
+    readonly CurrentNetwork: Windows.Networking.NetworkOperators.MobileBroadbandNetwork;
+    readonly DeviceInformation: Windows.Networking.NetworkOperators.MobileBroadbandDeviceInformation;
+    readonly DeviceServices: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceInformation> | Windows.Networking.NetworkOperators.MobileBroadbandDeviceServiceInformation[];
+    readonly IsResetSupported: boolean;
+    readonly MaxDeviceServiceCommandSizeInBytes: number;
+    readonly MaxDeviceServiceDataSizeInBytes: number;
+  }
+  var IMobileBroadbandModem: abstract new (...args: any[]) => IMobileBroadbandModem;
+
+  interface IMobileBroadbandModem2 {
+    GetIsPassthroughEnabledAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    SetIsPassthroughEnabledAsync(value: boolean): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IMobileBroadbandModem2: abstract new (...args: any[]) => IMobileBroadbandModem2;
+
+  interface IMobileBroadbandModem3 {
+    TryGetPcoAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandPco>;
+    readonly IsInEmergencyCallMode: boolean;
+    IsInEmergencyCallModeChanged: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandModem, Object> | null;
+  }
+  var IMobileBroadbandModem3: abstract new (...args: any[]) => IMobileBroadbandModem3;
+
+  interface IMobileBroadbandModem4 {
+    GetIsPassthroughEnabled(slotindex: number): boolean;
+    GetIsPassthroughEnabledAsync(slotindex: number): Windows.Foundation.IAsyncOperation<boolean>;
+    SetIsPassthroughEnabled(value: boolean, slotindex: number): number;
+    SetIsPassthroughEnabledAsync(value: boolean, slotindex: number): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IMobileBroadbandModem4: abstract new (...args: any[]) => IMobileBroadbandModem4;
+
+  interface IMobileBroadbandModemConfiguration {
+    readonly HomeProviderId: string;
+    readonly HomeProviderName: string;
+    readonly Uicc: Windows.Networking.NetworkOperators.MobileBroadbandUicc;
+  }
+  var IMobileBroadbandModemConfiguration: abstract new (...args: any[]) => IMobileBroadbandModemConfiguration;
+
+  interface IMobileBroadbandModemConfiguration2 {
+    readonly SarManager: Windows.Networking.NetworkOperators.MobileBroadbandSarManager;
+  }
+  var IMobileBroadbandModemConfiguration2: abstract new (...args: any[]) => IMobileBroadbandModemConfiguration2;
+
+  interface IMobileBroadbandModemIsolation {
+    AddAllowedHost(host: Windows.Networking.HostName): void;
+    AddAllowedHostRange(first: Windows.Networking.HostName, last: Windows.Networking.HostName): void;
+    ApplyConfigurationAsync(): Windows.Foundation.IAsyncAction;
+    ClearConfigurationAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var IMobileBroadbandModemIsolation: abstract new (...args: any[]) => IMobileBroadbandModemIsolation;
+
+  interface IMobileBroadbandModemIsolationFactory {
+    Create(modemDeviceId: string, ruleGroupId: string): Windows.Networking.NetworkOperators.MobileBroadbandModemIsolation;
+  }
+  var IMobileBroadbandModemIsolationFactory: abstract new (...args: any[]) => IMobileBroadbandModemIsolationFactory;
+
+  interface IMobileBroadbandModemStatics {
+    FromId(deviceId: string): Windows.Networking.NetworkOperators.MobileBroadbandModem;
+    GetDefault(): Windows.Networking.NetworkOperators.MobileBroadbandModem;
+    GetDeviceSelector(): string;
+  }
+  var IMobileBroadbandModemStatics: abstract new (...args: any[]) => IMobileBroadbandModemStatics;
+
+  interface IMobileBroadbandNetwork {
+    ShowConnectionUI(): void;
+    readonly AccessPointName: string;
+    readonly ActivationNetworkError: number;
+    readonly NetworkAdapter: Windows.Networking.Connectivity.NetworkAdapter;
+    readonly NetworkRegistrationState: number;
+    readonly PacketAttachNetworkError: number;
+    readonly RegisteredDataClass: number;
+    readonly RegisteredProviderId: string;
+    readonly RegisteredProviderName: string;
+    readonly RegistrationNetworkError: number;
+  }
+  var IMobileBroadbandNetwork: abstract new (...args: any[]) => IMobileBroadbandNetwork;
+
+  interface IMobileBroadbandNetwork2 {
+    GetVoiceCallSupportAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly RegistrationUiccApps: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandUiccApp> | Windows.Networking.NetworkOperators.MobileBroadbandUiccApp[];
+  }
+  var IMobileBroadbandNetwork2: abstract new (...args: any[]) => IMobileBroadbandNetwork2;
+
+  interface IMobileBroadbandNetwork3 {
+    GetCellsInfoAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandCellsInfo>;
+  }
+  var IMobileBroadbandNetwork3: abstract new (...args: any[]) => IMobileBroadbandNetwork3;
+
+  interface IMobileBroadbandNetworkRegistrationStateChange {
+    readonly DeviceId: string;
+    readonly Network: Windows.Networking.NetworkOperators.MobileBroadbandNetwork;
+  }
+  var IMobileBroadbandNetworkRegistrationStateChange: abstract new (...args: any[]) => IMobileBroadbandNetworkRegistrationStateChange;
+
+  interface IMobileBroadbandNetworkRegistrationStateChangeTriggerDetails {
+    readonly NetworkRegistrationStateChanges: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandNetworkRegistrationStateChange> | Windows.Networking.NetworkOperators.MobileBroadbandNetworkRegistrationStateChange[];
+  }
+  var IMobileBroadbandNetworkRegistrationStateChangeTriggerDetails: abstract new (...args: any[]) => IMobileBroadbandNetworkRegistrationStateChangeTriggerDetails;
+
+  interface IMobileBroadbandPco {
+    readonly Data: Windows.Storage.Streams.IBuffer;
+    readonly DeviceId: string;
+    readonly IsComplete: boolean;
+  }
+  var IMobileBroadbandPco: abstract new (...args: any[]) => IMobileBroadbandPco;
+
+  interface IMobileBroadbandPcoDataChangeTriggerDetails {
+    readonly UpdatedData: Windows.Networking.NetworkOperators.MobileBroadbandPco;
+  }
+  var IMobileBroadbandPcoDataChangeTriggerDetails: abstract new (...args: any[]) => IMobileBroadbandPcoDataChangeTriggerDetails;
+
+  interface IMobileBroadbandPin {
+    ChangeAsync(currentPin: string, newPin: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandPinOperationResult>;
+    DisableAsync(currentPin: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandPinOperationResult>;
+    EnableAsync(currentPin: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandPinOperationResult>;
+    EnterAsync(currentPin: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandPinOperationResult>;
+    UnblockAsync(pinUnblockKey: string, newPin: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandPinOperationResult>;
+    readonly AttemptsRemaining: number;
+    readonly Enabled: boolean;
+    readonly Format: number;
+    readonly LockState: number;
+    readonly MaxLength: number;
+    readonly MinLength: number;
+    readonly Type: number;
+  }
+  var IMobileBroadbandPin: abstract new (...args: any[]) => IMobileBroadbandPin;
+
+  interface IMobileBroadbandPinLockStateChange {
+    readonly DeviceId: string;
+    readonly PinLockState: number;
+    readonly PinType: number;
+  }
+  var IMobileBroadbandPinLockStateChange: abstract new (...args: any[]) => IMobileBroadbandPinLockStateChange;
+
+  interface IMobileBroadbandPinLockStateChangeTriggerDetails {
+    readonly PinLockStateChanges: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandPinLockStateChange> | Windows.Networking.NetworkOperators.MobileBroadbandPinLockStateChange[];
+  }
+  var IMobileBroadbandPinLockStateChangeTriggerDetails: abstract new (...args: any[]) => IMobileBroadbandPinLockStateChangeTriggerDetails;
+
+  interface IMobileBroadbandPinManager {
+    GetPin(pinType: number): Windows.Networking.NetworkOperators.MobileBroadbandPin;
+    readonly SupportedPins: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IMobileBroadbandPinManager: abstract new (...args: any[]) => IMobileBroadbandPinManager;
+
+  interface IMobileBroadbandPinOperationResult {
+    readonly AttemptsRemaining: number;
+    readonly IsSuccessful: boolean;
+  }
+  var IMobileBroadbandPinOperationResult: abstract new (...args: any[]) => IMobileBroadbandPinOperationResult;
+
+  interface IMobileBroadbandRadioStateChange {
+    readonly DeviceId: string;
+    readonly RadioState: number;
+  }
+  var IMobileBroadbandRadioStateChange: abstract new (...args: any[]) => IMobileBroadbandRadioStateChange;
+
+  interface IMobileBroadbandRadioStateChangeTriggerDetails {
+    readonly RadioStateChanges: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandRadioStateChange> | Windows.Networking.NetworkOperators.MobileBroadbandRadioStateChange[];
+  }
+  var IMobileBroadbandRadioStateChangeTriggerDetails: abstract new (...args: any[]) => IMobileBroadbandRadioStateChangeTriggerDetails;
+
+  interface IMobileBroadbandSarManager {
+    DisableBackoffAsync(): Windows.Foundation.IAsyncAction;
+    EnableBackoffAsync(): Windows.Foundation.IAsyncAction;
+    GetIsTransmittingAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    RevertSarToHardwareControlAsync(): Windows.Foundation.IAsyncAction;
+    SetConfigurationAsync(antennas: Windows.Foundation.Collections.IIterable<Windows.Networking.NetworkOperators.MobileBroadbandAntennaSar> | Windows.Networking.NetworkOperators.MobileBroadbandAntennaSar[]): Windows.Foundation.IAsyncAction;
+    SetTransmissionStateChangedHysteresisAsync(timerPeriod: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncAction;
+    StartTransmissionStateMonitoring(): void;
+    StopTransmissionStateMonitoring(): void;
+    readonly Antennas: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandAntennaSar> | Windows.Networking.NetworkOperators.MobileBroadbandAntennaSar[];
+    readonly HysteresisTimerPeriod: Windows.Foundation.TimeSpan;
+    readonly IsBackoffEnabled: boolean;
+    readonly IsSarControlledByHardware: boolean;
+    readonly IsWiFiHardwareIntegrated: boolean;
+    TransmissionStateChanged: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandSarManager, Windows.Networking.NetworkOperators.MobileBroadbandTransmissionStateChangedEventArgs> | null;
+  }
+  var IMobileBroadbandSarManager: abstract new (...args: any[]) => IMobileBroadbandSarManager;
+
+  interface IMobileBroadbandSlotInfo {
+    readonly Index: number;
+    readonly State: number;
+  }
+  var IMobileBroadbandSlotInfo: abstract new (...args: any[]) => IMobileBroadbandSlotInfo;
+
+  interface IMobileBroadbandSlotInfo2 {
+    readonly IccId: string;
+  }
+  var IMobileBroadbandSlotInfo2: abstract new (...args: any[]) => IMobileBroadbandSlotInfo2;
+
+  interface IMobileBroadbandSlotInfoChangedEventArgs {
+    readonly SlotInfo: Windows.Networking.NetworkOperators.MobileBroadbandSlotInfo;
+  }
+  var IMobileBroadbandSlotInfoChangedEventArgs: abstract new (...args: any[]) => IMobileBroadbandSlotInfoChangedEventArgs;
+
+  interface IMobileBroadbandSlotManager {
+    SetCurrentSlot(slotIndex: number): number;
+    SetCurrentSlotAsync(slotIndex: number): Windows.Foundation.IAsyncOperation<number>;
+    readonly CurrentSlotIndex: number;
+    readonly SlotInfos: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandSlotInfo> | Windows.Networking.NetworkOperators.MobileBroadbandSlotInfo[];
+    CurrentSlotIndexChanged: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandSlotManager, Windows.Networking.NetworkOperators.MobileBroadbandCurrentSlotIndexChangedEventArgs> | null;
+    SlotInfoChanged: Windows.Foundation.TypedEventHandler<Windows.Networking.NetworkOperators.MobileBroadbandSlotManager, Windows.Networking.NetworkOperators.MobileBroadbandSlotInfoChangedEventArgs> | null;
+  }
+  var IMobileBroadbandSlotManager: abstract new (...args: any[]) => IMobileBroadbandSlotManager;
+
+  interface IMobileBroadbandTransmissionStateChangedEventArgs {
+    readonly IsTransmitting: boolean;
+  }
+  var IMobileBroadbandTransmissionStateChangedEventArgs: abstract new (...args: any[]) => IMobileBroadbandTransmissionStateChangedEventArgs;
+
+  interface IMobileBroadbandUicc {
+    GetUiccAppsAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandUiccAppsResult>;
+    readonly SimIccId: string;
+  }
+  var IMobileBroadbandUicc: abstract new (...args: any[]) => IMobileBroadbandUicc;
+
+  interface IMobileBroadbandUiccApp {
+    GetRecordDetailsAsync(uiccFilePath: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandUiccAppRecordDetailsResult>;
+    ReadRecordAsync(uiccFilePath: Windows.Foundation.Collections.IIterable<number> | number[], recordIndex: number): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.MobileBroadbandUiccAppReadRecordResult>;
+    readonly Id: Windows.Storage.Streams.IBuffer;
+    readonly Kind: number;
+  }
+  var IMobileBroadbandUiccApp: abstract new (...args: any[]) => IMobileBroadbandUiccApp;
+
+  interface IMobileBroadbandUiccAppReadRecordResult {
+    readonly Data: Windows.Storage.Streams.IBuffer;
+    readonly Status: number;
+  }
+  var IMobileBroadbandUiccAppReadRecordResult: abstract new (...args: any[]) => IMobileBroadbandUiccAppReadRecordResult;
+
+  interface IMobileBroadbandUiccAppRecordDetailsResult {
+    readonly Kind: number;
+    readonly ReadAccessCondition: number;
+    readonly RecordCount: number;
+    readonly RecordSize: number;
+    readonly Status: number;
+    readonly WriteAccessCondition: number;
+  }
+  var IMobileBroadbandUiccAppRecordDetailsResult: abstract new (...args: any[]) => IMobileBroadbandUiccAppRecordDetailsResult;
+
+  interface IMobileBroadbandUiccAppsResult {
+    readonly Status: number;
+    readonly UiccApps: Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.MobileBroadbandUiccApp> | Windows.Networking.NetworkOperators.MobileBroadbandUiccApp[];
+  }
+  var IMobileBroadbandUiccAppsResult: abstract new (...args: any[]) => IMobileBroadbandUiccAppsResult;
+
+  interface INetworkOperatorDataUsageTriggerDetails {
+    readonly NotificationKind: number;
+  }
+  var INetworkOperatorDataUsageTriggerDetails: abstract new (...args: any[]) => INetworkOperatorDataUsageTriggerDetails;
+
+  interface INetworkOperatorNotificationEventDetails {
+    readonly EncodingType: number;
+    readonly Message: string;
+    readonly NetworkAccountId: string;
+    readonly NotificationType: number;
+    readonly RuleId: string;
+    readonly SmsMessage: Windows.Devices.Sms.ISmsMessage;
+  }
+  var INetworkOperatorNotificationEventDetails: abstract new (...args: any[]) => INetworkOperatorNotificationEventDetails;
+
+  interface INetworkOperatorTetheringAccessPointConfiguration {
+    Passphrase: string;
+    Ssid: string;
+  }
+  var INetworkOperatorTetheringAccessPointConfiguration: abstract new (...args: any[]) => INetworkOperatorTetheringAccessPointConfiguration;
+
+  interface INetworkOperatorTetheringAccessPointConfiguration2 {
+    IsBandSupported(band: number): boolean;
+    IsBandSupportedAsync(band: number): Windows.Foundation.IAsyncOperation<boolean>;
+    Band: number;
+  }
+  var INetworkOperatorTetheringAccessPointConfiguration2: abstract new (...args: any[]) => INetworkOperatorTetheringAccessPointConfiguration2;
+
+  interface INetworkOperatorTetheringAccessPointConfiguration3 {
+    IsAuthenticationKindSupported(authenticationKind: number): boolean;
+    IsAuthenticationKindSupportedAsync(authenticationKind: number): Windows.Foundation.IAsyncOperation<boolean>;
+    AuthenticationKind: number;
+  }
+  var INetworkOperatorTetheringAccessPointConfiguration3: abstract new (...args: any[]) => INetworkOperatorTetheringAccessPointConfiguration3;
+
+  interface INetworkOperatorTetheringClient {
+    readonly HostNames: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[];
+    readonly MacAddress: string;
+  }
+  var INetworkOperatorTetheringClient: abstract new (...args: any[]) => INetworkOperatorTetheringClient;
+
+  interface INetworkOperatorTetheringClientManager {
+    GetTetheringClients(): Windows.Foundation.Collections.IVectorView<Windows.Networking.NetworkOperators.NetworkOperatorTetheringClient> | Windows.Networking.NetworkOperators.NetworkOperatorTetheringClient[];
+  }
+  var INetworkOperatorTetheringClientManager: abstract new (...args: any[]) => INetworkOperatorTetheringClientManager;
+
+  interface INetworkOperatorTetheringEntitlementCheck {
+    AuthorizeTethering(allow: boolean, entitlementFailureReason: string): void;
+  }
+  var INetworkOperatorTetheringEntitlementCheck: abstract new (...args: any[]) => INetworkOperatorTetheringEntitlementCheck;
+
+  interface INetworkOperatorTetheringManager {
+    ConfigureAccessPointAsync(configuration: Windows.Networking.NetworkOperators.NetworkOperatorTetheringAccessPointConfiguration): Windows.Foundation.IAsyncAction;
+    GetCurrentAccessPointConfiguration(): Windows.Networking.NetworkOperators.NetworkOperatorTetheringAccessPointConfiguration;
+    StartTetheringAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.NetworkOperatorTetheringOperationResult>;
+    StopTetheringAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.NetworkOperatorTetheringOperationResult>;
+    readonly ClientCount: number;
+    readonly MaxClientCount: number;
+    readonly TetheringOperationalState: number;
+  }
+  var INetworkOperatorTetheringManager: abstract new (...args: any[]) => INetworkOperatorTetheringManager;
+
+  interface INetworkOperatorTetheringManager2 {
+    StartTetheringAsync(configuration: Windows.Networking.NetworkOperators.NetworkOperatorTetheringSessionAccessPointConfiguration): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.NetworkOperatorTetheringOperationResult>;
+  }
+  var INetworkOperatorTetheringManager2: abstract new (...args: any[]) => INetworkOperatorTetheringManager2;
+
+  interface INetworkOperatorTetheringManagerStatics {
+    CreateFromNetworkAccountId(networkAccountId: string): Windows.Networking.NetworkOperators.NetworkOperatorTetheringManager;
+    GetTetheringCapability(networkAccountId: string): number;
+  }
+  var INetworkOperatorTetheringManagerStatics: abstract new (...args: any[]) => INetworkOperatorTetheringManagerStatics;
+
+  interface INetworkOperatorTetheringManagerStatics2 {
+    CreateFromConnectionProfile(profile: Windows.Networking.Connectivity.ConnectionProfile): Windows.Networking.NetworkOperators.NetworkOperatorTetheringManager;
+    GetTetheringCapabilityFromConnectionProfile(profile: Windows.Networking.Connectivity.ConnectionProfile): number;
+  }
+  var INetworkOperatorTetheringManagerStatics2: abstract new (...args: any[]) => INetworkOperatorTetheringManagerStatics2;
+
+  interface INetworkOperatorTetheringManagerStatics3 {
+    CreateFromConnectionProfile(profile: Windows.Networking.Connectivity.ConnectionProfile, adapter: Windows.Networking.Connectivity.NetworkAdapter): Windows.Networking.NetworkOperators.NetworkOperatorTetheringManager;
+  }
+  var INetworkOperatorTetheringManagerStatics3: abstract new (...args: any[]) => INetworkOperatorTetheringManagerStatics3;
+
+  interface INetworkOperatorTetheringManagerStatics4 {
+    DisableNoConnectionsTimeout(): void;
+    DisableNoConnectionsTimeoutAsync(): Windows.Foundation.IAsyncAction;
+    EnableNoConnectionsTimeout(): void;
+    EnableNoConnectionsTimeoutAsync(): Windows.Foundation.IAsyncAction;
+    IsNoConnectionsTimeoutEnabled(): boolean;
+  }
+  var INetworkOperatorTetheringManagerStatics4: abstract new (...args: any[]) => INetworkOperatorTetheringManagerStatics4;
+
+  interface INetworkOperatorTetheringOperationResult {
+    readonly AdditionalErrorMessage: string;
+    readonly Status: number;
+  }
+  var INetworkOperatorTetheringOperationResult: abstract new (...args: any[]) => INetworkOperatorTetheringOperationResult;
+
+  interface INetworkOperatorTetheringSessionAccessPointConfiguration {
+    IsAuthenticationKindSupported(authenticationKind: number): boolean;
+    IsAuthenticationKindSupportedAsync(authenticationKind: number): Windows.Foundation.IAsyncOperation<boolean>;
+    IsBandSupported(band: number): boolean;
+    IsBandSupportedAsync(band: number): Windows.Foundation.IAsyncOperation<boolean>;
+    AuthenticationKind: number;
+    Band: number;
+    Passphrase: string;
+    PerformancePriority: number;
+    Ssid: string;
+  }
+  var INetworkOperatorTetheringSessionAccessPointConfiguration: abstract new (...args: any[]) => INetworkOperatorTetheringSessionAccessPointConfiguration;
+
+  interface IProvisionFromXmlDocumentResults {
+    readonly AllElementsProvisioned: boolean;
+    readonly ProvisionResultsXml: string;
+  }
+  var IProvisionFromXmlDocumentResults: abstract new (...args: any[]) => IProvisionFromXmlDocumentResults;
+
+  interface IProvisionedProfile {
+    UpdateCost(value: number): void;
+    UpdateUsage(value: Windows.Networking.NetworkOperators.ProfileUsage): void;
+  }
+  var IProvisionedProfile: abstract new (...args: any[]) => IProvisionedProfile;
+
+  interface IProvisioningAgent {
+    GetProvisionedProfile(mediaType: number, profileName: string): Windows.Networking.NetworkOperators.ProvisionedProfile;
+    ProvisionFromXmlDocumentAsync(provisioningXmlDocument: string): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.ProvisionFromXmlDocumentResults>;
+  }
+  var IProvisioningAgent: abstract new (...args: any[]) => IProvisioningAgent;
+
+  interface IProvisioningAgentStaticMethods {
+    CreateFromNetworkAccountId(networkAccountId: string): Windows.Networking.NetworkOperators.ProvisioningAgent;
+  }
+  var IProvisioningAgentStaticMethods: abstract new (...args: any[]) => IProvisioningAgentStaticMethods;
+
+  interface ITetheringEntitlementCheckTriggerDetails {
+    AllowTethering(): void;
+    DenyTethering(entitlementFailureReason: string): void;
+    readonly NetworkAccountId: string;
+  }
+  var ITetheringEntitlementCheckTriggerDetails: abstract new (...args: any[]) => ITetheringEntitlementCheckTriggerDetails;
+
+  interface IUssdMessage {
+    GetPayload(): number[];
+    SetPayload(value: number[]): void;
+    DataCodingScheme: number;
+    PayloadAsText: string;
+  }
+  var IUssdMessage: abstract new (...args: any[]) => IUssdMessage;
+
+  interface IUssdMessageFactory {
+    CreateMessage(messageText: string): Windows.Networking.NetworkOperators.UssdMessage;
+  }
+  var IUssdMessageFactory: abstract new (...args: any[]) => IUssdMessageFactory;
+
+  interface IUssdReply {
+    readonly Message: Windows.Networking.NetworkOperators.UssdMessage;
+    readonly ResultCode: number;
+  }
+  var IUssdReply: abstract new (...args: any[]) => IUssdReply;
+
+  interface IUssdSession {
+    Close(): void;
+    SendMessageAndGetReplyAsync(message: Windows.Networking.NetworkOperators.UssdMessage): Windows.Foundation.IAsyncOperation<Windows.Networking.NetworkOperators.UssdReply>;
+  }
+  var IUssdSession: abstract new (...args: any[]) => IUssdSession;
+
+  interface IUssdSessionStatics {
+    CreateFromNetworkAccountId(networkAccountId: string): Windows.Networking.NetworkOperators.UssdSession;
+    CreateFromNetworkInterfaceId(networkInterfaceId: string): Windows.Networking.NetworkOperators.UssdSession;
+  }
+  var IUssdSessionStatics: abstract new (...args: any[]) => IUssdSessionStatics;
+
+  interface LegacyNetworkOperatorsContract {
+  }
+  var LegacyNetworkOperatorsContract: {
+    new(fields: {  }): LegacyNetworkOperatorsContract;
+  };
+
+  interface ProfileUsage {
+    UsageInMegabytes: number;
+    LastSyncTime: Windows.Foundation.DateTime;
+  }
+  var ProfileUsage: {
+    new(usageInMegabytes: number, lastSyncTime: Windows.Foundation.DateTime): ProfileUsage;
+    new(fields: { UsageInMegabytes?: number; LastSyncTime?: Windows.Foundation.DateTime }): ProfileUsage;
+  };
+
+}
+
+declare namespace Windows.Networking.Proximity {
+  class ConnectionRequestedEventArgs implements Windows.Networking.Proximity.IConnectionRequestedEventArgs {
+    readonly PeerInformation: Windows.Networking.Proximity.PeerInformation;
+  }
+
+  class PeerFinder {
+    static ConnectAsync(peerInformation: Windows.Networking.Proximity.PeerInformation): Windows.Foundation.IAsyncOperation<Windows.Networking.Sockets.StreamSocket>;
+    static CreateWatcher(): Windows.Networking.Proximity.PeerWatcher;
+    static FindAllPeersAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.Proximity.PeerInformation> | Windows.Networking.Proximity.PeerInformation[]>;
+    static Start(): void;
+    static Start(peerMessage: string): void;
+    static Stop(): void;
+    static AllowBluetooth: boolean;
+    static AllowInfrastructure: boolean;
+    static AllowWiFiDirect: boolean;
+    static readonly AlternateIdentities: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    static DiscoveryData: Windows.Storage.Streams.IBuffer;
+    static DisplayName: string;
+    static Role: number;
+    static readonly SupportedDiscoveryTypes: number;
+    static ConnectionRequested: Windows.Foundation.TypedEventHandler<Object, Windows.Networking.Proximity.ConnectionRequestedEventArgs> | null;
+    static TriggeredConnectionStateChanged: Windows.Foundation.TypedEventHandler<Object, Windows.Networking.Proximity.TriggeredConnectionStateChangedEventArgs> | null;
+  }
+
+  class PeerInformation implements Windows.Networking.Proximity.IPeerInformation, Windows.Networking.Proximity.IPeerInformation3, Windows.Networking.Proximity.IPeerInformationWithHostAndService {
+    readonly DiscoveryData: Windows.Storage.Streams.IBuffer;
+    readonly DisplayName: string;
+    readonly HostName: Windows.Networking.HostName;
+    readonly Id: string;
+    readonly ServiceName: string;
+  }
+
+  class PeerWatcher implements Windows.Networking.Proximity.IPeerWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.Networking.Proximity.PeerWatcher, Windows.Networking.Proximity.PeerInformation> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Networking.Proximity.PeerWatcher, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.Networking.Proximity.PeerWatcher, Windows.Networking.Proximity.PeerInformation> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Networking.Proximity.PeerWatcher, Object> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.Networking.Proximity.PeerWatcher, Windows.Networking.Proximity.PeerInformation> | null;
+  }
+
+  class ProximityDevice implements Windows.Networking.Proximity.IProximityDevice {
+    static FromId(deviceId: string): Windows.Networking.Proximity.ProximityDevice;
+    static GetDefault(): Windows.Networking.Proximity.ProximityDevice;
+    static GetDeviceSelector(): string;
+    PublishBinaryMessage(messageType: string, message: Windows.Storage.Streams.IBuffer): number | bigint;
+    PublishBinaryMessage(messageType: string, message: Windows.Storage.Streams.IBuffer, messageTransmittedHandler: Windows.Networking.Proximity.MessageTransmittedHandler): number | bigint;
+    PublishMessage(messageType: string, message: string): number | bigint;
+    PublishMessage(messageType: string, message: string, messageTransmittedHandler: Windows.Networking.Proximity.MessageTransmittedHandler): number | bigint;
+    PublishUriMessage(message: Windows.Foundation.Uri): number | bigint;
+    PublishUriMessage(message: Windows.Foundation.Uri, messageTransmittedHandler: Windows.Networking.Proximity.MessageTransmittedHandler): number | bigint;
+    StopPublishingMessage(messageId: number | bigint): void;
+    StopSubscribingForMessage(subscriptionId: number | bigint): void;
+    SubscribeForMessage(messageType: string, messageReceivedHandler: Windows.Networking.Proximity.MessageReceivedHandler): number | bigint;
+    readonly BitsPerSecond: number | bigint;
+    readonly DeviceId: string;
+    readonly MaxMessageBytes: number;
+    DeviceArrived: Windows.Networking.Proximity.DeviceArrivedEventHandler | null;
+    DeviceDeparted: Windows.Networking.Proximity.DeviceDepartedEventHandler | null;
+  }
+
+  class ProximityMessage implements Windows.Networking.Proximity.IProximityMessage {
+    readonly Data: Windows.Storage.Streams.IBuffer;
+    readonly DataAsString: string;
+    readonly MessageType: string;
+    readonly SubscriptionId: number | bigint;
+  }
+
+  class TriggeredConnectionStateChangedEventArgs implements Windows.Networking.Proximity.ITriggeredConnectionStateChangedEventArgs {
+    readonly Id: number;
+    readonly Socket: Windows.Networking.Sockets.StreamSocket;
+    readonly State: number;
+  }
+
+  enum PeerDiscoveryTypes {
+    None = 0,
+    Browse = 1,
+    Triggered = 2,
+  }
+
+  enum PeerRole {
+    Peer = 0,
+    Host = 1,
+    Client = 2,
+  }
+
+  enum PeerWatcherStatus {
+    Created = 0,
+    Started = 1,
+    EnumerationCompleted = 2,
+    Stopping = 3,
+    Stopped = 4,
+    Aborted = 5,
+  }
+
+  enum TriggeredConnectState {
+    PeerFound = 0,
+    Listening = 1,
+    Connecting = 2,
+    Completed = 3,
+    Canceled = 4,
+    Failed = 5,
+  }
+
+  interface DeviceArrivedEventHandler {
+    (sender: Windows.Networking.Proximity.ProximityDevice): void;
+  }
+  var DeviceArrivedEventHandler: {
+    new(callback: (sender: Windows.Networking.Proximity.ProximityDevice) => void): DeviceArrivedEventHandler;
+  };
+
+  interface DeviceDepartedEventHandler {
+    (sender: Windows.Networking.Proximity.ProximityDevice): void;
+  }
+  var DeviceDepartedEventHandler: {
+    new(callback: (sender: Windows.Networking.Proximity.ProximityDevice) => void): DeviceDepartedEventHandler;
+  };
+
+  interface IConnectionRequestedEventArgs {
+    readonly PeerInformation: Windows.Networking.Proximity.PeerInformation;
+  }
+  var IConnectionRequestedEventArgs: abstract new (...args: any[]) => IConnectionRequestedEventArgs;
+
+  interface IPeerFinderStatics {
+    ConnectAsync(peerInformation: Windows.Networking.Proximity.PeerInformation): Windows.Foundation.IAsyncOperation<Windows.Networking.Sockets.StreamSocket>;
+    FindAllPeersAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.Proximity.PeerInformation> | Windows.Networking.Proximity.PeerInformation[]>;
+    Start(): void;
+    Start(peerMessage: string): void;
+    Stop(): void;
+    AllowBluetooth: boolean;
+    AllowInfrastructure: boolean;
+    AllowWiFiDirect: boolean;
+    readonly AlternateIdentities: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    DisplayName: string;
+    readonly SupportedDiscoveryTypes: number;
+    ConnectionRequested: Windows.Foundation.TypedEventHandler<Object, Windows.Networking.Proximity.ConnectionRequestedEventArgs> | null;
+    TriggeredConnectionStateChanged: Windows.Foundation.TypedEventHandler<Object, Windows.Networking.Proximity.TriggeredConnectionStateChangedEventArgs> | null;
+  }
+  var IPeerFinderStatics: abstract new (...args: any[]) => IPeerFinderStatics;
+
+  interface IPeerFinderStatics2 {
+    CreateWatcher(): Windows.Networking.Proximity.PeerWatcher;
+    DiscoveryData: Windows.Storage.Streams.IBuffer;
+    Role: number;
+  }
+  var IPeerFinderStatics2: abstract new (...args: any[]) => IPeerFinderStatics2;
+
+  interface IPeerInformation {
+    readonly DisplayName: string;
+  }
+  var IPeerInformation: abstract new (...args: any[]) => IPeerInformation;
+
+  interface IPeerInformation3 {
+    readonly DiscoveryData: Windows.Storage.Streams.IBuffer;
+    readonly Id: string;
+  }
+  var IPeerInformation3: abstract new (...args: any[]) => IPeerInformation3;
+
+  interface IPeerInformationWithHostAndService {
+    readonly HostName: Windows.Networking.HostName;
+    readonly ServiceName: string;
+  }
+  var IPeerInformationWithHostAndService: abstract new (...args: any[]) => IPeerInformationWithHostAndService;
+
+  interface IPeerWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.Networking.Proximity.PeerWatcher, Windows.Networking.Proximity.PeerInformation> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Networking.Proximity.PeerWatcher, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.Networking.Proximity.PeerWatcher, Windows.Networking.Proximity.PeerInformation> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Networking.Proximity.PeerWatcher, Object> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.Networking.Proximity.PeerWatcher, Windows.Networking.Proximity.PeerInformation> | null;
+  }
+  var IPeerWatcher: abstract new (...args: any[]) => IPeerWatcher;
+
+  interface IProximityDevice {
+    PublishBinaryMessage(messageType: string, message: Windows.Storage.Streams.IBuffer): number | bigint;
+    PublishBinaryMessage(messageType: string, message: Windows.Storage.Streams.IBuffer, messageTransmittedHandler: Windows.Networking.Proximity.MessageTransmittedHandler): number | bigint;
+    PublishMessage(messageType: string, message: string): number | bigint;
+    PublishMessage(messageType: string, message: string, messageTransmittedHandler: Windows.Networking.Proximity.MessageTransmittedHandler): number | bigint;
+    PublishUriMessage(message: Windows.Foundation.Uri): number | bigint;
+    PublishUriMessage(message: Windows.Foundation.Uri, messageTransmittedHandler: Windows.Networking.Proximity.MessageTransmittedHandler): number | bigint;
+    StopPublishingMessage(messageId: number | bigint): void;
+    StopSubscribingForMessage(subscriptionId: number | bigint): void;
+    SubscribeForMessage(messageType: string, messageReceivedHandler: Windows.Networking.Proximity.MessageReceivedHandler): number | bigint;
+    readonly BitsPerSecond: number | bigint;
+    readonly DeviceId: string;
+    readonly MaxMessageBytes: number;
+    DeviceArrived: Windows.Networking.Proximity.DeviceArrivedEventHandler | null;
+    DeviceDeparted: Windows.Networking.Proximity.DeviceDepartedEventHandler | null;
+  }
+  var IProximityDevice: abstract new (...args: any[]) => IProximityDevice;
+
+  interface IProximityDeviceStatics {
+    FromId(deviceId: string): Windows.Networking.Proximity.ProximityDevice;
+    GetDefault(): Windows.Networking.Proximity.ProximityDevice;
+    GetDeviceSelector(): string;
+  }
+  var IProximityDeviceStatics: abstract new (...args: any[]) => IProximityDeviceStatics;
+
+  interface IProximityMessage {
+    readonly Data: Windows.Storage.Streams.IBuffer;
+    readonly DataAsString: string;
+    readonly MessageType: string;
+    readonly SubscriptionId: number | bigint;
+  }
+  var IProximityMessage: abstract new (...args: any[]) => IProximityMessage;
+
+  interface ITriggeredConnectionStateChangedEventArgs {
+    readonly Id: number;
+    readonly Socket: Windows.Networking.Sockets.StreamSocket;
+    readonly State: number;
+  }
+  var ITriggeredConnectionStateChangedEventArgs: abstract new (...args: any[]) => ITriggeredConnectionStateChangedEventArgs;
+
+  interface MessageReceivedHandler {
+    (sender: Windows.Networking.Proximity.ProximityDevice, message: Windows.Networking.Proximity.ProximityMessage): void;
+  }
+  var MessageReceivedHandler: {
+    new(callback: (sender: Windows.Networking.Proximity.ProximityDevice, message: Windows.Networking.Proximity.ProximityMessage) => void): MessageReceivedHandler;
+  };
+
+  interface MessageTransmittedHandler {
+    (sender: Windows.Networking.Proximity.ProximityDevice, messageId: number | bigint): void;
+  }
+  var MessageTransmittedHandler: {
+    new(callback: (sender: Windows.Networking.Proximity.ProximityDevice, messageId: number | bigint) => void): MessageTransmittedHandler;
+  };
+
+}
+
+declare namespace Windows.Networking.PushNotifications {
+  class PushNotificationChannel implements Windows.Networking.PushNotifications.IPushNotificationChannel {
+    Close(): void;
+    readonly ExpirationTime: Windows.Foundation.DateTime;
+    readonly Uri: string;
+    PushNotificationReceived: Windows.Foundation.TypedEventHandler<Windows.Networking.PushNotifications.PushNotificationChannel, Windows.Networking.PushNotifications.PushNotificationReceivedEventArgs> | null;
+  }
+
+  class PushNotificationChannelManager {
+    static CreatePushNotificationChannelForApplicationAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.PushNotifications.PushNotificationChannel>;
+    static CreatePushNotificationChannelForApplicationAsync(applicationId: string): Windows.Foundation.IAsyncOperation<Windows.Networking.PushNotifications.PushNotificationChannel>;
+    static CreatePushNotificationChannelForSecondaryTileAsync(tileId: string): Windows.Foundation.IAsyncOperation<Windows.Networking.PushNotifications.PushNotificationChannel>;
+    static GetDefault(): Windows.Networking.PushNotifications.PushNotificationChannelManagerForUser;
+    static GetForUser(user: Windows.System.User): Windows.Networking.PushNotifications.PushNotificationChannelManagerForUser;
+    static ChannelsRevoked: Windows.Foundation.EventHandler<Windows.Networking.PushNotifications.PushNotificationChannelsRevokedEventArgs> | null;
+  }
+
+  class PushNotificationChannelManagerForUser implements Windows.Networking.PushNotifications.IPushNotificationChannelManagerForUser, Windows.Networking.PushNotifications.IPushNotificationChannelManagerForUser2 {
+    CreatePushNotificationChannelForApplicationAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.PushNotifications.PushNotificationChannel>;
+    CreatePushNotificationChannelForApplicationAsync(applicationId: string): Windows.Foundation.IAsyncOperation<Windows.Networking.PushNotifications.PushNotificationChannel>;
+    CreatePushNotificationChannelForSecondaryTileAsync(tileId: string): Windows.Foundation.IAsyncOperation<Windows.Networking.PushNotifications.PushNotificationChannel>;
+    CreateRawPushNotificationChannelWithAlternateKeyForApplicationAsync(appServerKey: Windows.Storage.Streams.IBuffer, channelId: string): Windows.Foundation.IAsyncOperation<Windows.Networking.PushNotifications.PushNotificationChannel>;
+    CreateRawPushNotificationChannelWithAlternateKeyForApplicationAsync(appServerKey: Windows.Storage.Streams.IBuffer, channelId: string, appId: string): Windows.Foundation.IAsyncOperation<Windows.Networking.PushNotifications.PushNotificationChannel>;
+    readonly User: Windows.System.User;
+  }
+
+  class PushNotificationChannelsRevokedEventArgs implements Windows.Networking.PushNotifications.IPushNotificationChannelsRevokedEventArgs {
+  }
+
+  class PushNotificationReceivedEventArgs implements Windows.Networking.PushNotifications.IPushNotificationReceivedEventArgs {
+    readonly BadgeNotification: Windows.UI.Notifications.BadgeNotification;
+    Cancel: boolean;
+    readonly NotificationType: number;
+    readonly RawNotification: Windows.Networking.PushNotifications.RawNotification;
+    readonly TileNotification: Windows.UI.Notifications.TileNotification;
+    readonly ToastNotification: Windows.UI.Notifications.ToastNotification;
+  }
+
+  class RawNotification implements Windows.Networking.PushNotifications.IRawNotification, Windows.Networking.PushNotifications.IRawNotification2, Windows.Networking.PushNotifications.IRawNotification3 {
+    readonly ChannelId: string;
+    readonly Content: string;
+    readonly ContentBytes: Windows.Storage.Streams.IBuffer;
+    readonly Headers: Windows.Foundation.Collections.IMapView<string, string>;
+  }
+
+  enum PushNotificationType {
+    Toast = 0,
+    Tile = 1,
+    Badge = 2,
+    Raw = 3,
+    TileFlyout = 4,
+  }
+
+  interface IPushNotificationChannel {
+    Close(): void;
+    readonly ExpirationTime: Windows.Foundation.DateTime;
+    readonly Uri: string;
+    PushNotificationReceived: Windows.Foundation.TypedEventHandler<Windows.Networking.PushNotifications.PushNotificationChannel, Windows.Networking.PushNotifications.PushNotificationReceivedEventArgs> | null;
+  }
+  var IPushNotificationChannel: abstract new (...args: any[]) => IPushNotificationChannel;
+
+  interface IPushNotificationChannelManagerForUser {
+    CreatePushNotificationChannelForApplicationAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.PushNotifications.PushNotificationChannel>;
+    CreatePushNotificationChannelForApplicationAsync(applicationId: string): Windows.Foundation.IAsyncOperation<Windows.Networking.PushNotifications.PushNotificationChannel>;
+    CreatePushNotificationChannelForSecondaryTileAsync(tileId: string): Windows.Foundation.IAsyncOperation<Windows.Networking.PushNotifications.PushNotificationChannel>;
+    readonly User: Windows.System.User;
+  }
+  var IPushNotificationChannelManagerForUser: abstract new (...args: any[]) => IPushNotificationChannelManagerForUser;
+
+  interface IPushNotificationChannelManagerForUser2 {
+    CreateRawPushNotificationChannelWithAlternateKeyForApplicationAsync(appServerKey: Windows.Storage.Streams.IBuffer, channelId: string): Windows.Foundation.IAsyncOperation<Windows.Networking.PushNotifications.PushNotificationChannel>;
+    CreateRawPushNotificationChannelWithAlternateKeyForApplicationAsync(appServerKey: Windows.Storage.Streams.IBuffer, channelId: string, appId: string): Windows.Foundation.IAsyncOperation<Windows.Networking.PushNotifications.PushNotificationChannel>;
+  }
+  var IPushNotificationChannelManagerForUser2: abstract new (...args: any[]) => IPushNotificationChannelManagerForUser2;
+
+  interface IPushNotificationChannelManagerStatics {
+    CreatePushNotificationChannelForApplicationAsync(): Windows.Foundation.IAsyncOperation<Windows.Networking.PushNotifications.PushNotificationChannel>;
+    CreatePushNotificationChannelForApplicationAsync(applicationId: string): Windows.Foundation.IAsyncOperation<Windows.Networking.PushNotifications.PushNotificationChannel>;
+    CreatePushNotificationChannelForSecondaryTileAsync(tileId: string): Windows.Foundation.IAsyncOperation<Windows.Networking.PushNotifications.PushNotificationChannel>;
+  }
+  var IPushNotificationChannelManagerStatics: abstract new (...args: any[]) => IPushNotificationChannelManagerStatics;
+
+  interface IPushNotificationChannelManagerStatics2 {
+    GetForUser(user: Windows.System.User): Windows.Networking.PushNotifications.PushNotificationChannelManagerForUser;
+  }
+  var IPushNotificationChannelManagerStatics2: abstract new (...args: any[]) => IPushNotificationChannelManagerStatics2;
+
+  interface IPushNotificationChannelManagerStatics3 {
+    GetDefault(): Windows.Networking.PushNotifications.PushNotificationChannelManagerForUser;
+  }
+  var IPushNotificationChannelManagerStatics3: abstract new (...args: any[]) => IPushNotificationChannelManagerStatics3;
+
+  interface IPushNotificationChannelManagerStatics4 {
+    ChannelsRevoked: Windows.Foundation.EventHandler<Windows.Networking.PushNotifications.PushNotificationChannelsRevokedEventArgs> | null;
+  }
+  var IPushNotificationChannelManagerStatics4: abstract new (...args: any[]) => IPushNotificationChannelManagerStatics4;
+
+  interface IPushNotificationChannelsRevokedEventArgs {
+  }
+  var IPushNotificationChannelsRevokedEventArgs: abstract new (...args: any[]) => IPushNotificationChannelsRevokedEventArgs;
+
+  interface IPushNotificationReceivedEventArgs {
+    readonly BadgeNotification: Windows.UI.Notifications.BadgeNotification;
+    Cancel: boolean;
+    readonly NotificationType: number;
+    readonly RawNotification: Windows.Networking.PushNotifications.RawNotification;
+    readonly TileNotification: Windows.UI.Notifications.TileNotification;
+    readonly ToastNotification: Windows.UI.Notifications.ToastNotification;
+  }
+  var IPushNotificationReceivedEventArgs: abstract new (...args: any[]) => IPushNotificationReceivedEventArgs;
+
+  interface IRawNotification {
+    readonly Content: string;
+  }
+  var IRawNotification: abstract new (...args: any[]) => IRawNotification;
+
+  interface IRawNotification2 {
+    readonly ChannelId: string;
+    readonly Headers: Windows.Foundation.Collections.IMapView<string, string>;
+  }
+  var IRawNotification2: abstract new (...args: any[]) => IRawNotification2;
+
+  interface IRawNotification3 {
+    readonly ContentBytes: Windows.Storage.Streams.IBuffer;
+  }
+  var IRawNotification3: abstract new (...args: any[]) => IRawNotification3;
+
+}
+
+declare namespace Windows.Networking.ServiceDiscovery.Dnssd {
+  class DnssdRegistrationResult implements Windows.Foundation.IStringable, Windows.Networking.ServiceDiscovery.Dnssd.IDnssdRegistrationResult {
+    constructor();
+    ToString(): string;
+    readonly HasInstanceNameChanged: boolean;
+    readonly IPAddress: Windows.Networking.HostName;
+    readonly Status: number;
+  }
+
+  class DnssdServiceInstance implements Windows.Foundation.IStringable, Windows.Networking.ServiceDiscovery.Dnssd.IDnssdServiceInstance {
+    constructor(dnssdServiceInstanceName: string, hostName: Windows.Networking.HostName, port: number);
+    RegisterDatagramSocketAsync(socket: Windows.Networking.Sockets.DatagramSocket): Windows.Foundation.IAsyncOperation<Windows.Networking.ServiceDiscovery.Dnssd.DnssdRegistrationResult>;
+    RegisterDatagramSocketAsync(socket: Windows.Networking.Sockets.DatagramSocket, adapter: Windows.Networking.Connectivity.NetworkAdapter): Windows.Foundation.IAsyncOperation<Windows.Networking.ServiceDiscovery.Dnssd.DnssdRegistrationResult>;
+    RegisterStreamSocketListenerAsync(socket: Windows.Networking.Sockets.StreamSocketListener): Windows.Foundation.IAsyncOperation<Windows.Networking.ServiceDiscovery.Dnssd.DnssdRegistrationResult>;
+    RegisterStreamSocketListenerAsync(socket: Windows.Networking.Sockets.StreamSocketListener, adapter: Windows.Networking.Connectivity.NetworkAdapter): Windows.Foundation.IAsyncOperation<Windows.Networking.ServiceDiscovery.Dnssd.DnssdRegistrationResult>;
+    ToString(): string;
+    DnssdServiceInstanceName: string;
+    HostName: Windows.Networking.HostName;
+    Port: number;
+    Priority: number;
+    readonly TextAttributes: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    Weight: number;
+  }
+
+  class DnssdServiceInstanceCollection {
+    First(): Windows.Foundation.Collections.IIterator<Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance>;
+    GetAt(index: number): Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance;
+    GetMany(startIndex: number, items: Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance[]): number;
+    IndexOf(value: Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance, index: number): boolean;
+    readonly Size: number;
+  }
+
+  class DnssdServiceWatcher implements Windows.Networking.ServiceDiscovery.Dnssd.IDnssdServiceWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher, Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher, Object> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher, Object> | null;
+  }
+
+  enum DnssdRegistrationStatus {
+    Success = 0,
+    InvalidServiceName = 1,
+    ServerError = 2,
+    SecurityError = 3,
+  }
+
+  enum DnssdServiceWatcherStatus {
+    Created = 0,
+    Started = 1,
+    EnumerationCompleted = 2,
+    Stopping = 3,
+    Stopped = 4,
+    Aborted = 5,
+  }
+
+  interface IDnssdRegistrationResult {
+    readonly HasInstanceNameChanged: boolean;
+    readonly IPAddress: Windows.Networking.HostName;
+    readonly Status: number;
+  }
+  var IDnssdRegistrationResult: abstract new (...args: any[]) => IDnssdRegistrationResult;
+
+  interface IDnssdServiceInstance {
+    RegisterDatagramSocketAsync(socket: Windows.Networking.Sockets.DatagramSocket): Windows.Foundation.IAsyncOperation<Windows.Networking.ServiceDiscovery.Dnssd.DnssdRegistrationResult>;
+    RegisterDatagramSocketAsync(socket: Windows.Networking.Sockets.DatagramSocket, adapter: Windows.Networking.Connectivity.NetworkAdapter): Windows.Foundation.IAsyncOperation<Windows.Networking.ServiceDiscovery.Dnssd.DnssdRegistrationResult>;
+    RegisterStreamSocketListenerAsync(socket: Windows.Networking.Sockets.StreamSocketListener): Windows.Foundation.IAsyncOperation<Windows.Networking.ServiceDiscovery.Dnssd.DnssdRegistrationResult>;
+    RegisterStreamSocketListenerAsync(socket: Windows.Networking.Sockets.StreamSocketListener, adapter: Windows.Networking.Connectivity.NetworkAdapter): Windows.Foundation.IAsyncOperation<Windows.Networking.ServiceDiscovery.Dnssd.DnssdRegistrationResult>;
+    DnssdServiceInstanceName: string;
+    HostName: Windows.Networking.HostName;
+    Port: number;
+    Priority: number;
+    readonly TextAttributes: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    Weight: number;
+  }
+  var IDnssdServiceInstance: abstract new (...args: any[]) => IDnssdServiceInstance;
+
+  interface IDnssdServiceInstanceFactory {
+    Create(dnssdServiceInstanceName: string, hostName: Windows.Networking.HostName, port: number): Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance;
+  }
+  var IDnssdServiceInstanceFactory: abstract new (...args: any[]) => IDnssdServiceInstanceFactory;
+
+  interface IDnssdServiceWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher, Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceInstance> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher, Object> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.Networking.ServiceDiscovery.Dnssd.DnssdServiceWatcher, Object> | null;
+  }
+  var IDnssdServiceWatcher: abstract new (...args: any[]) => IDnssdServiceWatcher;
+
+}
+
+declare namespace Windows.Networking.Sockets {
+  class ControlChannelTrigger implements Windows.Foundation.IClosable, Windows.Networking.Sockets.IControlChannelTrigger, Windows.Networking.Sockets.IControlChannelTrigger2 {
+    constructor(channelId: string, serverKeepAliveIntervalInMinutes: number);
+    constructor(channelId: string, serverKeepAliveIntervalInMinutes: number, resourceRequestType: number);
+    Close(): void;
+    DecreaseNetworkKeepAliveInterval(): void;
+    FlushTransport(): void;
+    UsingTransport(transport: Object): void;
+    WaitForPushEnabled(): number;
+    readonly ControlChannelTriggerId: string;
+    readonly CurrentKeepAliveIntervalInMinutes: number;
+    readonly IsWakeFromLowPowerSupported: boolean;
+    readonly KeepAliveTrigger: Windows.ApplicationModel.Background.IBackgroundTrigger;
+    readonly PushNotificationTrigger: Windows.ApplicationModel.Background.IBackgroundTrigger;
+    ServerKeepAliveIntervalInMinutes: number;
+    readonly TransportObject: Object;
+  }
+
+  class DatagramSocket implements Windows.Foundation.IClosable, Windows.Networking.Sockets.IDatagramSocket, Windows.Networking.Sockets.IDatagramSocket2, Windows.Networking.Sockets.IDatagramSocket3 {
+    constructor();
+    BindEndpointAsync(localHostName: Windows.Networking.HostName, localServiceName: string): Windows.Foundation.IAsyncAction;
+    BindServiceNameAsync(localServiceName: string): Windows.Foundation.IAsyncAction;
+    BindServiceNameAsync(localServiceName: string, adapter: Windows.Networking.Connectivity.NetworkAdapter): Windows.Foundation.IAsyncAction;
+    CancelIOAsync(): Windows.Foundation.IAsyncAction;
+    Close(): void;
+    ConnectAsync(remoteHostName: Windows.Networking.HostName, remoteServiceName: string): Windows.Foundation.IAsyncAction;
+    ConnectAsync(endpointPair: Windows.Networking.EndpointPair): Windows.Foundation.IAsyncAction;
+    EnableTransferOwnership(taskId: Guid): void;
+    EnableTransferOwnership(taskId: Guid, connectedStandbyAction: number): void;
+    static GetEndpointPairsAsync(remoteHostName: Windows.Networking.HostName, remoteServiceName: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.EndpointPair> | Windows.Networking.EndpointPair[]>;
+    static GetEndpointPairsAsync(remoteHostName: Windows.Networking.HostName, remoteServiceName: string, sortOptions: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.EndpointPair> | Windows.Networking.EndpointPair[]>;
+    GetOutputStreamAsync(remoteHostName: Windows.Networking.HostName, remoteServiceName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IOutputStream>;
+    GetOutputStreamAsync(endpointPair: Windows.Networking.EndpointPair): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IOutputStream>;
+    JoinMulticastGroup(host: Windows.Networking.HostName): void;
+    TransferOwnership(socketId: string): void;
+    TransferOwnership(socketId: string, data: Windows.Networking.Sockets.SocketActivityContext): void;
+    TransferOwnership(socketId: string, data: Windows.Networking.Sockets.SocketActivityContext, keepAliveTime: Windows.Foundation.TimeSpan): void;
+    readonly Control: Windows.Networking.Sockets.DatagramSocketControl;
+    readonly Information: Windows.Networking.Sockets.DatagramSocketInformation;
+    readonly OutputStream: Windows.Storage.Streams.IOutputStream;
+    MessageReceived: Windows.Foundation.TypedEventHandler<Windows.Networking.Sockets.DatagramSocket, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs> | null;
+  }
+
+  class DatagramSocketControl implements Windows.Networking.Sockets.IDatagramSocketControl, Windows.Networking.Sockets.IDatagramSocketControl2, Windows.Networking.Sockets.IDatagramSocketControl3 {
+    DontFragment: boolean;
+    InboundBufferSizeInBytes: number;
+    MulticastOnly: boolean;
+    OutboundUnicastHopLimit: number;
+    QualityOfService: number;
+  }
+
+  class DatagramSocketInformation implements Windows.Networking.Sockets.IDatagramSocketInformation {
+    readonly LocalAddress: Windows.Networking.HostName;
+    readonly LocalPort: string;
+    readonly RemoteAddress: Windows.Networking.HostName;
+    readonly RemotePort: string;
+  }
+
+  class DatagramSocketMessageReceivedEventArgs implements Windows.Networking.Sockets.IDatagramSocketMessageReceivedEventArgs {
+    GetDataReader(): Windows.Storage.Streams.DataReader;
+    GetDataStream(): Windows.Storage.Streams.IInputStream;
+    readonly LocalAddress: Windows.Networking.HostName;
+    readonly RemoteAddress: Windows.Networking.HostName;
+    readonly RemotePort: string;
+  }
+
+  class MessageWebSocket implements Windows.Foundation.IClosable, Windows.Networking.Sockets.IMessageWebSocket, Windows.Networking.Sockets.IMessageWebSocket2, Windows.Networking.Sockets.IMessageWebSocket3, Windows.Networking.Sockets.IWebSocket {
+    constructor();
+    Close(code: number, reason: string): void;
+    Close(): void;
+    ConnectAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncAction;
+    SendFinalFrameAsync(data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    SendNonfinalFrameAsync(data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    SetRequestHeader(headerName: string, headerValue: string): void;
+    readonly Control: Windows.Networking.Sockets.MessageWebSocketControl;
+    readonly Information: Windows.Networking.Sockets.MessageWebSocketInformation;
+    readonly OutputStream: Windows.Storage.Streams.IOutputStream;
+    MessageReceived: Windows.Foundation.TypedEventHandler<Windows.Networking.Sockets.MessageWebSocket, Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs> | null;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Networking.Sockets.IWebSocket, Windows.Networking.Sockets.WebSocketClosedEventArgs> | null;
+    ServerCustomValidationRequested: Windows.Foundation.TypedEventHandler<Windows.Networking.Sockets.MessageWebSocket, Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs> | null;
+  }
+
+  class MessageWebSocketControl implements Windows.Networking.Sockets.IMessageWebSocketControl, Windows.Networking.Sockets.IMessageWebSocketControl2, Windows.Networking.Sockets.IWebSocketControl, Windows.Networking.Sockets.IWebSocketControl2 {
+    readonly ActualUnsolicitedPongInterval: Windows.Foundation.TimeSpan;
+    ClientCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    DesiredUnsolicitedPongInterval: Windows.Foundation.TimeSpan;
+    readonly IgnorableServerCertificateErrors: Windows.Foundation.Collections.IVector<number> | number[];
+    MaxMessageSize: number;
+    MessageType: number;
+    OutboundBufferSizeInBytes: number;
+    ProxyCredential: Windows.Security.Credentials.PasswordCredential;
+    ReceiveMode: number;
+    ServerCredential: Windows.Security.Credentials.PasswordCredential;
+    readonly SupportedProtocols: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+
+  class MessageWebSocketInformation implements Windows.Networking.Sockets.IWebSocketInformation, Windows.Networking.Sockets.IWebSocketInformation2 {
+    readonly BandwidthStatistics: Windows.Networking.Sockets.BandwidthStatistics;
+    readonly LocalAddress: Windows.Networking.HostName;
+    readonly Protocol: string;
+    readonly ServerCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    readonly ServerCertificateErrorSeverity: number;
+    readonly ServerCertificateErrors: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly ServerIntermediateCertificates: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+  }
+
+  class MessageWebSocketMessageReceivedEventArgs implements Windows.Networking.Sockets.IMessageWebSocketMessageReceivedEventArgs, Windows.Networking.Sockets.IMessageWebSocketMessageReceivedEventArgs2 {
+    GetDataReader(): Windows.Storage.Streams.DataReader;
+    GetDataStream(): Windows.Storage.Streams.IInputStream;
+    readonly IsMessageComplete: boolean;
+    readonly MessageType: number;
+  }
+
+  class ServerMessageWebSocket implements Windows.Foundation.IClosable, Windows.Networking.Sockets.IServerMessageWebSocket {
+    Close(code: number, reason: string): void;
+    Close(): void;
+    readonly Control: Windows.Networking.Sockets.ServerMessageWebSocketControl;
+    readonly Information: Windows.Networking.Sockets.ServerMessageWebSocketInformation;
+    readonly OutputStream: Windows.Storage.Streams.IOutputStream;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Networking.Sockets.ServerMessageWebSocket, Windows.Networking.Sockets.WebSocketClosedEventArgs> | null;
+    MessageReceived: Windows.Foundation.TypedEventHandler<Windows.Networking.Sockets.ServerMessageWebSocket, Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs> | null;
+  }
+
+  class ServerMessageWebSocketControl implements Windows.Networking.Sockets.IServerMessageWebSocketControl {
+    MessageType: number;
+  }
+
+  class ServerMessageWebSocketInformation implements Windows.Networking.Sockets.IServerMessageWebSocketInformation {
+    readonly BandwidthStatistics: Windows.Networking.Sockets.BandwidthStatistics;
+    readonly LocalAddress: Windows.Networking.HostName;
+    readonly Protocol: string;
+  }
+
+  class ServerStreamWebSocket implements Windows.Foundation.IClosable, Windows.Networking.Sockets.IServerStreamWebSocket {
+    Close(code: number, reason: string): void;
+    Close(): void;
+    readonly Information: Windows.Networking.Sockets.ServerStreamWebSocketInformation;
+    readonly InputStream: Windows.Storage.Streams.IInputStream;
+    readonly OutputStream: Windows.Storage.Streams.IOutputStream;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Networking.Sockets.ServerStreamWebSocket, Windows.Networking.Sockets.WebSocketClosedEventArgs> | null;
+  }
+
+  class ServerStreamWebSocketInformation implements Windows.Networking.Sockets.IServerStreamWebSocketInformation {
+    readonly BandwidthStatistics: Windows.Networking.Sockets.BandwidthStatistics;
+    readonly LocalAddress: Windows.Networking.HostName;
+    readonly Protocol: string;
+  }
+
+  class SocketActivityContext implements Windows.Networking.Sockets.ISocketActivityContext {
+    constructor(data: Windows.Storage.Streams.IBuffer);
+    readonly Data: Windows.Storage.Streams.IBuffer;
+  }
+
+  class SocketActivityInformation implements Windows.Networking.Sockets.ISocketActivityInformation {
+    static readonly AllSockets: Windows.Foundation.Collections.IMapView<string, Windows.Networking.Sockets.SocketActivityInformation>;
+    readonly Context: Windows.Networking.Sockets.SocketActivityContext;
+    readonly DatagramSocket: Windows.Networking.Sockets.DatagramSocket;
+    readonly Id: string;
+    readonly SocketKind: number;
+    readonly StreamSocket: Windows.Networking.Sockets.StreamSocket;
+    readonly StreamSocketListener: Windows.Networking.Sockets.StreamSocketListener;
+    readonly TaskId: Guid;
+  }
+
+  class SocketActivityTriggerDetails implements Windows.Networking.Sockets.ISocketActivityTriggerDetails {
+    readonly Reason: number;
+    readonly SocketInformation: Windows.Networking.Sockets.SocketActivityInformation;
+  }
+
+  class SocketError {
+    static GetStatus(hresult: number): number;
+  }
+
+  class StreamSocket implements Windows.Foundation.IClosable, Windows.Networking.Sockets.IStreamSocket, Windows.Networking.Sockets.IStreamSocket2, Windows.Networking.Sockets.IStreamSocket3 {
+    constructor();
+    CancelIOAsync(): Windows.Foundation.IAsyncAction;
+    Close(): void;
+    ConnectAsync(endpointPair: Windows.Networking.EndpointPair): Windows.Foundation.IAsyncAction;
+    ConnectAsync(remoteHostName: Windows.Networking.HostName, remoteServiceName: string): Windows.Foundation.IAsyncAction;
+    ConnectAsync(remoteHostName: Windows.Networking.HostName, remoteServiceName: string, protectionLevel: number): Windows.Foundation.IAsyncAction;
+    ConnectAsync(remoteHostName: Windows.Networking.HostName, remoteServiceName: string, protectionLevel: number, adapter: Windows.Networking.Connectivity.NetworkAdapter): Windows.Foundation.IAsyncAction;
+    EnableTransferOwnership(taskId: Guid): void;
+    EnableTransferOwnership(taskId: Guid, connectedStandbyAction: number): void;
+    static GetEndpointPairsAsync(remoteHostName: Windows.Networking.HostName, remoteServiceName: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.EndpointPair> | Windows.Networking.EndpointPair[]>;
+    static GetEndpointPairsAsync(remoteHostName: Windows.Networking.HostName, remoteServiceName: string, sortOptions: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.EndpointPair> | Windows.Networking.EndpointPair[]>;
+    TransferOwnership(socketId: string): void;
+    TransferOwnership(socketId: string, data: Windows.Networking.Sockets.SocketActivityContext): void;
+    TransferOwnership(socketId: string, data: Windows.Networking.Sockets.SocketActivityContext, keepAliveTime: Windows.Foundation.TimeSpan): void;
+    UpgradeToSslAsync(protectionLevel: number, validationHostName: Windows.Networking.HostName): Windows.Foundation.IAsyncAction;
+    readonly Control: Windows.Networking.Sockets.StreamSocketControl;
+    readonly Information: Windows.Networking.Sockets.StreamSocketInformation;
+    readonly InputStream: Windows.Storage.Streams.IInputStream;
+    readonly OutputStream: Windows.Storage.Streams.IOutputStream;
+  }
+
+  class StreamSocketControl implements Windows.Networking.Sockets.IStreamSocketControl, Windows.Networking.Sockets.IStreamSocketControl2, Windows.Networking.Sockets.IStreamSocketControl3, Windows.Networking.Sockets.IStreamSocketControl4 {
+    ClientCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    readonly IgnorableServerCertificateErrors: Windows.Foundation.Collections.IVector<number> | number[];
+    KeepAlive: boolean;
+    MinProtectionLevel: number;
+    NoDelay: boolean;
+    OutboundBufferSizeInBytes: number;
+    OutboundUnicastHopLimit: number;
+    QualityOfService: number;
+    SerializeConnectionAttempts: boolean;
+  }
+
+  class StreamSocketInformation implements Windows.Networking.Sockets.IStreamSocketInformation, Windows.Networking.Sockets.IStreamSocketInformation2 {
+    readonly BandwidthStatistics: Windows.Networking.Sockets.BandwidthStatistics;
+    readonly LocalAddress: Windows.Networking.HostName;
+    readonly LocalPort: string;
+    readonly ProtectionLevel: number;
+    readonly RemoteAddress: Windows.Networking.HostName;
+    readonly RemoteHostName: Windows.Networking.HostName;
+    readonly RemotePort: string;
+    readonly RemoteServiceName: string;
+    readonly RoundTripTimeStatistics: Windows.Networking.Sockets.RoundTripTimeStatistics;
+    readonly ServerCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    readonly ServerCertificateErrorSeverity: number;
+    readonly ServerCertificateErrors: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly ServerIntermediateCertificates: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+    readonly SessionKey: Windows.Storage.Streams.IBuffer;
+  }
+
+  class StreamSocketListener implements Windows.Foundation.IClosable, Windows.Networking.Sockets.IStreamSocketListener, Windows.Networking.Sockets.IStreamSocketListener2, Windows.Networking.Sockets.IStreamSocketListener3 {
+    constructor();
+    BindEndpointAsync(localHostName: Windows.Networking.HostName, localServiceName: string): Windows.Foundation.IAsyncAction;
+    BindServiceNameAsync(localServiceName: string): Windows.Foundation.IAsyncAction;
+    BindServiceNameAsync(localServiceName: string, protectionLevel: number): Windows.Foundation.IAsyncAction;
+    BindServiceNameAsync(localServiceName: string, protectionLevel: number, adapter: Windows.Networking.Connectivity.NetworkAdapter): Windows.Foundation.IAsyncAction;
+    CancelIOAsync(): Windows.Foundation.IAsyncAction;
+    Close(): void;
+    EnableTransferOwnership(taskId: Guid): void;
+    EnableTransferOwnership(taskId: Guid, connectedStandbyAction: number): void;
+    TransferOwnership(socketId: string): void;
+    TransferOwnership(socketId: string, data: Windows.Networking.Sockets.SocketActivityContext): void;
+    readonly Control: Windows.Networking.Sockets.StreamSocketListenerControl;
+    readonly Information: Windows.Networking.Sockets.StreamSocketListenerInformation;
+    ConnectionReceived: Windows.Foundation.TypedEventHandler<Windows.Networking.Sockets.StreamSocketListener, Windows.Networking.Sockets.StreamSocketListenerConnectionReceivedEventArgs> | null;
+  }
+
+  class StreamSocketListenerConnectionReceivedEventArgs implements Windows.Networking.Sockets.IStreamSocketListenerConnectionReceivedEventArgs {
+    readonly Socket: Windows.Networking.Sockets.StreamSocket;
+  }
+
+  class StreamSocketListenerControl implements Windows.Networking.Sockets.IStreamSocketListenerControl, Windows.Networking.Sockets.IStreamSocketListenerControl2 {
+    KeepAlive: boolean;
+    NoDelay: boolean;
+    OutboundBufferSizeInBytes: number;
+    OutboundUnicastHopLimit: number;
+    QualityOfService: number;
+  }
+
+  class StreamSocketListenerInformation implements Windows.Networking.Sockets.IStreamSocketListenerInformation {
+    readonly LocalPort: string;
+  }
+
+  class StreamWebSocket implements Windows.Foundation.IClosable, Windows.Networking.Sockets.IStreamWebSocket, Windows.Networking.Sockets.IStreamWebSocket2, Windows.Networking.Sockets.IWebSocket {
+    constructor();
+    Close(code: number, reason: string): void;
+    Close(): void;
+    ConnectAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncAction;
+    SetRequestHeader(headerName: string, headerValue: string): void;
+    readonly Control: Windows.Networking.Sockets.StreamWebSocketControl;
+    readonly Information: Windows.Networking.Sockets.StreamWebSocketInformation;
+    readonly InputStream: Windows.Storage.Streams.IInputStream;
+    readonly OutputStream: Windows.Storage.Streams.IOutputStream;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Networking.Sockets.IWebSocket, Windows.Networking.Sockets.WebSocketClosedEventArgs> | null;
+    ServerCustomValidationRequested: Windows.Foundation.TypedEventHandler<Windows.Networking.Sockets.StreamWebSocket, Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs> | null;
+  }
+
+  class StreamWebSocketControl implements Windows.Networking.Sockets.IStreamWebSocketControl, Windows.Networking.Sockets.IStreamWebSocketControl2, Windows.Networking.Sockets.IWebSocketControl, Windows.Networking.Sockets.IWebSocketControl2 {
+    readonly ActualUnsolicitedPongInterval: Windows.Foundation.TimeSpan;
+    ClientCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    DesiredUnsolicitedPongInterval: Windows.Foundation.TimeSpan;
+    readonly IgnorableServerCertificateErrors: Windows.Foundation.Collections.IVector<number> | number[];
+    NoDelay: boolean;
+    OutboundBufferSizeInBytes: number;
+    ProxyCredential: Windows.Security.Credentials.PasswordCredential;
+    ServerCredential: Windows.Security.Credentials.PasswordCredential;
+    readonly SupportedProtocols: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+
+  class StreamWebSocketInformation implements Windows.Networking.Sockets.IWebSocketInformation, Windows.Networking.Sockets.IWebSocketInformation2 {
+    readonly BandwidthStatistics: Windows.Networking.Sockets.BandwidthStatistics;
+    readonly LocalAddress: Windows.Networking.HostName;
+    readonly Protocol: string;
+    readonly ServerCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    readonly ServerCertificateErrorSeverity: number;
+    readonly ServerCertificateErrors: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly ServerIntermediateCertificates: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+  }
+
+  class WebSocketClosedEventArgs implements Windows.Networking.Sockets.IWebSocketClosedEventArgs {
+    readonly Code: number;
+    readonly Reason: string;
+  }
+
+  class WebSocketError {
+    static GetStatus(hresult: number): number;
+  }
+
+  class WebSocketKeepAlive implements Windows.ApplicationModel.Background.IBackgroundTask {
+    constructor();
+    Run(taskInstance: Windows.ApplicationModel.Background.IBackgroundTaskInstance): void;
+  }
+
+  class WebSocketServerCustomValidationRequestedEventArgs implements Windows.Networking.Sockets.IWebSocketServerCustomValidationRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Reject(): void;
+    readonly ServerCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    readonly ServerCertificateErrorSeverity: number;
+    readonly ServerCertificateErrors: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly ServerIntermediateCertificates: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+  }
+
+  enum ControlChannelTriggerResetReason {
+    FastUserSwitched = 0,
+    LowPowerExit = 1,
+    QuietHoursExit = 2,
+    ApplicationRestart = 3,
+  }
+
+  enum ControlChannelTriggerResourceType {
+    RequestSoftwareSlot = 0,
+    RequestHardwareSlot = 1,
+  }
+
+  enum ControlChannelTriggerStatus {
+    HardwareSlotRequested = 0,
+    SoftwareSlotAllocated = 1,
+    HardwareSlotAllocated = 2,
+    PolicyError = 3,
+    SystemError = 4,
+    TransportDisconnected = 5,
+    ServiceUnavailable = 6,
+  }
+
+  enum MessageWebSocketReceiveMode {
+    FullMessage = 0,
+    PartialMessage = 1,
+  }
+
+  enum SocketActivityConnectedStandbyAction {
+    DoNotWake = 0,
+    Wake = 1,
+  }
+
+  enum SocketActivityKind {
+    None = 0,
+    StreamSocketListener = 1,
+    DatagramSocket = 2,
+    StreamSocket = 3,
+  }
+
+  enum SocketActivityTriggerReason {
+    None = 0,
+    SocketActivity = 1,
+    ConnectionAccepted = 2,
+    KeepAliveTimerExpired = 3,
+    SocketClosed = 4,
+  }
+
+  enum SocketErrorStatus {
+    Unknown = 0,
+    OperationAborted = 1,
+    HttpInvalidServerResponse = 2,
+    ConnectionTimedOut = 3,
+    AddressFamilyNotSupported = 4,
+    SocketTypeNotSupported = 5,
+    HostNotFound = 6,
+    NoDataRecordOfRequestedType = 7,
+    NonAuthoritativeHostNotFound = 8,
+    ClassTypeNotFound = 9,
+    AddressAlreadyInUse = 10,
+    CannotAssignRequestedAddress = 11,
+    ConnectionRefused = 12,
+    NetworkIsUnreachable = 13,
+    UnreachableHost = 14,
+    NetworkIsDown = 15,
+    NetworkDroppedConnectionOnReset = 16,
+    SoftwareCausedConnectionAbort = 17,
+    ConnectionResetByPeer = 18,
+    HostIsDown = 19,
+    NoAddressesFound = 20,
+    TooManyOpenFiles = 21,
+    MessageTooLong = 22,
+    CertificateExpired = 23,
+    CertificateUntrustedRoot = 24,
+    CertificateCommonNameIsIncorrect = 25,
+    CertificateWrongUsage = 26,
+    CertificateRevoked = 27,
+    CertificateNoRevocationCheck = 28,
+    CertificateRevocationServerOffline = 29,
+    CertificateIsInvalid = 30,
+  }
+
+  enum SocketMessageType {
+    Binary = 0,
+    Utf8 = 1,
+  }
+
+  enum SocketProtectionLevel {
+    PlainSocket = 0,
+    Ssl = 1,
+    SslAllowNullEncryption = 2,
+    BluetoothEncryptionAllowNullAuthentication = 3,
+    BluetoothEncryptionWithAuthentication = 4,
+    Ssl3AllowWeakEncryption = 5,
+    Tls10 = 6,
+    Tls11 = 7,
+    Tls12 = 8,
+    Unspecified = 9,
+    Tls13 = 10,
+  }
+
+  enum SocketQualityOfService {
+    Normal = 0,
+    LowLatency = 1,
+  }
+
+  enum SocketSslErrorSeverity {
+    None = 0,
+    Ignorable = 1,
+    Fatal = 2,
+  }
+
+  interface BandwidthStatistics {
+    OutboundBitsPerSecond: number | bigint;
+    InboundBitsPerSecond: number | bigint;
+    OutboundBitsPerSecondInstability: number | bigint;
+    InboundBitsPerSecondInstability: number | bigint;
+    OutboundBandwidthPeaked: boolean;
+    InboundBandwidthPeaked: boolean;
+  }
+  var BandwidthStatistics: {
+    new(outboundBitsPerSecond: number | bigint, inboundBitsPerSecond: number | bigint, outboundBitsPerSecondInstability: number | bigint, inboundBitsPerSecondInstability: number | bigint, outboundBandwidthPeaked: boolean, inboundBandwidthPeaked: boolean): BandwidthStatistics;
+    new(fields: { OutboundBitsPerSecond?: number | bigint; InboundBitsPerSecond?: number | bigint; OutboundBitsPerSecondInstability?: number | bigint; InboundBitsPerSecondInstability?: number | bigint; OutboundBandwidthPeaked?: boolean; InboundBandwidthPeaked?: boolean }): BandwidthStatistics;
+  };
+
+  interface ControlChannelTriggerContract {
+  }
+  var ControlChannelTriggerContract: {
+    new(fields: {  }): ControlChannelTriggerContract;
+  };
+
+  interface IControlChannelTrigger extends Windows.Foundation.IClosable {
+    Close(): void;
+    DecreaseNetworkKeepAliveInterval(): void;
+    FlushTransport(): void;
+    UsingTransport(transport: Object): void;
+    WaitForPushEnabled(): number;
+    readonly ControlChannelTriggerId: string;
+    readonly CurrentKeepAliveIntervalInMinutes: number;
+    readonly KeepAliveTrigger: Windows.ApplicationModel.Background.IBackgroundTrigger;
+    readonly PushNotificationTrigger: Windows.ApplicationModel.Background.IBackgroundTrigger;
+    ServerKeepAliveIntervalInMinutes: number;
+    readonly TransportObject: Object;
+  }
+  var IControlChannelTrigger: abstract new (...args: any[]) => IControlChannelTrigger;
+
+  interface IControlChannelTrigger2 {
+    readonly IsWakeFromLowPowerSupported: boolean;
+  }
+  var IControlChannelTrigger2: abstract new (...args: any[]) => IControlChannelTrigger2;
+
+  interface IControlChannelTriggerEventDetails {
+    readonly ControlChannelTrigger: Windows.Networking.Sockets.ControlChannelTrigger;
+  }
+  var IControlChannelTriggerEventDetails: abstract new (...args: any[]) => IControlChannelTriggerEventDetails;
+
+  interface IControlChannelTriggerFactory {
+    CreateControlChannelTrigger(channelId: string, serverKeepAliveIntervalInMinutes: number): Windows.Networking.Sockets.ControlChannelTrigger;
+    CreateControlChannelTriggerEx(channelId: string, serverKeepAliveIntervalInMinutes: number, resourceRequestType: number): Windows.Networking.Sockets.ControlChannelTrigger;
+  }
+  var IControlChannelTriggerFactory: abstract new (...args: any[]) => IControlChannelTriggerFactory;
+
+  interface IControlChannelTriggerResetEventDetails {
+    readonly HardwareSlotReset: boolean;
+    readonly ResetReason: number;
+    readonly SoftwareSlotReset: boolean;
+  }
+  var IControlChannelTriggerResetEventDetails: abstract new (...args: any[]) => IControlChannelTriggerResetEventDetails;
+
+  interface IDatagramSocket extends Windows.Foundation.IClosable {
+    BindEndpointAsync(localHostName: Windows.Networking.HostName, localServiceName: string): Windows.Foundation.IAsyncAction;
+    BindServiceNameAsync(localServiceName: string): Windows.Foundation.IAsyncAction;
+    Close(): void;
+    ConnectAsync(remoteHostName: Windows.Networking.HostName, remoteServiceName: string): Windows.Foundation.IAsyncAction;
+    ConnectAsync(endpointPair: Windows.Networking.EndpointPair): Windows.Foundation.IAsyncAction;
+    GetOutputStreamAsync(remoteHostName: Windows.Networking.HostName, remoteServiceName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IOutputStream>;
+    GetOutputStreamAsync(endpointPair: Windows.Networking.EndpointPair): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IOutputStream>;
+    JoinMulticastGroup(host: Windows.Networking.HostName): void;
+    readonly Control: Windows.Networking.Sockets.DatagramSocketControl;
+    readonly Information: Windows.Networking.Sockets.DatagramSocketInformation;
+    readonly OutputStream: Windows.Storage.Streams.IOutputStream;
+    MessageReceived: Windows.Foundation.TypedEventHandler<Windows.Networking.Sockets.DatagramSocket, Windows.Networking.Sockets.DatagramSocketMessageReceivedEventArgs> | null;
+  }
+  var IDatagramSocket: abstract new (...args: any[]) => IDatagramSocket;
+
+  interface IDatagramSocket2 extends Windows.Foundation.IClosable {
+    BindServiceNameAsync(localServiceName: string, adapter: Windows.Networking.Connectivity.NetworkAdapter): Windows.Foundation.IAsyncAction;
+    Close(): void;
+  }
+  var IDatagramSocket2: abstract new (...args: any[]) => IDatagramSocket2;
+
+  interface IDatagramSocket3 {
+    CancelIOAsync(): Windows.Foundation.IAsyncAction;
+    EnableTransferOwnership(taskId: Guid): void;
+    EnableTransferOwnership(taskId: Guid, connectedStandbyAction: number): void;
+    TransferOwnership(socketId: string): void;
+    TransferOwnership(socketId: string, data: Windows.Networking.Sockets.SocketActivityContext): void;
+    TransferOwnership(socketId: string, data: Windows.Networking.Sockets.SocketActivityContext, keepAliveTime: Windows.Foundation.TimeSpan): void;
+  }
+  var IDatagramSocket3: abstract new (...args: any[]) => IDatagramSocket3;
+
+  interface IDatagramSocketControl {
+    OutboundUnicastHopLimit: number;
+    QualityOfService: number;
+  }
+  var IDatagramSocketControl: abstract new (...args: any[]) => IDatagramSocketControl;
+
+  interface IDatagramSocketControl2 {
+    DontFragment: boolean;
+    InboundBufferSizeInBytes: number;
+  }
+  var IDatagramSocketControl2: abstract new (...args: any[]) => IDatagramSocketControl2;
+
+  interface IDatagramSocketControl3 {
+    MulticastOnly: boolean;
+  }
+  var IDatagramSocketControl3: abstract new (...args: any[]) => IDatagramSocketControl3;
+
+  interface IDatagramSocketInformation {
+    readonly LocalAddress: Windows.Networking.HostName;
+    readonly LocalPort: string;
+    readonly RemoteAddress: Windows.Networking.HostName;
+    readonly RemotePort: string;
+  }
+  var IDatagramSocketInformation: abstract new (...args: any[]) => IDatagramSocketInformation;
+
+  interface IDatagramSocketMessageReceivedEventArgs {
+    GetDataReader(): Windows.Storage.Streams.DataReader;
+    GetDataStream(): Windows.Storage.Streams.IInputStream;
+    readonly LocalAddress: Windows.Networking.HostName;
+    readonly RemoteAddress: Windows.Networking.HostName;
+    readonly RemotePort: string;
+  }
+  var IDatagramSocketMessageReceivedEventArgs: abstract new (...args: any[]) => IDatagramSocketMessageReceivedEventArgs;
+
+  interface IDatagramSocketStatics {
+    GetEndpointPairsAsync(remoteHostName: Windows.Networking.HostName, remoteServiceName: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.EndpointPair> | Windows.Networking.EndpointPair[]>;
+    GetEndpointPairsAsync(remoteHostName: Windows.Networking.HostName, remoteServiceName: string, sortOptions: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.EndpointPair> | Windows.Networking.EndpointPair[]>;
+  }
+  var IDatagramSocketStatics: abstract new (...args: any[]) => IDatagramSocketStatics;
+
+  interface IMessageWebSocket extends Windows.Foundation.IClosable, Windows.Networking.Sockets.IWebSocket {
+    Close(code: number, reason: string): void;
+    Close(): void;
+    ConnectAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncAction;
+    SetRequestHeader(headerName: string, headerValue: string): void;
+    readonly Control: Windows.Networking.Sockets.MessageWebSocketControl;
+    readonly Information: Windows.Networking.Sockets.MessageWebSocketInformation;
+    MessageReceived: Windows.Foundation.TypedEventHandler<Windows.Networking.Sockets.MessageWebSocket, Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs> | null;
+  }
+  var IMessageWebSocket: abstract new (...args: any[]) => IMessageWebSocket;
+
+  interface IMessageWebSocket2 extends Windows.Foundation.IClosable, Windows.Networking.Sockets.IMessageWebSocket, Windows.Networking.Sockets.IWebSocket {
+    Close(code: number, reason: string): void;
+    Close(): void;
+    ConnectAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncAction;
+    SetRequestHeader(headerName: string, headerValue: string): void;
+    ServerCustomValidationRequested: Windows.Foundation.TypedEventHandler<Windows.Networking.Sockets.MessageWebSocket, Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs> | null;
+  }
+  var IMessageWebSocket2: abstract new (...args: any[]) => IMessageWebSocket2;
+
+  interface IMessageWebSocket3 {
+    SendFinalFrameAsync(data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    SendNonfinalFrameAsync(data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+  }
+  var IMessageWebSocket3: abstract new (...args: any[]) => IMessageWebSocket3;
+
+  interface IMessageWebSocketControl extends Windows.Networking.Sockets.IWebSocketControl {
+    MaxMessageSize: number;
+    MessageType: number;
+  }
+  var IMessageWebSocketControl: abstract new (...args: any[]) => IMessageWebSocketControl;
+
+  interface IMessageWebSocketControl2 {
+    readonly ActualUnsolicitedPongInterval: Windows.Foundation.TimeSpan;
+    ClientCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    DesiredUnsolicitedPongInterval: Windows.Foundation.TimeSpan;
+    ReceiveMode: number;
+  }
+  var IMessageWebSocketControl2: abstract new (...args: any[]) => IMessageWebSocketControl2;
+
+  interface IMessageWebSocketMessageReceivedEventArgs {
+    GetDataReader(): Windows.Storage.Streams.DataReader;
+    GetDataStream(): Windows.Storage.Streams.IInputStream;
+    readonly MessageType: number;
+  }
+  var IMessageWebSocketMessageReceivedEventArgs: abstract new (...args: any[]) => IMessageWebSocketMessageReceivedEventArgs;
+
+  interface IMessageWebSocketMessageReceivedEventArgs2 extends Windows.Networking.Sockets.IMessageWebSocketMessageReceivedEventArgs {
+    GetDataReader(): Windows.Storage.Streams.DataReader;
+    GetDataStream(): Windows.Storage.Streams.IInputStream;
+    readonly IsMessageComplete: boolean;
+  }
+  var IMessageWebSocketMessageReceivedEventArgs2: abstract new (...args: any[]) => IMessageWebSocketMessageReceivedEventArgs2;
+
+  interface IServerMessageWebSocket extends Windows.Foundation.IClosable {
+    Close(code: number, reason: string): void;
+    Close(): void;
+    readonly Control: Windows.Networking.Sockets.ServerMessageWebSocketControl;
+    readonly Information: Windows.Networking.Sockets.ServerMessageWebSocketInformation;
+    readonly OutputStream: Windows.Storage.Streams.IOutputStream;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Networking.Sockets.ServerMessageWebSocket, Windows.Networking.Sockets.WebSocketClosedEventArgs> | null;
+    MessageReceived: Windows.Foundation.TypedEventHandler<Windows.Networking.Sockets.ServerMessageWebSocket, Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs> | null;
+  }
+  var IServerMessageWebSocket: abstract new (...args: any[]) => IServerMessageWebSocket;
+
+  interface IServerMessageWebSocketControl {
+    MessageType: number;
+  }
+  var IServerMessageWebSocketControl: abstract new (...args: any[]) => IServerMessageWebSocketControl;
+
+  interface IServerMessageWebSocketInformation {
+    readonly BandwidthStatistics: Windows.Networking.Sockets.BandwidthStatistics;
+    readonly LocalAddress: Windows.Networking.HostName;
+    readonly Protocol: string;
+  }
+  var IServerMessageWebSocketInformation: abstract new (...args: any[]) => IServerMessageWebSocketInformation;
+
+  interface IServerStreamWebSocket extends Windows.Foundation.IClosable {
+    Close(code: number, reason: string): void;
+    Close(): void;
+    readonly Information: Windows.Networking.Sockets.ServerStreamWebSocketInformation;
+    readonly InputStream: Windows.Storage.Streams.IInputStream;
+    readonly OutputStream: Windows.Storage.Streams.IOutputStream;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Networking.Sockets.ServerStreamWebSocket, Windows.Networking.Sockets.WebSocketClosedEventArgs> | null;
+  }
+  var IServerStreamWebSocket: abstract new (...args: any[]) => IServerStreamWebSocket;
+
+  interface IServerStreamWebSocketInformation {
+    readonly BandwidthStatistics: Windows.Networking.Sockets.BandwidthStatistics;
+    readonly LocalAddress: Windows.Networking.HostName;
+    readonly Protocol: string;
+  }
+  var IServerStreamWebSocketInformation: abstract new (...args: any[]) => IServerStreamWebSocketInformation;
+
+  interface ISocketActivityContext {
+    readonly Data: Windows.Storage.Streams.IBuffer;
+  }
+  var ISocketActivityContext: abstract new (...args: any[]) => ISocketActivityContext;
+
+  interface ISocketActivityContextFactory {
+    Create(data: Windows.Storage.Streams.IBuffer): Windows.Networking.Sockets.SocketActivityContext;
+  }
+  var ISocketActivityContextFactory: abstract new (...args: any[]) => ISocketActivityContextFactory;
+
+  interface ISocketActivityInformation {
+    readonly Context: Windows.Networking.Sockets.SocketActivityContext;
+    readonly DatagramSocket: Windows.Networking.Sockets.DatagramSocket;
+    readonly Id: string;
+    readonly SocketKind: number;
+    readonly StreamSocket: Windows.Networking.Sockets.StreamSocket;
+    readonly StreamSocketListener: Windows.Networking.Sockets.StreamSocketListener;
+    readonly TaskId: Guid;
+  }
+  var ISocketActivityInformation: abstract new (...args: any[]) => ISocketActivityInformation;
+
+  interface ISocketActivityInformationStatics {
+    readonly AllSockets: Windows.Foundation.Collections.IMapView<string, Windows.Networking.Sockets.SocketActivityInformation>;
+  }
+  var ISocketActivityInformationStatics: abstract new (...args: any[]) => ISocketActivityInformationStatics;
+
+  interface ISocketActivityTriggerDetails {
+    readonly Reason: number;
+    readonly SocketInformation: Windows.Networking.Sockets.SocketActivityInformation;
+  }
+  var ISocketActivityTriggerDetails: abstract new (...args: any[]) => ISocketActivityTriggerDetails;
+
+  interface ISocketErrorStatics {
+    GetStatus(hresult: number): number;
+  }
+  var ISocketErrorStatics: abstract new (...args: any[]) => ISocketErrorStatics;
+
+  interface IStreamSocket extends Windows.Foundation.IClosable {
+    Close(): void;
+    ConnectAsync(endpointPair: Windows.Networking.EndpointPair): Windows.Foundation.IAsyncAction;
+    ConnectAsync(remoteHostName: Windows.Networking.HostName, remoteServiceName: string): Windows.Foundation.IAsyncAction;
+    ConnectAsync(remoteHostName: Windows.Networking.HostName, remoteServiceName: string, protectionLevel: number): Windows.Foundation.IAsyncAction;
+    UpgradeToSslAsync(protectionLevel: number, validationHostName: Windows.Networking.HostName): Windows.Foundation.IAsyncAction;
+    readonly Control: Windows.Networking.Sockets.StreamSocketControl;
+    readonly Information: Windows.Networking.Sockets.StreamSocketInformation;
+    readonly InputStream: Windows.Storage.Streams.IInputStream;
+    readonly OutputStream: Windows.Storage.Streams.IOutputStream;
+  }
+  var IStreamSocket: abstract new (...args: any[]) => IStreamSocket;
+
+  interface IStreamSocket2 extends Windows.Foundation.IClosable {
+    Close(): void;
+    ConnectAsync(remoteHostName: Windows.Networking.HostName, remoteServiceName: string, protectionLevel: number, adapter: Windows.Networking.Connectivity.NetworkAdapter): Windows.Foundation.IAsyncAction;
+  }
+  var IStreamSocket2: abstract new (...args: any[]) => IStreamSocket2;
+
+  interface IStreamSocket3 {
+    CancelIOAsync(): Windows.Foundation.IAsyncAction;
+    EnableTransferOwnership(taskId: Guid): void;
+    EnableTransferOwnership(taskId: Guid, connectedStandbyAction: number): void;
+    TransferOwnership(socketId: string): void;
+    TransferOwnership(socketId: string, data: Windows.Networking.Sockets.SocketActivityContext): void;
+    TransferOwnership(socketId: string, data: Windows.Networking.Sockets.SocketActivityContext, keepAliveTime: Windows.Foundation.TimeSpan): void;
+  }
+  var IStreamSocket3: abstract new (...args: any[]) => IStreamSocket3;
+
+  interface IStreamSocketControl {
+    KeepAlive: boolean;
+    NoDelay: boolean;
+    OutboundBufferSizeInBytes: number;
+    OutboundUnicastHopLimit: number;
+    QualityOfService: number;
+  }
+  var IStreamSocketControl: abstract new (...args: any[]) => IStreamSocketControl;
+
+  interface IStreamSocketControl2 {
+    readonly IgnorableServerCertificateErrors: Windows.Foundation.Collections.IVector<number> | number[];
+  }
+  var IStreamSocketControl2: abstract new (...args: any[]) => IStreamSocketControl2;
+
+  interface IStreamSocketControl3 {
+    ClientCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    SerializeConnectionAttempts: boolean;
+  }
+  var IStreamSocketControl3: abstract new (...args: any[]) => IStreamSocketControl3;
+
+  interface IStreamSocketControl4 {
+    MinProtectionLevel: number;
+  }
+  var IStreamSocketControl4: abstract new (...args: any[]) => IStreamSocketControl4;
+
+  interface IStreamSocketInformation {
+    readonly BandwidthStatistics: Windows.Networking.Sockets.BandwidthStatistics;
+    readonly LocalAddress: Windows.Networking.HostName;
+    readonly LocalPort: string;
+    readonly ProtectionLevel: number;
+    readonly RemoteAddress: Windows.Networking.HostName;
+    readonly RemoteHostName: Windows.Networking.HostName;
+    readonly RemotePort: string;
+    readonly RemoteServiceName: string;
+    readonly RoundTripTimeStatistics: Windows.Networking.Sockets.RoundTripTimeStatistics;
+    readonly SessionKey: Windows.Storage.Streams.IBuffer;
+  }
+  var IStreamSocketInformation: abstract new (...args: any[]) => IStreamSocketInformation;
+
+  interface IStreamSocketInformation2 {
+    readonly ServerCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    readonly ServerCertificateErrorSeverity: number;
+    readonly ServerCertificateErrors: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly ServerIntermediateCertificates: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+  }
+  var IStreamSocketInformation2: abstract new (...args: any[]) => IStreamSocketInformation2;
+
+  interface IStreamSocketListener extends Windows.Foundation.IClosable {
+    BindEndpointAsync(localHostName: Windows.Networking.HostName, localServiceName: string): Windows.Foundation.IAsyncAction;
+    BindServiceNameAsync(localServiceName: string): Windows.Foundation.IAsyncAction;
+    Close(): void;
+    readonly Control: Windows.Networking.Sockets.StreamSocketListenerControl;
+    readonly Information: Windows.Networking.Sockets.StreamSocketListenerInformation;
+    ConnectionReceived: Windows.Foundation.TypedEventHandler<Windows.Networking.Sockets.StreamSocketListener, Windows.Networking.Sockets.StreamSocketListenerConnectionReceivedEventArgs> | null;
+  }
+  var IStreamSocketListener: abstract new (...args: any[]) => IStreamSocketListener;
+
+  interface IStreamSocketListener2 extends Windows.Foundation.IClosable {
+    BindServiceNameAsync(localServiceName: string, protectionLevel: number): Windows.Foundation.IAsyncAction;
+    BindServiceNameAsync(localServiceName: string, protectionLevel: number, adapter: Windows.Networking.Connectivity.NetworkAdapter): Windows.Foundation.IAsyncAction;
+    Close(): void;
+  }
+  var IStreamSocketListener2: abstract new (...args: any[]) => IStreamSocketListener2;
+
+  interface IStreamSocketListener3 {
+    CancelIOAsync(): Windows.Foundation.IAsyncAction;
+    EnableTransferOwnership(taskId: Guid): void;
+    EnableTransferOwnership(taskId: Guid, connectedStandbyAction: number): void;
+    TransferOwnership(socketId: string): void;
+    TransferOwnership(socketId: string, data: Windows.Networking.Sockets.SocketActivityContext): void;
+  }
+  var IStreamSocketListener3: abstract new (...args: any[]) => IStreamSocketListener3;
+
+  interface IStreamSocketListenerConnectionReceivedEventArgs {
+    readonly Socket: Windows.Networking.Sockets.StreamSocket;
+  }
+  var IStreamSocketListenerConnectionReceivedEventArgs: abstract new (...args: any[]) => IStreamSocketListenerConnectionReceivedEventArgs;
+
+  interface IStreamSocketListenerControl {
+    QualityOfService: number;
+  }
+  var IStreamSocketListenerControl: abstract new (...args: any[]) => IStreamSocketListenerControl;
+
+  interface IStreamSocketListenerControl2 {
+    KeepAlive: boolean;
+    NoDelay: boolean;
+    OutboundBufferSizeInBytes: number;
+    OutboundUnicastHopLimit: number;
+  }
+  var IStreamSocketListenerControl2: abstract new (...args: any[]) => IStreamSocketListenerControl2;
+
+  interface IStreamSocketListenerInformation {
+    readonly LocalPort: string;
+  }
+  var IStreamSocketListenerInformation: abstract new (...args: any[]) => IStreamSocketListenerInformation;
+
+  interface IStreamSocketStatics {
+    GetEndpointPairsAsync(remoteHostName: Windows.Networking.HostName, remoteServiceName: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.EndpointPair> | Windows.Networking.EndpointPair[]>;
+    GetEndpointPairsAsync(remoteHostName: Windows.Networking.HostName, remoteServiceName: string, sortOptions: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.EndpointPair> | Windows.Networking.EndpointPair[]>;
+  }
+  var IStreamSocketStatics: abstract new (...args: any[]) => IStreamSocketStatics;
+
+  interface IStreamWebSocket extends Windows.Foundation.IClosable, Windows.Networking.Sockets.IWebSocket {
+    Close(code: number, reason: string): void;
+    Close(): void;
+    ConnectAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncAction;
+    SetRequestHeader(headerName: string, headerValue: string): void;
+    readonly Control: Windows.Networking.Sockets.StreamWebSocketControl;
+    readonly Information: Windows.Networking.Sockets.StreamWebSocketInformation;
+    readonly InputStream: Windows.Storage.Streams.IInputStream;
+  }
+  var IStreamWebSocket: abstract new (...args: any[]) => IStreamWebSocket;
+
+  interface IStreamWebSocket2 extends Windows.Foundation.IClosable, Windows.Networking.Sockets.IStreamWebSocket, Windows.Networking.Sockets.IWebSocket {
+    Close(code: number, reason: string): void;
+    Close(): void;
+    ConnectAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncAction;
+    SetRequestHeader(headerName: string, headerValue: string): void;
+    ServerCustomValidationRequested: Windows.Foundation.TypedEventHandler<Windows.Networking.Sockets.StreamWebSocket, Windows.Networking.Sockets.WebSocketServerCustomValidationRequestedEventArgs> | null;
+  }
+  var IStreamWebSocket2: abstract new (...args: any[]) => IStreamWebSocket2;
+
+  interface IStreamWebSocketControl extends Windows.Networking.Sockets.IWebSocketControl {
+    NoDelay: boolean;
+  }
+  var IStreamWebSocketControl: abstract new (...args: any[]) => IStreamWebSocketControl;
+
+  interface IStreamWebSocketControl2 {
+    readonly ActualUnsolicitedPongInterval: Windows.Foundation.TimeSpan;
+    ClientCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    DesiredUnsolicitedPongInterval: Windows.Foundation.TimeSpan;
+  }
+  var IStreamWebSocketControl2: abstract new (...args: any[]) => IStreamWebSocketControl2;
+
+  interface IWebSocket extends Windows.Foundation.IClosable {
+    Close(code: number, reason: string): void;
+    Close(): void;
+    ConnectAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncAction;
+    SetRequestHeader(headerName: string, headerValue: string): void;
+    readonly OutputStream: Windows.Storage.Streams.IOutputStream;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.Networking.Sockets.IWebSocket, Windows.Networking.Sockets.WebSocketClosedEventArgs> | null;
+  }
+  var IWebSocket: abstract new (...args: any[]) => IWebSocket;
+
+  interface IWebSocketClosedEventArgs {
+    readonly Code: number;
+    readonly Reason: string;
+  }
+  var IWebSocketClosedEventArgs: abstract new (...args: any[]) => IWebSocketClosedEventArgs;
+
+  interface IWebSocketControl {
+    OutboundBufferSizeInBytes: number;
+    ProxyCredential: Windows.Security.Credentials.PasswordCredential;
+    ServerCredential: Windows.Security.Credentials.PasswordCredential;
+    readonly SupportedProtocols: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var IWebSocketControl: abstract new (...args: any[]) => IWebSocketControl;
+
+  interface IWebSocketControl2 extends Windows.Networking.Sockets.IWebSocketControl {
+    readonly IgnorableServerCertificateErrors: Windows.Foundation.Collections.IVector<number> | number[];
+  }
+  var IWebSocketControl2: abstract new (...args: any[]) => IWebSocketControl2;
+
+  interface IWebSocketErrorStatics {
+    GetStatus(hresult: number): number;
+  }
+  var IWebSocketErrorStatics: abstract new (...args: any[]) => IWebSocketErrorStatics;
+
+  interface IWebSocketInformation {
+    readonly BandwidthStatistics: Windows.Networking.Sockets.BandwidthStatistics;
+    readonly LocalAddress: Windows.Networking.HostName;
+    readonly Protocol: string;
+  }
+  var IWebSocketInformation: abstract new (...args: any[]) => IWebSocketInformation;
+
+  interface IWebSocketInformation2 extends Windows.Networking.Sockets.IWebSocketInformation {
+    readonly ServerCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    readonly ServerCertificateErrorSeverity: number;
+    readonly ServerCertificateErrors: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly ServerIntermediateCertificates: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+  }
+  var IWebSocketInformation2: abstract new (...args: any[]) => IWebSocketInformation2;
+
+  interface IWebSocketServerCustomValidationRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Reject(): void;
+    readonly ServerCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    readonly ServerCertificateErrorSeverity: number;
+    readonly ServerCertificateErrors: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly ServerIntermediateCertificates: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+  }
+  var IWebSocketServerCustomValidationRequestedEventArgs: abstract new (...args: any[]) => IWebSocketServerCustomValidationRequestedEventArgs;
+
+  interface RoundTripTimeStatistics {
+    Variance: number;
+    Max: number;
+    Min: number;
+    Sum: number;
+  }
+  var RoundTripTimeStatistics: {
+    new(variance: number, max: number, min: number, sum: number): RoundTripTimeStatistics;
+    new(fields: { Variance?: number; Max?: number; Min?: number; Sum?: number }): RoundTripTimeStatistics;
+  };
+
+}
+
+declare namespace Windows.Networking.Vpn {
+  class VpnAppId implements Windows.Networking.Vpn.IVpnAppId {
+    constructor(type: number, value: string);
+    Type: number;
+    Value: string;
+  }
+
+  class VpnChannel implements Windows.Networking.Vpn.IVpnChannel, Windows.Networking.Vpn.IVpnChannel2, Windows.Networking.Vpn.IVpnChannel4, Windows.Networking.Vpn.IVpnChannel5, Windows.Networking.Vpn.IVpnChannel6 {
+    ActivateForeground(packageRelativeAppId: string, sharedContext: Windows.Foundation.Collections.ValueSet): Windows.Foundation.Collections.ValueSet;
+    AddAndAssociateTransport(transport: Object, context: Object): void;
+    AppendVpnReceivePacketBuffer(decapsulatedPacketBuffer: Windows.Networking.Vpn.VpnPacketBuffer): void;
+    AppendVpnSendPacketBuffer(encapsulatedPacketBuffer: Windows.Networking.Vpn.VpnPacketBuffer): void;
+    AssociateTransport(mainOuterTunnelTransport: Object, optionalOuterTunnelTransport: Object): void;
+    FlushVpnReceivePacketBuffers(): void;
+    FlushVpnSendPacketBuffers(): void;
+    GetSlotTypeForTransportContext(context: Object): number;
+    GetVpnReceivePacketBuffer(): Windows.Networking.Vpn.VpnPacketBuffer;
+    GetVpnSendPacketBuffer(): Windows.Networking.Vpn.VpnPacketBuffer;
+    LogDiagnosticMessage(message: string): void;
+    static ProcessEventAsync(thirdPartyPlugIn: Object, event: Object): void;
+    ReplaceAndAssociateTransport(transport: Object, context: Object): void;
+    RequestCredentials(credType: number, isRetry: boolean, isSingleSignOnCredential: boolean, certificate: Windows.Security.Cryptography.Certificates.Certificate): Windows.Networking.Vpn.VpnPickedCredential;
+    RequestCredentialsAsync(credType: number, credOptions: number, certificate: Windows.Security.Cryptography.Certificates.Certificate): Windows.Foundation.IAsyncOperation<Windows.Networking.Vpn.VpnCredential>;
+    RequestCredentialsAsync(credType: number, credOptions: number): Windows.Foundation.IAsyncOperation<Windows.Networking.Vpn.VpnCredential>;
+    RequestCredentialsAsync(credType: number): Windows.Foundation.IAsyncOperation<Windows.Networking.Vpn.VpnCredential>;
+    RequestCustomPrompt(customPrompt: Windows.Foundation.Collections.IVectorView<Windows.Networking.Vpn.IVpnCustomPrompt> | Windows.Networking.Vpn.IVpnCustomPrompt[]): void;
+    RequestCustomPromptAsync(customPromptElement: Windows.Foundation.Collections.IVectorView<Windows.Networking.Vpn.IVpnCustomPromptElement> | Windows.Networking.Vpn.IVpnCustomPromptElement[]): Windows.Foundation.IAsyncAction;
+    RequestVpnPacketBuffer(type: number, vpnPacketBuffer: Windows.Networking.Vpn.VpnPacketBuffer): void;
+    SetAllowedSslTlsVersions(tunnelTransport: Object, useTls12: boolean): void;
+    SetErrorMessage(message: string): void;
+    Start(assignedClientIPv4list: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[], assignedClientIPv6list: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[], vpnInterfaceId: Windows.Networking.Vpn.VpnInterfaceId, routeScope: Windows.Networking.Vpn.VpnRouteAssignment, namespaceScope: Windows.Networking.Vpn.VpnNamespaceAssignment, mtuSize: number, maxFrameSize: number, optimizeForLowCostNetwork: boolean, mainOuterTunnelTransport: Object, optionalOuterTunnelTransport: Object): void;
+    StartExistingTransports(assignedClientIPv4list: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[], assignedClientIPv6list: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[], vpnInterfaceId: Windows.Networking.Vpn.VpnInterfaceId, assignedRoutes: Windows.Networking.Vpn.VpnRouteAssignment, assignedDomainName: Windows.Networking.Vpn.VpnDomainNameAssignment, mtuSize: number, maxFrameSize: number, Reserved: boolean): void;
+    StartReconnectingTransport(transport: Object, context: Object): void;
+    StartWithMainTransport(assignedClientIPv4list: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[], assignedClientIPv6list: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[], vpnInterfaceId: Windows.Networking.Vpn.VpnInterfaceId, assignedRoutes: Windows.Networking.Vpn.VpnRouteAssignment, assignedDomainName: Windows.Networking.Vpn.VpnDomainNameAssignment, mtuSize: number, maxFrameSize: number, Reserved: boolean, mainOuterTunnelTransport: Object): void;
+    StartWithTrafficFilter(assignedClientIpv4List: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[], assignedClientIpv6List: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[], vpnInterfaceId: Windows.Networking.Vpn.VpnInterfaceId, assignedRoutes: Windows.Networking.Vpn.VpnRouteAssignment, assignedNamespace: Windows.Networking.Vpn.VpnDomainNameAssignment, mtuSize: number, maxFrameSize: number, reserved: boolean, mainOuterTunnelTransport: Object, optionalOuterTunnelTransport: Object, assignedTrafficFilters: Windows.Networking.Vpn.VpnTrafficFilterAssignment): void;
+    StartWithTrafficFilter(assignedClientIpv4Addresses: Windows.Foundation.Collections.IIterable<Windows.Networking.HostName> | Windows.Networking.HostName[], assignedClientIpv6Addresses: Windows.Foundation.Collections.IIterable<Windows.Networking.HostName> | Windows.Networking.HostName[], vpninterfaceId: Windows.Networking.Vpn.VpnInterfaceId, assignedRoutes: Windows.Networking.Vpn.VpnRouteAssignment, assignedNamespace: Windows.Networking.Vpn.VpnDomainNameAssignment, mtuSize: number, maxFrameSize: number, reserved: boolean, transports: Windows.Foundation.Collections.IIterable<Object> | Object[], assignedTrafficFilters: Windows.Networking.Vpn.VpnTrafficFilterAssignment): void;
+    Stop(): void;
+    TerminateConnection(message: string): void;
+    readonly Configuration: Windows.Networking.Vpn.VpnChannelConfiguration;
+    readonly CurrentRequestTransportContext: Object;
+    readonly Id: number;
+    PlugInContext: Object;
+    readonly SystemHealth: Windows.Networking.Vpn.VpnSystemHealth;
+    ActivityChange: Windows.Foundation.TypedEventHandler<Windows.Networking.Vpn.VpnChannel, Windows.Networking.Vpn.VpnChannelActivityEventArgs> | null;
+    ActivityStateChange: Windows.Foundation.TypedEventHandler<Windows.Networking.Vpn.VpnChannel, Windows.Networking.Vpn.VpnChannelActivityStateChangedArgs> | null;
+  }
+
+  class VpnChannelActivityEventArgs implements Windows.Networking.Vpn.IVpnChannelActivityEventArgs {
+    readonly Type: number;
+  }
+
+  class VpnChannelActivityStateChangedArgs implements Windows.Networking.Vpn.IVpnChannelActivityStateChangedArgs {
+    readonly ActivityState: number;
+  }
+
+  class VpnChannelConfiguration implements Windows.Networking.Vpn.IVpnChannelConfiguration, Windows.Networking.Vpn.IVpnChannelConfiguration2 {
+    readonly CustomField: string;
+    readonly ServerHostNameList: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[];
+    readonly ServerServiceName: string;
+    readonly ServerUris: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+  }
+
+  class VpnCredential implements Windows.Networking.Vpn.IVpnCredential {
+    readonly AdditionalPin: string;
+    readonly CertificateCredential: Windows.Security.Cryptography.Certificates.Certificate;
+    readonly OldPasswordCredential: Windows.Security.Credentials.PasswordCredential;
+    readonly PasskeyCredential: Windows.Security.Credentials.PasswordCredential;
+  }
+
+  class VpnCustomCheckBox implements Windows.Networking.Vpn.IVpnCustomCheckBox, Windows.Networking.Vpn.IVpnCustomPrompt {
+    constructor();
+    Bordered: boolean;
+    readonly Checked: boolean;
+    Compulsory: boolean;
+    InitialCheckState: boolean;
+    Label: string;
+  }
+
+  class VpnCustomComboBox implements Windows.Networking.Vpn.IVpnCustomComboBox, Windows.Networking.Vpn.IVpnCustomPrompt {
+    constructor();
+    Bordered: boolean;
+    Compulsory: boolean;
+    Label: string;
+    OptionsText: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Selected: number;
+  }
+
+  class VpnCustomEditBox implements Windows.Networking.Vpn.IVpnCustomEditBox, Windows.Networking.Vpn.IVpnCustomPrompt {
+    constructor();
+    Bordered: boolean;
+    Compulsory: boolean;
+    DefaultText: string;
+    Label: string;
+    NoEcho: boolean;
+    readonly Text: string;
+  }
+
+  class VpnCustomErrorBox implements Windows.Networking.Vpn.IVpnCustomErrorBox, Windows.Networking.Vpn.IVpnCustomPrompt {
+    constructor();
+    Bordered: boolean;
+    Compulsory: boolean;
+    Label: string;
+  }
+
+  class VpnCustomPromptBooleanInput implements Windows.Networking.Vpn.IVpnCustomPromptBooleanInput, Windows.Networking.Vpn.IVpnCustomPromptElement {
+    constructor();
+    Compulsory: boolean;
+    DisplayName: string;
+    Emphasized: boolean;
+    InitialValue: boolean;
+    readonly Value: boolean;
+  }
+
+  class VpnCustomPromptOptionSelector implements Windows.Networking.Vpn.IVpnCustomPromptElement, Windows.Networking.Vpn.IVpnCustomPromptOptionSelector {
+    constructor();
+    Compulsory: boolean;
+    DisplayName: string;
+    Emphasized: boolean;
+    readonly Options: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly SelectedIndex: number;
+  }
+
+  class VpnCustomPromptText implements Windows.Networking.Vpn.IVpnCustomPromptElement, Windows.Networking.Vpn.IVpnCustomPromptText {
+    constructor();
+    Compulsory: boolean;
+    DisplayName: string;
+    Emphasized: boolean;
+    Text: string;
+  }
+
+  class VpnCustomPromptTextInput implements Windows.Networking.Vpn.IVpnCustomPromptElement, Windows.Networking.Vpn.IVpnCustomPromptTextInput {
+    constructor();
+    Compulsory: boolean;
+    DisplayName: string;
+    Emphasized: boolean;
+    IsTextHidden: boolean;
+    PlaceholderText: string;
+    readonly Text: string;
+  }
+
+  class VpnCustomTextBox implements Windows.Networking.Vpn.IVpnCustomPrompt, Windows.Networking.Vpn.IVpnCustomTextBox {
+    constructor();
+    Bordered: boolean;
+    Compulsory: boolean;
+    DisplayText: string;
+    Label: string;
+  }
+
+  class VpnDomainNameAssignment implements Windows.Networking.Vpn.IVpnDomainNameAssignment {
+    constructor();
+    readonly DomainNameList: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnDomainNameInfo> | Windows.Networking.Vpn.VpnDomainNameInfo[];
+    ProxyAutoConfigurationUri: Windows.Foundation.Uri;
+  }
+
+  class VpnDomainNameInfo implements Windows.Networking.Vpn.IVpnDomainNameInfo, Windows.Networking.Vpn.IVpnDomainNameInfo2 {
+    constructor(name: string, nameType: number, dnsServerList: Windows.Foundation.Collections.IIterable<Windows.Networking.HostName> | Windows.Networking.HostName[], proxyServerList: Windows.Foundation.Collections.IIterable<Windows.Networking.HostName> | Windows.Networking.HostName[]);
+    readonly DnsServers: Windows.Foundation.Collections.IVector<Windows.Networking.HostName> | Windows.Networking.HostName[];
+    DomainName: Windows.Networking.HostName;
+    DomainNameType: number;
+    readonly WebProxyServers: Windows.Foundation.Collections.IVector<Windows.Networking.HostName> | Windows.Networking.HostName[];
+    readonly WebProxyUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+  }
+
+  class VpnForegroundActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.Networking.Vpn.IVpnForegroundActivatedEventArgs {
+    readonly ActivationOperation: Windows.Networking.Vpn.VpnForegroundActivationOperation;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly ProfileName: string;
+    readonly SharedContext: Windows.Foundation.Collections.ValueSet;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class VpnForegroundActivationOperation implements Windows.Networking.Vpn.IVpnForegroundActivationOperation {
+    Complete(result: Windows.Foundation.Collections.ValueSet): void;
+  }
+
+  class VpnInterfaceId implements Windows.Networking.Vpn.IVpnInterfaceId {
+    constructor(address: number[]);
+    GetAddressInfo(id: number[]): void;
+  }
+
+  class VpnManagementAgent implements Windows.Networking.Vpn.IVpnManagementAgent {
+    constructor();
+    AddProfileFromObjectAsync(profile: Windows.Networking.Vpn.IVpnProfile): Windows.Foundation.IAsyncOperation<number>;
+    AddProfileFromXmlAsync(xml: string): Windows.Foundation.IAsyncOperation<number>;
+    ConnectProfileAsync(profile: Windows.Networking.Vpn.IVpnProfile): Windows.Foundation.IAsyncOperation<number>;
+    ConnectProfileWithPasswordCredentialAsync(profile: Windows.Networking.Vpn.IVpnProfile, passwordCredential: Windows.Security.Credentials.PasswordCredential): Windows.Foundation.IAsyncOperation<number>;
+    DeleteProfileAsync(profile: Windows.Networking.Vpn.IVpnProfile): Windows.Foundation.IAsyncOperation<number>;
+    DisconnectProfileAsync(profile: Windows.Networking.Vpn.IVpnProfile): Windows.Foundation.IAsyncOperation<number>;
+    GetProfilesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.Vpn.IVpnProfile> | Windows.Networking.Vpn.IVpnProfile[]>;
+    UpdateProfileFromObjectAsync(profile: Windows.Networking.Vpn.IVpnProfile): Windows.Foundation.IAsyncOperation<number>;
+    UpdateProfileFromXmlAsync(xml: string): Windows.Foundation.IAsyncOperation<number>;
+  }
+
+  class VpnNamespaceAssignment implements Windows.Networking.Vpn.IVpnNamespaceAssignment {
+    constructor();
+    NamespaceList: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnNamespaceInfo> | Windows.Networking.Vpn.VpnNamespaceInfo[];
+    ProxyAutoConfigUri: Windows.Foundation.Uri;
+  }
+
+  class VpnNamespaceInfo implements Windows.Networking.Vpn.IVpnNamespaceInfo {
+    constructor(name: string, dnsServerList: Windows.Foundation.Collections.IVector<Windows.Networking.HostName> | Windows.Networking.HostName[], proxyServerList: Windows.Foundation.Collections.IVector<Windows.Networking.HostName> | Windows.Networking.HostName[]);
+    DnsServers: Windows.Foundation.Collections.IVector<Windows.Networking.HostName> | Windows.Networking.HostName[];
+    Namespace: string;
+    WebProxyServers: Windows.Foundation.Collections.IVector<Windows.Networking.HostName> | Windows.Networking.HostName[];
+  }
+
+  class VpnNativeProfile implements Windows.Networking.Vpn.IVpnNativeProfile, Windows.Networking.Vpn.IVpnNativeProfile2, Windows.Networking.Vpn.IVpnProfile {
+    constructor();
+    AlwaysOn: boolean;
+    readonly AppTriggers: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnAppId> | Windows.Networking.Vpn.VpnAppId[];
+    readonly ConnectionStatus: number;
+    readonly DomainNameInfoList: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnDomainNameInfo> | Windows.Networking.Vpn.VpnDomainNameInfo[];
+    EapConfiguration: string;
+    NativeProtocolType: number;
+    ProfileName: string;
+    RememberCredentials: boolean;
+    RequireVpnClientAppUI: boolean;
+    readonly Routes: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnRoute> | Windows.Networking.Vpn.VpnRoute[];
+    RoutingPolicyType: number;
+    readonly Servers: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly TrafficFilters: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnTrafficFilter> | Windows.Networking.Vpn.VpnTrafficFilter[];
+    TunnelAuthenticationMethod: number;
+    UserAuthenticationMethod: number;
+  }
+
+  class VpnPacketBuffer implements Windows.Networking.Vpn.IVpnPacketBuffer, Windows.Networking.Vpn.IVpnPacketBuffer2, Windows.Networking.Vpn.IVpnPacketBuffer3 {
+    constructor(parentBuffer: Windows.Networking.Vpn.VpnPacketBuffer, offset: number, length: number);
+    readonly AppId: Windows.Networking.Vpn.VpnAppId;
+    readonly Buffer: Windows.Storage.Streams.Buffer;
+    Status: number;
+    TransportAffinity: number;
+    TransportContext: Object;
+  }
+
+  class VpnPacketBufferList implements Windows.Networking.Vpn.IVpnPacketBufferList {
+    AddAtBegin(nextVpnPacketBuffer: Windows.Networking.Vpn.VpnPacketBuffer): void;
+    Append(nextVpnPacketBuffer: Windows.Networking.Vpn.VpnPacketBuffer): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Networking.Vpn.VpnPacketBuffer>;
+    RemoveAtBegin(): Windows.Networking.Vpn.VpnPacketBuffer;
+    RemoveAtEnd(): Windows.Networking.Vpn.VpnPacketBuffer;
+    readonly Size: number;
+    Status: number;
+  }
+
+  class VpnPickedCredential implements Windows.Networking.Vpn.IVpnPickedCredential {
+    readonly AdditionalPin: string;
+    readonly OldPasswordCredential: Windows.Security.Credentials.PasswordCredential;
+    readonly PasskeyCredential: Windows.Security.Credentials.PasswordCredential;
+  }
+
+  class VpnPlugInProfile implements Windows.Networking.Vpn.IVpnPlugInProfile, Windows.Networking.Vpn.IVpnPlugInProfile2, Windows.Networking.Vpn.IVpnProfile {
+    constructor();
+    AlwaysOn: boolean;
+    readonly AppTriggers: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnAppId> | Windows.Networking.Vpn.VpnAppId[];
+    readonly ConnectionStatus: number;
+    CustomConfiguration: string;
+    readonly DomainNameInfoList: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnDomainNameInfo> | Windows.Networking.Vpn.VpnDomainNameInfo[];
+    ProfileName: string;
+    RememberCredentials: boolean;
+    RequireVpnClientAppUI: boolean;
+    readonly Routes: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnRoute> | Windows.Networking.Vpn.VpnRoute[];
+    readonly ServerUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly TrafficFilters: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnTrafficFilter> | Windows.Networking.Vpn.VpnTrafficFilter[];
+    VpnPluginPackageFamilyName: string;
+  }
+
+  class VpnRoute implements Windows.Networking.Vpn.IVpnRoute {
+    constructor(address: Windows.Networking.HostName, prefixSize: number);
+    Address: Windows.Networking.HostName;
+    PrefixSize: number;
+  }
+
+  class VpnRouteAssignment implements Windows.Networking.Vpn.IVpnRouteAssignment {
+    constructor();
+    ExcludeLocalSubnets: boolean;
+    Ipv4ExclusionRoutes: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnRoute> | Windows.Networking.Vpn.VpnRoute[];
+    Ipv4InclusionRoutes: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnRoute> | Windows.Networking.Vpn.VpnRoute[];
+    Ipv6ExclusionRoutes: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnRoute> | Windows.Networking.Vpn.VpnRoute[];
+    Ipv6InclusionRoutes: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnRoute> | Windows.Networking.Vpn.VpnRoute[];
+  }
+
+  class VpnSystemHealth implements Windows.Networking.Vpn.IVpnSystemHealth {
+    readonly StatementOfHealth: Windows.Storage.Streams.Buffer;
+  }
+
+  class VpnTrafficFilter implements Windows.Networking.Vpn.IVpnTrafficFilter {
+    constructor(appId: Windows.Networking.Vpn.VpnAppId);
+    readonly AppClaims: Windows.Foundation.Collections.IVector<string> | string[];
+    AppId: Windows.Networking.Vpn.VpnAppId;
+    readonly LocalAddressRanges: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly LocalPortRanges: Windows.Foundation.Collections.IVector<string> | string[];
+    Protocol: number;
+    readonly RemoteAddressRanges: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly RemotePortRanges: Windows.Foundation.Collections.IVector<string> | string[];
+    RoutingPolicyType: number;
+  }
+
+  class VpnTrafficFilterAssignment implements Windows.Networking.Vpn.IVpnTrafficFilterAssignment {
+    constructor();
+    AllowInbound: boolean;
+    AllowOutbound: boolean;
+    readonly TrafficFilterList: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnTrafficFilter> | Windows.Networking.Vpn.VpnTrafficFilter[];
+  }
+
+  enum VpnAppIdType {
+    PackageFamilyName = 0,
+    FullyQualifiedBinaryName = 1,
+    FilePath = 2,
+  }
+
+  enum VpnAuthenticationMethod {
+    Mschapv2 = 0,
+    Eap = 1,
+    Certificate = 2,
+    PresharedKey = 3,
+  }
+
+  enum VpnChannelActivityEventType {
+    Idle = 0,
+    Active = 1,
+  }
+
+  enum VpnChannelRequestCredentialsOptions {
+    None = 0,
+    Retrying = 1,
+    UseForSingleSignIn = 2,
+  }
+
+  enum VpnCredentialType {
+    UsernamePassword = 0,
+    UsernameOtpPin = 1,
+    UsernamePasswordAndPin = 2,
+    UsernamePasswordChange = 3,
+    SmartCard = 4,
+    ProtectedCertificate = 5,
+    UnProtectedCertificate = 6,
+  }
+
+  enum VpnDataPathType {
+    Send = 0,
+    Receive = 1,
+  }
+
+  enum VpnDomainNameType {
+    Suffix = 0,
+    FullyQualified = 1,
+    Reserved = 65535,
+  }
+
+  enum VpnIPProtocol {
+    None = 0,
+    Tcp = 6,
+    Udp = 17,
+    Icmp = 1,
+    Ipv6Icmp = 58,
+    Igmp = 2,
+    Pgm = 113,
+  }
+
+  enum VpnManagementConnectionStatus {
+    Disconnected = 0,
+    Disconnecting = 1,
+    Connected = 2,
+    Connecting = 3,
+  }
+
+  enum VpnManagementErrorStatus {
+    Ok = 0,
+    Other = 1,
+    InvalidXmlSyntax = 2,
+    ProfileNameTooLong = 3,
+    ProfileInvalidAppId = 4,
+    AccessDenied = 5,
+    CannotFindProfile = 6,
+    AlreadyDisconnecting = 7,
+    AlreadyConnected = 8,
+    GeneralAuthenticationFailure = 9,
+    EapFailure = 10,
+    SmartCardFailure = 11,
+    CertificateFailure = 12,
+    ServerConfiguration = 13,
+    NoConnection = 14,
+    ServerConnection = 15,
+    UserNamePassword = 16,
+    DnsNotResolvable = 17,
+    InvalidIP = 18,
+  }
+
+  enum VpnNativeProtocolType {
+    Pptp = 0,
+    L2tp = 1,
+    IpsecIkev2 = 2,
+  }
+
+  enum VpnPacketBufferStatus {
+    Ok = 0,
+    InvalidBufferSize = 1,
+  }
+
+  enum VpnRoutingPolicyType {
+    SplitRouting = 0,
+    ForceAllTrafficOverVpn = 1,
+  }
+
+  interface IVpnAppId {
+    Type: number;
+    Value: string;
+  }
+  var IVpnAppId: abstract new (...args: any[]) => IVpnAppId;
+
+  interface IVpnAppIdFactory {
+    Create(type: number, value: string): Windows.Networking.Vpn.VpnAppId;
+  }
+  var IVpnAppIdFactory: abstract new (...args: any[]) => IVpnAppIdFactory;
+
+  interface IVpnChannel {
+    AssociateTransport(mainOuterTunnelTransport: Object, optionalOuterTunnelTransport: Object): void;
+    LogDiagnosticMessage(message: string): void;
+    RequestCredentials(credType: number, isRetry: boolean, isSingleSignOnCredential: boolean, certificate: Windows.Security.Cryptography.Certificates.Certificate): Windows.Networking.Vpn.VpnPickedCredential;
+    RequestCustomPrompt(customPrompt: Windows.Foundation.Collections.IVectorView<Windows.Networking.Vpn.IVpnCustomPrompt> | Windows.Networking.Vpn.IVpnCustomPrompt[]): void;
+    RequestVpnPacketBuffer(type: number, vpnPacketBuffer: Windows.Networking.Vpn.VpnPacketBuffer): void;
+    SetAllowedSslTlsVersions(tunnelTransport: Object, useTls12: boolean): void;
+    SetErrorMessage(message: string): void;
+    Start(assignedClientIPv4list: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[], assignedClientIPv6list: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[], vpnInterfaceId: Windows.Networking.Vpn.VpnInterfaceId, routeScope: Windows.Networking.Vpn.VpnRouteAssignment, namespaceScope: Windows.Networking.Vpn.VpnNamespaceAssignment, mtuSize: number, maxFrameSize: number, optimizeForLowCostNetwork: boolean, mainOuterTunnelTransport: Object, optionalOuterTunnelTransport: Object): void;
+    Stop(): void;
+    readonly Configuration: Windows.Networking.Vpn.VpnChannelConfiguration;
+    readonly Id: number;
+    PlugInContext: Object;
+    readonly SystemHealth: Windows.Networking.Vpn.VpnSystemHealth;
+    ActivityChange: Windows.Foundation.TypedEventHandler<Windows.Networking.Vpn.VpnChannel, Windows.Networking.Vpn.VpnChannelActivityEventArgs> | null;
+  }
+  var IVpnChannel: abstract new (...args: any[]) => IVpnChannel;
+
+  interface IVpnChannel2 {
+    GetVpnReceivePacketBuffer(): Windows.Networking.Vpn.VpnPacketBuffer;
+    GetVpnSendPacketBuffer(): Windows.Networking.Vpn.VpnPacketBuffer;
+    RequestCredentialsAsync(credType: number, credOptions: number, certificate: Windows.Security.Cryptography.Certificates.Certificate): Windows.Foundation.IAsyncOperation<Windows.Networking.Vpn.VpnCredential>;
+    RequestCredentialsAsync(credType: number, credOptions: number): Windows.Foundation.IAsyncOperation<Windows.Networking.Vpn.VpnCredential>;
+    RequestCredentialsAsync(credType: number): Windows.Foundation.IAsyncOperation<Windows.Networking.Vpn.VpnCredential>;
+    RequestCustomPromptAsync(customPromptElement: Windows.Foundation.Collections.IVectorView<Windows.Networking.Vpn.IVpnCustomPromptElement> | Windows.Networking.Vpn.IVpnCustomPromptElement[]): Windows.Foundation.IAsyncAction;
+    StartExistingTransports(assignedClientIPv4list: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[], assignedClientIPv6list: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[], vpnInterfaceId: Windows.Networking.Vpn.VpnInterfaceId, assignedRoutes: Windows.Networking.Vpn.VpnRouteAssignment, assignedDomainName: Windows.Networking.Vpn.VpnDomainNameAssignment, mtuSize: number, maxFrameSize: number, Reserved: boolean): void;
+    StartWithMainTransport(assignedClientIPv4list: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[], assignedClientIPv6list: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[], vpnInterfaceId: Windows.Networking.Vpn.VpnInterfaceId, assignedRoutes: Windows.Networking.Vpn.VpnRouteAssignment, assignedDomainName: Windows.Networking.Vpn.VpnDomainNameAssignment, mtuSize: number, maxFrameSize: number, Reserved: boolean, mainOuterTunnelTransport: Object): void;
+    StartWithTrafficFilter(assignedClientIpv4List: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[], assignedClientIpv6List: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[], vpnInterfaceId: Windows.Networking.Vpn.VpnInterfaceId, assignedRoutes: Windows.Networking.Vpn.VpnRouteAssignment, assignedNamespace: Windows.Networking.Vpn.VpnDomainNameAssignment, mtuSize: number, maxFrameSize: number, reserved: boolean, mainOuterTunnelTransport: Object, optionalOuterTunnelTransport: Object, assignedTrafficFilters: Windows.Networking.Vpn.VpnTrafficFilterAssignment): void;
+    TerminateConnection(message: string): void;
+    ActivityStateChange: Windows.Foundation.TypedEventHandler<Windows.Networking.Vpn.VpnChannel, Windows.Networking.Vpn.VpnChannelActivityStateChangedArgs> | null;
+  }
+  var IVpnChannel2: abstract new (...args: any[]) => IVpnChannel2;
+
+  interface IVpnChannel4 {
+    AddAndAssociateTransport(transport: Object, context: Object): void;
+    GetSlotTypeForTransportContext(context: Object): number;
+    ReplaceAndAssociateTransport(transport: Object, context: Object): void;
+    StartReconnectingTransport(transport: Object, context: Object): void;
+    StartWithTrafficFilter(assignedClientIpv4Addresses: Windows.Foundation.Collections.IIterable<Windows.Networking.HostName> | Windows.Networking.HostName[], assignedClientIpv6Addresses: Windows.Foundation.Collections.IIterable<Windows.Networking.HostName> | Windows.Networking.HostName[], vpninterfaceId: Windows.Networking.Vpn.VpnInterfaceId, assignedRoutes: Windows.Networking.Vpn.VpnRouteAssignment, assignedNamespace: Windows.Networking.Vpn.VpnDomainNameAssignment, mtuSize: number, maxFrameSize: number, reserved: boolean, transports: Windows.Foundation.Collections.IIterable<Object> | Object[], assignedTrafficFilters: Windows.Networking.Vpn.VpnTrafficFilterAssignment): void;
+    readonly CurrentRequestTransportContext: Object;
+  }
+  var IVpnChannel4: abstract new (...args: any[]) => IVpnChannel4;
+
+  interface IVpnChannel5 {
+    AppendVpnReceivePacketBuffer(decapsulatedPacketBuffer: Windows.Networking.Vpn.VpnPacketBuffer): void;
+    AppendVpnSendPacketBuffer(encapsulatedPacketBuffer: Windows.Networking.Vpn.VpnPacketBuffer): void;
+    FlushVpnReceivePacketBuffers(): void;
+    FlushVpnSendPacketBuffers(): void;
+  }
+  var IVpnChannel5: abstract new (...args: any[]) => IVpnChannel5;
+
+  interface IVpnChannel6 {
+    ActivateForeground(packageRelativeAppId: string, sharedContext: Windows.Foundation.Collections.ValueSet): Windows.Foundation.Collections.ValueSet;
+  }
+  var IVpnChannel6: abstract new (...args: any[]) => IVpnChannel6;
+
+  interface IVpnChannelActivityEventArgs {
+    readonly Type: number;
+  }
+  var IVpnChannelActivityEventArgs: abstract new (...args: any[]) => IVpnChannelActivityEventArgs;
+
+  interface IVpnChannelActivityStateChangedArgs {
+    readonly ActivityState: number;
+  }
+  var IVpnChannelActivityStateChangedArgs: abstract new (...args: any[]) => IVpnChannelActivityStateChangedArgs;
+
+  interface IVpnChannelConfiguration {
+    readonly CustomField: string;
+    readonly ServerHostNameList: Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[];
+    readonly ServerServiceName: string;
+  }
+  var IVpnChannelConfiguration: abstract new (...args: any[]) => IVpnChannelConfiguration;
+
+  interface IVpnChannelConfiguration2 {
+    readonly ServerUris: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+  }
+  var IVpnChannelConfiguration2: abstract new (...args: any[]) => IVpnChannelConfiguration2;
+
+  interface IVpnChannelStatics {
+    ProcessEventAsync(thirdPartyPlugIn: Object, event: Object): void;
+  }
+  var IVpnChannelStatics: abstract new (...args: any[]) => IVpnChannelStatics;
+
+  interface IVpnCredential {
+    readonly AdditionalPin: string;
+    readonly CertificateCredential: Windows.Security.Cryptography.Certificates.Certificate;
+    readonly OldPasswordCredential: Windows.Security.Credentials.PasswordCredential;
+    readonly PasskeyCredential: Windows.Security.Credentials.PasswordCredential;
+  }
+  var IVpnCredential: abstract new (...args: any[]) => IVpnCredential;
+
+  interface IVpnCustomCheckBox extends Windows.Networking.Vpn.IVpnCustomPrompt {
+    readonly Checked: boolean;
+    InitialCheckState: boolean;
+  }
+  var IVpnCustomCheckBox: abstract new (...args: any[]) => IVpnCustomCheckBox;
+
+  interface IVpnCustomComboBox extends Windows.Networking.Vpn.IVpnCustomPrompt {
+    OptionsText: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Selected: number;
+  }
+  var IVpnCustomComboBox: abstract new (...args: any[]) => IVpnCustomComboBox;
+
+  interface IVpnCustomEditBox extends Windows.Networking.Vpn.IVpnCustomPrompt {
+    DefaultText: string;
+    NoEcho: boolean;
+    readonly Text: string;
+  }
+  var IVpnCustomEditBox: abstract new (...args: any[]) => IVpnCustomEditBox;
+
+  interface IVpnCustomErrorBox extends Windows.Networking.Vpn.IVpnCustomPrompt {
+  }
+  var IVpnCustomErrorBox: abstract new (...args: any[]) => IVpnCustomErrorBox;
+
+  interface IVpnCustomPrompt {
+    Bordered: boolean;
+    Compulsory: boolean;
+    Label: string;
+  }
+  var IVpnCustomPrompt: abstract new (...args: any[]) => IVpnCustomPrompt;
+
+  interface IVpnCustomPromptBooleanInput extends Windows.Networking.Vpn.IVpnCustomPromptElement {
+    InitialValue: boolean;
+    readonly Value: boolean;
+  }
+  var IVpnCustomPromptBooleanInput: abstract new (...args: any[]) => IVpnCustomPromptBooleanInput;
+
+  interface IVpnCustomPromptElement {
+    Compulsory: boolean;
+    DisplayName: string;
+    Emphasized: boolean;
+  }
+  var IVpnCustomPromptElement: abstract new (...args: any[]) => IVpnCustomPromptElement;
+
+  interface IVpnCustomPromptOptionSelector extends Windows.Networking.Vpn.IVpnCustomPromptElement {
+    readonly Options: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly SelectedIndex: number;
+  }
+  var IVpnCustomPromptOptionSelector: abstract new (...args: any[]) => IVpnCustomPromptOptionSelector;
+
+  interface IVpnCustomPromptText extends Windows.Networking.Vpn.IVpnCustomPromptElement {
+    Text: string;
+  }
+  var IVpnCustomPromptText: abstract new (...args: any[]) => IVpnCustomPromptText;
+
+  interface IVpnCustomPromptTextInput extends Windows.Networking.Vpn.IVpnCustomPromptElement {
+    IsTextHidden: boolean;
+    PlaceholderText: string;
+    readonly Text: string;
+  }
+  var IVpnCustomPromptTextInput: abstract new (...args: any[]) => IVpnCustomPromptTextInput;
+
+  interface IVpnCustomTextBox extends Windows.Networking.Vpn.IVpnCustomPrompt {
+    DisplayText: string;
+  }
+  var IVpnCustomTextBox: abstract new (...args: any[]) => IVpnCustomTextBox;
+
+  interface IVpnDomainNameAssignment {
+    readonly DomainNameList: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnDomainNameInfo> | Windows.Networking.Vpn.VpnDomainNameInfo[];
+    ProxyAutoConfigurationUri: Windows.Foundation.Uri;
+  }
+  var IVpnDomainNameAssignment: abstract new (...args: any[]) => IVpnDomainNameAssignment;
+
+  interface IVpnDomainNameInfo {
+    readonly DnsServers: Windows.Foundation.Collections.IVector<Windows.Networking.HostName> | Windows.Networking.HostName[];
+    DomainName: Windows.Networking.HostName;
+    DomainNameType: number;
+    readonly WebProxyServers: Windows.Foundation.Collections.IVector<Windows.Networking.HostName> | Windows.Networking.HostName[];
+  }
+  var IVpnDomainNameInfo: abstract new (...args: any[]) => IVpnDomainNameInfo;
+
+  interface IVpnDomainNameInfo2 {
+    readonly WebProxyUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+  }
+  var IVpnDomainNameInfo2: abstract new (...args: any[]) => IVpnDomainNameInfo2;
+
+  interface IVpnDomainNameInfoFactory {
+    CreateVpnDomainNameInfo(name: string, nameType: number, dnsServerList: Windows.Foundation.Collections.IIterable<Windows.Networking.HostName> | Windows.Networking.HostName[], proxyServerList: Windows.Foundation.Collections.IIterable<Windows.Networking.HostName> | Windows.Networking.HostName[]): Windows.Networking.Vpn.VpnDomainNameInfo;
+  }
+  var IVpnDomainNameInfoFactory: abstract new (...args: any[]) => IVpnDomainNameInfoFactory;
+
+  interface IVpnForegroundActivatedEventArgs {
+    readonly ActivationOperation: Windows.Networking.Vpn.VpnForegroundActivationOperation;
+    readonly ProfileName: string;
+    readonly SharedContext: Windows.Foundation.Collections.ValueSet;
+  }
+  var IVpnForegroundActivatedEventArgs: abstract new (...args: any[]) => IVpnForegroundActivatedEventArgs;
+
+  interface IVpnForegroundActivationOperation {
+    Complete(result: Windows.Foundation.Collections.ValueSet): void;
+  }
+  var IVpnForegroundActivationOperation: abstract new (...args: any[]) => IVpnForegroundActivationOperation;
+
+  interface IVpnInterfaceId {
+    GetAddressInfo(id: number[]): void;
+  }
+  var IVpnInterfaceId: abstract new (...args: any[]) => IVpnInterfaceId;
+
+  interface IVpnInterfaceIdFactory {
+    CreateVpnInterfaceId(address: number[]): Windows.Networking.Vpn.VpnInterfaceId;
+  }
+  var IVpnInterfaceIdFactory: abstract new (...args: any[]) => IVpnInterfaceIdFactory;
+
+  interface IVpnManagementAgent {
+    AddProfileFromObjectAsync(profile: Windows.Networking.Vpn.IVpnProfile): Windows.Foundation.IAsyncOperation<number>;
+    AddProfileFromXmlAsync(xml: string): Windows.Foundation.IAsyncOperation<number>;
+    ConnectProfileAsync(profile: Windows.Networking.Vpn.IVpnProfile): Windows.Foundation.IAsyncOperation<number>;
+    ConnectProfileWithPasswordCredentialAsync(profile: Windows.Networking.Vpn.IVpnProfile, passwordCredential: Windows.Security.Credentials.PasswordCredential): Windows.Foundation.IAsyncOperation<number>;
+    DeleteProfileAsync(profile: Windows.Networking.Vpn.IVpnProfile): Windows.Foundation.IAsyncOperation<number>;
+    DisconnectProfileAsync(profile: Windows.Networking.Vpn.IVpnProfile): Windows.Foundation.IAsyncOperation<number>;
+    GetProfilesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Networking.Vpn.IVpnProfile> | Windows.Networking.Vpn.IVpnProfile[]>;
+    UpdateProfileFromObjectAsync(profile: Windows.Networking.Vpn.IVpnProfile): Windows.Foundation.IAsyncOperation<number>;
+    UpdateProfileFromXmlAsync(xml: string): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IVpnManagementAgent: abstract new (...args: any[]) => IVpnManagementAgent;
+
+  interface IVpnNamespaceAssignment {
+    NamespaceList: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnNamespaceInfo> | Windows.Networking.Vpn.VpnNamespaceInfo[];
+    ProxyAutoConfigUri: Windows.Foundation.Uri;
+  }
+  var IVpnNamespaceAssignment: abstract new (...args: any[]) => IVpnNamespaceAssignment;
+
+  interface IVpnNamespaceInfo {
+    DnsServers: Windows.Foundation.Collections.IVector<Windows.Networking.HostName> | Windows.Networking.HostName[];
+    Namespace: string;
+    WebProxyServers: Windows.Foundation.Collections.IVector<Windows.Networking.HostName> | Windows.Networking.HostName[];
+  }
+  var IVpnNamespaceInfo: abstract new (...args: any[]) => IVpnNamespaceInfo;
+
+  interface IVpnNamespaceInfoFactory {
+    CreateVpnNamespaceInfo(name: string, dnsServerList: Windows.Foundation.Collections.IVector<Windows.Networking.HostName> | Windows.Networking.HostName[], proxyServerList: Windows.Foundation.Collections.IVector<Windows.Networking.HostName> | Windows.Networking.HostName[]): Windows.Networking.Vpn.VpnNamespaceInfo;
+  }
+  var IVpnNamespaceInfoFactory: abstract new (...args: any[]) => IVpnNamespaceInfoFactory;
+
+  interface IVpnNativeProfile extends Windows.Networking.Vpn.IVpnProfile {
+    EapConfiguration: string;
+    NativeProtocolType: number;
+    RoutingPolicyType: number;
+    readonly Servers: Windows.Foundation.Collections.IVector<string> | string[];
+    TunnelAuthenticationMethod: number;
+    UserAuthenticationMethod: number;
+  }
+  var IVpnNativeProfile: abstract new (...args: any[]) => IVpnNativeProfile;
+
+  interface IVpnNativeProfile2 {
+    readonly ConnectionStatus: number;
+    RequireVpnClientAppUI: boolean;
+  }
+  var IVpnNativeProfile2: abstract new (...args: any[]) => IVpnNativeProfile2;
+
+  interface IVpnPacketBuffer {
+    readonly Buffer: Windows.Storage.Streams.Buffer;
+    Status: number;
+    TransportAffinity: number;
+  }
+  var IVpnPacketBuffer: abstract new (...args: any[]) => IVpnPacketBuffer;
+
+  interface IVpnPacketBuffer2 {
+    readonly AppId: Windows.Networking.Vpn.VpnAppId;
+  }
+  var IVpnPacketBuffer2: abstract new (...args: any[]) => IVpnPacketBuffer2;
+
+  interface IVpnPacketBuffer3 {
+    TransportContext: Object;
+  }
+  var IVpnPacketBuffer3: abstract new (...args: any[]) => IVpnPacketBuffer3;
+
+  interface IVpnPacketBufferFactory {
+    CreateVpnPacketBuffer(parentBuffer: Windows.Networking.Vpn.VpnPacketBuffer, offset: number, length: number): Windows.Networking.Vpn.VpnPacketBuffer;
+  }
+  var IVpnPacketBufferFactory: abstract new (...args: any[]) => IVpnPacketBufferFactory;
+
+  interface IVpnPacketBufferList {
+    AddAtBegin(nextVpnPacketBuffer: Windows.Networking.Vpn.VpnPacketBuffer): void;
+    Append(nextVpnPacketBuffer: Windows.Networking.Vpn.VpnPacketBuffer): void;
+    Clear(): void;
+    RemoveAtBegin(): Windows.Networking.Vpn.VpnPacketBuffer;
+    RemoveAtEnd(): Windows.Networking.Vpn.VpnPacketBuffer;
+    readonly Size: number;
+    Status: number;
+  }
+  var IVpnPacketBufferList: abstract new (...args: any[]) => IVpnPacketBufferList;
+
+  interface IVpnPacketBufferList2 {
+    AddLeadingPacket(nextVpnPacketBuffer: Windows.Networking.Vpn.VpnPacketBuffer): void;
+    AddTrailingPacket(nextVpnPacketBuffer: Windows.Networking.Vpn.VpnPacketBuffer): void;
+    RemoveLeadingPacket(): Windows.Networking.Vpn.VpnPacketBuffer;
+    RemoveTrailingPacket(): Windows.Networking.Vpn.VpnPacketBuffer;
+  }
+  var IVpnPacketBufferList2: abstract new (...args: any[]) => IVpnPacketBufferList2;
+
+  interface IVpnPickedCredential {
+    readonly AdditionalPin: string;
+    readonly OldPasswordCredential: Windows.Security.Credentials.PasswordCredential;
+    readonly PasskeyCredential: Windows.Security.Credentials.PasswordCredential;
+  }
+  var IVpnPickedCredential: abstract new (...args: any[]) => IVpnPickedCredential;
+
+  interface IVpnPlugIn {
+    Connect(channel: Windows.Networking.Vpn.VpnChannel): void;
+    Decapsulate(channel: Windows.Networking.Vpn.VpnChannel, encapBuffer: Windows.Networking.Vpn.VpnPacketBuffer, decapsulatedPackets: Windows.Networking.Vpn.VpnPacketBufferList, controlPacketsToSend: Windows.Networking.Vpn.VpnPacketBufferList): void;
+    Disconnect(channel: Windows.Networking.Vpn.VpnChannel): void;
+    Encapsulate(channel: Windows.Networking.Vpn.VpnChannel, packets: Windows.Networking.Vpn.VpnPacketBufferList, encapulatedPackets: Windows.Networking.Vpn.VpnPacketBufferList): void;
+    GetKeepAlivePayload(channel: Windows.Networking.Vpn.VpnChannel, keepAlivePacket: Windows.Networking.Vpn.VpnPacketBuffer): void;
+  }
+  var IVpnPlugIn: abstract new (...args: any[]) => IVpnPlugIn;
+
+  interface IVpnPlugInProfile extends Windows.Networking.Vpn.IVpnProfile {
+    CustomConfiguration: string;
+    readonly ServerUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    VpnPluginPackageFamilyName: string;
+  }
+  var IVpnPlugInProfile: abstract new (...args: any[]) => IVpnPlugInProfile;
+
+  interface IVpnPlugInProfile2 extends Windows.Networking.Vpn.IVpnProfile {
+    readonly ConnectionStatus: number;
+    RequireVpnClientAppUI: boolean;
+  }
+  var IVpnPlugInProfile2: abstract new (...args: any[]) => IVpnPlugInProfile2;
+
+  interface IVpnPlugInReconnectTransport {
+    ReconnectTransport(channel: Windows.Networking.Vpn.VpnChannel, context: Object): void;
+  }
+  var IVpnPlugInReconnectTransport: abstract new (...args: any[]) => IVpnPlugInReconnectTransport;
+
+  interface IVpnProfile {
+    AlwaysOn: boolean;
+    readonly AppTriggers: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnAppId> | Windows.Networking.Vpn.VpnAppId[];
+    readonly DomainNameInfoList: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnDomainNameInfo> | Windows.Networking.Vpn.VpnDomainNameInfo[];
+    ProfileName: string;
+    RememberCredentials: boolean;
+    readonly Routes: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnRoute> | Windows.Networking.Vpn.VpnRoute[];
+    readonly TrafficFilters: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnTrafficFilter> | Windows.Networking.Vpn.VpnTrafficFilter[];
+  }
+  var IVpnProfile: abstract new (...args: any[]) => IVpnProfile;
+
+  interface IVpnRoute {
+    Address: Windows.Networking.HostName;
+    PrefixSize: number;
+  }
+  var IVpnRoute: abstract new (...args: any[]) => IVpnRoute;
+
+  interface IVpnRouteAssignment {
+    ExcludeLocalSubnets: boolean;
+    Ipv4ExclusionRoutes: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnRoute> | Windows.Networking.Vpn.VpnRoute[];
+    Ipv4InclusionRoutes: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnRoute> | Windows.Networking.Vpn.VpnRoute[];
+    Ipv6ExclusionRoutes: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnRoute> | Windows.Networking.Vpn.VpnRoute[];
+    Ipv6InclusionRoutes: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnRoute> | Windows.Networking.Vpn.VpnRoute[];
+  }
+  var IVpnRouteAssignment: abstract new (...args: any[]) => IVpnRouteAssignment;
+
+  interface IVpnRouteFactory {
+    CreateVpnRoute(address: Windows.Networking.HostName, prefixSize: number): Windows.Networking.Vpn.VpnRoute;
+  }
+  var IVpnRouteFactory: abstract new (...args: any[]) => IVpnRouteFactory;
+
+  interface IVpnSystemHealth {
+    readonly StatementOfHealth: Windows.Storage.Streams.Buffer;
+  }
+  var IVpnSystemHealth: abstract new (...args: any[]) => IVpnSystemHealth;
+
+  interface IVpnTrafficFilter {
+    readonly AppClaims: Windows.Foundation.Collections.IVector<string> | string[];
+    AppId: Windows.Networking.Vpn.VpnAppId;
+    readonly LocalAddressRanges: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly LocalPortRanges: Windows.Foundation.Collections.IVector<string> | string[];
+    Protocol: number;
+    readonly RemoteAddressRanges: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly RemotePortRanges: Windows.Foundation.Collections.IVector<string> | string[];
+    RoutingPolicyType: number;
+  }
+  var IVpnTrafficFilter: abstract new (...args: any[]) => IVpnTrafficFilter;
+
+  interface IVpnTrafficFilterAssignment {
+    AllowInbound: boolean;
+    AllowOutbound: boolean;
+    readonly TrafficFilterList: Windows.Foundation.Collections.IVector<Windows.Networking.Vpn.VpnTrafficFilter> | Windows.Networking.Vpn.VpnTrafficFilter[];
+  }
+  var IVpnTrafficFilterAssignment: abstract new (...args: any[]) => IVpnTrafficFilterAssignment;
+
+  interface IVpnTrafficFilterFactory {
+    Create(appId: Windows.Networking.Vpn.VpnAppId): Windows.Networking.Vpn.VpnTrafficFilter;
+  }
+  var IVpnTrafficFilterFactory: abstract new (...args: any[]) => IVpnTrafficFilterFactory;
+
+}
+
+declare namespace Windows.Networking.XboxLive {
+  class XboxLiveDeviceAddress implements Windows.Networking.XboxLive.IXboxLiveDeviceAddress {
+    Compare(otherDeviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress): number;
+    static CreateFromSnapshotBase64(base64: string): Windows.Networking.XboxLive.XboxLiveDeviceAddress;
+    static CreateFromSnapshotBuffer(buffer: Windows.Storage.Streams.IBuffer): Windows.Networking.XboxLive.XboxLiveDeviceAddress;
+    static CreateFromSnapshotBytes(buffer: number[]): Windows.Networking.XboxLive.XboxLiveDeviceAddress;
+    static GetLocal(): Windows.Networking.XboxLive.XboxLiveDeviceAddress;
+    GetSnapshotAsBase64(): string;
+    GetSnapshotAsBuffer(): Windows.Storage.Streams.IBuffer;
+    GetSnapshotAsBytes(buffer: number[], bytesWritten: number): void;
+    readonly IsLocal: boolean;
+    readonly IsValid: boolean;
+    static readonly MaxSnapshotBytesSize: number;
+    readonly NetworkAccessKind: number;
+    SnapshotChanged: Windows.Foundation.TypedEventHandler<Windows.Networking.XboxLive.XboxLiveDeviceAddress, Object> | null;
+  }
+
+  class XboxLiveEndpointPair implements Windows.Networking.XboxLive.IXboxLiveEndpointPair {
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    static FindEndpointPairByHostNamesAndPorts(localHostName: Windows.Networking.HostName, localPort: string, remoteHostName: Windows.Networking.HostName, remotePort: string): Windows.Networking.XboxLive.XboxLiveEndpointPair;
+    static FindEndpointPairBySocketAddressBytes(localSocketAddress: number[], remoteSocketAddress: number[]): Windows.Networking.XboxLive.XboxLiveEndpointPair;
+    GetLocalSocketAddressBytes(socketAddress: number[]): void;
+    GetRemoteSocketAddressBytes(socketAddress: number[]): void;
+    readonly LocalHostName: Windows.Networking.HostName;
+    readonly LocalPort: string;
+    readonly RemoteDeviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress;
+    readonly RemoteHostName: Windows.Networking.HostName;
+    readonly RemotePort: string;
+    readonly State: number;
+    readonly Template: Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Networking.XboxLive.XboxLiveEndpointPair, Windows.Networking.XboxLive.XboxLiveEndpointPairStateChangedEventArgs> | null;
+  }
+
+  class XboxLiveEndpointPairCreationResult implements Windows.Networking.XboxLive.IXboxLiveEndpointPairCreationResult {
+    readonly DeviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress;
+    readonly EndpointPair: Windows.Networking.XboxLive.XboxLiveEndpointPair;
+    readonly IsExistingPathEvaluation: boolean;
+    readonly Status: number;
+  }
+
+  class XboxLiveEndpointPairStateChangedEventArgs implements Windows.Networking.XboxLive.IXboxLiveEndpointPairStateChangedEventArgs {
+    readonly NewState: number;
+    readonly OldState: number;
+  }
+
+  class XboxLiveEndpointPairTemplate implements Windows.Networking.XboxLive.IXboxLiveEndpointPairTemplate {
+    CreateEndpointPairAsync(deviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress): Windows.Foundation.IAsyncOperation<Windows.Networking.XboxLive.XboxLiveEndpointPairCreationResult>;
+    CreateEndpointPairAsync(deviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress, behaviors: number): Windows.Foundation.IAsyncOperation<Windows.Networking.XboxLive.XboxLiveEndpointPairCreationResult>;
+    CreateEndpointPairForPortsAsync(deviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress, initiatorPort: string, acceptorPort: string): Windows.Foundation.IAsyncOperation<Windows.Networking.XboxLive.XboxLiveEndpointPairCreationResult>;
+    CreateEndpointPairForPortsAsync(deviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress, initiatorPort: string, acceptorPort: string, behaviors: number): Windows.Foundation.IAsyncOperation<Windows.Networking.XboxLive.XboxLiveEndpointPairCreationResult>;
+    static GetTemplateByName(name: string): Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate;
+    readonly AcceptorBoundPortRangeLower: number;
+    readonly AcceptorBoundPortRangeUpper: number;
+    readonly EndpointPairs: Windows.Foundation.Collections.IVectorView<Windows.Networking.XboxLive.XboxLiveEndpointPair> | Windows.Networking.XboxLive.XboxLiveEndpointPair[];
+    readonly InitiatorBoundPortRangeLower: number;
+    readonly InitiatorBoundPortRangeUpper: number;
+    readonly Name: string;
+    readonly SocketKind: number;
+    static readonly Templates: Windows.Foundation.Collections.IVectorView<Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate> | Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate[];
+    InboundEndpointPairCreated: Windows.Foundation.TypedEventHandler<Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate, Windows.Networking.XboxLive.XboxLiveInboundEndpointPairCreatedEventArgs> | null;
+  }
+
+  class XboxLiveInboundEndpointPairCreatedEventArgs implements Windows.Networking.XboxLive.IXboxLiveInboundEndpointPairCreatedEventArgs {
+    readonly EndpointPair: Windows.Networking.XboxLive.XboxLiveEndpointPair;
+  }
+
+  class XboxLiveQualityOfServiceMeasurement implements Windows.Networking.XboxLive.IXboxLiveQualityOfServiceMeasurement {
+    constructor();
+    static ClearPrivatePayload(): void;
+    GetMetricResult(deviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress, metric: number): Windows.Networking.XboxLive.XboxLiveQualityOfServiceMetricResult;
+    GetMetricResultsForDevice(deviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress): Windows.Foundation.Collections.IVectorView<Windows.Networking.XboxLive.XboxLiveQualityOfServiceMetricResult> | Windows.Networking.XboxLive.XboxLiveQualityOfServiceMetricResult[];
+    GetMetricResultsForMetric(metric: number): Windows.Foundation.Collections.IVectorView<Windows.Networking.XboxLive.XboxLiveQualityOfServiceMetricResult> | Windows.Networking.XboxLive.XboxLiveQualityOfServiceMetricResult[];
+    GetPrivatePayloadResult(deviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress): Windows.Networking.XboxLive.XboxLiveQualityOfServicePrivatePayloadResult;
+    MeasureAsync(): Windows.Foundation.IAsyncAction;
+    static PublishPrivatePayloadBytes(payload: number[]): void;
+    readonly DeviceAddresses: Windows.Foundation.Collections.IVector<Windows.Networking.XboxLive.XboxLiveDeviceAddress> | Windows.Networking.XboxLive.XboxLiveDeviceAddress[];
+    static IsSystemInboundBandwidthConstrained: boolean;
+    static IsSystemOutboundBandwidthConstrained: boolean;
+    static readonly MaxPrivatePayloadSize: number;
+    static MaxSimultaneousProbeConnections: number;
+    readonly MetricResults: Windows.Foundation.Collections.IVectorView<Windows.Networking.XboxLive.XboxLiveQualityOfServiceMetricResult> | Windows.Networking.XboxLive.XboxLiveQualityOfServiceMetricResult[];
+    readonly Metrics: Windows.Foundation.Collections.IVector<number> | number[];
+    NumberOfProbesToAttempt: number;
+    readonly NumberOfResultsPending: number;
+    readonly PrivatePayloadResults: Windows.Foundation.Collections.IVectorView<Windows.Networking.XboxLive.XboxLiveQualityOfServicePrivatePayloadResult> | Windows.Networking.XboxLive.XboxLiveQualityOfServicePrivatePayloadResult[];
+    static PublishedPrivatePayload: Windows.Storage.Streams.IBuffer;
+    ShouldRequestPrivatePayloads: boolean;
+    TimeoutInMilliseconds: number;
+  }
+
+  class XboxLiveQualityOfServiceMetricResult implements Windows.Networking.XboxLive.IXboxLiveQualityOfServiceMetricResult {
+    readonly DeviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress;
+    readonly Metric: number;
+    readonly Status: number;
+    readonly Value: number | bigint;
+  }
+
+  class XboxLiveQualityOfServicePrivatePayloadResult implements Windows.Networking.XboxLive.IXboxLiveQualityOfServicePrivatePayloadResult {
+    readonly DeviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress;
+    readonly Status: number;
+    readonly Value: Windows.Storage.Streams.IBuffer;
+  }
+
+  enum XboxLiveEndpointPairCreationBehaviors {
+    None = 0,
+    ReevaluatePath = 1,
+  }
+
+  enum XboxLiveEndpointPairCreationStatus {
+    Succeeded = 0,
+    NoLocalNetworks = 1,
+    NoCompatibleNetworkPaths = 2,
+    LocalSystemNotAuthorized = 3,
+    Canceled = 4,
+    TimedOut = 5,
+    RemoteSystemNotAuthorized = 6,
+    RefusedDueToConfiguration = 7,
+    UnexpectedInternalError = 8,
+  }
+
+  enum XboxLiveEndpointPairState {
+    Invalid = 0,
+    CreatingOutbound = 1,
+    CreatingInbound = 2,
+    Ready = 3,
+    DeletingLocally = 4,
+    RemoteEndpointTerminating = 5,
+    Deleted = 6,
+  }
+
+  enum XboxLiveNetworkAccessKind {
+    Open = 0,
+    Moderate = 1,
+    Strict = 2,
+  }
+
+  enum XboxLiveQualityOfServiceMeasurementStatus {
+    NotStarted = 0,
+    InProgress = 1,
+    InProgressWithProvisionalResults = 2,
+    Succeeded = 3,
+    NoLocalNetworks = 4,
+    NoCompatibleNetworkPaths = 5,
+    LocalSystemNotAuthorized = 6,
+    Canceled = 7,
+    TimedOut = 8,
+    RemoteSystemNotAuthorized = 9,
+    RefusedDueToConfiguration = 10,
+    UnexpectedInternalError = 11,
+  }
+
+  enum XboxLiveQualityOfServiceMetric {
+    AverageLatencyInMilliseconds = 0,
+    MinLatencyInMilliseconds = 1,
+    MaxLatencyInMilliseconds = 2,
+    AverageOutboundBitsPerSecond = 3,
+    MinOutboundBitsPerSecond = 4,
+    MaxOutboundBitsPerSecond = 5,
+    AverageInboundBitsPerSecond = 6,
+    MinInboundBitsPerSecond = 7,
+    MaxInboundBitsPerSecond = 8,
+  }
+
+  enum XboxLiveSocketKind {
+    None = 0,
+    Datagram = 1,
+    Stream = 2,
+  }
+
+  interface IXboxLiveDeviceAddress {
+    Compare(otherDeviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress): number;
+    GetSnapshotAsBase64(): string;
+    GetSnapshotAsBuffer(): Windows.Storage.Streams.IBuffer;
+    GetSnapshotAsBytes(buffer: number[], bytesWritten: number): void;
+    readonly IsLocal: boolean;
+    readonly IsValid: boolean;
+    readonly NetworkAccessKind: number;
+    SnapshotChanged: Windows.Foundation.TypedEventHandler<Windows.Networking.XboxLive.XboxLiveDeviceAddress, Object> | null;
+  }
+  var IXboxLiveDeviceAddress: abstract new (...args: any[]) => IXboxLiveDeviceAddress;
+
+  interface IXboxLiveDeviceAddressStatics {
+    CreateFromSnapshotBase64(base64: string): Windows.Networking.XboxLive.XboxLiveDeviceAddress;
+    CreateFromSnapshotBuffer(buffer: Windows.Storage.Streams.IBuffer): Windows.Networking.XboxLive.XboxLiveDeviceAddress;
+    CreateFromSnapshotBytes(buffer: number[]): Windows.Networking.XboxLive.XboxLiveDeviceAddress;
+    GetLocal(): Windows.Networking.XboxLive.XboxLiveDeviceAddress;
+    readonly MaxSnapshotBytesSize: number;
+  }
+  var IXboxLiveDeviceAddressStatics: abstract new (...args: any[]) => IXboxLiveDeviceAddressStatics;
+
+  interface IXboxLiveEndpointPair {
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    GetLocalSocketAddressBytes(socketAddress: number[]): void;
+    GetRemoteSocketAddressBytes(socketAddress: number[]): void;
+    readonly LocalHostName: Windows.Networking.HostName;
+    readonly LocalPort: string;
+    readonly RemoteDeviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress;
+    readonly RemoteHostName: Windows.Networking.HostName;
+    readonly RemotePort: string;
+    readonly State: number;
+    readonly Template: Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Networking.XboxLive.XboxLiveEndpointPair, Windows.Networking.XboxLive.XboxLiveEndpointPairStateChangedEventArgs> | null;
+  }
+  var IXboxLiveEndpointPair: abstract new (...args: any[]) => IXboxLiveEndpointPair;
+
+  interface IXboxLiveEndpointPairCreationResult {
+    readonly DeviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress;
+    readonly EndpointPair: Windows.Networking.XboxLive.XboxLiveEndpointPair;
+    readonly IsExistingPathEvaluation: boolean;
+    readonly Status: number;
+  }
+  var IXboxLiveEndpointPairCreationResult: abstract new (...args: any[]) => IXboxLiveEndpointPairCreationResult;
+
+  interface IXboxLiveEndpointPairStateChangedEventArgs {
+    readonly NewState: number;
+    readonly OldState: number;
+  }
+  var IXboxLiveEndpointPairStateChangedEventArgs: abstract new (...args: any[]) => IXboxLiveEndpointPairStateChangedEventArgs;
+
+  interface IXboxLiveEndpointPairStatics {
+    FindEndpointPairByHostNamesAndPorts(localHostName: Windows.Networking.HostName, localPort: string, remoteHostName: Windows.Networking.HostName, remotePort: string): Windows.Networking.XboxLive.XboxLiveEndpointPair;
+    FindEndpointPairBySocketAddressBytes(localSocketAddress: number[], remoteSocketAddress: number[]): Windows.Networking.XboxLive.XboxLiveEndpointPair;
+  }
+  var IXboxLiveEndpointPairStatics: abstract new (...args: any[]) => IXboxLiveEndpointPairStatics;
+
+  interface IXboxLiveEndpointPairTemplate {
+    CreateEndpointPairAsync(deviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress): Windows.Foundation.IAsyncOperation<Windows.Networking.XboxLive.XboxLiveEndpointPairCreationResult>;
+    CreateEndpointPairAsync(deviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress, behaviors: number): Windows.Foundation.IAsyncOperation<Windows.Networking.XboxLive.XboxLiveEndpointPairCreationResult>;
+    CreateEndpointPairForPortsAsync(deviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress, initiatorPort: string, acceptorPort: string): Windows.Foundation.IAsyncOperation<Windows.Networking.XboxLive.XboxLiveEndpointPairCreationResult>;
+    CreateEndpointPairForPortsAsync(deviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress, initiatorPort: string, acceptorPort: string, behaviors: number): Windows.Foundation.IAsyncOperation<Windows.Networking.XboxLive.XboxLiveEndpointPairCreationResult>;
+    readonly AcceptorBoundPortRangeLower: number;
+    readonly AcceptorBoundPortRangeUpper: number;
+    readonly EndpointPairs: Windows.Foundation.Collections.IVectorView<Windows.Networking.XboxLive.XboxLiveEndpointPair> | Windows.Networking.XboxLive.XboxLiveEndpointPair[];
+    readonly InitiatorBoundPortRangeLower: number;
+    readonly InitiatorBoundPortRangeUpper: number;
+    readonly Name: string;
+    readonly SocketKind: number;
+    InboundEndpointPairCreated: Windows.Foundation.TypedEventHandler<Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate, Windows.Networking.XboxLive.XboxLiveInboundEndpointPairCreatedEventArgs> | null;
+  }
+  var IXboxLiveEndpointPairTemplate: abstract new (...args: any[]) => IXboxLiveEndpointPairTemplate;
+
+  interface IXboxLiveEndpointPairTemplateStatics {
+    GetTemplateByName(name: string): Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate;
+    readonly Templates: Windows.Foundation.Collections.IVectorView<Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate> | Windows.Networking.XboxLive.XboxLiveEndpointPairTemplate[];
+  }
+  var IXboxLiveEndpointPairTemplateStatics: abstract new (...args: any[]) => IXboxLiveEndpointPairTemplateStatics;
+
+  interface IXboxLiveInboundEndpointPairCreatedEventArgs {
+    readonly EndpointPair: Windows.Networking.XboxLive.XboxLiveEndpointPair;
+  }
+  var IXboxLiveInboundEndpointPairCreatedEventArgs: abstract new (...args: any[]) => IXboxLiveInboundEndpointPairCreatedEventArgs;
+
+  interface IXboxLiveQualityOfServiceMeasurement {
+    GetMetricResult(deviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress, metric: number): Windows.Networking.XboxLive.XboxLiveQualityOfServiceMetricResult;
+    GetMetricResultsForDevice(deviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress): Windows.Foundation.Collections.IVectorView<Windows.Networking.XboxLive.XboxLiveQualityOfServiceMetricResult> | Windows.Networking.XboxLive.XboxLiveQualityOfServiceMetricResult[];
+    GetMetricResultsForMetric(metric: number): Windows.Foundation.Collections.IVectorView<Windows.Networking.XboxLive.XboxLiveQualityOfServiceMetricResult> | Windows.Networking.XboxLive.XboxLiveQualityOfServiceMetricResult[];
+    GetPrivatePayloadResult(deviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress): Windows.Networking.XboxLive.XboxLiveQualityOfServicePrivatePayloadResult;
+    MeasureAsync(): Windows.Foundation.IAsyncAction;
+    readonly DeviceAddresses: Windows.Foundation.Collections.IVector<Windows.Networking.XboxLive.XboxLiveDeviceAddress> | Windows.Networking.XboxLive.XboxLiveDeviceAddress[];
+    readonly MetricResults: Windows.Foundation.Collections.IVectorView<Windows.Networking.XboxLive.XboxLiveQualityOfServiceMetricResult> | Windows.Networking.XboxLive.XboxLiveQualityOfServiceMetricResult[];
+    readonly Metrics: Windows.Foundation.Collections.IVector<number> | number[];
+    NumberOfProbesToAttempt: number;
+    readonly NumberOfResultsPending: number;
+    readonly PrivatePayloadResults: Windows.Foundation.Collections.IVectorView<Windows.Networking.XboxLive.XboxLiveQualityOfServicePrivatePayloadResult> | Windows.Networking.XboxLive.XboxLiveQualityOfServicePrivatePayloadResult[];
+    ShouldRequestPrivatePayloads: boolean;
+    TimeoutInMilliseconds: number;
+  }
+  var IXboxLiveQualityOfServiceMeasurement: abstract new (...args: any[]) => IXboxLiveQualityOfServiceMeasurement;
+
+  interface IXboxLiveQualityOfServiceMeasurementStatics {
+    ClearPrivatePayload(): void;
+    PublishPrivatePayloadBytes(payload: number[]): void;
+    IsSystemInboundBandwidthConstrained: boolean;
+    IsSystemOutboundBandwidthConstrained: boolean;
+    readonly MaxPrivatePayloadSize: number;
+    MaxSimultaneousProbeConnections: number;
+    PublishedPrivatePayload: Windows.Storage.Streams.IBuffer;
+  }
+  var IXboxLiveQualityOfServiceMeasurementStatics: abstract new (...args: any[]) => IXboxLiveQualityOfServiceMeasurementStatics;
+
+  interface IXboxLiveQualityOfServiceMetricResult {
+    readonly DeviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress;
+    readonly Metric: number;
+    readonly Status: number;
+    readonly Value: number | bigint;
+  }
+  var IXboxLiveQualityOfServiceMetricResult: abstract new (...args: any[]) => IXboxLiveQualityOfServiceMetricResult;
+
+  interface IXboxLiveQualityOfServicePrivatePayloadResult {
+    readonly DeviceAddress: Windows.Networking.XboxLive.XboxLiveDeviceAddress;
+    readonly Status: number;
+    readonly Value: Windows.Storage.Streams.IBuffer;
+  }
+  var IXboxLiveQualityOfServicePrivatePayloadResult: abstract new (...args: any[]) => IXboxLiveQualityOfServicePrivatePayloadResult;
+
+  interface XboxLiveSecureSocketsContract {
+  }
+  var XboxLiveSecureSocketsContract: {
+    new(fields: {  }): XboxLiveSecureSocketsContract;
+  };
+
+}
+
+declare namespace Windows.Perception {
+  class PerceptionTimestamp implements Windows.Perception.IPerceptionTimestamp, Windows.Perception.IPerceptionTimestamp2 {
+    readonly PredictionAmount: Windows.Foundation.TimeSpan;
+    readonly SystemRelativeTargetTime: Windows.Foundation.TimeSpan;
+    readonly TargetTime: Windows.Foundation.DateTime;
+  }
+
+  class PerceptionTimestampHelper {
+    static FromHistoricalTargetTime(targetTime: Windows.Foundation.DateTime): Windows.Perception.PerceptionTimestamp;
+    static FromSystemRelativeTargetTime(targetTime: Windows.Foundation.TimeSpan): Windows.Perception.PerceptionTimestamp;
+  }
+
+  interface IPerceptionTimestamp {
+    readonly PredictionAmount: Windows.Foundation.TimeSpan;
+    readonly TargetTime: Windows.Foundation.DateTime;
+  }
+  var IPerceptionTimestamp: abstract new (...args: any[]) => IPerceptionTimestamp;
+
+  interface IPerceptionTimestamp2 {
+    readonly SystemRelativeTargetTime: Windows.Foundation.TimeSpan;
+  }
+  var IPerceptionTimestamp2: abstract new (...args: any[]) => IPerceptionTimestamp2;
+
+  interface IPerceptionTimestampHelperStatics {
+    FromHistoricalTargetTime(targetTime: Windows.Foundation.DateTime): Windows.Perception.PerceptionTimestamp;
+  }
+  var IPerceptionTimestampHelperStatics: abstract new (...args: any[]) => IPerceptionTimestampHelperStatics;
+
+  interface IPerceptionTimestampHelperStatics2 {
+    FromSystemRelativeTargetTime(targetTime: Windows.Foundation.TimeSpan): Windows.Perception.PerceptionTimestamp;
+  }
+  var IPerceptionTimestampHelperStatics2: abstract new (...args: any[]) => IPerceptionTimestampHelperStatics2;
+
+}
+
+declare namespace Windows.Perception.Automation.Core {
+  class CorePerceptionAutomation {
+    static SetActivationFactoryProvider(provider: Windows.Foundation.IGetActivationFactory): void;
+  }
+
+  interface ICorePerceptionAutomationStatics {
+    SetActivationFactoryProvider(provider: Windows.Foundation.IGetActivationFactory): void;
+  }
+  var ICorePerceptionAutomationStatics: abstract new (...args: any[]) => ICorePerceptionAutomationStatics;
+
+  interface PerceptionAutomationCoreContract {
+  }
+  var PerceptionAutomationCoreContract: {
+    new(fields: {  }): PerceptionAutomationCoreContract;
+  };
+
+}
+
+declare namespace Windows.Perception.People {
+  class EyesPose implements Windows.Perception.People.IEyesPose {
+    static IsSupported(): boolean;
+    static RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly Gaze: Windows.Perception.Spatial.SpatialRay | null;
+    readonly IsCalibrationValid: boolean;
+    readonly UpdateTimestamp: Windows.Perception.PerceptionTimestamp;
+  }
+
+  class HandMeshObserver implements Windows.Perception.People.IHandMeshObserver {
+    GetTriangleIndices(indices: number[]): void;
+    GetVertexStateForPose(handPose: Windows.Perception.People.HandPose): Windows.Perception.People.HandMeshVertexState;
+    readonly ModelId: number;
+    readonly NeutralPose: Windows.Perception.People.HandPose;
+    readonly NeutralPoseVersion: number;
+    readonly Source: Windows.UI.Input.Spatial.SpatialInteractionSource;
+    readonly TriangleIndexCount: number;
+    readonly VertexCount: number;
+  }
+
+  class HandMeshVertexState implements Windows.Perception.People.IHandMeshVertexState {
+    GetVertices(vertices: Windows.Perception.People.HandMeshVertex[]): void;
+    readonly CoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem;
+    readonly UpdateTimestamp: Windows.Perception.PerceptionTimestamp;
+  }
+
+  class HandPose implements Windows.Perception.People.IHandPose {
+    GetRelativeJoint(joint: number, referenceJoint: number): Windows.Perception.People.JointPose;
+    GetRelativeJoints(joints: number[], referenceJoints: number[], jointPoses: Windows.Perception.People.JointPose[]): void;
+    TryGetJoint(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, joint: number, jointPose: Windows.Perception.People.JointPose): boolean;
+    TryGetJoints(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, joints: number[], jointPoses: Windows.Perception.People.JointPose[]): boolean;
+  }
+
+  class HeadPose implements Windows.Perception.People.IHeadPose {
+    readonly ForwardDirection: Windows.Foundation.Numerics.Vector3;
+    readonly Position: Windows.Foundation.Numerics.Vector3;
+    readonly UpDirection: Windows.Foundation.Numerics.Vector3;
+  }
+
+  enum HandJointKind {
+    Palm = 0,
+    Wrist = 1,
+    ThumbMetacarpal = 2,
+    ThumbProximal = 3,
+    ThumbDistal = 4,
+    ThumbTip = 5,
+    IndexMetacarpal = 6,
+    IndexProximal = 7,
+    IndexIntermediate = 8,
+    IndexDistal = 9,
+    IndexTip = 10,
+    MiddleMetacarpal = 11,
+    MiddleProximal = 12,
+    MiddleIntermediate = 13,
+    MiddleDistal = 14,
+    MiddleTip = 15,
+    RingMetacarpal = 16,
+    RingProximal = 17,
+    RingIntermediate = 18,
+    RingDistal = 19,
+    RingTip = 20,
+    LittleMetacarpal = 21,
+    LittleProximal = 22,
+    LittleIntermediate = 23,
+    LittleDistal = 24,
+    LittleTip = 25,
+  }
+
+  enum JointPoseAccuracy {
+    High = 0,
+    Approximate = 1,
+  }
+
+  interface HandMeshVertex {
+    Position: Windows.Foundation.Numerics.Vector3;
+    Normal: Windows.Foundation.Numerics.Vector3;
+  }
+  var HandMeshVertex: {
+    new(position: Windows.Foundation.Numerics.Vector3, normal: Windows.Foundation.Numerics.Vector3): HandMeshVertex;
+    new(fields: { Position?: Windows.Foundation.Numerics.Vector3; Normal?: Windows.Foundation.Numerics.Vector3 }): HandMeshVertex;
+  };
+
+  interface IEyesPose {
+    readonly Gaze: Windows.Perception.Spatial.SpatialRay | null;
+    readonly IsCalibrationValid: boolean;
+    readonly UpdateTimestamp: Windows.Perception.PerceptionTimestamp;
+  }
+  var IEyesPose: abstract new (...args: any[]) => IEyesPose;
+
+  interface IEyesPoseStatics {
+    IsSupported(): boolean;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IEyesPoseStatics: abstract new (...args: any[]) => IEyesPoseStatics;
+
+  interface IHandMeshObserver {
+    GetTriangleIndices(indices: number[]): void;
+    GetVertexStateForPose(handPose: Windows.Perception.People.HandPose): Windows.Perception.People.HandMeshVertexState;
+    readonly ModelId: number;
+    readonly NeutralPose: Windows.Perception.People.HandPose;
+    readonly NeutralPoseVersion: number;
+    readonly Source: Windows.UI.Input.Spatial.SpatialInteractionSource;
+    readonly TriangleIndexCount: number;
+    readonly VertexCount: number;
+  }
+  var IHandMeshObserver: abstract new (...args: any[]) => IHandMeshObserver;
+
+  interface IHandMeshVertexState {
+    GetVertices(vertices: Windows.Perception.People.HandMeshVertex[]): void;
+    readonly CoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem;
+    readonly UpdateTimestamp: Windows.Perception.PerceptionTimestamp;
+  }
+  var IHandMeshVertexState: abstract new (...args: any[]) => IHandMeshVertexState;
+
+  interface IHandPose {
+    GetRelativeJoint(joint: number, referenceJoint: number): Windows.Perception.People.JointPose;
+    GetRelativeJoints(joints: number[], referenceJoints: number[], jointPoses: Windows.Perception.People.JointPose[]): void;
+    TryGetJoint(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, joint: number, jointPose: Windows.Perception.People.JointPose): boolean;
+    TryGetJoints(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, joints: number[], jointPoses: Windows.Perception.People.JointPose[]): boolean;
+  }
+  var IHandPose: abstract new (...args: any[]) => IHandPose;
+
+  interface IHeadPose {
+    readonly ForwardDirection: Windows.Foundation.Numerics.Vector3;
+    readonly Position: Windows.Foundation.Numerics.Vector3;
+    readonly UpDirection: Windows.Foundation.Numerics.Vector3;
+  }
+  var IHeadPose: abstract new (...args: any[]) => IHeadPose;
+
+  interface JointPose {
+    Orientation: Windows.Foundation.Numerics.Quaternion;
+    Position: Windows.Foundation.Numerics.Vector3;
+    Radius: number;
+    Accuracy: number;
+  }
+  var JointPose: {
+    new(orientation: Windows.Foundation.Numerics.Quaternion, position: Windows.Foundation.Numerics.Vector3, radius: number, accuracy: number): JointPose;
+    new(fields: { Orientation?: Windows.Foundation.Numerics.Quaternion; Position?: Windows.Foundation.Numerics.Vector3; Radius?: number; Accuracy?: number }): JointPose;
+  };
+
+}
+
+declare namespace Windows.Perception.Spatial {
+  class SpatialAnchor implements Windows.Perception.Spatial.ISpatialAnchor, Windows.Perception.Spatial.ISpatialAnchor2 {
+    static TryCreateRelativeTo(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Perception.Spatial.SpatialAnchor;
+    static TryCreateRelativeTo(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, position: Windows.Foundation.Numerics.Vector3): Windows.Perception.Spatial.SpatialAnchor;
+    static TryCreateRelativeTo(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, position: Windows.Foundation.Numerics.Vector3, orientation: Windows.Foundation.Numerics.Quaternion): Windows.Perception.Spatial.SpatialAnchor;
+    readonly CoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem;
+    readonly RawCoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem;
+    readonly RemovedByUser: boolean;
+    RawCoordinateSystemAdjusted: Windows.Foundation.TypedEventHandler<Windows.Perception.Spatial.SpatialAnchor, Windows.Perception.Spatial.SpatialAnchorRawCoordinateSystemAdjustedEventArgs> | null;
+  }
+
+  class SpatialAnchorExportSufficiency implements Windows.Perception.Spatial.ISpatialAnchorExportSufficiency {
+    readonly IsMinimallySufficient: boolean;
+    readonly RecommendedSufficiencyLevel: number;
+    readonly SufficiencyLevel: number;
+  }
+
+  class SpatialAnchorExporter implements Windows.Perception.Spatial.ISpatialAnchorExporter {
+    GetAnchorExportSufficiencyAsync(anchor: Windows.Perception.Spatial.SpatialAnchor, purpose: number): Windows.Foundation.IAsyncOperation<Windows.Perception.Spatial.SpatialAnchorExportSufficiency>;
+    static GetDefault(): Windows.Perception.Spatial.SpatialAnchorExporter;
+    static RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    TryExportAnchorAsync(anchor: Windows.Perception.Spatial.SpatialAnchor, purpose: number, stream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+
+  class SpatialAnchorManager {
+    static RequestStoreAsync(): Windows.Foundation.IAsyncOperation<Windows.Perception.Spatial.SpatialAnchorStore>;
+  }
+
+  class SpatialAnchorRawCoordinateSystemAdjustedEventArgs implements Windows.Perception.Spatial.ISpatialAnchorRawCoordinateSystemAdjustedEventArgs {
+    readonly OldRawCoordinateSystemToNewRawCoordinateSystemTransform: Windows.Foundation.Numerics.Matrix4x4;
+  }
+
+  class SpatialAnchorStore implements Windows.Perception.Spatial.ISpatialAnchorStore {
+    Clear(): void;
+    GetAllSavedAnchors(): Windows.Foundation.Collections.IMapView<string, Windows.Perception.Spatial.SpatialAnchor>;
+    Remove(id: string): void;
+    TrySave(id: string, anchor: Windows.Perception.Spatial.SpatialAnchor): boolean;
+  }
+
+  class SpatialAnchorTransferManager {
+    static RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    static TryExportAnchorsAsync(anchors: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Perception.Spatial.SpatialAnchor>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Perception.Spatial.SpatialAnchor>[], stream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperation<boolean>;
+    static TryImportAnchorsAsync(stream: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<string, Windows.Perception.Spatial.SpatialAnchor>>;
+  }
+
+  class SpatialBoundingVolume implements Windows.Perception.Spatial.ISpatialBoundingVolume {
+    static FromBox(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, box: Windows.Perception.Spatial.SpatialBoundingBox): Windows.Perception.Spatial.SpatialBoundingVolume;
+    static FromFrustum(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, frustum: Windows.Perception.Spatial.SpatialBoundingFrustum): Windows.Perception.Spatial.SpatialBoundingVolume;
+    static FromOrientedBox(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, box: Windows.Perception.Spatial.SpatialBoundingOrientedBox): Windows.Perception.Spatial.SpatialBoundingVolume;
+    static FromSphere(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, sphere: Windows.Perception.Spatial.SpatialBoundingSphere): Windows.Perception.Spatial.SpatialBoundingVolume;
+  }
+
+  class SpatialCoordinateSystem implements Windows.Perception.Spatial.ISpatialCoordinateSystem {
+    TryGetTransformTo(target: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Foundation.Numerics.Matrix4x4 | null;
+  }
+
+  class SpatialEntity implements Windows.Perception.Spatial.ISpatialEntity {
+    constructor(spatialAnchor: Windows.Perception.Spatial.SpatialAnchor);
+    constructor(spatialAnchor: Windows.Perception.Spatial.SpatialAnchor, propertySet: Windows.Foundation.Collections.ValueSet);
+    readonly Anchor: Windows.Perception.Spatial.SpatialAnchor;
+    readonly Id: string;
+    readonly Properties: Windows.Foundation.Collections.ValueSet;
+  }
+
+  class SpatialEntityAddedEventArgs implements Windows.Perception.Spatial.ISpatialEntityAddedEventArgs {
+    readonly Entity: Windows.Perception.Spatial.SpatialEntity;
+  }
+
+  class SpatialEntityRemovedEventArgs implements Windows.Perception.Spatial.ISpatialEntityRemovedEventArgs {
+    readonly Entity: Windows.Perception.Spatial.SpatialEntity;
+  }
+
+  class SpatialEntityStore implements Windows.Perception.Spatial.ISpatialEntityStore {
+    CreateEntityWatcher(): Windows.Perception.Spatial.SpatialEntityWatcher;
+    RemoveAsync(entity: Windows.Perception.Spatial.SpatialEntity): Windows.Foundation.IAsyncAction;
+    SaveAsync(entity: Windows.Perception.Spatial.SpatialEntity): Windows.Foundation.IAsyncAction;
+    static TryGet(session: Windows.System.RemoteSystems.RemoteSystemSession): Windows.Perception.Spatial.SpatialEntityStore;
+    static readonly IsSupported: boolean;
+  }
+
+  class SpatialEntityUpdatedEventArgs implements Windows.Perception.Spatial.ISpatialEntityUpdatedEventArgs {
+    readonly Entity: Windows.Perception.Spatial.SpatialEntity;
+  }
+
+  class SpatialEntityWatcher implements Windows.Perception.Spatial.ISpatialEntityWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.Perception.Spatial.SpatialEntityWatcher, Windows.Perception.Spatial.SpatialEntityAddedEventArgs> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Perception.Spatial.SpatialEntityWatcher, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.Perception.Spatial.SpatialEntityWatcher, Windows.Perception.Spatial.SpatialEntityRemovedEventArgs> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.Perception.Spatial.SpatialEntityWatcher, Windows.Perception.Spatial.SpatialEntityUpdatedEventArgs> | null;
+  }
+
+  class SpatialLocation implements Windows.Perception.Spatial.ISpatialLocation, Windows.Perception.Spatial.ISpatialLocation2 {
+    readonly AbsoluteAngularAcceleration: Windows.Foundation.Numerics.Quaternion;
+    readonly AbsoluteAngularAccelerationAxisAngle: Windows.Foundation.Numerics.Vector3;
+    readonly AbsoluteAngularVelocity: Windows.Foundation.Numerics.Quaternion;
+    readonly AbsoluteAngularVelocityAxisAngle: Windows.Foundation.Numerics.Vector3;
+    readonly AbsoluteLinearAcceleration: Windows.Foundation.Numerics.Vector3;
+    readonly AbsoluteLinearVelocity: Windows.Foundation.Numerics.Vector3;
+    readonly Orientation: Windows.Foundation.Numerics.Quaternion;
+    readonly Position: Windows.Foundation.Numerics.Vector3;
+  }
+
+  class SpatialLocator implements Windows.Perception.Spatial.ISpatialLocator {
+    CreateAttachedFrameOfReferenceAtCurrentHeading(): Windows.Perception.Spatial.SpatialLocatorAttachedFrameOfReference;
+    CreateAttachedFrameOfReferenceAtCurrentHeading(relativePosition: Windows.Foundation.Numerics.Vector3): Windows.Perception.Spatial.SpatialLocatorAttachedFrameOfReference;
+    CreateAttachedFrameOfReferenceAtCurrentHeading(relativePosition: Windows.Foundation.Numerics.Vector3, relativeOrientation: Windows.Foundation.Numerics.Quaternion): Windows.Perception.Spatial.SpatialLocatorAttachedFrameOfReference;
+    CreateAttachedFrameOfReferenceAtCurrentHeading(relativePosition: Windows.Foundation.Numerics.Vector3, relativeOrientation: Windows.Foundation.Numerics.Quaternion, relativeHeadingInRadians: number): Windows.Perception.Spatial.SpatialLocatorAttachedFrameOfReference;
+    CreateStationaryFrameOfReferenceAtCurrentLocation(): Windows.Perception.Spatial.SpatialStationaryFrameOfReference;
+    CreateStationaryFrameOfReferenceAtCurrentLocation(relativePosition: Windows.Foundation.Numerics.Vector3): Windows.Perception.Spatial.SpatialStationaryFrameOfReference;
+    CreateStationaryFrameOfReferenceAtCurrentLocation(relativePosition: Windows.Foundation.Numerics.Vector3, relativeOrientation: Windows.Foundation.Numerics.Quaternion): Windows.Perception.Spatial.SpatialStationaryFrameOfReference;
+    CreateStationaryFrameOfReferenceAtCurrentLocation(relativePosition: Windows.Foundation.Numerics.Vector3, relativeOrientation: Windows.Foundation.Numerics.Quaternion, relativeHeadingInRadians: number): Windows.Perception.Spatial.SpatialStationaryFrameOfReference;
+    static GetDefault(): Windows.Perception.Spatial.SpatialLocator;
+    TryLocateAtTimestamp(timestamp: Windows.Perception.PerceptionTimestamp, coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Perception.Spatial.SpatialLocation;
+    readonly Locatability: number;
+    LocatabilityChanged: Windows.Foundation.TypedEventHandler<Windows.Perception.Spatial.SpatialLocator, Object> | null;
+    PositionalTrackingDeactivating: Windows.Foundation.TypedEventHandler<Windows.Perception.Spatial.SpatialLocator, Windows.Perception.Spatial.SpatialLocatorPositionalTrackingDeactivatingEventArgs> | null;
+  }
+
+  class SpatialLocatorAttachedFrameOfReference implements Windows.Perception.Spatial.ISpatialLocatorAttachedFrameOfReference {
+    AdjustHeading(headingOffsetInRadians: number): void;
+    GetStationaryCoordinateSystemAtTimestamp(timestamp: Windows.Perception.PerceptionTimestamp): Windows.Perception.Spatial.SpatialCoordinateSystem;
+    TryGetRelativeHeadingAtTimestamp(timestamp: Windows.Perception.PerceptionTimestamp): number | null;
+    RelativeOrientation: Windows.Foundation.Numerics.Quaternion;
+    RelativePosition: Windows.Foundation.Numerics.Vector3;
+  }
+
+  class SpatialLocatorPositionalTrackingDeactivatingEventArgs implements Windows.Perception.Spatial.ISpatialLocatorPositionalTrackingDeactivatingEventArgs {
+    Canceled: boolean;
+  }
+
+  class SpatialStageFrameOfReference implements Windows.Perception.Spatial.ISpatialStageFrameOfReference {
+    GetCoordinateSystemAtCurrentLocation(locator: Windows.Perception.Spatial.SpatialLocator): Windows.Perception.Spatial.SpatialCoordinateSystem;
+    static RequestNewStageAsync(): Windows.Foundation.IAsyncOperation<Windows.Perception.Spatial.SpatialStageFrameOfReference>;
+    TryGetMovementBounds(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Foundation.Numerics.Vector3[];
+    readonly CoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem;
+    static readonly Current: Windows.Perception.Spatial.SpatialStageFrameOfReference;
+    readonly LookDirectionRange: number;
+    readonly MovementRange: number;
+    static CurrentChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class SpatialStationaryFrameOfReference implements Windows.Perception.Spatial.ISpatialStationaryFrameOfReference {
+    readonly CoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem;
+  }
+
+  enum SpatialAnchorExportPurpose {
+    Relocalization = 0,
+    Sharing = 1,
+  }
+
+  enum SpatialEntityWatcherStatus {
+    Created = 0,
+    Started = 1,
+    EnumerationCompleted = 2,
+    Stopping = 3,
+    Stopped = 4,
+    Aborted = 5,
+  }
+
+  enum SpatialLocatability {
+    Unavailable = 0,
+    OrientationOnly = 1,
+    PositionalTrackingActivating = 2,
+    PositionalTrackingActive = 3,
+    PositionalTrackingInhibited = 4,
+  }
+
+  enum SpatialLookDirectionRange {
+    ForwardOnly = 0,
+    Omnidirectional = 1,
+  }
+
+  enum SpatialMovementRange {
+    NoMovement = 0,
+    Bounded = 1,
+  }
+
+  enum SpatialPerceptionAccessStatus {
+    Unspecified = 0,
+    Allowed = 1,
+    DeniedByUser = 2,
+    DeniedBySystem = 3,
+  }
+
+  interface ISpatialAnchor {
+    readonly CoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem;
+    readonly RawCoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem;
+    RawCoordinateSystemAdjusted: Windows.Foundation.TypedEventHandler<Windows.Perception.Spatial.SpatialAnchor, Windows.Perception.Spatial.SpatialAnchorRawCoordinateSystemAdjustedEventArgs> | null;
+  }
+  var ISpatialAnchor: abstract new (...args: any[]) => ISpatialAnchor;
+
+  interface ISpatialAnchor2 {
+    readonly RemovedByUser: boolean;
+  }
+  var ISpatialAnchor2: abstract new (...args: any[]) => ISpatialAnchor2;
+
+  interface ISpatialAnchorExportSufficiency {
+    readonly IsMinimallySufficient: boolean;
+    readonly RecommendedSufficiencyLevel: number;
+    readonly SufficiencyLevel: number;
+  }
+  var ISpatialAnchorExportSufficiency: abstract new (...args: any[]) => ISpatialAnchorExportSufficiency;
+
+  interface ISpatialAnchorExporter {
+    GetAnchorExportSufficiencyAsync(anchor: Windows.Perception.Spatial.SpatialAnchor, purpose: number): Windows.Foundation.IAsyncOperation<Windows.Perception.Spatial.SpatialAnchorExportSufficiency>;
+    TryExportAnchorAsync(anchor: Windows.Perception.Spatial.SpatialAnchor, purpose: number, stream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var ISpatialAnchorExporter: abstract new (...args: any[]) => ISpatialAnchorExporter;
+
+  interface ISpatialAnchorExporterStatics {
+    GetDefault(): Windows.Perception.Spatial.SpatialAnchorExporter;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var ISpatialAnchorExporterStatics: abstract new (...args: any[]) => ISpatialAnchorExporterStatics;
+
+  interface ISpatialAnchorManagerStatics {
+    RequestStoreAsync(): Windows.Foundation.IAsyncOperation<Windows.Perception.Spatial.SpatialAnchorStore>;
+  }
+  var ISpatialAnchorManagerStatics: abstract new (...args: any[]) => ISpatialAnchorManagerStatics;
+
+  interface ISpatialAnchorRawCoordinateSystemAdjustedEventArgs {
+    readonly OldRawCoordinateSystemToNewRawCoordinateSystemTransform: Windows.Foundation.Numerics.Matrix4x4;
+  }
+  var ISpatialAnchorRawCoordinateSystemAdjustedEventArgs: abstract new (...args: any[]) => ISpatialAnchorRawCoordinateSystemAdjustedEventArgs;
+
+  interface ISpatialAnchorStatics {
+    TryCreateRelativeTo(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Perception.Spatial.SpatialAnchor;
+    TryCreateRelativeTo(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, position: Windows.Foundation.Numerics.Vector3): Windows.Perception.Spatial.SpatialAnchor;
+    TryCreateRelativeTo(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, position: Windows.Foundation.Numerics.Vector3, orientation: Windows.Foundation.Numerics.Quaternion): Windows.Perception.Spatial.SpatialAnchor;
+  }
+  var ISpatialAnchorStatics: abstract new (...args: any[]) => ISpatialAnchorStatics;
+
+  interface ISpatialAnchorStore {
+    Clear(): void;
+    GetAllSavedAnchors(): Windows.Foundation.Collections.IMapView<string, Windows.Perception.Spatial.SpatialAnchor>;
+    Remove(id: string): void;
+    TrySave(id: string, anchor: Windows.Perception.Spatial.SpatialAnchor): boolean;
+  }
+  var ISpatialAnchorStore: abstract new (...args: any[]) => ISpatialAnchorStore;
+
+  interface ISpatialAnchorTransferManagerStatics {
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    TryExportAnchorsAsync(anchors: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Perception.Spatial.SpatialAnchor>> | Windows.Foundation.Collections.IKeyValuePair<string, Windows.Perception.Spatial.SpatialAnchor>[], stream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperation<boolean>;
+    TryImportAnchorsAsync(stream: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<string, Windows.Perception.Spatial.SpatialAnchor>>;
+  }
+  var ISpatialAnchorTransferManagerStatics: abstract new (...args: any[]) => ISpatialAnchorTransferManagerStatics;
+
+  interface ISpatialBoundingVolume {
+  }
+  var ISpatialBoundingVolume: abstract new (...args: any[]) => ISpatialBoundingVolume;
+
+  interface ISpatialBoundingVolumeStatics {
+    FromBox(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, box: Windows.Perception.Spatial.SpatialBoundingBox): Windows.Perception.Spatial.SpatialBoundingVolume;
+    FromFrustum(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, frustum: Windows.Perception.Spatial.SpatialBoundingFrustum): Windows.Perception.Spatial.SpatialBoundingVolume;
+    FromOrientedBox(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, box: Windows.Perception.Spatial.SpatialBoundingOrientedBox): Windows.Perception.Spatial.SpatialBoundingVolume;
+    FromSphere(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, sphere: Windows.Perception.Spatial.SpatialBoundingSphere): Windows.Perception.Spatial.SpatialBoundingVolume;
+  }
+  var ISpatialBoundingVolumeStatics: abstract new (...args: any[]) => ISpatialBoundingVolumeStatics;
+
+  interface ISpatialCoordinateSystem {
+    TryGetTransformTo(target: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Foundation.Numerics.Matrix4x4 | null;
+  }
+  var ISpatialCoordinateSystem: abstract new (...args: any[]) => ISpatialCoordinateSystem;
+
+  interface ISpatialEntity {
+    readonly Anchor: Windows.Perception.Spatial.SpatialAnchor;
+    readonly Id: string;
+    readonly Properties: Windows.Foundation.Collections.ValueSet;
+  }
+  var ISpatialEntity: abstract new (...args: any[]) => ISpatialEntity;
+
+  interface ISpatialEntityAddedEventArgs {
+    readonly Entity: Windows.Perception.Spatial.SpatialEntity;
+  }
+  var ISpatialEntityAddedEventArgs: abstract new (...args: any[]) => ISpatialEntityAddedEventArgs;
+
+  interface ISpatialEntityFactory {
+    CreateWithSpatialAnchor(spatialAnchor: Windows.Perception.Spatial.SpatialAnchor): Windows.Perception.Spatial.SpatialEntity;
+    CreateWithSpatialAnchorAndProperties(spatialAnchor: Windows.Perception.Spatial.SpatialAnchor, propertySet: Windows.Foundation.Collections.ValueSet): Windows.Perception.Spatial.SpatialEntity;
+  }
+  var ISpatialEntityFactory: abstract new (...args: any[]) => ISpatialEntityFactory;
+
+  interface ISpatialEntityRemovedEventArgs {
+    readonly Entity: Windows.Perception.Spatial.SpatialEntity;
+  }
+  var ISpatialEntityRemovedEventArgs: abstract new (...args: any[]) => ISpatialEntityRemovedEventArgs;
+
+  interface ISpatialEntityStore {
+    CreateEntityWatcher(): Windows.Perception.Spatial.SpatialEntityWatcher;
+    RemoveAsync(entity: Windows.Perception.Spatial.SpatialEntity): Windows.Foundation.IAsyncAction;
+    SaveAsync(entity: Windows.Perception.Spatial.SpatialEntity): Windows.Foundation.IAsyncAction;
+  }
+  var ISpatialEntityStore: abstract new (...args: any[]) => ISpatialEntityStore;
+
+  interface ISpatialEntityStoreStatics {
+    TryGet(session: Windows.System.RemoteSystems.RemoteSystemSession): Windows.Perception.Spatial.SpatialEntityStore;
+    readonly IsSupported: boolean;
+  }
+  var ISpatialEntityStoreStatics: abstract new (...args: any[]) => ISpatialEntityStoreStatics;
+
+  interface ISpatialEntityUpdatedEventArgs {
+    readonly Entity: Windows.Perception.Spatial.SpatialEntity;
+  }
+  var ISpatialEntityUpdatedEventArgs: abstract new (...args: any[]) => ISpatialEntityUpdatedEventArgs;
+
+  interface ISpatialEntityWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.Perception.Spatial.SpatialEntityWatcher, Windows.Perception.Spatial.SpatialEntityAddedEventArgs> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.Perception.Spatial.SpatialEntityWatcher, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.Perception.Spatial.SpatialEntityWatcher, Windows.Perception.Spatial.SpatialEntityRemovedEventArgs> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.Perception.Spatial.SpatialEntityWatcher, Windows.Perception.Spatial.SpatialEntityUpdatedEventArgs> | null;
+  }
+  var ISpatialEntityWatcher: abstract new (...args: any[]) => ISpatialEntityWatcher;
+
+  interface ISpatialLocation {
+    readonly AbsoluteAngularAcceleration: Windows.Foundation.Numerics.Quaternion;
+    readonly AbsoluteAngularVelocity: Windows.Foundation.Numerics.Quaternion;
+    readonly AbsoluteLinearAcceleration: Windows.Foundation.Numerics.Vector3;
+    readonly AbsoluteLinearVelocity: Windows.Foundation.Numerics.Vector3;
+    readonly Orientation: Windows.Foundation.Numerics.Quaternion;
+    readonly Position: Windows.Foundation.Numerics.Vector3;
+  }
+  var ISpatialLocation: abstract new (...args: any[]) => ISpatialLocation;
+
+  interface ISpatialLocation2 {
+    readonly AbsoluteAngularAccelerationAxisAngle: Windows.Foundation.Numerics.Vector3;
+    readonly AbsoluteAngularVelocityAxisAngle: Windows.Foundation.Numerics.Vector3;
+  }
+  var ISpatialLocation2: abstract new (...args: any[]) => ISpatialLocation2;
+
+  interface ISpatialLocator {
+    CreateAttachedFrameOfReferenceAtCurrentHeading(): Windows.Perception.Spatial.SpatialLocatorAttachedFrameOfReference;
+    CreateAttachedFrameOfReferenceAtCurrentHeading(relativePosition: Windows.Foundation.Numerics.Vector3): Windows.Perception.Spatial.SpatialLocatorAttachedFrameOfReference;
+    CreateAttachedFrameOfReferenceAtCurrentHeading(relativePosition: Windows.Foundation.Numerics.Vector3, relativeOrientation: Windows.Foundation.Numerics.Quaternion): Windows.Perception.Spatial.SpatialLocatorAttachedFrameOfReference;
+    CreateAttachedFrameOfReferenceAtCurrentHeading(relativePosition: Windows.Foundation.Numerics.Vector3, relativeOrientation: Windows.Foundation.Numerics.Quaternion, relativeHeadingInRadians: number): Windows.Perception.Spatial.SpatialLocatorAttachedFrameOfReference;
+    CreateStationaryFrameOfReferenceAtCurrentLocation(): Windows.Perception.Spatial.SpatialStationaryFrameOfReference;
+    CreateStationaryFrameOfReferenceAtCurrentLocation(relativePosition: Windows.Foundation.Numerics.Vector3): Windows.Perception.Spatial.SpatialStationaryFrameOfReference;
+    CreateStationaryFrameOfReferenceAtCurrentLocation(relativePosition: Windows.Foundation.Numerics.Vector3, relativeOrientation: Windows.Foundation.Numerics.Quaternion): Windows.Perception.Spatial.SpatialStationaryFrameOfReference;
+    CreateStationaryFrameOfReferenceAtCurrentLocation(relativePosition: Windows.Foundation.Numerics.Vector3, relativeOrientation: Windows.Foundation.Numerics.Quaternion, relativeHeadingInRadians: number): Windows.Perception.Spatial.SpatialStationaryFrameOfReference;
+    TryLocateAtTimestamp(timestamp: Windows.Perception.PerceptionTimestamp, coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Perception.Spatial.SpatialLocation;
+    readonly Locatability: number;
+    LocatabilityChanged: Windows.Foundation.TypedEventHandler<Windows.Perception.Spatial.SpatialLocator, Object> | null;
+    PositionalTrackingDeactivating: Windows.Foundation.TypedEventHandler<Windows.Perception.Spatial.SpatialLocator, Windows.Perception.Spatial.SpatialLocatorPositionalTrackingDeactivatingEventArgs> | null;
+  }
+  var ISpatialLocator: abstract new (...args: any[]) => ISpatialLocator;
+
+  interface ISpatialLocatorAttachedFrameOfReference {
+    AdjustHeading(headingOffsetInRadians: number): void;
+    GetStationaryCoordinateSystemAtTimestamp(timestamp: Windows.Perception.PerceptionTimestamp): Windows.Perception.Spatial.SpatialCoordinateSystem;
+    TryGetRelativeHeadingAtTimestamp(timestamp: Windows.Perception.PerceptionTimestamp): number | null;
+    RelativeOrientation: Windows.Foundation.Numerics.Quaternion;
+    RelativePosition: Windows.Foundation.Numerics.Vector3;
+  }
+  var ISpatialLocatorAttachedFrameOfReference: abstract new (...args: any[]) => ISpatialLocatorAttachedFrameOfReference;
+
+  interface ISpatialLocatorPositionalTrackingDeactivatingEventArgs {
+    Canceled: boolean;
+  }
+  var ISpatialLocatorPositionalTrackingDeactivatingEventArgs: abstract new (...args: any[]) => ISpatialLocatorPositionalTrackingDeactivatingEventArgs;
+
+  interface ISpatialLocatorStatics {
+    GetDefault(): Windows.Perception.Spatial.SpatialLocator;
+  }
+  var ISpatialLocatorStatics: abstract new (...args: any[]) => ISpatialLocatorStatics;
+
+  interface ISpatialStageFrameOfReference {
+    GetCoordinateSystemAtCurrentLocation(locator: Windows.Perception.Spatial.SpatialLocator): Windows.Perception.Spatial.SpatialCoordinateSystem;
+    TryGetMovementBounds(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Foundation.Numerics.Vector3[];
+    readonly CoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem;
+    readonly LookDirectionRange: number;
+    readonly MovementRange: number;
+  }
+  var ISpatialStageFrameOfReference: abstract new (...args: any[]) => ISpatialStageFrameOfReference;
+
+  interface ISpatialStageFrameOfReferenceStatics {
+    RequestNewStageAsync(): Windows.Foundation.IAsyncOperation<Windows.Perception.Spatial.SpatialStageFrameOfReference>;
+    readonly Current: Windows.Perception.Spatial.SpatialStageFrameOfReference;
+    CurrentChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var ISpatialStageFrameOfReferenceStatics: abstract new (...args: any[]) => ISpatialStageFrameOfReferenceStatics;
+
+  interface ISpatialStationaryFrameOfReference {
+    readonly CoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem;
+  }
+  var ISpatialStationaryFrameOfReference: abstract new (...args: any[]) => ISpatialStationaryFrameOfReference;
+
+  interface SpatialBoundingBox {
+    Center: Windows.Foundation.Numerics.Vector3;
+    Extents: Windows.Foundation.Numerics.Vector3;
+  }
+  var SpatialBoundingBox: {
+    new(center: Windows.Foundation.Numerics.Vector3, extents: Windows.Foundation.Numerics.Vector3): SpatialBoundingBox;
+    new(fields: { Center?: Windows.Foundation.Numerics.Vector3; Extents?: Windows.Foundation.Numerics.Vector3 }): SpatialBoundingBox;
+  };
+
+  interface SpatialBoundingFrustum {
+    Near: Windows.Foundation.Numerics.Plane;
+    Far: Windows.Foundation.Numerics.Plane;
+    Right: Windows.Foundation.Numerics.Plane;
+    Left: Windows.Foundation.Numerics.Plane;
+    Top: Windows.Foundation.Numerics.Plane;
+    Bottom: Windows.Foundation.Numerics.Plane;
+  }
+  var SpatialBoundingFrustum: {
+    new(near: Windows.Foundation.Numerics.Plane, far: Windows.Foundation.Numerics.Plane, right: Windows.Foundation.Numerics.Plane, left: Windows.Foundation.Numerics.Plane, top: Windows.Foundation.Numerics.Plane, bottom: Windows.Foundation.Numerics.Plane): SpatialBoundingFrustum;
+    new(fields: { Near?: Windows.Foundation.Numerics.Plane; Far?: Windows.Foundation.Numerics.Plane; Right?: Windows.Foundation.Numerics.Plane; Left?: Windows.Foundation.Numerics.Plane; Top?: Windows.Foundation.Numerics.Plane; Bottom?: Windows.Foundation.Numerics.Plane }): SpatialBoundingFrustum;
+  };
+
+  interface SpatialBoundingOrientedBox {
+    Center: Windows.Foundation.Numerics.Vector3;
+    Extents: Windows.Foundation.Numerics.Vector3;
+    Orientation: Windows.Foundation.Numerics.Quaternion;
+  }
+  var SpatialBoundingOrientedBox: {
+    new(center: Windows.Foundation.Numerics.Vector3, extents: Windows.Foundation.Numerics.Vector3, orientation: Windows.Foundation.Numerics.Quaternion): SpatialBoundingOrientedBox;
+    new(fields: { Center?: Windows.Foundation.Numerics.Vector3; Extents?: Windows.Foundation.Numerics.Vector3; Orientation?: Windows.Foundation.Numerics.Quaternion }): SpatialBoundingOrientedBox;
+  };
+
+  interface SpatialBoundingSphere {
+    Center: Windows.Foundation.Numerics.Vector3;
+    Radius: number;
+  }
+  var SpatialBoundingSphere: {
+    new(center: Windows.Foundation.Numerics.Vector3, radius: number): SpatialBoundingSphere;
+    new(fields: { Center?: Windows.Foundation.Numerics.Vector3; Radius?: number }): SpatialBoundingSphere;
+  };
+
+  interface SpatialRay {
+    Origin: Windows.Foundation.Numerics.Vector3;
+    Direction: Windows.Foundation.Numerics.Vector3;
+  }
+  var SpatialRay: {
+    new(origin: Windows.Foundation.Numerics.Vector3, direction: Windows.Foundation.Numerics.Vector3): SpatialRay;
+    new(fields: { Origin?: Windows.Foundation.Numerics.Vector3; Direction?: Windows.Foundation.Numerics.Vector3 }): SpatialRay;
+  };
+
+}
+
+declare namespace Windows.Perception.Spatial.Preview {
+  class SpatialGraphInteropFrameOfReferencePreview implements Windows.Perception.Spatial.Preview.ISpatialGraphInteropFrameOfReferencePreview {
+    readonly CoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem;
+    readonly CoordinateSystemToNodeTransform: Windows.Foundation.Numerics.Matrix4x4;
+    readonly NodeId: Guid;
+  }
+
+  class SpatialGraphInteropPreview {
+    static CreateCoordinateSystemForNode(nodeId: Guid): Windows.Perception.Spatial.SpatialCoordinateSystem;
+    static CreateCoordinateSystemForNode(nodeId: Guid, relativePosition: Windows.Foundation.Numerics.Vector3): Windows.Perception.Spatial.SpatialCoordinateSystem;
+    static CreateCoordinateSystemForNode(nodeId: Guid, relativePosition: Windows.Foundation.Numerics.Vector3, relativeOrientation: Windows.Foundation.Numerics.Quaternion): Windows.Perception.Spatial.SpatialCoordinateSystem;
+    static CreateLocatorForNode(nodeId: Guid): Windows.Perception.Spatial.SpatialLocator;
+    static TryCreateFrameOfReference(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Perception.Spatial.Preview.SpatialGraphInteropFrameOfReferencePreview;
+    static TryCreateFrameOfReference(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, relativePosition: Windows.Foundation.Numerics.Vector3): Windows.Perception.Spatial.Preview.SpatialGraphInteropFrameOfReferencePreview;
+    static TryCreateFrameOfReference(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, relativePosition: Windows.Foundation.Numerics.Vector3, relativeOrientation: Windows.Foundation.Numerics.Quaternion): Windows.Perception.Spatial.Preview.SpatialGraphInteropFrameOfReferencePreview;
+  }
+
+  interface ISpatialGraphInteropFrameOfReferencePreview {
+    readonly CoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem;
+    readonly CoordinateSystemToNodeTransform: Windows.Foundation.Numerics.Matrix4x4;
+    readonly NodeId: Guid;
+  }
+  var ISpatialGraphInteropFrameOfReferencePreview: abstract new (...args: any[]) => ISpatialGraphInteropFrameOfReferencePreview;
+
+  interface ISpatialGraphInteropPreviewStatics {
+    CreateCoordinateSystemForNode(nodeId: Guid): Windows.Perception.Spatial.SpatialCoordinateSystem;
+    CreateCoordinateSystemForNode(nodeId: Guid, relativePosition: Windows.Foundation.Numerics.Vector3): Windows.Perception.Spatial.SpatialCoordinateSystem;
+    CreateCoordinateSystemForNode(nodeId: Guid, relativePosition: Windows.Foundation.Numerics.Vector3, relativeOrientation: Windows.Foundation.Numerics.Quaternion): Windows.Perception.Spatial.SpatialCoordinateSystem;
+    CreateLocatorForNode(nodeId: Guid): Windows.Perception.Spatial.SpatialLocator;
+  }
+  var ISpatialGraphInteropPreviewStatics: abstract new (...args: any[]) => ISpatialGraphInteropPreviewStatics;
+
+  interface ISpatialGraphInteropPreviewStatics2 {
+    TryCreateFrameOfReference(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Perception.Spatial.Preview.SpatialGraphInteropFrameOfReferencePreview;
+    TryCreateFrameOfReference(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, relativePosition: Windows.Foundation.Numerics.Vector3): Windows.Perception.Spatial.Preview.SpatialGraphInteropFrameOfReferencePreview;
+    TryCreateFrameOfReference(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, relativePosition: Windows.Foundation.Numerics.Vector3, relativeOrientation: Windows.Foundation.Numerics.Quaternion): Windows.Perception.Spatial.Preview.SpatialGraphInteropFrameOfReferencePreview;
+  }
+  var ISpatialGraphInteropPreviewStatics2: abstract new (...args: any[]) => ISpatialGraphInteropPreviewStatics2;
+
+}
+
+declare namespace Windows.Perception.Spatial.Surfaces {
+  class SpatialSurfaceInfo implements Windows.Perception.Spatial.Surfaces.ISpatialSurfaceInfo {
+    TryComputeLatestMeshAsync(maxTrianglesPerCubicMeter: number): Windows.Foundation.IAsyncOperation<Windows.Perception.Spatial.Surfaces.SpatialSurfaceMesh>;
+    TryComputeLatestMeshAsync(maxTrianglesPerCubicMeter: number, options: Windows.Perception.Spatial.Surfaces.SpatialSurfaceMeshOptions): Windows.Foundation.IAsyncOperation<Windows.Perception.Spatial.Surfaces.SpatialSurfaceMesh>;
+    TryGetBounds(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Perception.Spatial.SpatialBoundingOrientedBox | null;
+    readonly Id: Guid;
+    readonly UpdateTime: Windows.Foundation.DateTime;
+  }
+
+  class SpatialSurfaceMesh implements Windows.Perception.Spatial.Surfaces.ISpatialSurfaceMesh {
+    readonly CoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem;
+    readonly SurfaceInfo: Windows.Perception.Spatial.Surfaces.SpatialSurfaceInfo;
+    readonly TriangleIndices: Windows.Perception.Spatial.Surfaces.SpatialSurfaceMeshBuffer;
+    readonly VertexNormals: Windows.Perception.Spatial.Surfaces.SpatialSurfaceMeshBuffer;
+    readonly VertexPositionScale: Windows.Foundation.Numerics.Vector3;
+    readonly VertexPositions: Windows.Perception.Spatial.Surfaces.SpatialSurfaceMeshBuffer;
+  }
+
+  class SpatialSurfaceMeshBuffer implements Windows.Perception.Spatial.Surfaces.ISpatialSurfaceMeshBuffer {
+    readonly Data: Windows.Storage.Streams.IBuffer;
+    readonly ElementCount: number;
+    readonly Format: number;
+    readonly Stride: number;
+  }
+
+  class SpatialSurfaceMeshOptions implements Windows.Perception.Spatial.Surfaces.ISpatialSurfaceMeshOptions {
+    constructor();
+    IncludeVertexNormals: boolean;
+    static readonly SupportedTriangleIndexFormats: Windows.Foundation.Collections.IVectorView<number> | number[];
+    static readonly SupportedVertexNormalFormats: Windows.Foundation.Collections.IVectorView<number> | number[];
+    static readonly SupportedVertexPositionFormats: Windows.Foundation.Collections.IVectorView<number> | number[];
+    TriangleIndexFormat: number;
+    VertexNormalFormat: number;
+    VertexPositionFormat: number;
+  }
+
+  class SpatialSurfaceObserver implements Windows.Perception.Spatial.Surfaces.ISpatialSurfaceObserver {
+    constructor();
+    GetObservedSurfaces(): Windows.Foundation.Collections.IMapView<Guid, Windows.Perception.Spatial.Surfaces.SpatialSurfaceInfo>;
+    static IsSupported(): boolean;
+    static RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    SetBoundingVolume(bounds: Windows.Perception.Spatial.SpatialBoundingVolume): void;
+    SetBoundingVolumes(bounds: Windows.Foundation.Collections.IIterable<Windows.Perception.Spatial.SpatialBoundingVolume> | Windows.Perception.Spatial.SpatialBoundingVolume[]): void;
+    ObservedSurfacesChanged: Windows.Foundation.TypedEventHandler<Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver, Object> | null;
+  }
+
+  interface ISpatialSurfaceInfo {
+    TryComputeLatestMeshAsync(maxTrianglesPerCubicMeter: number): Windows.Foundation.IAsyncOperation<Windows.Perception.Spatial.Surfaces.SpatialSurfaceMesh>;
+    TryComputeLatestMeshAsync(maxTrianglesPerCubicMeter: number, options: Windows.Perception.Spatial.Surfaces.SpatialSurfaceMeshOptions): Windows.Foundation.IAsyncOperation<Windows.Perception.Spatial.Surfaces.SpatialSurfaceMesh>;
+    TryGetBounds(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Perception.Spatial.SpatialBoundingOrientedBox | null;
+    readonly Id: Guid;
+    readonly UpdateTime: Windows.Foundation.DateTime;
+  }
+  var ISpatialSurfaceInfo: abstract new (...args: any[]) => ISpatialSurfaceInfo;
+
+  interface ISpatialSurfaceMesh {
+    readonly CoordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem;
+    readonly SurfaceInfo: Windows.Perception.Spatial.Surfaces.SpatialSurfaceInfo;
+    readonly TriangleIndices: Windows.Perception.Spatial.Surfaces.SpatialSurfaceMeshBuffer;
+    readonly VertexNormals: Windows.Perception.Spatial.Surfaces.SpatialSurfaceMeshBuffer;
+    readonly VertexPositionScale: Windows.Foundation.Numerics.Vector3;
+    readonly VertexPositions: Windows.Perception.Spatial.Surfaces.SpatialSurfaceMeshBuffer;
+  }
+  var ISpatialSurfaceMesh: abstract new (...args: any[]) => ISpatialSurfaceMesh;
+
+  interface ISpatialSurfaceMeshBuffer {
+    readonly Data: Windows.Storage.Streams.IBuffer;
+    readonly ElementCount: number;
+    readonly Format: number;
+    readonly Stride: number;
+  }
+  var ISpatialSurfaceMeshBuffer: abstract new (...args: any[]) => ISpatialSurfaceMeshBuffer;
+
+  interface ISpatialSurfaceMeshOptions {
+    IncludeVertexNormals: boolean;
+    TriangleIndexFormat: number;
+    VertexNormalFormat: number;
+    VertexPositionFormat: number;
+  }
+  var ISpatialSurfaceMeshOptions: abstract new (...args: any[]) => ISpatialSurfaceMeshOptions;
+
+  interface ISpatialSurfaceMeshOptionsStatics {
+    readonly SupportedTriangleIndexFormats: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedVertexNormalFormats: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly SupportedVertexPositionFormats: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var ISpatialSurfaceMeshOptionsStatics: abstract new (...args: any[]) => ISpatialSurfaceMeshOptionsStatics;
+
+  interface ISpatialSurfaceObserver {
+    GetObservedSurfaces(): Windows.Foundation.Collections.IMapView<Guid, Windows.Perception.Spatial.Surfaces.SpatialSurfaceInfo>;
+    SetBoundingVolume(bounds: Windows.Perception.Spatial.SpatialBoundingVolume): void;
+    SetBoundingVolumes(bounds: Windows.Foundation.Collections.IIterable<Windows.Perception.Spatial.SpatialBoundingVolume> | Windows.Perception.Spatial.SpatialBoundingVolume[]): void;
+    ObservedSurfacesChanged: Windows.Foundation.TypedEventHandler<Windows.Perception.Spatial.Surfaces.SpatialSurfaceObserver, Object> | null;
+  }
+  var ISpatialSurfaceObserver: abstract new (...args: any[]) => ISpatialSurfaceObserver;
+
+  interface ISpatialSurfaceObserverStatics {
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var ISpatialSurfaceObserverStatics: abstract new (...args: any[]) => ISpatialSurfaceObserverStatics;
+
+  interface ISpatialSurfaceObserverStatics2 extends Windows.Perception.Spatial.Surfaces.ISpatialSurfaceObserverStatics {
+    IsSupported(): boolean;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var ISpatialSurfaceObserverStatics2: abstract new (...args: any[]) => ISpatialSurfaceObserverStatics2;
+
+}
+
+declare namespace Windows.Security.Authentication.Identity {
+  class EnterpriseKeyCredentialRegistrationInfo implements Windows.Security.Authentication.Identity.IEnterpriseKeyCredentialRegistrationInfo {
+    readonly KeyId: string;
+    readonly KeyName: string;
+    readonly Subject: string;
+    readonly TenantId: string;
+    readonly TenantName: string;
+  }
+
+  class EnterpriseKeyCredentialRegistrationManager implements Windows.Security.Authentication.Identity.IEnterpriseKeyCredentialRegistrationManager {
+    GetRegistrationsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Security.Authentication.Identity.EnterpriseKeyCredentialRegistrationInfo> | Windows.Security.Authentication.Identity.EnterpriseKeyCredentialRegistrationInfo[]>;
+    static readonly Current: Windows.Security.Authentication.Identity.EnterpriseKeyCredentialRegistrationManager;
+  }
+
+  interface IEnterpriseKeyCredentialRegistrationInfo {
+    readonly KeyId: string;
+    readonly KeyName: string;
+    readonly Subject: string;
+    readonly TenantId: string;
+    readonly TenantName: string;
+  }
+  var IEnterpriseKeyCredentialRegistrationInfo: abstract new (...args: any[]) => IEnterpriseKeyCredentialRegistrationInfo;
+
+  interface IEnterpriseKeyCredentialRegistrationManager {
+    GetRegistrationsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Security.Authentication.Identity.EnterpriseKeyCredentialRegistrationInfo> | Windows.Security.Authentication.Identity.EnterpriseKeyCredentialRegistrationInfo[]>;
+  }
+  var IEnterpriseKeyCredentialRegistrationManager: abstract new (...args: any[]) => IEnterpriseKeyCredentialRegistrationManager;
+
+  interface IEnterpriseKeyCredentialRegistrationManagerStatics {
+    readonly Current: Windows.Security.Authentication.Identity.EnterpriseKeyCredentialRegistrationManager;
+  }
+  var IEnterpriseKeyCredentialRegistrationManagerStatics: abstract new (...args: any[]) => IEnterpriseKeyCredentialRegistrationManagerStatics;
+
+}
+
+declare namespace Windows.Security.Authentication.Identity.Core {
+  class MicrosoftAccountMultiFactorAuthenticationManager implements Windows.Security.Authentication.Identity.Core.IMicrosoftAccountMultiFactorAuthenticationManager {
+    AddDeviceAsync(userAccountId: string, authenticationToken: string, wnsChannelId: string): Windows.Foundation.IAsyncOperation<number>;
+    ApproveSessionAsync(sessionAuthentictionStatus: number, authenticationSessionInfo: Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorSessionInfo): Windows.Foundation.IAsyncOperation<number>;
+    ApproveSessionAsync(sessionAuthentictionStatus: number, userAccountId: string, sessionId: string, sessionAuthenticationType: number): Windows.Foundation.IAsyncOperation<number>;
+    DenySessionAsync(authenticationSessionInfo: Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorSessionInfo): Windows.Foundation.IAsyncOperation<number>;
+    DenySessionAsync(userAccountId: string, sessionId: string, sessionAuthenticationType: number): Windows.Foundation.IAsyncOperation<number>;
+    GetOneTimePassCodeAsync(userAccountId: string, codeLength: number): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorOneTimeCodedInfo>;
+    GetSessionsAndUnregisteredAccountsAsync(userAccountIdList: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorUnregisteredAccountsAndSessionInfo>;
+    GetSessionsAsync(userAccountIdList: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorGetSessionsResult>;
+    RemoveDeviceAsync(userAccountId: string): Windows.Foundation.IAsyncOperation<number>;
+    UpdateWnsChannelAsync(userAccountId: string, channelUri: string): Windows.Foundation.IAsyncOperation<number>;
+    static readonly Current: Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorAuthenticationManager;
+  }
+
+  class MicrosoftAccountMultiFactorGetSessionsResult implements Windows.Security.Authentication.Identity.Core.IMicrosoftAccountMultiFactorGetSessionsResult {
+    readonly ServiceResponse: number;
+    readonly Sessions: Windows.Foundation.Collections.IVectorView<Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorSessionInfo> | Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorSessionInfo[];
+  }
+
+  class MicrosoftAccountMultiFactorOneTimeCodedInfo implements Windows.Security.Authentication.Identity.Core.IMicrosoftAccountMultiFactorOneTimeCodedInfo {
+    readonly Code: string;
+    readonly ServiceResponse: number;
+    readonly TimeInterval: Windows.Foundation.TimeSpan;
+    readonly TimeToLive: Windows.Foundation.TimeSpan;
+  }
+
+  class MicrosoftAccountMultiFactorSessionInfo implements Windows.Security.Authentication.Identity.Core.IMicrosoftAccountMultiFactorSessionInfo {
+    readonly ApprovalStatus: number;
+    readonly AuthenticationType: number;
+    readonly DisplaySessionId: string;
+    readonly ExpirationTime: Windows.Foundation.DateTime;
+    readonly RequestTime: Windows.Foundation.DateTime;
+    readonly SessionId: string;
+    readonly UserAccountId: string;
+  }
+
+  class MicrosoftAccountMultiFactorUnregisteredAccountsAndSessionInfo implements Windows.Security.Authentication.Identity.Core.IMicrosoftAccountMultiFactorUnregisteredAccountsAndSessionInfo {
+    readonly ServiceResponse: number;
+    readonly Sessions: Windows.Foundation.Collections.IVectorView<Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorSessionInfo> | Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorSessionInfo[];
+    readonly UnregisteredAccounts: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+
+  enum MicrosoftAccountMultiFactorAuthenticationType {
+    User = 0,
+    Device = 1,
+  }
+
+  enum MicrosoftAccountMultiFactorServiceResponse {
+    Success = 0,
+    Error = 1,
+    NoNetworkConnection = 2,
+    ServiceUnavailable = 3,
+    TotpSetupDenied = 4,
+    NgcNotSetup = 5,
+    SessionAlreadyDenied = 6,
+    SessionAlreadyApproved = 7,
+    SessionExpired = 8,
+    NgcNonceExpired = 9,
+    InvalidSessionId = 10,
+    InvalidSessionType = 11,
+    InvalidOperation = 12,
+    InvalidStateTransition = 13,
+    DeviceNotFound = 14,
+    FlowDisabled = 15,
+    SessionNotApproved = 16,
+    OperationCanceledByUser = 17,
+    NgcDisabledByServer = 18,
+    NgcKeyNotFoundOnServer = 19,
+    UIRequired = 20,
+    DeviceIdChanged = 21,
+  }
+
+  enum MicrosoftAccountMultiFactorSessionApprovalStatus {
+    Pending = 0,
+    Approved = 1,
+    Denied = 2,
+  }
+
+  enum MicrosoftAccountMultiFactorSessionAuthenticationStatus {
+    Authenticated = 0,
+    Unauthenticated = 1,
+  }
+
+  interface IMicrosoftAccountMultiFactorAuthenticationManager {
+    AddDeviceAsync(userAccountId: string, authenticationToken: string, wnsChannelId: string): Windows.Foundation.IAsyncOperation<number>;
+    ApproveSessionAsync(sessionAuthentictionStatus: number, authenticationSessionInfo: Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorSessionInfo): Windows.Foundation.IAsyncOperation<number>;
+    ApproveSessionAsync(sessionAuthentictionStatus: number, userAccountId: string, sessionId: string, sessionAuthenticationType: number): Windows.Foundation.IAsyncOperation<number>;
+    DenySessionAsync(authenticationSessionInfo: Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorSessionInfo): Windows.Foundation.IAsyncOperation<number>;
+    DenySessionAsync(userAccountId: string, sessionId: string, sessionAuthenticationType: number): Windows.Foundation.IAsyncOperation<number>;
+    GetOneTimePassCodeAsync(userAccountId: string, codeLength: number): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorOneTimeCodedInfo>;
+    GetSessionsAndUnregisteredAccountsAsync(userAccountIdList: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorUnregisteredAccountsAndSessionInfo>;
+    GetSessionsAsync(userAccountIdList: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorGetSessionsResult>;
+    RemoveDeviceAsync(userAccountId: string): Windows.Foundation.IAsyncOperation<number>;
+    UpdateWnsChannelAsync(userAccountId: string, channelUri: string): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IMicrosoftAccountMultiFactorAuthenticationManager: abstract new (...args: any[]) => IMicrosoftAccountMultiFactorAuthenticationManager;
+
+  interface IMicrosoftAccountMultiFactorAuthenticatorStatics {
+    readonly Current: Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorAuthenticationManager;
+  }
+  var IMicrosoftAccountMultiFactorAuthenticatorStatics: abstract new (...args: any[]) => IMicrosoftAccountMultiFactorAuthenticatorStatics;
+
+  interface IMicrosoftAccountMultiFactorGetSessionsResult {
+    readonly ServiceResponse: number;
+    readonly Sessions: Windows.Foundation.Collections.IVectorView<Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorSessionInfo> | Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorSessionInfo[];
+  }
+  var IMicrosoftAccountMultiFactorGetSessionsResult: abstract new (...args: any[]) => IMicrosoftAccountMultiFactorGetSessionsResult;
+
+  interface IMicrosoftAccountMultiFactorOneTimeCodedInfo {
+    readonly Code: string;
+    readonly ServiceResponse: number;
+    readonly TimeInterval: Windows.Foundation.TimeSpan;
+    readonly TimeToLive: Windows.Foundation.TimeSpan;
+  }
+  var IMicrosoftAccountMultiFactorOneTimeCodedInfo: abstract new (...args: any[]) => IMicrosoftAccountMultiFactorOneTimeCodedInfo;
+
+  interface IMicrosoftAccountMultiFactorSessionInfo {
+    readonly ApprovalStatus: number;
+    readonly AuthenticationType: number;
+    readonly DisplaySessionId: string;
+    readonly ExpirationTime: Windows.Foundation.DateTime;
+    readonly RequestTime: Windows.Foundation.DateTime;
+    readonly SessionId: string;
+    readonly UserAccountId: string;
+  }
+  var IMicrosoftAccountMultiFactorSessionInfo: abstract new (...args: any[]) => IMicrosoftAccountMultiFactorSessionInfo;
+
+  interface IMicrosoftAccountMultiFactorUnregisteredAccountsAndSessionInfo {
+    readonly ServiceResponse: number;
+    readonly Sessions: Windows.Foundation.Collections.IVectorView<Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorSessionInfo> | Windows.Security.Authentication.Identity.Core.MicrosoftAccountMultiFactorSessionInfo[];
+    readonly UnregisteredAccounts: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var IMicrosoftAccountMultiFactorUnregisteredAccountsAndSessionInfo: abstract new (...args: any[]) => IMicrosoftAccountMultiFactorUnregisteredAccountsAndSessionInfo;
+
+}
+
+declare namespace Windows.Security.Authentication.Identity.Provider {
+  class SecondaryAuthenticationFactorAuthentication implements Windows.Security.Authentication.Identity.Provider.ISecondaryAuthenticationFactorAuthentication {
+    AbortAuthenticationAsync(errorLogMessage: string): Windows.Foundation.IAsyncAction;
+    FinishAuthenticationAsync(deviceHmac: Windows.Storage.Streams.IBuffer, sessionHmac: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<number>;
+    static GetAuthenticationStageInfoAsync(): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageInfo>;
+    static ShowNotificationMessageAsync(deviceName: string, message: number): Windows.Foundation.IAsyncAction;
+    static StartAuthenticationAsync(deviceId: string, serviceAuthenticationNonce: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationResult>;
+    readonly DeviceConfigurationData: Windows.Storage.Streams.IBuffer;
+    readonly DeviceNonce: Windows.Storage.Streams.IBuffer;
+    readonly ServiceAuthenticationHmac: Windows.Storage.Streams.IBuffer;
+    readonly SessionNonce: Windows.Storage.Streams.IBuffer;
+    static AuthenticationStageChanged: Windows.Foundation.EventHandler<Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs> | null;
+  }
+
+  class SecondaryAuthenticationFactorAuthenticationResult implements Windows.Security.Authentication.Identity.Provider.ISecondaryAuthenticationFactorAuthenticationResult {
+    readonly Authentication: Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication;
+    readonly Status: number;
+  }
+
+  class SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs implements Windows.Security.Authentication.Identity.Provider.ISecondaryAuthenticationFactorAuthenticationStageChangedEventArgs {
+    readonly StageInfo: Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageInfo;
+  }
+
+  class SecondaryAuthenticationFactorAuthenticationStageInfo implements Windows.Security.Authentication.Identity.Provider.ISecondaryAuthenticationFactorAuthenticationStageInfo {
+    readonly DeviceId: string;
+    readonly Scenario: number;
+    readonly Stage: number;
+  }
+
+  class SecondaryAuthenticationFactorInfo implements Windows.Security.Authentication.Identity.Provider.ISecondaryAuthenticationFactorInfo, Windows.Security.Authentication.Identity.Provider.ISecondaryAuthenticationFactorInfo2 {
+    UpdateDevicePresenceAsync(presenceState: number): Windows.Foundation.IAsyncAction;
+    readonly DeviceConfigurationData: Windows.Storage.Streams.IBuffer;
+    readonly DeviceFriendlyName: string;
+    readonly DeviceId: string;
+    readonly DeviceModelNumber: string;
+    readonly IsAuthenticationSupported: boolean;
+    readonly PresenceMonitoringMode: number;
+  }
+
+  class SecondaryAuthenticationFactorRegistration implements Windows.Security.Authentication.Identity.Provider.ISecondaryAuthenticationFactorRegistration {
+    AbortRegisteringDeviceAsync(errorLogMessage: string): Windows.Foundation.IAsyncAction;
+    static FindAllRegisteredDeviceInfoAsync(queryType: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorInfo> | Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorInfo[]>;
+    FinishRegisteringDeviceAsync(deviceConfigurationData: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncAction;
+    static IsDevicePresenceMonitoringSupported(): boolean;
+    static RegisterDevicePresenceMonitoringAsync(deviceId: string, deviceInstancePath: string, monitoringMode: number): Windows.Foundation.IAsyncOperation<number>;
+    static RegisterDevicePresenceMonitoringAsync(deviceId: string, deviceInstancePath: string, monitoringMode: number, deviceFriendlyName: string, deviceModelNumber: string, deviceConfigurationData: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<number>;
+    static RequestStartRegisteringDeviceAsync(deviceId: string, capabilities: number, deviceFriendlyName: string, deviceModelNumber: string, deviceKey: Windows.Storage.Streams.IBuffer, mutualAuthenticationKey: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistrationResult>;
+    static UnregisterDeviceAsync(deviceId: string): Windows.Foundation.IAsyncAction;
+    static UnregisterDevicePresenceMonitoringAsync(deviceId: string): Windows.Foundation.IAsyncAction;
+    static UpdateDeviceConfigurationDataAsync(deviceId: string, deviceConfigurationData: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncAction;
+  }
+
+  class SecondaryAuthenticationFactorRegistrationResult implements Windows.Security.Authentication.Identity.Provider.ISecondaryAuthenticationFactorRegistrationResult {
+    readonly Registration: Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistration;
+    readonly Status: number;
+  }
+
+  enum SecondaryAuthenticationFactorAuthenticationMessage {
+    Invalid = 0,
+    SwipeUpWelcome = 1,
+    TapWelcome = 2,
+    DeviceNeedsAttention = 3,
+    LookingForDevice = 4,
+    LookingForDevicePluggedin = 5,
+    BluetoothIsDisabled = 6,
+    NfcIsDisabled = 7,
+    WiFiIsDisabled = 8,
+    ExtraTapIsRequired = 9,
+    DisabledByPolicy = 10,
+    TapOnDeviceRequired = 11,
+    HoldFinger = 12,
+    ScanFinger = 13,
+    UnauthorizedUser = 14,
+    ReregisterRequired = 15,
+    TryAgain = 16,
+    SayPassphrase = 17,
+    ReadyToSignIn = 18,
+    UseAnotherSignInOption = 19,
+    ConnectionRequired = 20,
+    TimeLimitExceeded = 21,
+    CanceledByUser = 22,
+    CenterHand = 23,
+    MoveHandCloser = 24,
+    MoveHandFarther = 25,
+    PlaceHandAbove = 26,
+    RecognitionFailed = 27,
+    DeviceUnavailable = 28,
+  }
+
+  enum SecondaryAuthenticationFactorAuthenticationScenario {
+    SignIn = 0,
+    CredentialPrompt = 1,
+  }
+
+  enum SecondaryAuthenticationFactorAuthenticationStage {
+    NotStarted = 0,
+    WaitingForUserConfirmation = 1,
+    CollectingCredential = 2,
+    SuspendingAuthentication = 3,
+    CredentialCollected = 4,
+    CredentialAuthenticated = 5,
+    StoppingAuthentication = 6,
+    ReadyForLock = 7,
+    CheckingDevicePresence = 8,
+  }
+
+  enum SecondaryAuthenticationFactorAuthenticationStatus {
+    Failed = 0,
+    Started = 1,
+    UnknownDevice = 2,
+    DisabledByPolicy = 3,
+    InvalidAuthenticationStage = 4,
+  }
+
+  enum SecondaryAuthenticationFactorDeviceCapabilities {
+    None = 0,
+    SecureStorage = 1,
+    StoreKeys = 2,
+    ConfirmUserIntentToAuthenticate = 4,
+    SupportSecureUserPresenceCheck = 8,
+    TransmittedDataIsEncrypted = 16,
+    HMacSha256 = 32,
+    CloseRangeDataTransmission = 64,
+  }
+
+  enum SecondaryAuthenticationFactorDeviceFindScope {
+    User = 0,
+    AllUsers = 1,
+  }
+
+  enum SecondaryAuthenticationFactorDevicePresence {
+    Absent = 0,
+    Present = 1,
+  }
+
+  enum SecondaryAuthenticationFactorDevicePresenceMonitoringMode {
+    Unsupported = 0,
+    AppManaged = 1,
+    SystemManaged = 2,
+  }
+
+  enum SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus {
+    Unsupported = 0,
+    Succeeded = 1,
+    DisabledByPolicy = 2,
+  }
+
+  enum SecondaryAuthenticationFactorFinishAuthenticationStatus {
+    Failed = 0,
+    Completed = 1,
+    NonceExpired = 2,
+  }
+
+  enum SecondaryAuthenticationFactorRegistrationStatus {
+    Failed = 0,
+    Started = 1,
+    CanceledByUser = 2,
+    PinSetupRequired = 3,
+    DisabledByPolicy = 4,
+  }
+
+  interface ISecondaryAuthenticationFactorAuthentication {
+    AbortAuthenticationAsync(errorLogMessage: string): Windows.Foundation.IAsyncAction;
+    FinishAuthenticationAsync(deviceHmac: Windows.Storage.Streams.IBuffer, sessionHmac: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<number>;
+    readonly DeviceConfigurationData: Windows.Storage.Streams.IBuffer;
+    readonly DeviceNonce: Windows.Storage.Streams.IBuffer;
+    readonly ServiceAuthenticationHmac: Windows.Storage.Streams.IBuffer;
+    readonly SessionNonce: Windows.Storage.Streams.IBuffer;
+  }
+  var ISecondaryAuthenticationFactorAuthentication: abstract new (...args: any[]) => ISecondaryAuthenticationFactorAuthentication;
+
+  interface ISecondaryAuthenticationFactorAuthenticationResult {
+    readonly Authentication: Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthentication;
+    readonly Status: number;
+  }
+  var ISecondaryAuthenticationFactorAuthenticationResult: abstract new (...args: any[]) => ISecondaryAuthenticationFactorAuthenticationResult;
+
+  interface ISecondaryAuthenticationFactorAuthenticationStageChangedEventArgs {
+    readonly StageInfo: Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageInfo;
+  }
+  var ISecondaryAuthenticationFactorAuthenticationStageChangedEventArgs: abstract new (...args: any[]) => ISecondaryAuthenticationFactorAuthenticationStageChangedEventArgs;
+
+  interface ISecondaryAuthenticationFactorAuthenticationStageInfo {
+    readonly DeviceId: string;
+    readonly Scenario: number;
+    readonly Stage: number;
+  }
+  var ISecondaryAuthenticationFactorAuthenticationStageInfo: abstract new (...args: any[]) => ISecondaryAuthenticationFactorAuthenticationStageInfo;
+
+  interface ISecondaryAuthenticationFactorAuthenticationStatics {
+    GetAuthenticationStageInfoAsync(): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageInfo>;
+    ShowNotificationMessageAsync(deviceName: string, message: number): Windows.Foundation.IAsyncAction;
+    StartAuthenticationAsync(deviceId: string, serviceAuthenticationNonce: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationResult>;
+    AuthenticationStageChanged: Windows.Foundation.EventHandler<Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs> | null;
+  }
+  var ISecondaryAuthenticationFactorAuthenticationStatics: abstract new (...args: any[]) => ISecondaryAuthenticationFactorAuthenticationStatics;
+
+  interface ISecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatics {
+    IsDevicePresenceMonitoringSupported(): boolean;
+    RegisterDevicePresenceMonitoringAsync(deviceId: string, deviceInstancePath: string, monitoringMode: number): Windows.Foundation.IAsyncOperation<number>;
+    RegisterDevicePresenceMonitoringAsync(deviceId: string, deviceInstancePath: string, monitoringMode: number, deviceFriendlyName: string, deviceModelNumber: string, deviceConfigurationData: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<number>;
+    UnregisterDevicePresenceMonitoringAsync(deviceId: string): Windows.Foundation.IAsyncAction;
+  }
+  var ISecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatics: abstract new (...args: any[]) => ISecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatics;
+
+  interface ISecondaryAuthenticationFactorInfo {
+    readonly DeviceConfigurationData: Windows.Storage.Streams.IBuffer;
+    readonly DeviceFriendlyName: string;
+    readonly DeviceId: string;
+    readonly DeviceModelNumber: string;
+  }
+  var ISecondaryAuthenticationFactorInfo: abstract new (...args: any[]) => ISecondaryAuthenticationFactorInfo;
+
+  interface ISecondaryAuthenticationFactorInfo2 extends Windows.Security.Authentication.Identity.Provider.ISecondaryAuthenticationFactorInfo {
+    UpdateDevicePresenceAsync(presenceState: number): Windows.Foundation.IAsyncAction;
+    readonly IsAuthenticationSupported: boolean;
+    readonly PresenceMonitoringMode: number;
+  }
+  var ISecondaryAuthenticationFactorInfo2: abstract new (...args: any[]) => ISecondaryAuthenticationFactorInfo2;
+
+  interface ISecondaryAuthenticationFactorRegistration {
+    AbortRegisteringDeviceAsync(errorLogMessage: string): Windows.Foundation.IAsyncAction;
+    FinishRegisteringDeviceAsync(deviceConfigurationData: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncAction;
+  }
+  var ISecondaryAuthenticationFactorRegistration: abstract new (...args: any[]) => ISecondaryAuthenticationFactorRegistration;
+
+  interface ISecondaryAuthenticationFactorRegistrationResult {
+    readonly Registration: Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistration;
+    readonly Status: number;
+  }
+  var ISecondaryAuthenticationFactorRegistrationResult: abstract new (...args: any[]) => ISecondaryAuthenticationFactorRegistrationResult;
+
+  interface ISecondaryAuthenticationFactorRegistrationStatics {
+    FindAllRegisteredDeviceInfoAsync(queryType: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorInfo> | Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorInfo[]>;
+    RequestStartRegisteringDeviceAsync(deviceId: string, capabilities: number, deviceFriendlyName: string, deviceModelNumber: string, deviceKey: Windows.Storage.Streams.IBuffer, mutualAuthenticationKey: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Identity.Provider.SecondaryAuthenticationFactorRegistrationResult>;
+    UnregisterDeviceAsync(deviceId: string): Windows.Foundation.IAsyncAction;
+    UpdateDeviceConfigurationDataAsync(deviceId: string, deviceConfigurationData: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncAction;
+  }
+  var ISecondaryAuthenticationFactorRegistrationStatics: abstract new (...args: any[]) => ISecondaryAuthenticationFactorRegistrationStatics;
+
+}
+
+declare namespace Windows.Security.Authentication.OnlineId {
+  class OnlineIdAuthenticator implements Windows.Security.Authentication.OnlineId.IOnlineIdAuthenticator {
+    constructor();
+    AuthenticateUserAsync(request: Windows.Security.Authentication.OnlineId.OnlineIdServiceTicketRequest): Windows.Security.Authentication.OnlineId.UserAuthenticationOperation;
+    AuthenticateUserAsync(requests: Windows.Foundation.Collections.IIterable<Windows.Security.Authentication.OnlineId.OnlineIdServiceTicketRequest> | Windows.Security.Authentication.OnlineId.OnlineIdServiceTicketRequest[], credentialPromptType: number): Windows.Security.Authentication.OnlineId.UserAuthenticationOperation;
+    SignOutUserAsync(): Windows.Security.Authentication.OnlineId.SignOutUserOperation;
+    ApplicationId: Guid;
+    readonly AuthenticatedSafeCustomerId: string;
+    readonly CanSignOut: boolean;
+  }
+
+  class OnlineIdServiceTicket implements Windows.Security.Authentication.OnlineId.IOnlineIdServiceTicket {
+    readonly ErrorCode: number;
+    readonly Request: Windows.Security.Authentication.OnlineId.OnlineIdServiceTicketRequest;
+    readonly Value: string;
+  }
+
+  class OnlineIdServiceTicketRequest implements Windows.Security.Authentication.OnlineId.IOnlineIdServiceTicketRequest {
+    constructor(service: string, policy: string);
+    constructor(service: string);
+    readonly Policy: string;
+    readonly Service: string;
+  }
+
+  class OnlineIdSystemAuthenticator {
+    static GetForUser(user: Windows.System.User): Windows.Security.Authentication.OnlineId.OnlineIdSystemAuthenticatorForUser;
+    static readonly Default: Windows.Security.Authentication.OnlineId.OnlineIdSystemAuthenticatorForUser;
+  }
+
+  class OnlineIdSystemAuthenticatorForUser implements Windows.Security.Authentication.OnlineId.IOnlineIdSystemAuthenticatorForUser {
+    GetTicketAsync(request: Windows.Security.Authentication.OnlineId.OnlineIdServiceTicketRequest): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.OnlineId.OnlineIdSystemTicketResult>;
+    ApplicationId: Guid;
+    readonly User: Windows.System.User;
+  }
+
+  class OnlineIdSystemIdentity implements Windows.Security.Authentication.OnlineId.IOnlineIdSystemIdentity {
+    readonly Id: string;
+    readonly Ticket: Windows.Security.Authentication.OnlineId.OnlineIdServiceTicket;
+  }
+
+  class OnlineIdSystemTicketResult implements Windows.Security.Authentication.OnlineId.IOnlineIdSystemTicketResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Identity: Windows.Security.Authentication.OnlineId.OnlineIdSystemIdentity;
+    readonly Status: number;
+  }
+
+  class SignOutUserOperation implements Windows.Foundation.IAsyncAction, Windows.Foundation.IAsyncInfo {
+    Cancel(): void;
+    Close(): void;
+    GetResults(): void;
+    Completed: Windows.Foundation.AsyncActionCompletedHandler;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly Id: number;
+    readonly Status: number;
+  }
+
+  class UserAuthenticationOperation implements Windows.Foundation.IAsyncInfo {
+    Cancel(): void;
+    Close(): void;
+    GetResults(): Windows.Security.Authentication.OnlineId.UserIdentity;
+    Completed: Windows.Foundation.AsyncOperationCompletedHandler<Windows.Security.Authentication.OnlineId.UserIdentity>;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly Id: number;
+    readonly Status: number;
+  }
+
+  class UserIdentity implements Windows.Security.Authentication.OnlineId.IUserIdentity {
+    readonly FirstName: string;
+    readonly Id: string;
+    readonly IsBetaAccount: boolean;
+    readonly IsConfirmedPC: boolean;
+    readonly LastName: string;
+    readonly SafeCustomerId: string;
+    readonly SignInName: string;
+    readonly Tickets: Windows.Foundation.Collections.IVectorView<Windows.Security.Authentication.OnlineId.OnlineIdServiceTicket> | Windows.Security.Authentication.OnlineId.OnlineIdServiceTicket[];
+  }
+
+  enum CredentialPromptType {
+    PromptIfNeeded = 0,
+    RetypeCredentials = 1,
+    DoNotPrompt = 2,
+  }
+
+  enum OnlineIdSystemTicketStatus {
+    Success = 0,
+    Error = 1,
+    ServiceConnectionError = 2,
+  }
+
+  interface IOnlineIdAuthenticator {
+    AuthenticateUserAsync(request: Windows.Security.Authentication.OnlineId.OnlineIdServiceTicketRequest): Windows.Security.Authentication.OnlineId.UserAuthenticationOperation;
+    AuthenticateUserAsync(requests: Windows.Foundation.Collections.IIterable<Windows.Security.Authentication.OnlineId.OnlineIdServiceTicketRequest> | Windows.Security.Authentication.OnlineId.OnlineIdServiceTicketRequest[], credentialPromptType: number): Windows.Security.Authentication.OnlineId.UserAuthenticationOperation;
+    SignOutUserAsync(): Windows.Security.Authentication.OnlineId.SignOutUserOperation;
+    ApplicationId: Guid;
+    readonly AuthenticatedSafeCustomerId: string;
+    readonly CanSignOut: boolean;
+  }
+  var IOnlineIdAuthenticator: abstract new (...args: any[]) => IOnlineIdAuthenticator;
+
+  interface IOnlineIdServiceTicket {
+    readonly ErrorCode: number;
+    readonly Request: Windows.Security.Authentication.OnlineId.OnlineIdServiceTicketRequest;
+    readonly Value: string;
+  }
+  var IOnlineIdServiceTicket: abstract new (...args: any[]) => IOnlineIdServiceTicket;
+
+  interface IOnlineIdServiceTicketRequest {
+    readonly Policy: string;
+    readonly Service: string;
+  }
+  var IOnlineIdServiceTicketRequest: abstract new (...args: any[]) => IOnlineIdServiceTicketRequest;
+
+  interface IOnlineIdServiceTicketRequestFactory {
+    CreateOnlineIdServiceTicketRequest(service: string, policy: string): Windows.Security.Authentication.OnlineId.OnlineIdServiceTicketRequest;
+    CreateOnlineIdServiceTicketRequestAdvanced(service: string): Windows.Security.Authentication.OnlineId.OnlineIdServiceTicketRequest;
+  }
+  var IOnlineIdServiceTicketRequestFactory: abstract new (...args: any[]) => IOnlineIdServiceTicketRequestFactory;
+
+  interface IOnlineIdSystemAuthenticatorForUser {
+    GetTicketAsync(request: Windows.Security.Authentication.OnlineId.OnlineIdServiceTicketRequest): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.OnlineId.OnlineIdSystemTicketResult>;
+    ApplicationId: Guid;
+    readonly User: Windows.System.User;
+  }
+  var IOnlineIdSystemAuthenticatorForUser: abstract new (...args: any[]) => IOnlineIdSystemAuthenticatorForUser;
+
+  interface IOnlineIdSystemAuthenticatorStatics {
+    GetForUser(user: Windows.System.User): Windows.Security.Authentication.OnlineId.OnlineIdSystemAuthenticatorForUser;
+    readonly Default: Windows.Security.Authentication.OnlineId.OnlineIdSystemAuthenticatorForUser;
+  }
+  var IOnlineIdSystemAuthenticatorStatics: abstract new (...args: any[]) => IOnlineIdSystemAuthenticatorStatics;
+
+  interface IOnlineIdSystemIdentity {
+    readonly Id: string;
+    readonly Ticket: Windows.Security.Authentication.OnlineId.OnlineIdServiceTicket;
+  }
+  var IOnlineIdSystemIdentity: abstract new (...args: any[]) => IOnlineIdSystemIdentity;
+
+  interface IOnlineIdSystemTicketResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Identity: Windows.Security.Authentication.OnlineId.OnlineIdSystemIdentity;
+    readonly Status: number;
+  }
+  var IOnlineIdSystemTicketResult: abstract new (...args: any[]) => IOnlineIdSystemTicketResult;
+
+  interface IUserIdentity {
+    readonly FirstName: string;
+    readonly Id: string;
+    readonly IsBetaAccount: boolean;
+    readonly IsConfirmedPC: boolean;
+    readonly LastName: string;
+    readonly SafeCustomerId: string;
+    readonly SignInName: string;
+    readonly Tickets: Windows.Foundation.Collections.IVectorView<Windows.Security.Authentication.OnlineId.OnlineIdServiceTicket> | Windows.Security.Authentication.OnlineId.OnlineIdServiceTicket[];
+  }
+  var IUserIdentity: abstract new (...args: any[]) => IUserIdentity;
+
+}
+
+declare namespace Windows.Security.Authentication.Web {
+  class WebAuthenticationBroker {
+    static AuthenticateAndContinue(requestUri: Windows.Foundation.Uri): void;
+    static AuthenticateAndContinue(requestUri: Windows.Foundation.Uri, callbackUri: Windows.Foundation.Uri): void;
+    static AuthenticateAndContinue(requestUri: Windows.Foundation.Uri, callbackUri: Windows.Foundation.Uri, continuationData: Windows.Foundation.Collections.ValueSet, options: number): void;
+    static AuthenticateAsync(options: number, requestUri: Windows.Foundation.Uri, callbackUri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.WebAuthenticationResult>;
+    static AuthenticateAsync(options: number, requestUri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.WebAuthenticationResult>;
+    static AuthenticateSilentlyAsync(requestUri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.WebAuthenticationResult>;
+    static AuthenticateSilentlyAsync(requestUri: Windows.Foundation.Uri, options: number): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.WebAuthenticationResult>;
+    static GetCurrentApplicationCallbackUri(): Windows.Foundation.Uri;
+  }
+
+  class WebAuthenticationResult implements Windows.Security.Authentication.Web.IWebAuthenticationResult {
+    readonly ResponseData: string;
+    readonly ResponseErrorDetail: number;
+    readonly ResponseStatus: number;
+  }
+
+  enum TokenBindingKeyType {
+    Rsa2048 = 0,
+    EcdsaP256 = 1,
+    AnyExisting = 2,
+  }
+
+  enum WebAuthenticationOptions {
+    None = 0,
+    SilentMode = 1,
+    UseTitle = 2,
+    UseHttpPost = 4,
+    UseCorporateNetwork = 8,
+  }
+
+  enum WebAuthenticationStatus {
+    Success = 0,
+    UserCancel = 1,
+    ErrorHttp = 2,
+  }
+
+  interface IWebAuthenticationBrokerStatics {
+    AuthenticateAsync(options: number, requestUri: Windows.Foundation.Uri, callbackUri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.WebAuthenticationResult>;
+    AuthenticateAsync(options: number, requestUri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.WebAuthenticationResult>;
+    GetCurrentApplicationCallbackUri(): Windows.Foundation.Uri;
+  }
+  var IWebAuthenticationBrokerStatics: abstract new (...args: any[]) => IWebAuthenticationBrokerStatics;
+
+  interface IWebAuthenticationBrokerStatics2 {
+    AuthenticateAndContinue(requestUri: Windows.Foundation.Uri): void;
+    AuthenticateAndContinue(requestUri: Windows.Foundation.Uri, callbackUri: Windows.Foundation.Uri): void;
+    AuthenticateAndContinue(requestUri: Windows.Foundation.Uri, callbackUri: Windows.Foundation.Uri, continuationData: Windows.Foundation.Collections.ValueSet, options: number): void;
+    AuthenticateSilentlyAsync(requestUri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.WebAuthenticationResult>;
+    AuthenticateSilentlyAsync(requestUri: Windows.Foundation.Uri, options: number): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.WebAuthenticationResult>;
+  }
+  var IWebAuthenticationBrokerStatics2: abstract new (...args: any[]) => IWebAuthenticationBrokerStatics2;
+
+  interface IWebAuthenticationResult {
+    readonly ResponseData: string;
+    readonly ResponseErrorDetail: number;
+    readonly ResponseStatus: number;
+  }
+  var IWebAuthenticationResult: abstract new (...args: any[]) => IWebAuthenticationResult;
+
+}
+
+declare namespace Windows.Security.Authentication.Web.Core {
+  class FindAllAccountsResult implements Windows.Security.Authentication.Web.Core.IFindAllAccountsResult {
+    readonly Accounts: Windows.Foundation.Collections.IVectorView<Windows.Security.Credentials.WebAccount> | Windows.Security.Credentials.WebAccount[];
+    readonly ProviderError: Windows.Security.Authentication.Web.Core.WebProviderError;
+    readonly Status: number;
+  }
+
+  class WebAccountEventArgs implements Windows.Security.Authentication.Web.Core.IWebAccountEventArgs {
+    readonly Account: Windows.Security.Credentials.WebAccount;
+  }
+
+  class WebAccountMonitor implements Windows.Security.Authentication.Web.Core.IWebAccountMonitor, Windows.Security.Authentication.Web.Core.IWebAccountMonitor2 {
+    DefaultSignInAccountChanged: Windows.Foundation.TypedEventHandler<Windows.Security.Authentication.Web.Core.WebAccountMonitor, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.Security.Authentication.Web.Core.WebAccountMonitor, Windows.Security.Authentication.Web.Core.WebAccountEventArgs> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.Security.Authentication.Web.Core.WebAccountMonitor, Windows.Security.Authentication.Web.Core.WebAccountEventArgs> | null;
+    AccountPictureUpdated: Windows.Foundation.TypedEventHandler<Windows.Security.Authentication.Web.Core.WebAccountMonitor, Windows.Security.Authentication.Web.Core.WebAccountEventArgs> | null;
+  }
+
+  class WebAuthenticationAddAccountResponse implements Windows.Security.Authentication.Web.Core.IWebAuthenticationAddAccountResponse {
+    constructor(webAccount: Windows.Security.Credentials.WebAccount);
+    readonly Properties: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    readonly WebAccount: Windows.Security.Credentials.WebAccount;
+  }
+
+  class WebAuthenticationAddAccountResult implements Windows.Security.Authentication.Web.Core.IWebAuthenticationAddAccountResult {
+    readonly ResponseData: Windows.Security.Authentication.Web.Core.WebAuthenticationAddAccountResponse;
+    readonly ResponseError: Windows.Security.Authentication.Web.Core.WebProviderError;
+    readonly ResponseStatus: number;
+  }
+
+  class WebAuthenticationCoreManager {
+    static AddAccountWithTransferTokenAsync(request: Windows.Security.Authentication.Web.Core.WebAuthenticationTransferTokenRequest): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebAuthenticationAddAccountResult>;
+    static CreateWebAccountMonitor(webAccounts: Windows.Foundation.Collections.IIterable<Windows.Security.Credentials.WebAccount> | Windows.Security.Credentials.WebAccount[]): Windows.Security.Authentication.Web.Core.WebAccountMonitor;
+    static FindAccountAsync(provider: Windows.Security.Credentials.WebAccountProvider, webAccountId: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccount>;
+    static FindAccountProviderAsync(webAccountProviderId: string, authority: string, user: Windows.System.User): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccountProvider>;
+    static FindAccountProviderAsync(webAccountProviderId: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccountProvider>;
+    static FindAccountProviderAsync(webAccountProviderId: string, authority: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccountProvider>;
+    static FindAllAccountsAsync(provider: Windows.Security.Credentials.WebAccountProvider): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.FindAllAccountsResult>;
+    static FindAllAccountsAsync(provider: Windows.Security.Credentials.WebAccountProvider, clientId: string): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.FindAllAccountsResult>;
+    static FindSystemAccountProviderAsync(webAccountProviderId: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccountProvider>;
+    static FindSystemAccountProviderAsync(webAccountProviderId: string, authority: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccountProvider>;
+    static FindSystemAccountProviderAsync(webAccountProviderId: string, authority: string, user: Windows.System.User): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccountProvider>;
+    static GetTokenSilentlyAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+    static GetTokenSilentlyAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest, webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+    static RequestTokenAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+    static RequestTokenAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest, webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+  }
+
+  class WebAuthenticationTransferTokenRequest implements Windows.Security.Authentication.Web.Core.IWebAuthenticationTransferTokenRequest {
+    constructor(provider: Windows.Security.Credentials.WebAccountProvider, transferToken: string);
+    constructor(provider: Windows.Security.Credentials.WebAccountProvider, transferToken: string, correlationId: string);
+    CorrelationId: string;
+    readonly Properties: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    TransferToken: string;
+    readonly WebAccountProvider: Windows.Security.Credentials.WebAccountProvider;
+  }
+
+  class WebProviderError implements Windows.Security.Authentication.Web.Core.IWebProviderError {
+    constructor(errorCode: number, errorMessage: string);
+    readonly ErrorCode: number;
+    readonly ErrorMessage: string;
+    readonly Properties: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+  }
+
+  class WebTokenRequest implements Windows.Security.Authentication.Web.Core.IWebTokenRequest, Windows.Security.Authentication.Web.Core.IWebTokenRequest2, Windows.Security.Authentication.Web.Core.IWebTokenRequest3 {
+    constructor(provider: Windows.Security.Credentials.WebAccountProvider, scope: string, clientId: string);
+    constructor(provider: Windows.Security.Credentials.WebAccountProvider, scope: string, clientId: string, promptType: number);
+    constructor(provider: Windows.Security.Credentials.WebAccountProvider);
+    constructor(provider: Windows.Security.Credentials.WebAccountProvider, scope: string);
+    readonly AppProperties: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    readonly ClientId: string;
+    CorrelationId: string;
+    readonly PromptType: number;
+    readonly Properties: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    readonly Scope: string;
+    readonly WebAccountProvider: Windows.Security.Credentials.WebAccountProvider;
+  }
+
+  class WebTokenRequestResult implements Windows.Security.Authentication.Web.Core.IWebTokenRequestResult {
+    InvalidateCacheAsync(): Windows.Foundation.IAsyncAction;
+    readonly ResponseData: Windows.Foundation.Collections.IVectorView<Windows.Security.Authentication.Web.Core.WebTokenResponse> | Windows.Security.Authentication.Web.Core.WebTokenResponse[];
+    readonly ResponseError: Windows.Security.Authentication.Web.Core.WebProviderError;
+    readonly ResponseStatus: number;
+  }
+
+  class WebTokenResponse implements Windows.Security.Authentication.Web.Core.IWebTokenResponse {
+    constructor(token: string);
+    constructor(token: string, webAccount: Windows.Security.Credentials.WebAccount);
+    constructor(token: string, webAccount: Windows.Security.Credentials.WebAccount, error: Windows.Security.Authentication.Web.Core.WebProviderError);
+    constructor();
+    readonly Properties: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    readonly ProviderError: Windows.Security.Authentication.Web.Core.WebProviderError;
+    readonly Token: string;
+    readonly WebAccount: Windows.Security.Credentials.WebAccount;
+  }
+
+  enum FindAllWebAccountsStatus {
+    Success = 0,
+    NotAllowedByProvider = 1,
+    NotSupportedByProvider = 2,
+    ProviderError = 3,
+  }
+
+  enum WebAuthenticationAddAccountStatus {
+    Success = 0,
+    Error = 1,
+    NotSupportedByProvider = 2,
+    ServiceConnectionError = 3,
+    ProviderError = 4,
+  }
+
+  enum WebTokenRequestPromptType {
+    Default = 0,
+    ForceAuthentication = 1,
+  }
+
+  enum WebTokenRequestStatus {
+    Success = 0,
+    UserCancel = 1,
+    AccountSwitch = 2,
+    UserInteractionRequired = 3,
+    AccountProviderNotAvailable = 4,
+    ProviderError = 5,
+  }
+
+  interface IFindAllAccountsResult {
+    readonly Accounts: Windows.Foundation.Collections.IVectorView<Windows.Security.Credentials.WebAccount> | Windows.Security.Credentials.WebAccount[];
+    readonly ProviderError: Windows.Security.Authentication.Web.Core.WebProviderError;
+    readonly Status: number;
+  }
+  var IFindAllAccountsResult: abstract new (...args: any[]) => IFindAllAccountsResult;
+
+  interface IWebAccountEventArgs {
+    readonly Account: Windows.Security.Credentials.WebAccount;
+  }
+  var IWebAccountEventArgs: abstract new (...args: any[]) => IWebAccountEventArgs;
+
+  interface IWebAccountMonitor {
+    DefaultSignInAccountChanged: Windows.Foundation.TypedEventHandler<Windows.Security.Authentication.Web.Core.WebAccountMonitor, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.Security.Authentication.Web.Core.WebAccountMonitor, Windows.Security.Authentication.Web.Core.WebAccountEventArgs> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.Security.Authentication.Web.Core.WebAccountMonitor, Windows.Security.Authentication.Web.Core.WebAccountEventArgs> | null;
+  }
+  var IWebAccountMonitor: abstract new (...args: any[]) => IWebAccountMonitor;
+
+  interface IWebAccountMonitor2 {
+    AccountPictureUpdated: Windows.Foundation.TypedEventHandler<Windows.Security.Authentication.Web.Core.WebAccountMonitor, Windows.Security.Authentication.Web.Core.WebAccountEventArgs> | null;
+  }
+  var IWebAccountMonitor2: abstract new (...args: any[]) => IWebAccountMonitor2;
+
+  interface IWebAuthenticationAddAccountResponse {
+    readonly Properties: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    readonly WebAccount: Windows.Security.Credentials.WebAccount;
+  }
+  var IWebAuthenticationAddAccountResponse: abstract new (...args: any[]) => IWebAuthenticationAddAccountResponse;
+
+  interface IWebAuthenticationAddAccountResponseFactory {
+    CreateWithAccount(webAccount: Windows.Security.Credentials.WebAccount): Windows.Security.Authentication.Web.Core.WebAuthenticationAddAccountResponse;
+  }
+  var IWebAuthenticationAddAccountResponseFactory: abstract new (...args: any[]) => IWebAuthenticationAddAccountResponseFactory;
+
+  interface IWebAuthenticationAddAccountResult {
+    readonly ResponseData: Windows.Security.Authentication.Web.Core.WebAuthenticationAddAccountResponse;
+    readonly ResponseError: Windows.Security.Authentication.Web.Core.WebProviderError;
+    readonly ResponseStatus: number;
+  }
+  var IWebAuthenticationAddAccountResult: abstract new (...args: any[]) => IWebAuthenticationAddAccountResult;
+
+  interface IWebAuthenticationCoreManagerStatics {
+    FindAccountAsync(provider: Windows.Security.Credentials.WebAccountProvider, webAccountId: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccount>;
+    FindAccountProviderAsync(webAccountProviderId: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccountProvider>;
+    FindAccountProviderAsync(webAccountProviderId: string, authority: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccountProvider>;
+    GetTokenSilentlyAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+    GetTokenSilentlyAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest, webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+    RequestTokenAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+    RequestTokenAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest, webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+  }
+  var IWebAuthenticationCoreManagerStatics: abstract new (...args: any[]) => IWebAuthenticationCoreManagerStatics;
+
+  interface IWebAuthenticationCoreManagerStatics2 extends Windows.Security.Authentication.Web.Core.IWebAuthenticationCoreManagerStatics {
+    FindAccountAsync(provider: Windows.Security.Credentials.WebAccountProvider, webAccountId: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccount>;
+    FindAccountProviderAsync(webAccountProviderId: string, authority: string, user: Windows.System.User): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccountProvider>;
+    FindAccountProviderAsync(webAccountProviderId: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccountProvider>;
+    FindAccountProviderAsync(webAccountProviderId: string, authority: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccountProvider>;
+    GetTokenSilentlyAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+    GetTokenSilentlyAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest, webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+    RequestTokenAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+    RequestTokenAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest, webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+  }
+  var IWebAuthenticationCoreManagerStatics2: abstract new (...args: any[]) => IWebAuthenticationCoreManagerStatics2;
+
+  interface IWebAuthenticationCoreManagerStatics3 extends Windows.Security.Authentication.Web.Core.IWebAuthenticationCoreManagerStatics {
+    CreateWebAccountMonitor(webAccounts: Windows.Foundation.Collections.IIterable<Windows.Security.Credentials.WebAccount> | Windows.Security.Credentials.WebAccount[]): Windows.Security.Authentication.Web.Core.WebAccountMonitor;
+    FindAccountAsync(provider: Windows.Security.Credentials.WebAccountProvider, webAccountId: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccount>;
+    FindAccountProviderAsync(webAccountProviderId: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccountProvider>;
+    FindAccountProviderAsync(webAccountProviderId: string, authority: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccountProvider>;
+    GetTokenSilentlyAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+    GetTokenSilentlyAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest, webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+    RequestTokenAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+    RequestTokenAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest, webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+  }
+  var IWebAuthenticationCoreManagerStatics3: abstract new (...args: any[]) => IWebAuthenticationCoreManagerStatics3;
+
+  interface IWebAuthenticationCoreManagerStatics4 extends Windows.Security.Authentication.Web.Core.IWebAuthenticationCoreManagerStatics {
+    FindAccountAsync(provider: Windows.Security.Credentials.WebAccountProvider, webAccountId: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccount>;
+    FindAccountProviderAsync(webAccountProviderId: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccountProvider>;
+    FindAccountProviderAsync(webAccountProviderId: string, authority: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccountProvider>;
+    FindAllAccountsAsync(provider: Windows.Security.Credentials.WebAccountProvider): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.FindAllAccountsResult>;
+    FindAllAccountsAsync(provider: Windows.Security.Credentials.WebAccountProvider, clientId: string): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.FindAllAccountsResult>;
+    FindSystemAccountProviderAsync(webAccountProviderId: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccountProvider>;
+    FindSystemAccountProviderAsync(webAccountProviderId: string, authority: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccountProvider>;
+    FindSystemAccountProviderAsync(webAccountProviderId: string, authority: string, user: Windows.System.User): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccountProvider>;
+    GetTokenSilentlyAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+    GetTokenSilentlyAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest, webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+    RequestTokenAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+    RequestTokenAsync(request: Windows.Security.Authentication.Web.Core.WebTokenRequest, webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebTokenRequestResult>;
+  }
+  var IWebAuthenticationCoreManagerStatics4: abstract new (...args: any[]) => IWebAuthenticationCoreManagerStatics4;
+
+  interface IWebAuthenticationCoreManagerStatics5 {
+    AddAccountWithTransferTokenAsync(request: Windows.Security.Authentication.Web.Core.WebAuthenticationTransferTokenRequest): Windows.Foundation.IAsyncOperation<Windows.Security.Authentication.Web.Core.WebAuthenticationAddAccountResult>;
+  }
+  var IWebAuthenticationCoreManagerStatics5: abstract new (...args: any[]) => IWebAuthenticationCoreManagerStatics5;
+
+  interface IWebAuthenticationTransferTokenRequest {
+    CorrelationId: string;
+    readonly Properties: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    TransferToken: string;
+    readonly WebAccountProvider: Windows.Security.Credentials.WebAccountProvider;
+  }
+  var IWebAuthenticationTransferTokenRequest: abstract new (...args: any[]) => IWebAuthenticationTransferTokenRequest;
+
+  interface IWebAuthenticationTransferTokenRequestFactory {
+    Create(provider: Windows.Security.Credentials.WebAccountProvider, transferToken: string): Windows.Security.Authentication.Web.Core.WebAuthenticationTransferTokenRequest;
+    CreateWithCorrelationId(provider: Windows.Security.Credentials.WebAccountProvider, transferToken: string, correlationId: string): Windows.Security.Authentication.Web.Core.WebAuthenticationTransferTokenRequest;
+  }
+  var IWebAuthenticationTransferTokenRequestFactory: abstract new (...args: any[]) => IWebAuthenticationTransferTokenRequestFactory;
+
+  interface IWebProviderError {
+    readonly ErrorCode: number;
+    readonly ErrorMessage: string;
+    readonly Properties: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+  }
+  var IWebProviderError: abstract new (...args: any[]) => IWebProviderError;
+
+  interface IWebProviderErrorFactory {
+    Create(errorCode: number, errorMessage: string): Windows.Security.Authentication.Web.Core.WebProviderError;
+  }
+  var IWebProviderErrorFactory: abstract new (...args: any[]) => IWebProviderErrorFactory;
+
+  interface IWebTokenRequest {
+    readonly ClientId: string;
+    readonly PromptType: number;
+    readonly Properties: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    readonly Scope: string;
+    readonly WebAccountProvider: Windows.Security.Credentials.WebAccountProvider;
+  }
+  var IWebTokenRequest: abstract new (...args: any[]) => IWebTokenRequest;
+
+  interface IWebTokenRequest2 {
+    readonly AppProperties: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+  }
+  var IWebTokenRequest2: abstract new (...args: any[]) => IWebTokenRequest2;
+
+  interface IWebTokenRequest3 {
+    CorrelationId: string;
+  }
+  var IWebTokenRequest3: abstract new (...args: any[]) => IWebTokenRequest3;
+
+  interface IWebTokenRequestFactory {
+    Create(provider: Windows.Security.Credentials.WebAccountProvider, scope: string, clientId: string): Windows.Security.Authentication.Web.Core.WebTokenRequest;
+    CreateWithPromptType(provider: Windows.Security.Credentials.WebAccountProvider, scope: string, clientId: string, promptType: number): Windows.Security.Authentication.Web.Core.WebTokenRequest;
+    CreateWithProvider(provider: Windows.Security.Credentials.WebAccountProvider): Windows.Security.Authentication.Web.Core.WebTokenRequest;
+    CreateWithScope(provider: Windows.Security.Credentials.WebAccountProvider, scope: string): Windows.Security.Authentication.Web.Core.WebTokenRequest;
+  }
+  var IWebTokenRequestFactory: abstract new (...args: any[]) => IWebTokenRequestFactory;
+
+  interface IWebTokenRequestResult {
+    InvalidateCacheAsync(): Windows.Foundation.IAsyncAction;
+    readonly ResponseData: Windows.Foundation.Collections.IVectorView<Windows.Security.Authentication.Web.Core.WebTokenResponse> | Windows.Security.Authentication.Web.Core.WebTokenResponse[];
+    readonly ResponseError: Windows.Security.Authentication.Web.Core.WebProviderError;
+    readonly ResponseStatus: number;
+  }
+  var IWebTokenRequestResult: abstract new (...args: any[]) => IWebTokenRequestResult;
+
+  interface IWebTokenResponse {
+    readonly Properties: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    readonly ProviderError: Windows.Security.Authentication.Web.Core.WebProviderError;
+    readonly Token: string;
+    readonly WebAccount: Windows.Security.Credentials.WebAccount;
+  }
+  var IWebTokenResponse: abstract new (...args: any[]) => IWebTokenResponse;
+
+  interface IWebTokenResponseFactory {
+    CreateWithToken(token: string): Windows.Security.Authentication.Web.Core.WebTokenResponse;
+    CreateWithTokenAccountAndError(token: string, webAccount: Windows.Security.Credentials.WebAccount, error: Windows.Security.Authentication.Web.Core.WebProviderError): Windows.Security.Authentication.Web.Core.WebTokenResponse;
+    CreateWithTokenAndAccount(token: string, webAccount: Windows.Security.Credentials.WebAccount): Windows.Security.Authentication.Web.Core.WebTokenResponse;
+  }
+  var IWebTokenResponseFactory: abstract new (...args: any[]) => IWebTokenResponseFactory;
+
+}
+
+declare namespace Windows.Security.Authentication.Web.Provider {
+  class WebAccountClientView implements Windows.Security.Authentication.Web.Provider.IWebAccountClientView {
+    constructor(viewType: number, applicationCallbackUri: Windows.Foundation.Uri);
+    constructor(viewType: number, applicationCallbackUri: Windows.Foundation.Uri, accountPairwiseId: string);
+    readonly AccountPairwiseId: string;
+    readonly ApplicationCallbackUri: Windows.Foundation.Uri;
+    readonly Type: number;
+  }
+
+  class WebAccountManager {
+    static AddWebAccountAsync(webAccountId: string, webAccountUserName: string, props: Windows.Foundation.Collections.IMapView<string, string>, scope: number, perUserWebAccountId: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccount>;
+    static AddWebAccountAsync(webAccountId: string, webAccountUserName: string, props: Windows.Foundation.Collections.IMapView<string, string>, scope: number): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccount>;
+    static AddWebAccountAsync(webAccountId: string, webAccountUserName: string, props: Windows.Foundation.Collections.IMapView<string, string>): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccount>;
+    static AddWebAccountForUserAsync(user: Windows.System.User, webAccountId: string, webAccountUserName: string, props: Windows.Foundation.Collections.IMapView<string, string>): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccount>;
+    static AddWebAccountForUserAsync(user: Windows.System.User, webAccountId: string, webAccountUserName: string, props: Windows.Foundation.Collections.IMapView<string, string>, scope: number): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccount>;
+    static AddWebAccountForUserAsync(user: Windows.System.User, webAccountId: string, webAccountUserName: string, props: Windows.Foundation.Collections.IMapView<string, string>, scope: number, perUserWebAccountId: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccount>;
+    static ClearPerUserFromPerAppAccountAsync(perAppAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncAction;
+    static ClearViewAsync(webAccount: Windows.Security.Credentials.WebAccount, applicationCallbackUri: Windows.Foundation.Uri): Windows.Foundation.IAsyncAction;
+    static ClearWebAccountPictureAsync(webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncAction;
+    static DeleteWebAccountAsync(webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncAction;
+    static FindAllProviderWebAccountsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Security.Credentials.WebAccount> | Windows.Security.Credentials.WebAccount[]>;
+    static FindAllProviderWebAccountsForUserAsync(user: Windows.System.User): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Security.Credentials.WebAccount> | Windows.Security.Credentials.WebAccount[]>;
+    static GetPerUserFromPerAppAccountAsync(perAppAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccount>;
+    static GetScope(webAccount: Windows.Security.Credentials.WebAccount): number;
+    static GetViewsAsync(webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Security.Authentication.Web.Provider.WebAccountClientView> | Windows.Security.Authentication.Web.Provider.WebAccountClientView[]>;
+    static InvalidateAppCacheForAccountAsync(webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncAction;
+    static InvalidateAppCacheForAllAccountsAsync(): Windows.Foundation.IAsyncAction;
+    static PullCookiesAsync(uriString: string, callerPFN: string): Windows.Foundation.IAsyncAction;
+    static PushCookiesAsync(uri: Windows.Foundation.Uri, cookies: Windows.Foundation.Collections.IVectorView<Windows.Web.Http.HttpCookie> | Windows.Web.Http.HttpCookie[]): Windows.Foundation.IAsyncAction;
+    static SetPerAppToPerUserAccountAsync(perAppAccount: Windows.Security.Credentials.WebAccount, perUserWebAccountId: string): Windows.Foundation.IAsyncAction;
+    static SetScopeAsync(webAccount: Windows.Security.Credentials.WebAccount, scope: number): Windows.Foundation.IAsyncAction;
+    static SetViewAsync(webAccount: Windows.Security.Credentials.WebAccount, view: Windows.Security.Authentication.Web.Provider.WebAccountClientView): Windows.Foundation.IAsyncAction;
+    static SetWebAccountPictureAsync(webAccount: Windows.Security.Credentials.WebAccount, webAccountPicture: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    static UpdateWebAccountPropertiesAsync(webAccount: Windows.Security.Credentials.WebAccount, webAccountUserName: string, additionalProperties: Windows.Foundation.Collections.IMapView<string, string>): Windows.Foundation.IAsyncAction;
+  }
+
+  class WebAccountProviderAddAccountOperation implements Windows.Security.Authentication.Web.Provider.IWebAccountProviderAddAccountOperation, Windows.Security.Authentication.Web.Provider.IWebAccountProviderOperation {
+    ReportCompleted(): void;
+    readonly Kind: number;
+  }
+
+  class WebAccountProviderDeleteAccountOperation implements Windows.Security.Authentication.Web.Provider.IWebAccountProviderBaseReportOperation, Windows.Security.Authentication.Web.Provider.IWebAccountProviderDeleteAccountOperation, Windows.Security.Authentication.Web.Provider.IWebAccountProviderOperation {
+    ReportCompleted(): void;
+    ReportError(value: Windows.Security.Authentication.Web.Core.WebProviderError): void;
+    readonly Kind: number;
+    readonly WebAccount: Windows.Security.Credentials.WebAccount;
+  }
+
+  class WebAccountProviderGetTokenSilentOperation implements Windows.Security.Authentication.Web.Provider.IWebAccountProviderBaseReportOperation, Windows.Security.Authentication.Web.Provider.IWebAccountProviderOperation, Windows.Security.Authentication.Web.Provider.IWebAccountProviderSilentReportOperation, Windows.Security.Authentication.Web.Provider.IWebAccountProviderTokenOperation {
+    ReportCompleted(): void;
+    ReportError(value: Windows.Security.Authentication.Web.Core.WebProviderError): void;
+    ReportUserInteractionRequired(): void;
+    ReportUserInteractionRequired(value: Windows.Security.Authentication.Web.Core.WebProviderError): void;
+    CacheExpirationTime: Windows.Foundation.DateTime;
+    readonly Kind: number;
+    readonly ProviderRequest: Windows.Security.Authentication.Web.Provider.WebProviderTokenRequest;
+    readonly ProviderResponses: Windows.Foundation.Collections.IVector<Windows.Security.Authentication.Web.Provider.WebProviderTokenResponse> | Windows.Security.Authentication.Web.Provider.WebProviderTokenResponse[];
+  }
+
+  class WebAccountProviderManageAccountOperation implements Windows.Security.Authentication.Web.Provider.IWebAccountProviderManageAccountOperation, Windows.Security.Authentication.Web.Provider.IWebAccountProviderOperation {
+    ReportCompleted(): void;
+    readonly Kind: number;
+    readonly WebAccount: Windows.Security.Credentials.WebAccount;
+  }
+
+  class WebAccountProviderRequestTokenOperation implements Windows.Security.Authentication.Web.Provider.IWebAccountProviderBaseReportOperation, Windows.Security.Authentication.Web.Provider.IWebAccountProviderOperation, Windows.Security.Authentication.Web.Provider.IWebAccountProviderTokenOperation, Windows.Security.Authentication.Web.Provider.IWebAccountProviderUIReportOperation {
+    ReportCompleted(): void;
+    ReportError(value: Windows.Security.Authentication.Web.Core.WebProviderError): void;
+    ReportUserCanceled(): void;
+    CacheExpirationTime: Windows.Foundation.DateTime;
+    readonly Kind: number;
+    readonly ProviderRequest: Windows.Security.Authentication.Web.Provider.WebProviderTokenRequest;
+    readonly ProviderResponses: Windows.Foundation.Collections.IVector<Windows.Security.Authentication.Web.Provider.WebProviderTokenResponse> | Windows.Security.Authentication.Web.Provider.WebProviderTokenResponse[];
+  }
+
+  class WebAccountProviderRetrieveCookiesOperation implements Windows.Security.Authentication.Web.Provider.IWebAccountProviderBaseReportOperation, Windows.Security.Authentication.Web.Provider.IWebAccountProviderOperation, Windows.Security.Authentication.Web.Provider.IWebAccountProviderRetrieveCookiesOperation {
+    ReportCompleted(): void;
+    ReportError(value: Windows.Security.Authentication.Web.Core.WebProviderError): void;
+    readonly ApplicationCallbackUri: Windows.Foundation.Uri;
+    readonly Context: Windows.Foundation.Uri;
+    readonly Cookies: Windows.Foundation.Collections.IVector<Windows.Web.Http.HttpCookie> | Windows.Web.Http.HttpCookie[];
+    readonly Kind: number;
+    Uri: Windows.Foundation.Uri;
+  }
+
+  class WebAccountProviderSignOutAccountOperation implements Windows.Security.Authentication.Web.Provider.IWebAccountProviderBaseReportOperation, Windows.Security.Authentication.Web.Provider.IWebAccountProviderOperation, Windows.Security.Authentication.Web.Provider.IWebAccountProviderSignOutAccountOperation {
+    ReportCompleted(): void;
+    ReportError(value: Windows.Security.Authentication.Web.Core.WebProviderError): void;
+    readonly ApplicationCallbackUri: Windows.Foundation.Uri;
+    readonly ClientId: string;
+    readonly Kind: number;
+    readonly WebAccount: Windows.Security.Credentials.WebAccount;
+  }
+
+  class WebAccountProviderTriggerDetails implements Windows.Security.Authentication.Web.Provider.IWebAccountProviderTokenObjects, Windows.Security.Authentication.Web.Provider.IWebAccountProviderTokenObjects2 {
+    readonly Operation: Windows.Security.Authentication.Web.Provider.IWebAccountProviderOperation;
+    readonly User: Windows.System.User;
+  }
+
+  class WebProviderTokenRequest implements Windows.Security.Authentication.Web.Provider.IWebProviderTokenRequest, Windows.Security.Authentication.Web.Provider.IWebProviderTokenRequest2, Windows.Security.Authentication.Web.Provider.IWebProviderTokenRequest3 {
+    CheckApplicationForCapabilityAsync(capabilityName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    GetApplicationTokenBindingKeyAsync(keyType: number, target: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Security.Cryptography.Core.CryptographicKey>;
+    GetApplicationTokenBindingKeyIdAsync(keyType: number, target: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    readonly ApplicationCallbackUri: Windows.Foundation.Uri;
+    readonly ApplicationPackageFamilyName: string;
+    readonly ApplicationProcessName: string;
+    readonly ClientRequest: Windows.Security.Authentication.Web.Core.WebTokenRequest;
+    readonly WebAccountSelectionOptions: number;
+    readonly WebAccounts: Windows.Foundation.Collections.IVectorView<Windows.Security.Credentials.WebAccount> | Windows.Security.Credentials.WebAccount[];
+  }
+
+  class WebProviderTokenResponse implements Windows.Security.Authentication.Web.Provider.IWebProviderTokenResponse {
+    constructor(webTokenResponse: Windows.Security.Authentication.Web.Core.WebTokenResponse);
+    readonly ClientResponse: Windows.Security.Authentication.Web.Core.WebTokenResponse;
+  }
+
+  enum WebAccountClientViewType {
+    IdOnly = 0,
+    IdAndProperties = 1,
+  }
+
+  enum WebAccountProviderOperationKind {
+    RequestToken = 0,
+    GetTokenSilently = 1,
+    AddAccount = 2,
+    ManageAccount = 3,
+    DeleteAccount = 4,
+    RetrieveCookies = 5,
+    SignOutAccount = 6,
+  }
+
+  enum WebAccountScope {
+    PerUser = 0,
+    PerApplication = 1,
+  }
+
+  enum WebAccountSelectionOptions {
+    Default = 0,
+    New = 1,
+  }
+
+  interface IWebAccountClientView {
+    readonly AccountPairwiseId: string;
+    readonly ApplicationCallbackUri: Windows.Foundation.Uri;
+    readonly Type: number;
+  }
+  var IWebAccountClientView: abstract new (...args: any[]) => IWebAccountClientView;
+
+  interface IWebAccountClientViewFactory {
+    Create(viewType: number, applicationCallbackUri: Windows.Foundation.Uri): Windows.Security.Authentication.Web.Provider.WebAccountClientView;
+    CreateWithPairwiseId(viewType: number, applicationCallbackUri: Windows.Foundation.Uri, accountPairwiseId: string): Windows.Security.Authentication.Web.Provider.WebAccountClientView;
+  }
+  var IWebAccountClientViewFactory: abstract new (...args: any[]) => IWebAccountClientViewFactory;
+
+  interface IWebAccountManagerStatics {
+    AddWebAccountAsync(webAccountId: string, webAccountUserName: string, props: Windows.Foundation.Collections.IMapView<string, string>): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccount>;
+    ClearViewAsync(webAccount: Windows.Security.Credentials.WebAccount, applicationCallbackUri: Windows.Foundation.Uri): Windows.Foundation.IAsyncAction;
+    ClearWebAccountPictureAsync(webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncAction;
+    DeleteWebAccountAsync(webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncAction;
+    FindAllProviderWebAccountsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Security.Credentials.WebAccount> | Windows.Security.Credentials.WebAccount[]>;
+    GetViewsAsync(webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Security.Authentication.Web.Provider.WebAccountClientView> | Windows.Security.Authentication.Web.Provider.WebAccountClientView[]>;
+    PushCookiesAsync(uri: Windows.Foundation.Uri, cookies: Windows.Foundation.Collections.IVectorView<Windows.Web.Http.HttpCookie> | Windows.Web.Http.HttpCookie[]): Windows.Foundation.IAsyncAction;
+    SetViewAsync(webAccount: Windows.Security.Credentials.WebAccount, view: Windows.Security.Authentication.Web.Provider.WebAccountClientView): Windows.Foundation.IAsyncAction;
+    SetWebAccountPictureAsync(webAccount: Windows.Security.Credentials.WebAccount, webAccountPicture: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    UpdateWebAccountPropertiesAsync(webAccount: Windows.Security.Credentials.WebAccount, webAccountUserName: string, additionalProperties: Windows.Foundation.Collections.IMapView<string, string>): Windows.Foundation.IAsyncAction;
+  }
+  var IWebAccountManagerStatics: abstract new (...args: any[]) => IWebAccountManagerStatics;
+
+  interface IWebAccountManagerStatics2 {
+    PullCookiesAsync(uriString: string, callerPFN: string): Windows.Foundation.IAsyncAction;
+  }
+  var IWebAccountManagerStatics2: abstract new (...args: any[]) => IWebAccountManagerStatics2;
+
+  interface IWebAccountManagerStatics3 {
+    AddWebAccountForUserAsync(user: Windows.System.User, webAccountId: string, webAccountUserName: string, props: Windows.Foundation.Collections.IMapView<string, string>): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccount>;
+    AddWebAccountForUserAsync(user: Windows.System.User, webAccountId: string, webAccountUserName: string, props: Windows.Foundation.Collections.IMapView<string, string>, scope: number): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccount>;
+    AddWebAccountForUserAsync(user: Windows.System.User, webAccountId: string, webAccountUserName: string, props: Windows.Foundation.Collections.IMapView<string, string>, scope: number, perUserWebAccountId: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccount>;
+    FindAllProviderWebAccountsForUserAsync(user: Windows.System.User): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Security.Credentials.WebAccount> | Windows.Security.Credentials.WebAccount[]>;
+  }
+  var IWebAccountManagerStatics3: abstract new (...args: any[]) => IWebAccountManagerStatics3;
+
+  interface IWebAccountManagerStatics4 {
+    InvalidateAppCacheForAccountAsync(webAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncAction;
+    InvalidateAppCacheForAllAccountsAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var IWebAccountManagerStatics4: abstract new (...args: any[]) => IWebAccountManagerStatics4;
+
+  interface IWebAccountMapManagerStatics {
+    AddWebAccountAsync(webAccountId: string, webAccountUserName: string, props: Windows.Foundation.Collections.IMapView<string, string>, scope: number, perUserWebAccountId: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccount>;
+    ClearPerUserFromPerAppAccountAsync(perAppAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncAction;
+    GetPerUserFromPerAppAccountAsync(perAppAccount: Windows.Security.Credentials.WebAccount): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccount>;
+    SetPerAppToPerUserAccountAsync(perAppAccount: Windows.Security.Credentials.WebAccount, perUserWebAccountId: string): Windows.Foundation.IAsyncAction;
+  }
+  var IWebAccountMapManagerStatics: abstract new (...args: any[]) => IWebAccountMapManagerStatics;
+
+  interface IWebAccountProviderAddAccountOperation extends Windows.Security.Authentication.Web.Provider.IWebAccountProviderOperation {
+    ReportCompleted(): void;
+  }
+  var IWebAccountProviderAddAccountOperation: abstract new (...args: any[]) => IWebAccountProviderAddAccountOperation;
+
+  interface IWebAccountProviderBaseReportOperation {
+    ReportCompleted(): void;
+    ReportError(value: Windows.Security.Authentication.Web.Core.WebProviderError): void;
+  }
+  var IWebAccountProviderBaseReportOperation: abstract new (...args: any[]) => IWebAccountProviderBaseReportOperation;
+
+  interface IWebAccountProviderDeleteAccountOperation extends Windows.Security.Authentication.Web.Provider.IWebAccountProviderOperation {
+    readonly WebAccount: Windows.Security.Credentials.WebAccount;
+  }
+  var IWebAccountProviderDeleteAccountOperation: abstract new (...args: any[]) => IWebAccountProviderDeleteAccountOperation;
+
+  interface IWebAccountProviderManageAccountOperation extends Windows.Security.Authentication.Web.Provider.IWebAccountProviderOperation {
+    ReportCompleted(): void;
+    readonly WebAccount: Windows.Security.Credentials.WebAccount;
+  }
+  var IWebAccountProviderManageAccountOperation: abstract new (...args: any[]) => IWebAccountProviderManageAccountOperation;
+
+  interface IWebAccountProviderOperation {
+    readonly Kind: number;
+  }
+  var IWebAccountProviderOperation: abstract new (...args: any[]) => IWebAccountProviderOperation;
+
+  interface IWebAccountProviderRetrieveCookiesOperation extends Windows.Security.Authentication.Web.Provider.IWebAccountProviderOperation {
+    readonly ApplicationCallbackUri: Windows.Foundation.Uri;
+    readonly Context: Windows.Foundation.Uri;
+    readonly Cookies: Windows.Foundation.Collections.IVector<Windows.Web.Http.HttpCookie> | Windows.Web.Http.HttpCookie[];
+    Uri: Windows.Foundation.Uri;
+  }
+  var IWebAccountProviderRetrieveCookiesOperation: abstract new (...args: any[]) => IWebAccountProviderRetrieveCookiesOperation;
+
+  interface IWebAccountProviderSignOutAccountOperation extends Windows.Security.Authentication.Web.Provider.IWebAccountProviderOperation {
+    readonly ApplicationCallbackUri: Windows.Foundation.Uri;
+    readonly ClientId: string;
+    readonly WebAccount: Windows.Security.Credentials.WebAccount;
+  }
+  var IWebAccountProviderSignOutAccountOperation: abstract new (...args: any[]) => IWebAccountProviderSignOutAccountOperation;
+
+  interface IWebAccountProviderSilentReportOperation extends Windows.Security.Authentication.Web.Provider.IWebAccountProviderBaseReportOperation {
+    ReportCompleted(): void;
+    ReportError(value: Windows.Security.Authentication.Web.Core.WebProviderError): void;
+    ReportUserInteractionRequired(): void;
+    ReportUserInteractionRequired(value: Windows.Security.Authentication.Web.Core.WebProviderError): void;
+  }
+  var IWebAccountProviderSilentReportOperation: abstract new (...args: any[]) => IWebAccountProviderSilentReportOperation;
+
+  interface IWebAccountProviderTokenObjects {
+    readonly Operation: Windows.Security.Authentication.Web.Provider.IWebAccountProviderOperation;
+  }
+  var IWebAccountProviderTokenObjects: abstract new (...args: any[]) => IWebAccountProviderTokenObjects;
+
+  interface IWebAccountProviderTokenObjects2 extends Windows.Security.Authentication.Web.Provider.IWebAccountProviderTokenObjects {
+    readonly User: Windows.System.User;
+  }
+  var IWebAccountProviderTokenObjects2: abstract new (...args: any[]) => IWebAccountProviderTokenObjects2;
+
+  interface IWebAccountProviderTokenOperation extends Windows.Security.Authentication.Web.Provider.IWebAccountProviderOperation {
+    CacheExpirationTime: Windows.Foundation.DateTime;
+    readonly ProviderRequest: Windows.Security.Authentication.Web.Provider.WebProviderTokenRequest;
+    readonly ProviderResponses: Windows.Foundation.Collections.IVector<Windows.Security.Authentication.Web.Provider.WebProviderTokenResponse> | Windows.Security.Authentication.Web.Provider.WebProviderTokenResponse[];
+  }
+  var IWebAccountProviderTokenOperation: abstract new (...args: any[]) => IWebAccountProviderTokenOperation;
+
+  interface IWebAccountProviderUIReportOperation extends Windows.Security.Authentication.Web.Provider.IWebAccountProviderBaseReportOperation {
+    ReportCompleted(): void;
+    ReportError(value: Windows.Security.Authentication.Web.Core.WebProviderError): void;
+    ReportUserCanceled(): void;
+  }
+  var IWebAccountProviderUIReportOperation: abstract new (...args: any[]) => IWebAccountProviderUIReportOperation;
+
+  interface IWebAccountScopeManagerStatics {
+    AddWebAccountAsync(webAccountId: string, webAccountUserName: string, props: Windows.Foundation.Collections.IMapView<string, string>, scope: number): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.WebAccount>;
+    GetScope(webAccount: Windows.Security.Credentials.WebAccount): number;
+    SetScopeAsync(webAccount: Windows.Security.Credentials.WebAccount, scope: number): Windows.Foundation.IAsyncAction;
+  }
+  var IWebAccountScopeManagerStatics: abstract new (...args: any[]) => IWebAccountScopeManagerStatics;
+
+  interface IWebProviderTokenRequest {
+    GetApplicationTokenBindingKeyAsync(keyType: number, target: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Security.Cryptography.Core.CryptographicKey>;
+    readonly ApplicationCallbackUri: Windows.Foundation.Uri;
+    readonly ClientRequest: Windows.Security.Authentication.Web.Core.WebTokenRequest;
+    readonly WebAccountSelectionOptions: number;
+    readonly WebAccounts: Windows.Foundation.Collections.IVectorView<Windows.Security.Credentials.WebAccount> | Windows.Security.Credentials.WebAccount[];
+  }
+  var IWebProviderTokenRequest: abstract new (...args: any[]) => IWebProviderTokenRequest;
+
+  interface IWebProviderTokenRequest2 {
+    GetApplicationTokenBindingKeyIdAsync(keyType: number, target: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+  }
+  var IWebProviderTokenRequest2: abstract new (...args: any[]) => IWebProviderTokenRequest2;
+
+  interface IWebProviderTokenRequest3 {
+    CheckApplicationForCapabilityAsync(capabilityName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly ApplicationPackageFamilyName: string;
+    readonly ApplicationProcessName: string;
+  }
+  var IWebProviderTokenRequest3: abstract new (...args: any[]) => IWebProviderTokenRequest3;
+
+  interface IWebProviderTokenResponse {
+    readonly ClientResponse: Windows.Security.Authentication.Web.Core.WebTokenResponse;
+  }
+  var IWebProviderTokenResponse: abstract new (...args: any[]) => IWebProviderTokenResponse;
+
+  interface IWebProviderTokenResponseFactory {
+    Create(webTokenResponse: Windows.Security.Authentication.Web.Core.WebTokenResponse): Windows.Security.Authentication.Web.Provider.WebProviderTokenResponse;
+  }
+  var IWebProviderTokenResponseFactory: abstract new (...args: any[]) => IWebProviderTokenResponseFactory;
+
+}
+
+declare namespace Windows.Security.Authorization.AppCapabilityAccess {
+  class AppCapability implements Windows.Security.Authorization.AppCapabilityAccess.IAppCapability, Windows.Security.Authorization.AppCapabilityAccess.IAppCapability2 {
+    CheckAccess(): number;
+    static Create(capabilityName: string): Windows.Security.Authorization.AppCapabilityAccess.AppCapability;
+    static CreateWithProcessIdForUser(user: Windows.System.User, capabilityName: string, pid: number): Windows.Security.Authorization.AppCapabilityAccess.AppCapability;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    static RequestAccessForCapabilitiesAsync(capabilityNames: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<string, number>>;
+    static RequestAccessForCapabilitiesForUserAsync(user: Windows.System.User, capabilityNames: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<string, number>>;
+    readonly CapabilityName: string;
+    DisplayMessage: string;
+    readonly User: Windows.System.User;
+    AccessChanged: Windows.Foundation.TypedEventHandler<Windows.Security.Authorization.AppCapabilityAccess.AppCapability, Windows.Security.Authorization.AppCapabilityAccess.AppCapabilityAccessChangedEventArgs> | null;
+  }
+
+  class AppCapabilityAccessChangedEventArgs implements Windows.Security.Authorization.AppCapabilityAccess.IAppCapabilityAccessChangedEventArgs {
+  }
+
+  enum AppCapabilityAccessStatus {
+    DeniedBySystem = 0,
+    NotDeclaredByApp = 1,
+    DeniedByUser = 2,
+    UserPromptRequired = 3,
+    Allowed = 4,
+  }
+
+  interface IAppCapability {
+    CheckAccess(): number;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly CapabilityName: string;
+    readonly User: Windows.System.User;
+    AccessChanged: Windows.Foundation.TypedEventHandler<Windows.Security.Authorization.AppCapabilityAccess.AppCapability, Windows.Security.Authorization.AppCapabilityAccess.AppCapabilityAccessChangedEventArgs> | null;
+  }
+  var IAppCapability: abstract new (...args: any[]) => IAppCapability;
+
+  interface IAppCapability2 {
+    DisplayMessage: string;
+  }
+  var IAppCapability2: abstract new (...args: any[]) => IAppCapability2;
+
+  interface IAppCapabilityAccessChangedEventArgs {
+  }
+  var IAppCapabilityAccessChangedEventArgs: abstract new (...args: any[]) => IAppCapabilityAccessChangedEventArgs;
+
+  interface IAppCapabilityStatics {
+    Create(capabilityName: string): Windows.Security.Authorization.AppCapabilityAccess.AppCapability;
+    CreateWithProcessIdForUser(user: Windows.System.User, capabilityName: string, pid: number): Windows.Security.Authorization.AppCapabilityAccess.AppCapability;
+    RequestAccessForCapabilitiesAsync(capabilityNames: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<string, number>>;
+    RequestAccessForCapabilitiesForUserAsync(user: Windows.System.User, capabilityNames: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<string, number>>;
+  }
+  var IAppCapabilityStatics: abstract new (...args: any[]) => IAppCapabilityStatics;
+
+}
+
+declare namespace Windows.Security.Credentials {
+  class KeyCredential implements Windows.Security.Credentials.IKeyCredential {
+    GetAttestationAsync(): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.KeyCredentialAttestationResult>;
+    RequestSignAsync(data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.KeyCredentialOperationResult>;
+    RetrievePublicKey(): Windows.Storage.Streams.IBuffer;
+    RetrievePublicKey(blobType: number): Windows.Storage.Streams.IBuffer;
+    readonly Name: string;
+  }
+
+  class KeyCredentialAttestationResult implements Windows.Security.Credentials.IKeyCredentialAttestationResult {
+    readonly AttestationBuffer: Windows.Storage.Streams.IBuffer;
+    readonly CertificateChainBuffer: Windows.Storage.Streams.IBuffer;
+    readonly Status: number;
+  }
+
+  class KeyCredentialManager {
+    static DeleteAsync(name: string): Windows.Foundation.IAsyncAction;
+    static IsSupportedAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    static OpenAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.KeyCredentialRetrievalResult>;
+    static RenewAttestationAsync(): Windows.Foundation.IAsyncAction;
+    static RequestCreateAsync(name: string, option: number): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.KeyCredentialRetrievalResult>;
+  }
+
+  class KeyCredentialOperationResult implements Windows.Security.Credentials.IKeyCredentialOperationResult {
+    readonly Result: Windows.Storage.Streams.IBuffer;
+    readonly Status: number;
+  }
+
+  class KeyCredentialRetrievalResult implements Windows.Security.Credentials.IKeyCredentialRetrievalResult {
+    readonly Credential: Windows.Security.Credentials.KeyCredential;
+    readonly Status: number;
+  }
+
+  class PasswordCredential implements Windows.Security.Credentials.IPasswordCredential {
+    constructor(resource: string, userName: string, password: string);
+    constructor();
+    RetrievePassword(): void;
+    Password: string;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+    Resource: string;
+    UserName: string;
+  }
+
+  class PasswordCredentialPropertyStore implements Windows.Foundation.Collections.IPropertySet {
+    constructor();
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, Object>>;
+    GetView(): Windows.Foundation.Collections.IMapView<string, Object>;
+    HasKey(key: string): boolean;
+    Insert(key: string, value: Object): boolean;
+    Lookup(key: string): Object;
+    Remove(key: string): void;
+    readonly Size: number;
+    MapChanged: Windows.Foundation.Collections.MapChangedEventHandler<string, Object> | null;
+  }
+
+  class PasswordVault implements Windows.Security.Credentials.IPasswordVault {
+    constructor();
+    Add(credential: Windows.Security.Credentials.PasswordCredential): void;
+    FindAllByResource(resource: string): Windows.Foundation.Collections.IVectorView<Windows.Security.Credentials.PasswordCredential> | Windows.Security.Credentials.PasswordCredential[];
+    FindAllByUserName(userName: string): Windows.Foundation.Collections.IVectorView<Windows.Security.Credentials.PasswordCredential> | Windows.Security.Credentials.PasswordCredential[];
+    Remove(credential: Windows.Security.Credentials.PasswordCredential): void;
+    Retrieve(resource: string, userName: string): Windows.Security.Credentials.PasswordCredential;
+    RetrieveAll(): Windows.Foundation.Collections.IVectorView<Windows.Security.Credentials.PasswordCredential> | Windows.Security.Credentials.PasswordCredential[];
+  }
+
+  class WebAccount implements Windows.Security.Credentials.IWebAccount, Windows.Security.Credentials.IWebAccount2 {
+    constructor(webAccountProvider: Windows.Security.Credentials.WebAccountProvider, userName: string, state: number);
+    GetPictureAsync(desizedSize: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    SignOutAsync(): Windows.Foundation.IAsyncAction;
+    SignOutAsync(clientId: string): Windows.Foundation.IAsyncAction;
+    readonly Id: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, string>;
+    readonly State: number;
+    readonly UserName: string;
+    readonly WebAccountProvider: Windows.Security.Credentials.WebAccountProvider;
+  }
+
+  class WebAccountProvider implements Windows.Security.Credentials.IWebAccountProvider, Windows.Security.Credentials.IWebAccountProvider2, Windows.Security.Credentials.IWebAccountProvider3, Windows.Security.Credentials.IWebAccountProvider4 {
+    constructor(id: string, displayName: string, iconUri: Windows.Foundation.Uri);
+    readonly Authority: string;
+    readonly DisplayName: string;
+    readonly DisplayPurpose: string;
+    readonly IconUri: Windows.Foundation.Uri;
+    readonly Id: string;
+    readonly IsSystemProvider: boolean;
+    readonly User: Windows.System.User;
+  }
+
+  enum KeyCredentialAttestationStatus {
+    Success = 0,
+    UnknownError = 1,
+    NotSupported = 2,
+    TemporaryFailure = 3,
+  }
+
+  enum KeyCredentialCreationOption {
+    ReplaceExisting = 0,
+    FailIfExists = 1,
+  }
+
+  enum KeyCredentialStatus {
+    Success = 0,
+    UnknownError = 1,
+    NotFound = 2,
+    UserCanceled = 3,
+    UserPrefersPassword = 4,
+    CredentialAlreadyExists = 5,
+    SecurityDeviceLocked = 6,
+  }
+
+  enum WebAccountPictureSize {
+    Size64x64 = 64,
+    Size208x208 = 208,
+    Size424x424 = 424,
+    Size1080x1080 = 1080,
+  }
+
+  enum WebAccountState {
+    None = 0,
+    Connected = 1,
+    Error = 2,
+  }
+
+  interface ICredentialFactory {
+    CreatePasswordCredential(resource: string, userName: string, password: string): Windows.Security.Credentials.PasswordCredential;
+  }
+  var ICredentialFactory: abstract new (...args: any[]) => ICredentialFactory;
+
+  interface IKeyCredential {
+    GetAttestationAsync(): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.KeyCredentialAttestationResult>;
+    RequestSignAsync(data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.KeyCredentialOperationResult>;
+    RetrievePublicKey(): Windows.Storage.Streams.IBuffer;
+    RetrievePublicKey(blobType: number): Windows.Storage.Streams.IBuffer;
+    readonly Name: string;
+  }
+  var IKeyCredential: abstract new (...args: any[]) => IKeyCredential;
+
+  interface IKeyCredentialAttestationResult {
+    readonly AttestationBuffer: Windows.Storage.Streams.IBuffer;
+    readonly CertificateChainBuffer: Windows.Storage.Streams.IBuffer;
+    readonly Status: number;
+  }
+  var IKeyCredentialAttestationResult: abstract new (...args: any[]) => IKeyCredentialAttestationResult;
+
+  interface IKeyCredentialManagerStatics {
+    DeleteAsync(name: string): Windows.Foundation.IAsyncAction;
+    IsSupportedAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    OpenAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.KeyCredentialRetrievalResult>;
+    RenewAttestationAsync(): Windows.Foundation.IAsyncAction;
+    RequestCreateAsync(name: string, option: number): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.KeyCredentialRetrievalResult>;
+  }
+  var IKeyCredentialManagerStatics: abstract new (...args: any[]) => IKeyCredentialManagerStatics;
+
+  interface IKeyCredentialOperationResult {
+    readonly Result: Windows.Storage.Streams.IBuffer;
+    readonly Status: number;
+  }
+  var IKeyCredentialOperationResult: abstract new (...args: any[]) => IKeyCredentialOperationResult;
+
+  interface IKeyCredentialRetrievalResult {
+    readonly Credential: Windows.Security.Credentials.KeyCredential;
+    readonly Status: number;
+  }
+  var IKeyCredentialRetrievalResult: abstract new (...args: any[]) => IKeyCredentialRetrievalResult;
+
+  interface IPasswordCredential {
+    RetrievePassword(): void;
+    Password: string;
+    readonly Properties: Windows.Foundation.Collections.IPropertySet;
+    Resource: string;
+    UserName: string;
+  }
+  var IPasswordCredential: abstract new (...args: any[]) => IPasswordCredential;
+
+  interface IPasswordVault {
+    Add(credential: Windows.Security.Credentials.PasswordCredential): void;
+    FindAllByResource(resource: string): Windows.Foundation.Collections.IVectorView<Windows.Security.Credentials.PasswordCredential> | Windows.Security.Credentials.PasswordCredential[];
+    FindAllByUserName(userName: string): Windows.Foundation.Collections.IVectorView<Windows.Security.Credentials.PasswordCredential> | Windows.Security.Credentials.PasswordCredential[];
+    Remove(credential: Windows.Security.Credentials.PasswordCredential): void;
+    Retrieve(resource: string, userName: string): Windows.Security.Credentials.PasswordCredential;
+    RetrieveAll(): Windows.Foundation.Collections.IVectorView<Windows.Security.Credentials.PasswordCredential> | Windows.Security.Credentials.PasswordCredential[];
+  }
+  var IPasswordVault: abstract new (...args: any[]) => IPasswordVault;
+
+  interface IWebAccount {
+    readonly State: number;
+    readonly UserName: string;
+    readonly WebAccountProvider: Windows.Security.Credentials.WebAccountProvider;
+  }
+  var IWebAccount: abstract new (...args: any[]) => IWebAccount;
+
+  interface IWebAccount2 extends Windows.Security.Credentials.IWebAccount {
+    GetPictureAsync(desizedSize: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    SignOutAsync(): Windows.Foundation.IAsyncAction;
+    SignOutAsync(clientId: string): Windows.Foundation.IAsyncAction;
+    readonly Id: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, string>;
+  }
+  var IWebAccount2: abstract new (...args: any[]) => IWebAccount2;
+
+  interface IWebAccountFactory {
+    CreateWebAccount(webAccountProvider: Windows.Security.Credentials.WebAccountProvider, userName: string, state: number): Windows.Security.Credentials.WebAccount;
+  }
+  var IWebAccountFactory: abstract new (...args: any[]) => IWebAccountFactory;
+
+  interface IWebAccountProvider {
+    readonly DisplayName: string;
+    readonly IconUri: Windows.Foundation.Uri;
+    readonly Id: string;
+  }
+  var IWebAccountProvider: abstract new (...args: any[]) => IWebAccountProvider;
+
+  interface IWebAccountProvider2 extends Windows.Security.Credentials.IWebAccountProvider {
+    readonly Authority: string;
+    readonly DisplayPurpose: string;
+  }
+  var IWebAccountProvider2: abstract new (...args: any[]) => IWebAccountProvider2;
+
+  interface IWebAccountProvider3 extends Windows.Security.Credentials.IWebAccountProvider, Windows.Security.Credentials.IWebAccountProvider2 {
+    readonly User: Windows.System.User;
+  }
+  var IWebAccountProvider3: abstract new (...args: any[]) => IWebAccountProvider3;
+
+  interface IWebAccountProvider4 {
+    readonly IsSystemProvider: boolean;
+  }
+  var IWebAccountProvider4: abstract new (...args: any[]) => IWebAccountProvider4;
+
+  interface IWebAccountProviderFactory {
+    CreateWebAccountProvider(id: string, displayName: string, iconUri: Windows.Foundation.Uri): Windows.Security.Credentials.WebAccountProvider;
+  }
+  var IWebAccountProviderFactory: abstract new (...args: any[]) => IWebAccountProviderFactory;
+
+}
+
+declare namespace Windows.Security.Credentials.UI {
+  class CredentialPicker {
+    static PickAsync(options: Windows.Security.Credentials.UI.CredentialPickerOptions): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.UI.CredentialPickerResults>;
+    static PickAsync(targetName: string, message: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.UI.CredentialPickerResults>;
+    static PickAsync(targetName: string, message: string, caption: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.UI.CredentialPickerResults>;
+  }
+
+  class CredentialPickerOptions implements Windows.Security.Credentials.UI.ICredentialPickerOptions {
+    constructor();
+    AlwaysDisplayDialog: boolean;
+    AuthenticationProtocol: number;
+    CallerSavesCredential: boolean;
+    Caption: string;
+    CredentialSaveOption: number;
+    CustomAuthenticationProtocol: string;
+    ErrorCode: number;
+    Message: string;
+    PreviousCredential: Windows.Storage.Streams.IBuffer;
+    TargetName: string;
+  }
+
+  class CredentialPickerResults implements Windows.Security.Credentials.UI.ICredentialPickerResults {
+    readonly Credential: Windows.Storage.Streams.IBuffer;
+    readonly CredentialDomainName: string;
+    readonly CredentialPassword: string;
+    readonly CredentialSaveOption: number;
+    readonly CredentialSaved: boolean;
+    readonly CredentialUserName: string;
+    readonly ErrorCode: number;
+  }
+
+  class UserConsentVerifier {
+    static CheckAvailabilityAsync(): Windows.Foundation.IAsyncOperation<number>;
+    static RequestVerificationAsync(message: string): Windows.Foundation.IAsyncOperation<number>;
+  }
+
+  enum AuthenticationProtocol {
+    Basic = 0,
+    Digest = 1,
+    Ntlm = 2,
+    Kerberos = 3,
+    Negotiate = 4,
+    CredSsp = 5,
+    Custom = 6,
+  }
+
+  enum CredentialSaveOption {
+    Unselected = 0,
+    Selected = 1,
+    Hidden = 2,
+  }
+
+  enum UserConsentVerificationResult {
+    Verified = 0,
+    DeviceNotPresent = 1,
+    NotConfiguredForUser = 2,
+    DisabledByPolicy = 3,
+    DeviceBusy = 4,
+    RetriesExhausted = 5,
+    Canceled = 6,
+  }
+
+  enum UserConsentVerifierAvailability {
+    Available = 0,
+    DeviceNotPresent = 1,
+    NotConfiguredForUser = 2,
+    DisabledByPolicy = 3,
+    DeviceBusy = 4,
+  }
+
+  interface ICredentialPickerOptions {
+    AlwaysDisplayDialog: boolean;
+    AuthenticationProtocol: number;
+    CallerSavesCredential: boolean;
+    Caption: string;
+    CredentialSaveOption: number;
+    CustomAuthenticationProtocol: string;
+    ErrorCode: number;
+    Message: string;
+    PreviousCredential: Windows.Storage.Streams.IBuffer;
+    TargetName: string;
+  }
+  var ICredentialPickerOptions: abstract new (...args: any[]) => ICredentialPickerOptions;
+
+  interface ICredentialPickerResults {
+    readonly Credential: Windows.Storage.Streams.IBuffer;
+    readonly CredentialDomainName: string;
+    readonly CredentialPassword: string;
+    readonly CredentialSaveOption: number;
+    readonly CredentialSaved: boolean;
+    readonly CredentialUserName: string;
+    readonly ErrorCode: number;
+  }
+  var ICredentialPickerResults: abstract new (...args: any[]) => ICredentialPickerResults;
+
+  interface ICredentialPickerStatics {
+    PickAsync(options: Windows.Security.Credentials.UI.CredentialPickerOptions): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.UI.CredentialPickerResults>;
+    PickAsync(targetName: string, message: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.UI.CredentialPickerResults>;
+    PickAsync(targetName: string, message: string, caption: string): Windows.Foundation.IAsyncOperation<Windows.Security.Credentials.UI.CredentialPickerResults>;
+  }
+  var ICredentialPickerStatics: abstract new (...args: any[]) => ICredentialPickerStatics;
+
+  interface IUserConsentVerifierStatics {
+    CheckAvailabilityAsync(): Windows.Foundation.IAsyncOperation<number>;
+    RequestVerificationAsync(message: string): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IUserConsentVerifierStatics: abstract new (...args: any[]) => IUserConsentVerifierStatics;
+
+}
+
+declare namespace Windows.Security.Cryptography {
+  class CryptographicBuffer {
+    static Compare(object1: Windows.Storage.Streams.IBuffer, object2: Windows.Storage.Streams.IBuffer): boolean;
+    static ConvertBinaryToString(encoding: number, buffer: Windows.Storage.Streams.IBuffer): string;
+    static ConvertStringToBinary(value: string, encoding: number): Windows.Storage.Streams.IBuffer;
+    static CopyToByteArray(buffer: Windows.Storage.Streams.IBuffer, value: number[]): void;
+    static CreateFromByteArray(value: number[]): Windows.Storage.Streams.IBuffer;
+    static DecodeFromBase64String(value: string): Windows.Storage.Streams.IBuffer;
+    static DecodeFromHexString(value: string): Windows.Storage.Streams.IBuffer;
+    static EncodeToBase64String(buffer: Windows.Storage.Streams.IBuffer): string;
+    static EncodeToHexString(buffer: Windows.Storage.Streams.IBuffer): string;
+    static GenerateRandom(length: number): Windows.Storage.Streams.IBuffer;
+    static GenerateRandomNumber(): number;
+  }
+
+  enum BinaryStringEncoding {
+    Utf8 = 0,
+    Utf16LE = 1,
+    Utf16BE = 2,
+  }
+
+  interface ICryptographicBufferStatics {
+    Compare(object1: Windows.Storage.Streams.IBuffer, object2: Windows.Storage.Streams.IBuffer): boolean;
+    ConvertBinaryToString(encoding: number, buffer: Windows.Storage.Streams.IBuffer): string;
+    ConvertStringToBinary(value: string, encoding: number): Windows.Storage.Streams.IBuffer;
+    CopyToByteArray(buffer: Windows.Storage.Streams.IBuffer, value: number[]): void;
+    CreateFromByteArray(value: number[]): Windows.Storage.Streams.IBuffer;
+    DecodeFromBase64String(value: string): Windows.Storage.Streams.IBuffer;
+    DecodeFromHexString(value: string): Windows.Storage.Streams.IBuffer;
+    EncodeToBase64String(buffer: Windows.Storage.Streams.IBuffer): string;
+    EncodeToHexString(buffer: Windows.Storage.Streams.IBuffer): string;
+    GenerateRandom(length: number): Windows.Storage.Streams.IBuffer;
+    GenerateRandomNumber(): number;
+  }
+  var ICryptographicBufferStatics: abstract new (...args: any[]) => ICryptographicBufferStatics;
+
+}
+
+declare namespace Windows.Security.Cryptography.Certificates {
+  class Certificate implements Windows.Security.Cryptography.Certificates.ICertificate, Windows.Security.Cryptography.Certificates.ICertificate2, Windows.Security.Cryptography.Certificates.ICertificate3 {
+    constructor(certBlob: Windows.Storage.Streams.IBuffer);
+    BuildChainAsync(certificates: Windows.Foundation.Collections.IIterable<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[]): Windows.Foundation.IAsyncOperation<Windows.Security.Cryptography.Certificates.CertificateChain>;
+    BuildChainAsync(certificates: Windows.Foundation.Collections.IIterable<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[], parameters: Windows.Security.Cryptography.Certificates.ChainBuildingParameters): Windows.Foundation.IAsyncOperation<Windows.Security.Cryptography.Certificates.CertificateChain>;
+    GetCertificateBlob(): Windows.Storage.Streams.IBuffer;
+    GetHashValue(): number[];
+    GetHashValue(hashAlgorithmName: string): number[];
+    readonly EnhancedKeyUsages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    FriendlyName: string;
+    readonly HasPrivateKey: boolean;
+    readonly IsPerUser: boolean;
+    readonly IsSecurityDeviceBound: boolean;
+    readonly IsStronglyProtected: boolean;
+    readonly Issuer: string;
+    readonly KeyAlgorithmName: string;
+    readonly KeyStorageProviderName: string;
+    readonly KeyUsages: Windows.Security.Cryptography.Certificates.CertificateKeyUsages;
+    readonly SerialNumber: number[];
+    readonly SignatureAlgorithmName: string;
+    readonly SignatureHashAlgorithmName: string;
+    readonly StoreName: string;
+    readonly Subject: string;
+    readonly SubjectAlternativeName: Windows.Security.Cryptography.Certificates.SubjectAlternativeNameInfo;
+    readonly ValidFrom: Windows.Foundation.DateTime;
+    readonly ValidTo: Windows.Foundation.DateTime;
+  }
+
+  class CertificateChain implements Windows.Security.Cryptography.Certificates.ICertificateChain {
+    GetCertificates(includeRoot: boolean): Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+    Validate(): number;
+    Validate(parameter: Windows.Security.Cryptography.Certificates.ChainValidationParameters): number;
+  }
+
+  class CertificateEnrollmentManager {
+    static CreateRequestAsync(request: Windows.Security.Cryptography.Certificates.CertificateRequestProperties): Windows.Foundation.IAsyncOperation<string>;
+    static ImportPfxDataAsync(pfxData: string, password: string, pfxImportParameters: Windows.Security.Cryptography.Certificates.PfxImportParameters): Windows.Foundation.IAsyncAction;
+    static ImportPfxDataAsync(pfxData: string, password: string, exportable: number, keyProtectionLevel: number, installOption: number, friendlyName: string, keyStorageProvider: string): Windows.Foundation.IAsyncAction;
+    static ImportPfxDataAsync(pfxData: string, password: string, exportable: number, keyProtectionLevel: number, installOption: number, friendlyName: string): Windows.Foundation.IAsyncAction;
+    static InstallCertificateAsync(certificate: string, installOption: number): Windows.Foundation.IAsyncAction;
+    static readonly UserCertificateEnrollmentManager: Windows.Security.Cryptography.Certificates.UserCertificateEnrollmentManager;
+  }
+
+  class CertificateExtension implements Windows.Security.Cryptography.Certificates.ICertificateExtension {
+    constructor();
+    EncodeValue(value: string): void;
+    IsCritical: boolean;
+    ObjectId: string;
+    Value: number[];
+  }
+
+  class CertificateKeyUsages implements Windows.Security.Cryptography.Certificates.ICertificateKeyUsages {
+    constructor();
+    CrlSign: boolean;
+    DataEncipherment: boolean;
+    DigitalSignature: boolean;
+    EncipherOnly: boolean;
+    KeyAgreement: boolean;
+    KeyCertificateSign: boolean;
+    KeyEncipherment: boolean;
+    NonRepudiation: boolean;
+  }
+
+  class CertificateQuery implements Windows.Security.Cryptography.Certificates.ICertificateQuery, Windows.Security.Cryptography.Certificates.ICertificateQuery2 {
+    constructor();
+    readonly EnhancedKeyUsages: Windows.Foundation.Collections.IVector<string> | string[];
+    FriendlyName: string;
+    HardwareOnly: boolean;
+    IncludeDuplicates: boolean;
+    IncludeExpiredCertificates: boolean;
+    IssuerName: string;
+    StoreName: string;
+    Thumbprint: number[];
+  }
+
+  class CertificateRequestProperties implements Windows.Security.Cryptography.Certificates.ICertificateRequestProperties, Windows.Security.Cryptography.Certificates.ICertificateRequestProperties2, Windows.Security.Cryptography.Certificates.ICertificateRequestProperties3, Windows.Security.Cryptography.Certificates.ICertificateRequestProperties4 {
+    constructor();
+    AttestationCredentialCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    ContainerName: string;
+    ContainerNamePrefix: string;
+    CurveName: string;
+    CurveParameters: number[];
+    Exportable: number;
+    readonly Extensions: Windows.Foundation.Collections.IVector<Windows.Security.Cryptography.Certificates.CertificateExtension> | Windows.Security.Cryptography.Certificates.CertificateExtension[];
+    FriendlyName: string;
+    HashAlgorithmName: string;
+    KeyAlgorithmName: string;
+    KeyProtectionLevel: number;
+    KeySize: number;
+    KeyStorageProviderName: string;
+    KeyUsages: number;
+    SigningCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    SmartcardReaderName: string;
+    Subject: string;
+    readonly SubjectAlternativeName: Windows.Security.Cryptography.Certificates.SubjectAlternativeNameInfo;
+    readonly SuppressedDefaults: Windows.Foundation.Collections.IVector<string> | string[];
+    UseExistingKey: boolean;
+  }
+
+  class CertificateStore implements Windows.Security.Cryptography.Certificates.ICertificateStore, Windows.Security.Cryptography.Certificates.ICertificateStore2 {
+    Add(certificate: Windows.Security.Cryptography.Certificates.Certificate): void;
+    Delete(certificate: Windows.Security.Cryptography.Certificates.Certificate): void;
+    readonly Name: string;
+  }
+
+  class CertificateStores {
+    static FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[]>;
+    static FindAllAsync(query: Windows.Security.Cryptography.Certificates.CertificateQuery): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[]>;
+    static GetStoreByName(storeName: string): Windows.Security.Cryptography.Certificates.CertificateStore;
+    static GetUserStoreByName(storeName: string): Windows.Security.Cryptography.Certificates.UserCertificateStore;
+    static readonly IntermediateCertificationAuthorities: Windows.Security.Cryptography.Certificates.CertificateStore;
+    static readonly TrustedRootCertificationAuthorities: Windows.Security.Cryptography.Certificates.CertificateStore;
+  }
+
+  class ChainBuildingParameters implements Windows.Security.Cryptography.Certificates.IChainBuildingParameters {
+    constructor();
+    AuthorityInformationAccessEnabled: boolean;
+    CurrentTimeValidationEnabled: boolean;
+    readonly EnhancedKeyUsages: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly ExclusiveTrustRoots: Windows.Foundation.Collections.IVector<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+    NetworkRetrievalEnabled: boolean;
+    RevocationCheckEnabled: boolean;
+    ValidationTimestamp: Windows.Foundation.DateTime;
+  }
+
+  class ChainValidationParameters implements Windows.Security.Cryptography.Certificates.IChainValidationParameters {
+    constructor();
+    CertificateChainPolicy: number;
+    ServerDnsName: Windows.Networking.HostName;
+  }
+
+  class CmsAttachedSignature implements Windows.Security.Cryptography.Certificates.ICmsAttachedSignature {
+    constructor(inputBlob: Windows.Storage.Streams.IBuffer);
+    static GenerateSignatureAsync(data: Windows.Storage.Streams.IBuffer, signers: Windows.Foundation.Collections.IIterable<Windows.Security.Cryptography.Certificates.CmsSignerInfo> | Windows.Security.Cryptography.Certificates.CmsSignerInfo[], certificates: Windows.Foundation.Collections.IIterable<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[]): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    VerifySignature(): number;
+    readonly Certificates: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+    readonly Content: number[];
+    readonly Signers: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.CmsSignerInfo> | Windows.Security.Cryptography.Certificates.CmsSignerInfo[];
+  }
+
+  class CmsDetachedSignature implements Windows.Security.Cryptography.Certificates.ICmsDetachedSignature {
+    constructor(inputBlob: Windows.Storage.Streams.IBuffer);
+    static GenerateSignatureAsync(data: Windows.Storage.Streams.IInputStream, signers: Windows.Foundation.Collections.IIterable<Windows.Security.Cryptography.Certificates.CmsSignerInfo> | Windows.Security.Cryptography.Certificates.CmsSignerInfo[], certificates: Windows.Foundation.Collections.IIterable<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[]): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    VerifySignatureAsync(data: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncOperation<number>;
+    readonly Certificates: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+    readonly Signers: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.CmsSignerInfo> | Windows.Security.Cryptography.Certificates.CmsSignerInfo[];
+  }
+
+  class CmsSignerInfo implements Windows.Security.Cryptography.Certificates.ICmsSignerInfo {
+    constructor();
+    Certificate: Windows.Security.Cryptography.Certificates.Certificate;
+    HashAlgorithmName: string;
+    readonly TimestampInfo: Windows.Security.Cryptography.Certificates.CmsTimestampInfo;
+  }
+
+  class CmsTimestampInfo implements Windows.Security.Cryptography.Certificates.ICmsTimestampInfo {
+    readonly Certificates: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+    readonly SigningCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class KeyAlgorithmNames {
+    static readonly Dsa: string;
+    static readonly Ecdh: string;
+    static readonly Ecdh256: string;
+    static readonly Ecdh384: string;
+    static readonly Ecdh521: string;
+    static readonly Ecdsa: string;
+    static readonly Ecdsa256: string;
+    static readonly Ecdsa384: string;
+    static readonly Ecdsa521: string;
+    static readonly Rsa: string;
+  }
+
+  class KeyAttestationHelper {
+    static DecryptTpmAttestationCredentialAsync(credential: string, containerName: string): Windows.Foundation.IAsyncOperation<string>;
+    static DecryptTpmAttestationCredentialAsync(credential: string): Windows.Foundation.IAsyncOperation<string>;
+    static GetTpmAttestationCredentialId(credential: string): string;
+  }
+
+  class KeyStorageProviderNames {
+    static readonly PassportKeyStorageProvider: string;
+    static readonly PlatformKeyStorageProvider: string;
+    static readonly SmartcardKeyStorageProvider: string;
+    static readonly SoftwareKeyStorageProvider: string;
+  }
+
+  class PfxImportParameters implements Windows.Security.Cryptography.Certificates.IPfxImportParameters {
+    constructor();
+    ContainerNamePrefix: string;
+    Exportable: number;
+    FriendlyName: string;
+    InstallOptions: number;
+    KeyProtectionLevel: number;
+    KeyStorageProviderName: string;
+    ReaderName: string;
+  }
+
+  class StandardCertificateStoreNames {
+    static readonly IntermediateCertificationAuthorities: string;
+    static readonly Personal: string;
+    static readonly TrustedRootCertificationAuthorities: string;
+  }
+
+  class SubjectAlternativeNameInfo implements Windows.Security.Cryptography.Certificates.ISubjectAlternativeNameInfo, Windows.Security.Cryptography.Certificates.ISubjectAlternativeNameInfo2 {
+    constructor();
+    readonly DistinguishedName: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly DistinguishedNames: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly DnsName: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly DnsNames: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly EmailName: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly EmailNames: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Extension: Windows.Security.Cryptography.Certificates.CertificateExtension;
+    readonly IPAddress: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly IPAddresses: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly PrincipalName: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly PrincipalNames: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Url: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Urls: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+
+  class UserCertificateEnrollmentManager implements Windows.Security.Cryptography.Certificates.IUserCertificateEnrollmentManager, Windows.Security.Cryptography.Certificates.IUserCertificateEnrollmentManager2 {
+    CreateRequestAsync(request: Windows.Security.Cryptography.Certificates.CertificateRequestProperties): Windows.Foundation.IAsyncOperation<string>;
+    ImportPfxDataAsync(pfxData: string, password: string, exportable: number, keyProtectionLevel: number, installOption: number, friendlyName: string): Windows.Foundation.IAsyncAction;
+    ImportPfxDataAsync(pfxData: string, password: string, exportable: number, keyProtectionLevel: number, installOption: number, friendlyName: string, keyStorageProvider: string): Windows.Foundation.IAsyncAction;
+    ImportPfxDataAsync(pfxData: string, password: string, pfxImportParameters: Windows.Security.Cryptography.Certificates.PfxImportParameters): Windows.Foundation.IAsyncAction;
+    InstallCertificateAsync(certificate: string, installOption: number): Windows.Foundation.IAsyncAction;
+  }
+
+  class UserCertificateStore implements Windows.Security.Cryptography.Certificates.IUserCertificateStore {
+    RequestAddAsync(certificate: Windows.Security.Cryptography.Certificates.Certificate): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestDeleteAsync(certificate: Windows.Security.Cryptography.Certificates.Certificate): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Name: string;
+  }
+
+  enum CertificateChainPolicy {
+    Base = 0,
+    Ssl = 1,
+    NTAuthentication = 2,
+    MicrosoftRoot = 3,
+  }
+
+  enum ChainValidationResult {
+    Success = 0,
+    Untrusted = 1,
+    Revoked = 2,
+    Expired = 3,
+    IncompleteChain = 4,
+    InvalidSignature = 5,
+    WrongUsage = 6,
+    InvalidName = 7,
+    InvalidCertificateAuthorityPolicy = 8,
+    BasicConstraintsError = 9,
+    UnknownCriticalExtension = 10,
+    RevocationInformationMissing = 11,
+    RevocationFailure = 12,
+    OtherErrors = 13,
+  }
+
+  enum EnrollKeyUsages {
+    None = 0,
+    Decryption = 1,
+    Signing = 2,
+    KeyAgreement = 4,
+    All = 16777215,
+  }
+
+  enum ExportOption {
+    NotExportable = 0,
+    Exportable = 1,
+  }
+
+  enum InstallOptions {
+    None = 0,
+    DeleteExpired = 1,
+  }
+
+  enum KeyProtectionLevel {
+    NoConsent = 0,
+    ConsentOnly = 1,
+    ConsentWithPassword = 2,
+    ConsentWithFingerprint = 3,
+  }
+
+  enum KeySize {
+    Invalid = 0,
+    Rsa2048 = 2048,
+    Rsa4096 = 4096,
+  }
+
+  enum SignatureValidationResult {
+    Success = 0,
+    InvalidParameter = 1,
+    BadMessage = 2,
+    InvalidSignature = 3,
+    OtherErrors = 4,
+  }
+
+  interface ICertificate {
+    BuildChainAsync(certificates: Windows.Foundation.Collections.IIterable<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[]): Windows.Foundation.IAsyncOperation<Windows.Security.Cryptography.Certificates.CertificateChain>;
+    BuildChainAsync(certificates: Windows.Foundation.Collections.IIterable<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[], parameters: Windows.Security.Cryptography.Certificates.ChainBuildingParameters): Windows.Foundation.IAsyncOperation<Windows.Security.Cryptography.Certificates.CertificateChain>;
+    GetCertificateBlob(): Windows.Storage.Streams.IBuffer;
+    GetHashValue(): number[];
+    GetHashValue(hashAlgorithmName: string): number[];
+    readonly EnhancedKeyUsages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    FriendlyName: string;
+    readonly HasPrivateKey: boolean;
+    readonly IsStronglyProtected: boolean;
+    readonly Issuer: string;
+    readonly SerialNumber: number[];
+    readonly Subject: string;
+    readonly ValidFrom: Windows.Foundation.DateTime;
+    readonly ValidTo: Windows.Foundation.DateTime;
+  }
+  var ICertificate: abstract new (...args: any[]) => ICertificate;
+
+  interface ICertificate2 {
+    readonly IsSecurityDeviceBound: boolean;
+    readonly KeyAlgorithmName: string;
+    readonly KeyUsages: Windows.Security.Cryptography.Certificates.CertificateKeyUsages;
+    readonly SignatureAlgorithmName: string;
+    readonly SignatureHashAlgorithmName: string;
+    readonly SubjectAlternativeName: Windows.Security.Cryptography.Certificates.SubjectAlternativeNameInfo;
+  }
+  var ICertificate2: abstract new (...args: any[]) => ICertificate2;
+
+  interface ICertificate3 {
+    readonly IsPerUser: boolean;
+    readonly KeyStorageProviderName: string;
+    readonly StoreName: string;
+  }
+  var ICertificate3: abstract new (...args: any[]) => ICertificate3;
+
+  interface ICertificateChain {
+    GetCertificates(includeRoot: boolean): Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+    Validate(): number;
+    Validate(parameter: Windows.Security.Cryptography.Certificates.ChainValidationParameters): number;
+  }
+  var ICertificateChain: abstract new (...args: any[]) => ICertificateChain;
+
+  interface ICertificateEnrollmentManagerStatics {
+    CreateRequestAsync(request: Windows.Security.Cryptography.Certificates.CertificateRequestProperties): Windows.Foundation.IAsyncOperation<string>;
+    ImportPfxDataAsync(pfxData: string, password: string, exportable: number, keyProtectionLevel: number, installOption: number, friendlyName: string): Windows.Foundation.IAsyncAction;
+    InstallCertificateAsync(certificate: string, installOption: number): Windows.Foundation.IAsyncAction;
+  }
+  var ICertificateEnrollmentManagerStatics: abstract new (...args: any[]) => ICertificateEnrollmentManagerStatics;
+
+  interface ICertificateEnrollmentManagerStatics2 {
+    ImportPfxDataAsync(pfxData: string, password: string, exportable: number, keyProtectionLevel: number, installOption: number, friendlyName: string, keyStorageProvider: string): Windows.Foundation.IAsyncAction;
+    readonly UserCertificateEnrollmentManager: Windows.Security.Cryptography.Certificates.UserCertificateEnrollmentManager;
+  }
+  var ICertificateEnrollmentManagerStatics2: abstract new (...args: any[]) => ICertificateEnrollmentManagerStatics2;
+
+  interface ICertificateEnrollmentManagerStatics3 {
+    ImportPfxDataAsync(pfxData: string, password: string, pfxImportParameters: Windows.Security.Cryptography.Certificates.PfxImportParameters): Windows.Foundation.IAsyncAction;
+  }
+  var ICertificateEnrollmentManagerStatics3: abstract new (...args: any[]) => ICertificateEnrollmentManagerStatics3;
+
+  interface ICertificateExtension {
+    EncodeValue(value: string): void;
+    IsCritical: boolean;
+    ObjectId: string;
+    Value: number[];
+  }
+  var ICertificateExtension: abstract new (...args: any[]) => ICertificateExtension;
+
+  interface ICertificateFactory {
+    CreateCertificate(certBlob: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Certificates.Certificate;
+  }
+  var ICertificateFactory: abstract new (...args: any[]) => ICertificateFactory;
+
+  interface ICertificateKeyUsages {
+    CrlSign: boolean;
+    DataEncipherment: boolean;
+    DigitalSignature: boolean;
+    EncipherOnly: boolean;
+    KeyAgreement: boolean;
+    KeyCertificateSign: boolean;
+    KeyEncipherment: boolean;
+    NonRepudiation: boolean;
+  }
+  var ICertificateKeyUsages: abstract new (...args: any[]) => ICertificateKeyUsages;
+
+  interface ICertificateQuery {
+    readonly EnhancedKeyUsages: Windows.Foundation.Collections.IVector<string> | string[];
+    FriendlyName: string;
+    HardwareOnly: boolean;
+    IssuerName: string;
+    Thumbprint: number[];
+  }
+  var ICertificateQuery: abstract new (...args: any[]) => ICertificateQuery;
+
+  interface ICertificateQuery2 {
+    IncludeDuplicates: boolean;
+    IncludeExpiredCertificates: boolean;
+    StoreName: string;
+  }
+  var ICertificateQuery2: abstract new (...args: any[]) => ICertificateQuery2;
+
+  interface ICertificateRequestProperties {
+    Exportable: number;
+    FriendlyName: string;
+    HashAlgorithmName: string;
+    KeyAlgorithmName: string;
+    KeyProtectionLevel: number;
+    KeySize: number;
+    KeyStorageProviderName: string;
+    KeyUsages: number;
+    Subject: string;
+  }
+  var ICertificateRequestProperties: abstract new (...args: any[]) => ICertificateRequestProperties;
+
+  interface ICertificateRequestProperties2 {
+    AttestationCredentialCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    SigningCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    SmartcardReaderName: string;
+  }
+  var ICertificateRequestProperties2: abstract new (...args: any[]) => ICertificateRequestProperties2;
+
+  interface ICertificateRequestProperties3 {
+    ContainerName: string;
+    ContainerNamePrefix: string;
+    CurveName: string;
+    CurveParameters: number[];
+    UseExistingKey: boolean;
+  }
+  var ICertificateRequestProperties3: abstract new (...args: any[]) => ICertificateRequestProperties3;
+
+  interface ICertificateRequestProperties4 {
+    readonly Extensions: Windows.Foundation.Collections.IVector<Windows.Security.Cryptography.Certificates.CertificateExtension> | Windows.Security.Cryptography.Certificates.CertificateExtension[];
+    readonly SubjectAlternativeName: Windows.Security.Cryptography.Certificates.SubjectAlternativeNameInfo;
+    readonly SuppressedDefaults: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var ICertificateRequestProperties4: abstract new (...args: any[]) => ICertificateRequestProperties4;
+
+  interface ICertificateStore {
+    Add(certificate: Windows.Security.Cryptography.Certificates.Certificate): void;
+    Delete(certificate: Windows.Security.Cryptography.Certificates.Certificate): void;
+  }
+  var ICertificateStore: abstract new (...args: any[]) => ICertificateStore;
+
+  interface ICertificateStore2 {
+    readonly Name: string;
+  }
+  var ICertificateStore2: abstract new (...args: any[]) => ICertificateStore2;
+
+  interface ICertificateStoresStatics {
+    FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[]>;
+    FindAllAsync(query: Windows.Security.Cryptography.Certificates.CertificateQuery): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[]>;
+    GetStoreByName(storeName: string): Windows.Security.Cryptography.Certificates.CertificateStore;
+    readonly IntermediateCertificationAuthorities: Windows.Security.Cryptography.Certificates.CertificateStore;
+    readonly TrustedRootCertificationAuthorities: Windows.Security.Cryptography.Certificates.CertificateStore;
+  }
+  var ICertificateStoresStatics: abstract new (...args: any[]) => ICertificateStoresStatics;
+
+  interface ICertificateStoresStatics2 {
+    GetUserStoreByName(storeName: string): Windows.Security.Cryptography.Certificates.UserCertificateStore;
+  }
+  var ICertificateStoresStatics2: abstract new (...args: any[]) => ICertificateStoresStatics2;
+
+  interface IChainBuildingParameters {
+    AuthorityInformationAccessEnabled: boolean;
+    CurrentTimeValidationEnabled: boolean;
+    readonly EnhancedKeyUsages: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly ExclusiveTrustRoots: Windows.Foundation.Collections.IVector<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+    NetworkRetrievalEnabled: boolean;
+    RevocationCheckEnabled: boolean;
+    ValidationTimestamp: Windows.Foundation.DateTime;
+  }
+  var IChainBuildingParameters: abstract new (...args: any[]) => IChainBuildingParameters;
+
+  interface IChainValidationParameters {
+    CertificateChainPolicy: number;
+    ServerDnsName: Windows.Networking.HostName;
+  }
+  var IChainValidationParameters: abstract new (...args: any[]) => IChainValidationParameters;
+
+  interface ICmsAttachedSignature {
+    VerifySignature(): number;
+    readonly Certificates: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+    readonly Content: number[];
+    readonly Signers: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.CmsSignerInfo> | Windows.Security.Cryptography.Certificates.CmsSignerInfo[];
+  }
+  var ICmsAttachedSignature: abstract new (...args: any[]) => ICmsAttachedSignature;
+
+  interface ICmsAttachedSignatureFactory {
+    CreateCmsAttachedSignature(inputBlob: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Certificates.CmsAttachedSignature;
+  }
+  var ICmsAttachedSignatureFactory: abstract new (...args: any[]) => ICmsAttachedSignatureFactory;
+
+  interface ICmsAttachedSignatureStatics {
+    GenerateSignatureAsync(data: Windows.Storage.Streams.IBuffer, signers: Windows.Foundation.Collections.IIterable<Windows.Security.Cryptography.Certificates.CmsSignerInfo> | Windows.Security.Cryptography.Certificates.CmsSignerInfo[], certificates: Windows.Foundation.Collections.IIterable<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[]): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+  }
+  var ICmsAttachedSignatureStatics: abstract new (...args: any[]) => ICmsAttachedSignatureStatics;
+
+  interface ICmsDetachedSignature {
+    VerifySignatureAsync(data: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncOperation<number>;
+    readonly Certificates: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+    readonly Signers: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.CmsSignerInfo> | Windows.Security.Cryptography.Certificates.CmsSignerInfo[];
+  }
+  var ICmsDetachedSignature: abstract new (...args: any[]) => ICmsDetachedSignature;
+
+  interface ICmsDetachedSignatureFactory {
+    CreateCmsDetachedSignature(inputBlob: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Certificates.CmsDetachedSignature;
+  }
+  var ICmsDetachedSignatureFactory: abstract new (...args: any[]) => ICmsDetachedSignatureFactory;
+
+  interface ICmsDetachedSignatureStatics {
+    GenerateSignatureAsync(data: Windows.Storage.Streams.IInputStream, signers: Windows.Foundation.Collections.IIterable<Windows.Security.Cryptography.Certificates.CmsSignerInfo> | Windows.Security.Cryptography.Certificates.CmsSignerInfo[], certificates: Windows.Foundation.Collections.IIterable<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[]): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+  }
+  var ICmsDetachedSignatureStatics: abstract new (...args: any[]) => ICmsDetachedSignatureStatics;
+
+  interface ICmsSignerInfo {
+    Certificate: Windows.Security.Cryptography.Certificates.Certificate;
+    HashAlgorithmName: string;
+    readonly TimestampInfo: Windows.Security.Cryptography.Certificates.CmsTimestampInfo;
+  }
+  var ICmsSignerInfo: abstract new (...args: any[]) => ICmsSignerInfo;
+
+  interface ICmsTimestampInfo {
+    readonly Certificates: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+    readonly SigningCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var ICmsTimestampInfo: abstract new (...args: any[]) => ICmsTimestampInfo;
+
+  interface IKeyAlgorithmNamesStatics {
+    readonly Dsa: string;
+    readonly Ecdh256: string;
+    readonly Ecdh384: string;
+    readonly Ecdh521: string;
+    readonly Ecdsa256: string;
+    readonly Ecdsa384: string;
+    readonly Ecdsa521: string;
+    readonly Rsa: string;
+  }
+  var IKeyAlgorithmNamesStatics: abstract new (...args: any[]) => IKeyAlgorithmNamesStatics;
+
+  interface IKeyAlgorithmNamesStatics2 {
+    readonly Ecdh: string;
+    readonly Ecdsa: string;
+  }
+  var IKeyAlgorithmNamesStatics2: abstract new (...args: any[]) => IKeyAlgorithmNamesStatics2;
+
+  interface IKeyAttestationHelperStatics {
+    DecryptTpmAttestationCredentialAsync(credential: string): Windows.Foundation.IAsyncOperation<string>;
+    GetTpmAttestationCredentialId(credential: string): string;
+  }
+  var IKeyAttestationHelperStatics: abstract new (...args: any[]) => IKeyAttestationHelperStatics;
+
+  interface IKeyAttestationHelperStatics2 {
+    DecryptTpmAttestationCredentialAsync(credential: string, containerName: string): Windows.Foundation.IAsyncOperation<string>;
+  }
+  var IKeyAttestationHelperStatics2: abstract new (...args: any[]) => IKeyAttestationHelperStatics2;
+
+  interface IKeyStorageProviderNamesStatics {
+    readonly PlatformKeyStorageProvider: string;
+    readonly SmartcardKeyStorageProvider: string;
+    readonly SoftwareKeyStorageProvider: string;
+  }
+  var IKeyStorageProviderNamesStatics: abstract new (...args: any[]) => IKeyStorageProviderNamesStatics;
+
+  interface IKeyStorageProviderNamesStatics2 {
+    readonly PassportKeyStorageProvider: string;
+  }
+  var IKeyStorageProviderNamesStatics2: abstract new (...args: any[]) => IKeyStorageProviderNamesStatics2;
+
+  interface IPfxImportParameters {
+    ContainerNamePrefix: string;
+    Exportable: number;
+    FriendlyName: string;
+    InstallOptions: number;
+    KeyProtectionLevel: number;
+    KeyStorageProviderName: string;
+    ReaderName: string;
+  }
+  var IPfxImportParameters: abstract new (...args: any[]) => IPfxImportParameters;
+
+  interface IStandardCertificateStoreNamesStatics {
+    readonly IntermediateCertificationAuthorities: string;
+    readonly Personal: string;
+    readonly TrustedRootCertificationAuthorities: string;
+  }
+  var IStandardCertificateStoreNamesStatics: abstract new (...args: any[]) => IStandardCertificateStoreNamesStatics;
+
+  interface ISubjectAlternativeNameInfo {
+    readonly DistinguishedName: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly DnsName: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly EmailName: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly IPAddress: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly PrincipalName: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Url: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var ISubjectAlternativeNameInfo: abstract new (...args: any[]) => ISubjectAlternativeNameInfo;
+
+  interface ISubjectAlternativeNameInfo2 {
+    readonly DistinguishedNames: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly DnsNames: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly EmailNames: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Extension: Windows.Security.Cryptography.Certificates.CertificateExtension;
+    readonly IPAddresses: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly PrincipalNames: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Urls: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var ISubjectAlternativeNameInfo2: abstract new (...args: any[]) => ISubjectAlternativeNameInfo2;
+
+  interface IUserCertificateEnrollmentManager {
+    CreateRequestAsync(request: Windows.Security.Cryptography.Certificates.CertificateRequestProperties): Windows.Foundation.IAsyncOperation<string>;
+    ImportPfxDataAsync(pfxData: string, password: string, exportable: number, keyProtectionLevel: number, installOption: number, friendlyName: string): Windows.Foundation.IAsyncAction;
+    ImportPfxDataAsync(pfxData: string, password: string, exportable: number, keyProtectionLevel: number, installOption: number, friendlyName: string, keyStorageProvider: string): Windows.Foundation.IAsyncAction;
+    InstallCertificateAsync(certificate: string, installOption: number): Windows.Foundation.IAsyncAction;
+  }
+  var IUserCertificateEnrollmentManager: abstract new (...args: any[]) => IUserCertificateEnrollmentManager;
+
+  interface IUserCertificateEnrollmentManager2 {
+    ImportPfxDataAsync(pfxData: string, password: string, pfxImportParameters: Windows.Security.Cryptography.Certificates.PfxImportParameters): Windows.Foundation.IAsyncAction;
+  }
+  var IUserCertificateEnrollmentManager2: abstract new (...args: any[]) => IUserCertificateEnrollmentManager2;
+
+  interface IUserCertificateStore {
+    RequestAddAsync(certificate: Windows.Security.Cryptography.Certificates.Certificate): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestDeleteAsync(certificate: Windows.Security.Cryptography.Certificates.Certificate): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Name: string;
+  }
+  var IUserCertificateStore: abstract new (...args: any[]) => IUserCertificateStore;
+
+}
+
+declare namespace Windows.Security.Cryptography.Core {
+  class AsymmetricAlgorithmNames {
+    static readonly DsaSha1: string;
+    static readonly DsaSha256: string;
+    static readonly EcdsaP256Sha256: string;
+    static readonly EcdsaP384Sha384: string;
+    static readonly EcdsaP521Sha512: string;
+    static readonly EcdsaSha256: string;
+    static readonly EcdsaSha384: string;
+    static readonly EcdsaSha512: string;
+    static readonly RsaOaepSha1: string;
+    static readonly RsaOaepSha256: string;
+    static readonly RsaOaepSha384: string;
+    static readonly RsaOaepSha512: string;
+    static readonly RsaPkcs1: string;
+    static readonly RsaSignPkcs1Sha1: string;
+    static readonly RsaSignPkcs1Sha256: string;
+    static readonly RsaSignPkcs1Sha384: string;
+    static readonly RsaSignPkcs1Sha512: string;
+    static readonly RsaSignPssSha1: string;
+    static readonly RsaSignPssSha256: string;
+    static readonly RsaSignPssSha384: string;
+    static readonly RsaSignPssSha512: string;
+  }
+
+  class AsymmetricKeyAlgorithmProvider implements Windows.Security.Cryptography.Core.IAsymmetricKeyAlgorithmProvider, Windows.Security.Cryptography.Core.IAsymmetricKeyAlgorithmProvider2 {
+    CreateKeyPair(keySize: number): Windows.Security.Cryptography.Core.CryptographicKey;
+    CreateKeyPairWithCurveName(curveName: string): Windows.Security.Cryptography.Core.CryptographicKey;
+    CreateKeyPairWithCurveParameters(parameters: number[]): Windows.Security.Cryptography.Core.CryptographicKey;
+    ImportKeyPair(keyBlob: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Core.CryptographicKey;
+    ImportKeyPair(keyBlob: Windows.Storage.Streams.IBuffer, BlobType: number): Windows.Security.Cryptography.Core.CryptographicKey;
+    ImportPublicKey(keyBlob: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Core.CryptographicKey;
+    ImportPublicKey(keyBlob: Windows.Storage.Streams.IBuffer, BlobType: number): Windows.Security.Cryptography.Core.CryptographicKey;
+    static OpenAlgorithm(algorithm: string): Windows.Security.Cryptography.Core.AsymmetricKeyAlgorithmProvider;
+    readonly AlgorithmName: string;
+  }
+
+  class CryptographicEngine {
+    static Decrypt(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer, iv: Windows.Storage.Streams.IBuffer): Windows.Storage.Streams.IBuffer;
+    static DecryptAndAuthenticate(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer, nonce: Windows.Storage.Streams.IBuffer, authenticationTag: Windows.Storage.Streams.IBuffer, authenticatedData: Windows.Storage.Streams.IBuffer): Windows.Storage.Streams.IBuffer;
+    static DecryptAsync(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer, iv: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    static DeriveKeyMaterial(key: Windows.Security.Cryptography.Core.CryptographicKey, parameters: Windows.Security.Cryptography.Core.KeyDerivationParameters, desiredKeySize: number): Windows.Storage.Streams.IBuffer;
+    static Encrypt(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer, iv: Windows.Storage.Streams.IBuffer): Windows.Storage.Streams.IBuffer;
+    static EncryptAndAuthenticate(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer, nonce: Windows.Storage.Streams.IBuffer, authenticatedData: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Core.EncryptedAndAuthenticatedData;
+    static Sign(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer): Windows.Storage.Streams.IBuffer;
+    static SignAsync(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    static SignHashedData(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer): Windows.Storage.Streams.IBuffer;
+    static SignHashedDataAsync(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    static VerifySignature(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer, signature: Windows.Storage.Streams.IBuffer): boolean;
+    static VerifySignatureWithHashInput(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer, signature: Windows.Storage.Streams.IBuffer): boolean;
+  }
+
+  class CryptographicHash implements Windows.Security.Cryptography.Core.IHashComputation {
+    Append(data: Windows.Storage.Streams.IBuffer): void;
+    GetValueAndReset(): Windows.Storage.Streams.IBuffer;
+  }
+
+  class CryptographicKey implements Windows.Security.Cryptography.Core.ICryptographicKey {
+    Export(): Windows.Storage.Streams.IBuffer;
+    Export(BlobType: number): Windows.Storage.Streams.IBuffer;
+    ExportPublicKey(): Windows.Storage.Streams.IBuffer;
+    ExportPublicKey(BlobType: number): Windows.Storage.Streams.IBuffer;
+    readonly KeySize: number;
+  }
+
+  class EccCurveNames {
+    static readonly AllEccCurveNames: Windows.Foundation.Collections.IVectorView<string> | string[];
+    static readonly BrainpoolP160r1: string;
+    static readonly BrainpoolP160t1: string;
+    static readonly BrainpoolP192r1: string;
+    static readonly BrainpoolP192t1: string;
+    static readonly BrainpoolP224r1: string;
+    static readonly BrainpoolP224t1: string;
+    static readonly BrainpoolP256r1: string;
+    static readonly BrainpoolP256t1: string;
+    static readonly BrainpoolP320r1: string;
+    static readonly BrainpoolP320t1: string;
+    static readonly BrainpoolP384r1: string;
+    static readonly BrainpoolP384t1: string;
+    static readonly BrainpoolP512r1: string;
+    static readonly BrainpoolP512t1: string;
+    static readonly Curve25519: string;
+    static readonly Ec192wapi: string;
+    static readonly NistP192: string;
+    static readonly NistP224: string;
+    static readonly NistP256: string;
+    static readonly NistP384: string;
+    static readonly NistP521: string;
+    static readonly NumsP256t1: string;
+    static readonly NumsP384t1: string;
+    static readonly NumsP512t1: string;
+    static readonly SecP160k1: string;
+    static readonly SecP160r1: string;
+    static readonly SecP160r2: string;
+    static readonly SecP192k1: string;
+    static readonly SecP192r1: string;
+    static readonly SecP224k1: string;
+    static readonly SecP224r1: string;
+    static readonly SecP256k1: string;
+    static readonly SecP256r1: string;
+    static readonly SecP384r1: string;
+    static readonly SecP521r1: string;
+    static readonly Wtls12: string;
+    static readonly Wtls7: string;
+    static readonly Wtls9: string;
+    static readonly X962P192v1: string;
+    static readonly X962P192v2: string;
+    static readonly X962P192v3: string;
+    static readonly X962P239v1: string;
+    static readonly X962P239v2: string;
+    static readonly X962P239v3: string;
+    static readonly X962P256v1: string;
+  }
+
+  class EncryptedAndAuthenticatedData implements Windows.Security.Cryptography.Core.IEncryptedAndAuthenticatedData {
+    readonly AuthenticationTag: Windows.Storage.Streams.IBuffer;
+    readonly EncryptedData: Windows.Storage.Streams.IBuffer;
+  }
+
+  class HashAlgorithmNames {
+    static readonly Md5: string;
+    static readonly Sha1: string;
+    static readonly Sha256: string;
+    static readonly Sha384: string;
+    static readonly Sha512: string;
+  }
+
+  class HashAlgorithmProvider implements Windows.Security.Cryptography.Core.IHashAlgorithmProvider {
+    CreateHash(): Windows.Security.Cryptography.Core.CryptographicHash;
+    HashData(data: Windows.Storage.Streams.IBuffer): Windows.Storage.Streams.IBuffer;
+    static OpenAlgorithm(algorithm: string): Windows.Security.Cryptography.Core.HashAlgorithmProvider;
+    readonly AlgorithmName: string;
+    readonly HashLength: number;
+  }
+
+  class KeyDerivationAlgorithmNames {
+    static readonly CapiKdfMd5: string;
+    static readonly CapiKdfSha1: string;
+    static readonly CapiKdfSha256: string;
+    static readonly CapiKdfSha384: string;
+    static readonly CapiKdfSha512: string;
+    static readonly Pbkdf2Md5: string;
+    static readonly Pbkdf2Sha1: string;
+    static readonly Pbkdf2Sha256: string;
+    static readonly Pbkdf2Sha384: string;
+    static readonly Pbkdf2Sha512: string;
+    static readonly Sp800108CtrHmacMd5: string;
+    static readonly Sp800108CtrHmacSha1: string;
+    static readonly Sp800108CtrHmacSha256: string;
+    static readonly Sp800108CtrHmacSha384: string;
+    static readonly Sp800108CtrHmacSha512: string;
+    static readonly Sp80056aConcatMd5: string;
+    static readonly Sp80056aConcatSha1: string;
+    static readonly Sp80056aConcatSha256: string;
+    static readonly Sp80056aConcatSha384: string;
+    static readonly Sp80056aConcatSha512: string;
+  }
+
+  class KeyDerivationAlgorithmProvider implements Windows.Security.Cryptography.Core.IKeyDerivationAlgorithmProvider {
+    CreateKey(keyMaterial: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Core.CryptographicKey;
+    static OpenAlgorithm(algorithm: string): Windows.Security.Cryptography.Core.KeyDerivationAlgorithmProvider;
+    readonly AlgorithmName: string;
+  }
+
+  class KeyDerivationParameters implements Windows.Security.Cryptography.Core.IKeyDerivationParameters, Windows.Security.Cryptography.Core.IKeyDerivationParameters2 {
+    static BuildForCapi1Kdf(capi1KdfTargetAlgorithm: number): Windows.Security.Cryptography.Core.KeyDerivationParameters;
+    static BuildForPbkdf2(pbkdf2Salt: Windows.Storage.Streams.IBuffer, iterationCount: number): Windows.Security.Cryptography.Core.KeyDerivationParameters;
+    static BuildForSP800108(label: Windows.Storage.Streams.IBuffer, context: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Core.KeyDerivationParameters;
+    static BuildForSP80056a(algorithmId: Windows.Storage.Streams.IBuffer, partyUInfo: Windows.Storage.Streams.IBuffer, partyVInfo: Windows.Storage.Streams.IBuffer, suppPubInfo: Windows.Storage.Streams.IBuffer, suppPrivInfo: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Core.KeyDerivationParameters;
+    Capi1KdfTargetAlgorithm: number;
+    readonly IterationCount: number;
+    KdfGenericBinary: Windows.Storage.Streams.IBuffer;
+  }
+
+  class MacAlgorithmNames {
+    static readonly AesCmac: string;
+    static readonly HmacMd5: string;
+    static readonly HmacSha1: string;
+    static readonly HmacSha256: string;
+    static readonly HmacSha384: string;
+    static readonly HmacSha512: string;
+  }
+
+  class MacAlgorithmProvider implements Windows.Security.Cryptography.Core.IMacAlgorithmProvider, Windows.Security.Cryptography.Core.IMacAlgorithmProvider2 {
+    CreateHash(keyMaterial: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Core.CryptographicHash;
+    CreateKey(keyMaterial: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Core.CryptographicKey;
+    static OpenAlgorithm(algorithm: string): Windows.Security.Cryptography.Core.MacAlgorithmProvider;
+    readonly AlgorithmName: string;
+    readonly MacLength: number;
+  }
+
+  class PersistedKeyProvider {
+    static OpenKeyPairFromCertificateAsync(certificate: Windows.Security.Cryptography.Certificates.Certificate, hashAlgorithmName: string, padding: number): Windows.Foundation.IAsyncOperation<Windows.Security.Cryptography.Core.CryptographicKey>;
+    static OpenPublicKeyFromCertificate(certificate: Windows.Security.Cryptography.Certificates.Certificate, hashAlgorithmName: string, padding: number): Windows.Security.Cryptography.Core.CryptographicKey;
+  }
+
+  class SymmetricAlgorithmNames {
+    static readonly AesCbc: string;
+    static readonly AesCbcPkcs7: string;
+    static readonly AesCcm: string;
+    static readonly AesEcb: string;
+    static readonly AesEcbPkcs7: string;
+    static readonly AesGcm: string;
+    static readonly DesCbc: string;
+    static readonly DesCbcPkcs7: string;
+    static readonly DesEcb: string;
+    static readonly DesEcbPkcs7: string;
+    static readonly Rc2Cbc: string;
+    static readonly Rc2CbcPkcs7: string;
+    static readonly Rc2Ecb: string;
+    static readonly Rc2EcbPkcs7: string;
+    static readonly Rc4: string;
+    static readonly TripleDesCbc: string;
+    static readonly TripleDesCbcPkcs7: string;
+    static readonly TripleDesEcb: string;
+    static readonly TripleDesEcbPkcs7: string;
+  }
+
+  class SymmetricKeyAlgorithmProvider implements Windows.Security.Cryptography.Core.ISymmetricKeyAlgorithmProvider {
+    CreateSymmetricKey(keyMaterial: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Core.CryptographicKey;
+    static OpenAlgorithm(algorithm: string): Windows.Security.Cryptography.Core.SymmetricKeyAlgorithmProvider;
+    readonly AlgorithmName: string;
+    readonly BlockLength: number;
+  }
+
+  enum Capi1KdfTargetAlgorithm {
+    NotAes = 0,
+    Aes = 1,
+  }
+
+  enum CryptographicPadding {
+    None = 0,
+    RsaOaep = 1,
+    RsaPkcs1V15 = 2,
+    RsaPss = 3,
+  }
+
+  enum CryptographicPrivateKeyBlobType {
+    Pkcs8RawPrivateKeyInfo = 0,
+    Pkcs1RsaPrivateKey = 1,
+    BCryptPrivateKey = 2,
+    Capi1PrivateKey = 3,
+    BCryptEccFullPrivateKey = 4,
+  }
+
+  enum CryptographicPublicKeyBlobType {
+    X509SubjectPublicKeyInfo = 0,
+    Pkcs1RsaPublicKey = 1,
+    BCryptPublicKey = 2,
+    Capi1PublicKey = 3,
+    BCryptEccFullPublicKey = 4,
+  }
+
+  interface IAsymmetricAlgorithmNamesStatics {
+    readonly DsaSha1: string;
+    readonly DsaSha256: string;
+    readonly EcdsaP256Sha256: string;
+    readonly EcdsaP384Sha384: string;
+    readonly EcdsaP521Sha512: string;
+    readonly RsaOaepSha1: string;
+    readonly RsaOaepSha256: string;
+    readonly RsaOaepSha384: string;
+    readonly RsaOaepSha512: string;
+    readonly RsaPkcs1: string;
+    readonly RsaSignPkcs1Sha1: string;
+    readonly RsaSignPkcs1Sha256: string;
+    readonly RsaSignPkcs1Sha384: string;
+    readonly RsaSignPkcs1Sha512: string;
+    readonly RsaSignPssSha1: string;
+    readonly RsaSignPssSha256: string;
+    readonly RsaSignPssSha384: string;
+    readonly RsaSignPssSha512: string;
+  }
+  var IAsymmetricAlgorithmNamesStatics: abstract new (...args: any[]) => IAsymmetricAlgorithmNamesStatics;
+
+  interface IAsymmetricAlgorithmNamesStatics2 {
+    readonly EcdsaSha256: string;
+    readonly EcdsaSha384: string;
+    readonly EcdsaSha512: string;
+  }
+  var IAsymmetricAlgorithmNamesStatics2: abstract new (...args: any[]) => IAsymmetricAlgorithmNamesStatics2;
+
+  interface IAsymmetricKeyAlgorithmProvider {
+    CreateKeyPair(keySize: number): Windows.Security.Cryptography.Core.CryptographicKey;
+    ImportKeyPair(keyBlob: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Core.CryptographicKey;
+    ImportKeyPair(keyBlob: Windows.Storage.Streams.IBuffer, BlobType: number): Windows.Security.Cryptography.Core.CryptographicKey;
+    ImportPublicKey(keyBlob: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Core.CryptographicKey;
+    ImportPublicKey(keyBlob: Windows.Storage.Streams.IBuffer, BlobType: number): Windows.Security.Cryptography.Core.CryptographicKey;
+    readonly AlgorithmName: string;
+  }
+  var IAsymmetricKeyAlgorithmProvider: abstract new (...args: any[]) => IAsymmetricKeyAlgorithmProvider;
+
+  interface IAsymmetricKeyAlgorithmProvider2 {
+    CreateKeyPairWithCurveName(curveName: string): Windows.Security.Cryptography.Core.CryptographicKey;
+    CreateKeyPairWithCurveParameters(parameters: number[]): Windows.Security.Cryptography.Core.CryptographicKey;
+  }
+  var IAsymmetricKeyAlgorithmProvider2: abstract new (...args: any[]) => IAsymmetricKeyAlgorithmProvider2;
+
+  interface IAsymmetricKeyAlgorithmProviderStatics {
+    OpenAlgorithm(algorithm: string): Windows.Security.Cryptography.Core.AsymmetricKeyAlgorithmProvider;
+  }
+  var IAsymmetricKeyAlgorithmProviderStatics: abstract new (...args: any[]) => IAsymmetricKeyAlgorithmProviderStatics;
+
+  interface ICryptographicEngineStatics {
+    Decrypt(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer, iv: Windows.Storage.Streams.IBuffer): Windows.Storage.Streams.IBuffer;
+    DecryptAndAuthenticate(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer, nonce: Windows.Storage.Streams.IBuffer, authenticationTag: Windows.Storage.Streams.IBuffer, authenticatedData: Windows.Storage.Streams.IBuffer): Windows.Storage.Streams.IBuffer;
+    DeriveKeyMaterial(key: Windows.Security.Cryptography.Core.CryptographicKey, parameters: Windows.Security.Cryptography.Core.KeyDerivationParameters, desiredKeySize: number): Windows.Storage.Streams.IBuffer;
+    Encrypt(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer, iv: Windows.Storage.Streams.IBuffer): Windows.Storage.Streams.IBuffer;
+    EncryptAndAuthenticate(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer, nonce: Windows.Storage.Streams.IBuffer, authenticatedData: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Core.EncryptedAndAuthenticatedData;
+    Sign(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer): Windows.Storage.Streams.IBuffer;
+    VerifySignature(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer, signature: Windows.Storage.Streams.IBuffer): boolean;
+  }
+  var ICryptographicEngineStatics: abstract new (...args: any[]) => ICryptographicEngineStatics;
+
+  interface ICryptographicEngineStatics2 {
+    DecryptAsync(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer, iv: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    SignAsync(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    SignHashedData(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer): Windows.Storage.Streams.IBuffer;
+    SignHashedDataAsync(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    VerifySignatureWithHashInput(key: Windows.Security.Cryptography.Core.CryptographicKey, data: Windows.Storage.Streams.IBuffer, signature: Windows.Storage.Streams.IBuffer): boolean;
+  }
+  var ICryptographicEngineStatics2: abstract new (...args: any[]) => ICryptographicEngineStatics2;
+
+  interface ICryptographicKey {
+    Export(): Windows.Storage.Streams.IBuffer;
+    Export(BlobType: number): Windows.Storage.Streams.IBuffer;
+    ExportPublicKey(): Windows.Storage.Streams.IBuffer;
+    ExportPublicKey(BlobType: number): Windows.Storage.Streams.IBuffer;
+    readonly KeySize: number;
+  }
+  var ICryptographicKey: abstract new (...args: any[]) => ICryptographicKey;
+
+  interface IEccCurveNamesStatics {
+    readonly AllEccCurveNames: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly BrainpoolP160r1: string;
+    readonly BrainpoolP160t1: string;
+    readonly BrainpoolP192r1: string;
+    readonly BrainpoolP192t1: string;
+    readonly BrainpoolP224r1: string;
+    readonly BrainpoolP224t1: string;
+    readonly BrainpoolP256r1: string;
+    readonly BrainpoolP256t1: string;
+    readonly BrainpoolP320r1: string;
+    readonly BrainpoolP320t1: string;
+    readonly BrainpoolP384r1: string;
+    readonly BrainpoolP384t1: string;
+    readonly BrainpoolP512r1: string;
+    readonly BrainpoolP512t1: string;
+    readonly Curve25519: string;
+    readonly Ec192wapi: string;
+    readonly NistP192: string;
+    readonly NistP224: string;
+    readonly NistP256: string;
+    readonly NistP384: string;
+    readonly NistP521: string;
+    readonly NumsP256t1: string;
+    readonly NumsP384t1: string;
+    readonly NumsP512t1: string;
+    readonly SecP160k1: string;
+    readonly SecP160r1: string;
+    readonly SecP160r2: string;
+    readonly SecP192k1: string;
+    readonly SecP192r1: string;
+    readonly SecP224k1: string;
+    readonly SecP224r1: string;
+    readonly SecP256k1: string;
+    readonly SecP256r1: string;
+    readonly SecP384r1: string;
+    readonly SecP521r1: string;
+    readonly Wtls12: string;
+    readonly Wtls7: string;
+    readonly Wtls9: string;
+    readonly X962P192v1: string;
+    readonly X962P192v2: string;
+    readonly X962P192v3: string;
+    readonly X962P239v1: string;
+    readonly X962P239v2: string;
+    readonly X962P239v3: string;
+    readonly X962P256v1: string;
+  }
+  var IEccCurveNamesStatics: abstract new (...args: any[]) => IEccCurveNamesStatics;
+
+  interface IEncryptedAndAuthenticatedData {
+    readonly AuthenticationTag: Windows.Storage.Streams.IBuffer;
+    readonly EncryptedData: Windows.Storage.Streams.IBuffer;
+  }
+  var IEncryptedAndAuthenticatedData: abstract new (...args: any[]) => IEncryptedAndAuthenticatedData;
+
+  interface IHashAlgorithmNamesStatics {
+    readonly Md5: string;
+    readonly Sha1: string;
+    readonly Sha256: string;
+    readonly Sha384: string;
+    readonly Sha512: string;
+  }
+  var IHashAlgorithmNamesStatics: abstract new (...args: any[]) => IHashAlgorithmNamesStatics;
+
+  interface IHashAlgorithmProvider {
+    CreateHash(): Windows.Security.Cryptography.Core.CryptographicHash;
+    HashData(data: Windows.Storage.Streams.IBuffer): Windows.Storage.Streams.IBuffer;
+    readonly AlgorithmName: string;
+    readonly HashLength: number;
+  }
+  var IHashAlgorithmProvider: abstract new (...args: any[]) => IHashAlgorithmProvider;
+
+  interface IHashAlgorithmProviderStatics {
+    OpenAlgorithm(algorithm: string): Windows.Security.Cryptography.Core.HashAlgorithmProvider;
+  }
+  var IHashAlgorithmProviderStatics: abstract new (...args: any[]) => IHashAlgorithmProviderStatics;
+
+  interface IHashComputation {
+    Append(data: Windows.Storage.Streams.IBuffer): void;
+    GetValueAndReset(): Windows.Storage.Streams.IBuffer;
+  }
+  var IHashComputation: abstract new (...args: any[]) => IHashComputation;
+
+  interface IKeyDerivationAlgorithmNamesStatics {
+    readonly Pbkdf2Md5: string;
+    readonly Pbkdf2Sha1: string;
+    readonly Pbkdf2Sha256: string;
+    readonly Pbkdf2Sha384: string;
+    readonly Pbkdf2Sha512: string;
+    readonly Sp800108CtrHmacMd5: string;
+    readonly Sp800108CtrHmacSha1: string;
+    readonly Sp800108CtrHmacSha256: string;
+    readonly Sp800108CtrHmacSha384: string;
+    readonly Sp800108CtrHmacSha512: string;
+    readonly Sp80056aConcatMd5: string;
+    readonly Sp80056aConcatSha1: string;
+    readonly Sp80056aConcatSha256: string;
+    readonly Sp80056aConcatSha384: string;
+    readonly Sp80056aConcatSha512: string;
+  }
+  var IKeyDerivationAlgorithmNamesStatics: abstract new (...args: any[]) => IKeyDerivationAlgorithmNamesStatics;
+
+  interface IKeyDerivationAlgorithmNamesStatics2 {
+    readonly CapiKdfMd5: string;
+    readonly CapiKdfSha1: string;
+    readonly CapiKdfSha256: string;
+    readonly CapiKdfSha384: string;
+    readonly CapiKdfSha512: string;
+  }
+  var IKeyDerivationAlgorithmNamesStatics2: abstract new (...args: any[]) => IKeyDerivationAlgorithmNamesStatics2;
+
+  interface IKeyDerivationAlgorithmProvider {
+    CreateKey(keyMaterial: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Core.CryptographicKey;
+    readonly AlgorithmName: string;
+  }
+  var IKeyDerivationAlgorithmProvider: abstract new (...args: any[]) => IKeyDerivationAlgorithmProvider;
+
+  interface IKeyDerivationAlgorithmProviderStatics {
+    OpenAlgorithm(algorithm: string): Windows.Security.Cryptography.Core.KeyDerivationAlgorithmProvider;
+  }
+  var IKeyDerivationAlgorithmProviderStatics: abstract new (...args: any[]) => IKeyDerivationAlgorithmProviderStatics;
+
+  interface IKeyDerivationParameters {
+    readonly IterationCount: number;
+    KdfGenericBinary: Windows.Storage.Streams.IBuffer;
+  }
+  var IKeyDerivationParameters: abstract new (...args: any[]) => IKeyDerivationParameters;
+
+  interface IKeyDerivationParameters2 {
+    Capi1KdfTargetAlgorithm: number;
+  }
+  var IKeyDerivationParameters2: abstract new (...args: any[]) => IKeyDerivationParameters2;
+
+  interface IKeyDerivationParametersStatics {
+    BuildForPbkdf2(pbkdf2Salt: Windows.Storage.Streams.IBuffer, iterationCount: number): Windows.Security.Cryptography.Core.KeyDerivationParameters;
+    BuildForSP800108(label: Windows.Storage.Streams.IBuffer, context: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Core.KeyDerivationParameters;
+    BuildForSP80056a(algorithmId: Windows.Storage.Streams.IBuffer, partyUInfo: Windows.Storage.Streams.IBuffer, partyVInfo: Windows.Storage.Streams.IBuffer, suppPubInfo: Windows.Storage.Streams.IBuffer, suppPrivInfo: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Core.KeyDerivationParameters;
+  }
+  var IKeyDerivationParametersStatics: abstract new (...args: any[]) => IKeyDerivationParametersStatics;
+
+  interface IKeyDerivationParametersStatics2 {
+    BuildForCapi1Kdf(capi1KdfTargetAlgorithm: number): Windows.Security.Cryptography.Core.KeyDerivationParameters;
+  }
+  var IKeyDerivationParametersStatics2: abstract new (...args: any[]) => IKeyDerivationParametersStatics2;
+
+  interface IMacAlgorithmNamesStatics {
+    readonly AesCmac: string;
+    readonly HmacMd5: string;
+    readonly HmacSha1: string;
+    readonly HmacSha256: string;
+    readonly HmacSha384: string;
+    readonly HmacSha512: string;
+  }
+  var IMacAlgorithmNamesStatics: abstract new (...args: any[]) => IMacAlgorithmNamesStatics;
+
+  interface IMacAlgorithmProvider {
+    CreateKey(keyMaterial: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Core.CryptographicKey;
+    readonly AlgorithmName: string;
+    readonly MacLength: number;
+  }
+  var IMacAlgorithmProvider: abstract new (...args: any[]) => IMacAlgorithmProvider;
+
+  interface IMacAlgorithmProvider2 {
+    CreateHash(keyMaterial: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Core.CryptographicHash;
+  }
+  var IMacAlgorithmProvider2: abstract new (...args: any[]) => IMacAlgorithmProvider2;
+
+  interface IMacAlgorithmProviderStatics {
+    OpenAlgorithm(algorithm: string): Windows.Security.Cryptography.Core.MacAlgorithmProvider;
+  }
+  var IMacAlgorithmProviderStatics: abstract new (...args: any[]) => IMacAlgorithmProviderStatics;
+
+  interface IPersistedKeyProviderStatics {
+    OpenKeyPairFromCertificateAsync(certificate: Windows.Security.Cryptography.Certificates.Certificate, hashAlgorithmName: string, padding: number): Windows.Foundation.IAsyncOperation<Windows.Security.Cryptography.Core.CryptographicKey>;
+    OpenPublicKeyFromCertificate(certificate: Windows.Security.Cryptography.Certificates.Certificate, hashAlgorithmName: string, padding: number): Windows.Security.Cryptography.Core.CryptographicKey;
+  }
+  var IPersistedKeyProviderStatics: abstract new (...args: any[]) => IPersistedKeyProviderStatics;
+
+  interface ISymmetricAlgorithmNamesStatics {
+    readonly AesCbc: string;
+    readonly AesCbcPkcs7: string;
+    readonly AesCcm: string;
+    readonly AesEcb: string;
+    readonly AesEcbPkcs7: string;
+    readonly AesGcm: string;
+    readonly DesCbc: string;
+    readonly DesCbcPkcs7: string;
+    readonly DesEcb: string;
+    readonly DesEcbPkcs7: string;
+    readonly Rc2Cbc: string;
+    readonly Rc2CbcPkcs7: string;
+    readonly Rc2Ecb: string;
+    readonly Rc2EcbPkcs7: string;
+    readonly Rc4: string;
+    readonly TripleDesCbc: string;
+    readonly TripleDesCbcPkcs7: string;
+    readonly TripleDesEcb: string;
+    readonly TripleDesEcbPkcs7: string;
+  }
+  var ISymmetricAlgorithmNamesStatics: abstract new (...args: any[]) => ISymmetricAlgorithmNamesStatics;
+
+  interface ISymmetricKeyAlgorithmProvider {
+    CreateSymmetricKey(keyMaterial: Windows.Storage.Streams.IBuffer): Windows.Security.Cryptography.Core.CryptographicKey;
+    readonly AlgorithmName: string;
+    readonly BlockLength: number;
+  }
+  var ISymmetricKeyAlgorithmProvider: abstract new (...args: any[]) => ISymmetricKeyAlgorithmProvider;
+
+  interface ISymmetricKeyAlgorithmProviderStatics {
+    OpenAlgorithm(algorithm: string): Windows.Security.Cryptography.Core.SymmetricKeyAlgorithmProvider;
+  }
+  var ISymmetricKeyAlgorithmProviderStatics: abstract new (...args: any[]) => ISymmetricKeyAlgorithmProviderStatics;
+
+}
+
+declare namespace Windows.Security.Cryptography.DataProtection {
+  class DataProtectionProvider implements Windows.Security.Cryptography.DataProtection.IDataProtectionProvider {
+    constructor(protectionDescriptor: string);
+    constructor();
+    ProtectAsync(data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    ProtectStreamAsync(src: Windows.Storage.Streams.IInputStream, dest: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncAction;
+    UnprotectAsync(data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    UnprotectStreamAsync(src: Windows.Storage.Streams.IInputStream, dest: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncAction;
+  }
+
+  interface IDataProtectionProvider {
+    ProtectAsync(data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    ProtectStreamAsync(src: Windows.Storage.Streams.IInputStream, dest: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncAction;
+    UnprotectAsync(data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    UnprotectStreamAsync(src: Windows.Storage.Streams.IInputStream, dest: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncAction;
+  }
+  var IDataProtectionProvider: abstract new (...args: any[]) => IDataProtectionProvider;
+
+  interface IDataProtectionProviderFactory {
+    CreateOverloadExplicit(protectionDescriptor: string): Windows.Security.Cryptography.DataProtection.DataProtectionProvider;
+  }
+  var IDataProtectionProviderFactory: abstract new (...args: any[]) => IDataProtectionProviderFactory;
+
+}
+
+declare namespace Windows.Security.DataProtection {
+  class UserDataAvailabilityStateChangedEventArgs implements Windows.Security.DataProtection.IUserDataAvailabilityStateChangedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+
+  class UserDataBufferUnprotectResult implements Windows.Security.DataProtection.IUserDataBufferUnprotectResult {
+    readonly Status: number;
+    readonly UnprotectedBuffer: Windows.Storage.Streams.IBuffer;
+  }
+
+  class UserDataProtectionManager implements Windows.Security.DataProtection.IUserDataProtectionManager {
+    GetStorageItemProtectionInfoAsync(storageItem: Windows.Storage.IStorageItem): Windows.Foundation.IAsyncOperation<Windows.Security.DataProtection.UserDataStorageItemProtectionInfo>;
+    IsContinuedDataAvailabilityExpected(availability: number): boolean;
+    ProtectBufferAsync(unprotectedBuffer: Windows.Storage.Streams.IBuffer, availability: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    ProtectStorageItemAsync(storageItem: Windows.Storage.IStorageItem, availability: number): Windows.Foundation.IAsyncOperation<number>;
+    static TryGetDefault(): Windows.Security.DataProtection.UserDataProtectionManager;
+    static TryGetForUser(user: Windows.System.User): Windows.Security.DataProtection.UserDataProtectionManager;
+    UnprotectBufferAsync(protectedBuffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Security.DataProtection.UserDataBufferUnprotectResult>;
+    DataAvailabilityStateChanged: Windows.Foundation.TypedEventHandler<Windows.Security.DataProtection.UserDataProtectionManager, Windows.Security.DataProtection.UserDataAvailabilityStateChangedEventArgs> | null;
+  }
+
+  class UserDataStorageItemProtectionInfo implements Windows.Security.DataProtection.IUserDataStorageItemProtectionInfo {
+    readonly Availability: number;
+  }
+
+  enum UserDataAvailability {
+    Always = 0,
+    AfterFirstUnlock = 1,
+    WhileUnlocked = 2,
+  }
+
+  enum UserDataBufferUnprotectStatus {
+    Succeeded = 0,
+    Unavailable = 1,
+  }
+
+  enum UserDataStorageItemProtectionStatus {
+    Succeeded = 0,
+    NotProtectable = 1,
+    DataUnavailable = 2,
+  }
+
+  interface IUserDataAvailabilityStateChangedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+  var IUserDataAvailabilityStateChangedEventArgs: abstract new (...args: any[]) => IUserDataAvailabilityStateChangedEventArgs;
+
+  interface IUserDataBufferUnprotectResult {
+    readonly Status: number;
+    readonly UnprotectedBuffer: Windows.Storage.Streams.IBuffer;
+  }
+  var IUserDataBufferUnprotectResult: abstract new (...args: any[]) => IUserDataBufferUnprotectResult;
+
+  interface IUserDataProtectionManager {
+    GetStorageItemProtectionInfoAsync(storageItem: Windows.Storage.IStorageItem): Windows.Foundation.IAsyncOperation<Windows.Security.DataProtection.UserDataStorageItemProtectionInfo>;
+    IsContinuedDataAvailabilityExpected(availability: number): boolean;
+    ProtectBufferAsync(unprotectedBuffer: Windows.Storage.Streams.IBuffer, availability: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    ProtectStorageItemAsync(storageItem: Windows.Storage.IStorageItem, availability: number): Windows.Foundation.IAsyncOperation<number>;
+    UnprotectBufferAsync(protectedBuffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Security.DataProtection.UserDataBufferUnprotectResult>;
+    DataAvailabilityStateChanged: Windows.Foundation.TypedEventHandler<Windows.Security.DataProtection.UserDataProtectionManager, Windows.Security.DataProtection.UserDataAvailabilityStateChangedEventArgs> | null;
+  }
+  var IUserDataProtectionManager: abstract new (...args: any[]) => IUserDataProtectionManager;
+
+  interface IUserDataProtectionManagerStatics {
+    TryGetDefault(): Windows.Security.DataProtection.UserDataProtectionManager;
+    TryGetForUser(user: Windows.System.User): Windows.Security.DataProtection.UserDataProtectionManager;
+  }
+  var IUserDataProtectionManagerStatics: abstract new (...args: any[]) => IUserDataProtectionManagerStatics;
+
+  interface IUserDataStorageItemProtectionInfo {
+    readonly Availability: number;
+  }
+  var IUserDataStorageItemProtectionInfo: abstract new (...args: any[]) => IUserDataStorageItemProtectionInfo;
+
+}
+
+declare namespace Windows.Security.EnterpriseData {
+  class BufferProtectUnprotectResult implements Windows.Security.EnterpriseData.IBufferProtectUnprotectResult {
+    readonly Buffer: Windows.Storage.Streams.IBuffer;
+    readonly ProtectionInfo: Windows.Security.EnterpriseData.DataProtectionInfo;
+  }
+
+  class DataProtectionInfo implements Windows.Security.EnterpriseData.IDataProtectionInfo {
+    readonly Identity: string;
+    readonly Status: number;
+  }
+
+  class DataProtectionManager {
+    static GetProtectionInfoAsync(protectedData: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.DataProtectionInfo>;
+    static GetStreamProtectionInfoAsync(protectedStream: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.DataProtectionInfo>;
+    static ProtectAsync(data: Windows.Storage.Streams.IBuffer, identity: string): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.BufferProtectUnprotectResult>;
+    static ProtectStreamAsync(unprotectedStream: Windows.Storage.Streams.IInputStream, identity: string, protectedStream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.DataProtectionInfo>;
+    static UnprotectAsync(data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.BufferProtectUnprotectResult>;
+    static UnprotectStreamAsync(protectedStream: Windows.Storage.Streams.IInputStream, unprotectedStream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.DataProtectionInfo>;
+  }
+
+  class FileProtectionInfo implements Windows.Security.EnterpriseData.IFileProtectionInfo, Windows.Security.EnterpriseData.IFileProtectionInfo2 {
+    readonly Identity: string;
+    readonly IsProtectWhileOpenSupported: boolean;
+    readonly IsRoamable: boolean;
+    readonly Status: number;
+  }
+
+  class FileProtectionManager {
+    static CopyProtectionAsync(source: Windows.Storage.IStorageItem, target: Windows.Storage.IStorageItem): Windows.Foundation.IAsyncOperation<boolean>;
+    static CreateProtectedAndOpenAsync(parentFolder: Windows.Storage.IStorageFolder, desiredName: string, identity: string, collisionOption: number): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.ProtectedFileCreateResult>;
+    static GetProtectionInfoAsync(source: Windows.Storage.IStorageItem): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.FileProtectionInfo>;
+    static IsContainerAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<boolean>;
+    static LoadFileFromContainerAsync(containerFile: Windows.Storage.IStorageFile, target: Windows.Storage.IStorageItem, collisionOption: number): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.ProtectedContainerImportResult>;
+    static LoadFileFromContainerAsync(containerFile: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.ProtectedContainerImportResult>;
+    static LoadFileFromContainerAsync(containerFile: Windows.Storage.IStorageFile, target: Windows.Storage.IStorageItem): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.ProtectedContainerImportResult>;
+    static ProtectAsync(target: Windows.Storage.IStorageItem, identity: string): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.FileProtectionInfo>;
+    static SaveFileAsContainerAsync(protectedFile: Windows.Storage.IStorageFile, sharedWithIdentities: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.ProtectedContainerExportResult>;
+    static SaveFileAsContainerAsync(protectedFile: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.ProtectedContainerExportResult>;
+    static UnprotectAsync(target: Windows.Storage.IStorageItem): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.FileProtectionInfo>;
+    static UnprotectAsync(target: Windows.Storage.IStorageItem, options: Windows.Security.EnterpriseData.FileUnprotectOptions): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.FileProtectionInfo>;
+  }
+
+  class FileRevocationManager {
+    static CopyProtectionAsync(sourceStorageItem: Windows.Storage.IStorageItem, targetStorageItem: Windows.Storage.IStorageItem): Windows.Foundation.IAsyncOperation<boolean>;
+    static GetStatusAsync(storageItem: Windows.Storage.IStorageItem): Windows.Foundation.IAsyncOperation<number>;
+    static ProtectAsync(storageItem: Windows.Storage.IStorageItem, enterpriseIdentity: string): Windows.Foundation.IAsyncOperation<number>;
+    static Revoke(enterpriseIdentity: string): void;
+  }
+
+  class FileUnprotectOptions implements Windows.Security.EnterpriseData.IFileUnprotectOptions {
+    constructor(audit: boolean);
+    Audit: boolean;
+  }
+
+  class ProtectedAccessResumedEventArgs implements Windows.Security.EnterpriseData.IProtectedAccessResumedEventArgs {
+    readonly Identities: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+
+  class ProtectedAccessSuspendingEventArgs implements Windows.Security.EnterpriseData.IProtectedAccessSuspendingEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Deadline: Windows.Foundation.DateTime;
+    readonly Identities: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+
+  class ProtectedContainerExportResult implements Windows.Security.EnterpriseData.IProtectedContainerExportResult {
+    readonly File: Windows.Storage.StorageFile;
+    readonly Status: number;
+  }
+
+  class ProtectedContainerImportResult implements Windows.Security.EnterpriseData.IProtectedContainerImportResult {
+    readonly File: Windows.Storage.StorageFile;
+    readonly Status: number;
+  }
+
+  class ProtectedContentRevokedEventArgs implements Windows.Security.EnterpriseData.IProtectedContentRevokedEventArgs {
+    readonly Identities: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+
+  class ProtectedFileCreateResult implements Windows.Security.EnterpriseData.IProtectedFileCreateResult {
+    readonly File: Windows.Storage.StorageFile;
+    readonly ProtectionInfo: Windows.Security.EnterpriseData.FileProtectionInfo;
+    readonly Stream: Windows.Storage.Streams.IRandomAccessStream;
+  }
+
+  class ProtectionPolicyAuditInfo implements Windows.Security.EnterpriseData.IProtectionPolicyAuditInfo {
+    constructor(action: number, dataDescription: string, sourceDescription: string, targetDescription: string);
+    constructor(action: number, dataDescription: string);
+    Action: number;
+    DataDescription: string;
+    SourceDescription: string;
+    TargetDescription: string;
+  }
+
+  class ProtectionPolicyManager implements Windows.Security.EnterpriseData.IProtectionPolicyManager, Windows.Security.EnterpriseData.IProtectionPolicyManager2 {
+    static CheckAccess(sourceIdentity: string, targetIdentity: string): number;
+    static CheckAccessForApp(sourceIdentity: string, appPackageFamilyName: string): number;
+    static ClearProcessUIPolicy(): void;
+    static CreateCurrentThreadNetworkContext(identity: string): Windows.Security.EnterpriseData.ThreadNetworkContext;
+    static GetEnforcementLevel(identity: string): number;
+    static GetForCurrentView(): Windows.Security.EnterpriseData.ProtectionPolicyManager;
+    static GetPrimaryManagedIdentityForIdentity(identity: string): string;
+    static GetPrimaryManagedIdentityForNetworkEndpointAsync(endpointHost: Windows.Networking.HostName): Windows.Foundation.IAsyncOperation<string>;
+    static HasContentBeenRevokedSince(identity: string, since: Windows.Foundation.DateTime): boolean;
+    static IsFileProtectionRequiredAsync(target: Windows.Storage.IStorageItem, identity: string): Windows.Foundation.IAsyncOperation<boolean>;
+    static IsFileProtectionRequiredForNewFileAsync(parentFolder: Windows.Storage.IStorageFolder, identity: string, desiredName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    static IsIdentityManaged(identity: string): boolean;
+    static IsProtectionUnderLockRequired(identity: string): boolean;
+    static IsRoamableProtectionEnabled(identity: string): boolean;
+    static IsUserDecryptionAllowed(identity: string): boolean;
+    static LogAuditEvent(sourceIdentity: string, targetIdentity: string, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo): void;
+    static RequestAccessAsync(sourceIdentity: string, targetIdentity: string, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo, messageFromApp: string, behavior: number): Windows.Foundation.IAsyncOperation<number>;
+    static RequestAccessAsync(sourceIdentity: string, targetIdentity: string, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo): Windows.Foundation.IAsyncOperation<number>;
+    static RequestAccessAsync(sourceIdentity: string, targetIdentity: string, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo, messageFromApp: string): Windows.Foundation.IAsyncOperation<number>;
+    static RequestAccessAsync(sourceIdentity: string, targetIdentity: string): Windows.Foundation.IAsyncOperation<number>;
+    static RequestAccessForAppAsync(sourceIdentity: string, appPackageFamilyName: string, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo, messageFromApp: string, behavior: number): Windows.Foundation.IAsyncOperation<number>;
+    static RequestAccessForAppAsync(sourceIdentity: string, appPackageFamilyName: string, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo): Windows.Foundation.IAsyncOperation<number>;
+    static RequestAccessForAppAsync(sourceIdentity: string, appPackageFamilyName: string, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo, messageFromApp: string): Windows.Foundation.IAsyncOperation<number>;
+    static RequestAccessForAppAsync(sourceIdentity: string, appPackageFamilyName: string): Windows.Foundation.IAsyncOperation<number>;
+    static RequestAccessToFilesForAppAsync(sourceItemList: Windows.Foundation.Collections.IIterable<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[], appPackageFamilyName: string, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo): Windows.Foundation.IAsyncOperation<number>;
+    static RequestAccessToFilesForAppAsync(sourceItemList: Windows.Foundation.Collections.IIterable<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[], appPackageFamilyName: string, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo, messageFromApp: string, behavior: number): Windows.Foundation.IAsyncOperation<number>;
+    static RequestAccessToFilesForProcessAsync(sourceItemList: Windows.Foundation.Collections.IIterable<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[], processId: number, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo): Windows.Foundation.IAsyncOperation<number>;
+    static RequestAccessToFilesForProcessAsync(sourceItemList: Windows.Foundation.Collections.IIterable<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[], processId: number, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo, messageFromApp: string, behavior: number): Windows.Foundation.IAsyncOperation<number>;
+    static RevokeContent(identity: string): void;
+    static TryApplyProcessUIPolicy(identity: string): boolean;
+    Identity: string;
+    static readonly IsProtectionEnabled: boolean;
+    static readonly PrimaryManagedIdentity: string;
+    ShowEnterpriseIndicator: boolean;
+    static PolicyChanged: Windows.Foundation.EventHandler<Object> | null;
+    static ProtectedAccessResumed: Windows.Foundation.EventHandler<Windows.Security.EnterpriseData.ProtectedAccessResumedEventArgs> | null;
+    static ProtectedAccessSuspending: Windows.Foundation.EventHandler<Windows.Security.EnterpriseData.ProtectedAccessSuspendingEventArgs> | null;
+    static ProtectedContentRevoked: Windows.Foundation.EventHandler<Windows.Security.EnterpriseData.ProtectedContentRevokedEventArgs> | null;
+  }
+
+  class ThreadNetworkContext implements Windows.Foundation.IClosable, Windows.Security.EnterpriseData.IThreadNetworkContext {
+    Close(): void;
+  }
+
+  enum DataProtectionStatus {
+    ProtectedToOtherIdentity = 0,
+    Protected = 1,
+    Revoked = 2,
+    Unprotected = 3,
+    LicenseExpired = 4,
+    AccessSuspended = 5,
+  }
+
+  enum EnforcementLevel {
+    NoProtection = 0,
+    Silent = 1,
+    Override = 2,
+    Block = 3,
+  }
+
+  enum FileProtectionStatus {
+    Undetermined = 0,
+    Unknown = 0,
+    Unprotected = 1,
+    Revoked = 2,
+    Protected = 3,
+    ProtectedByOtherUser = 4,
+    ProtectedToOtherEnterprise = 5,
+    NotProtectable = 6,
+    ProtectedToOtherIdentity = 7,
+    LicenseExpired = 8,
+    AccessSuspended = 9,
+    FileInUse = 10,
+  }
+
+  enum ProtectedImportExportStatus {
+    Ok = 0,
+    Undetermined = 1,
+    Unprotected = 2,
+    Revoked = 3,
+    NotRoamable = 4,
+    ProtectedToOtherIdentity = 5,
+    LicenseExpired = 6,
+    AccessSuspended = 7,
+  }
+
+  enum ProtectionPolicyAuditAction {
+    Decrypt = 0,
+    CopyToLocation = 1,
+    SendToRecipient = 2,
+    Other = 3,
+  }
+
+  enum ProtectionPolicyEvaluationResult {
+    Allowed = 0,
+    Blocked = 1,
+    ConsentRequired = 2,
+  }
+
+  enum ProtectionPolicyRequestAccessBehavior {
+    Decrypt = 0,
+    TreatOverridePolicyAsBlock = 1,
+  }
+
+  interface EnterpriseDataContract {
+  }
+  var EnterpriseDataContract: {
+    new(fields: {  }): EnterpriseDataContract;
+  };
+
+  interface IBufferProtectUnprotectResult {
+    readonly Buffer: Windows.Storage.Streams.IBuffer;
+    readonly ProtectionInfo: Windows.Security.EnterpriseData.DataProtectionInfo;
+  }
+  var IBufferProtectUnprotectResult: abstract new (...args: any[]) => IBufferProtectUnprotectResult;
+
+  interface IDataProtectionInfo {
+    readonly Identity: string;
+    readonly Status: number;
+  }
+  var IDataProtectionInfo: abstract new (...args: any[]) => IDataProtectionInfo;
+
+  interface IDataProtectionManagerStatics {
+    GetProtectionInfoAsync(protectedData: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.DataProtectionInfo>;
+    GetStreamProtectionInfoAsync(protectedStream: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.DataProtectionInfo>;
+    ProtectAsync(data: Windows.Storage.Streams.IBuffer, identity: string): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.BufferProtectUnprotectResult>;
+    ProtectStreamAsync(unprotectedStream: Windows.Storage.Streams.IInputStream, identity: string, protectedStream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.DataProtectionInfo>;
+    UnprotectAsync(data: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.BufferProtectUnprotectResult>;
+    UnprotectStreamAsync(protectedStream: Windows.Storage.Streams.IInputStream, unprotectedStream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.DataProtectionInfo>;
+  }
+  var IDataProtectionManagerStatics: abstract new (...args: any[]) => IDataProtectionManagerStatics;
+
+  interface IFileProtectionInfo {
+    readonly Identity: string;
+    readonly IsRoamable: boolean;
+    readonly Status: number;
+  }
+  var IFileProtectionInfo: abstract new (...args: any[]) => IFileProtectionInfo;
+
+  interface IFileProtectionInfo2 {
+    readonly IsProtectWhileOpenSupported: boolean;
+  }
+  var IFileProtectionInfo2: abstract new (...args: any[]) => IFileProtectionInfo2;
+
+  interface IFileProtectionManagerStatics {
+    CopyProtectionAsync(source: Windows.Storage.IStorageItem, target: Windows.Storage.IStorageItem): Windows.Foundation.IAsyncOperation<boolean>;
+    CreateProtectedAndOpenAsync(parentFolder: Windows.Storage.IStorageFolder, desiredName: string, identity: string, collisionOption: number): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.ProtectedFileCreateResult>;
+    GetProtectionInfoAsync(source: Windows.Storage.IStorageItem): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.FileProtectionInfo>;
+    LoadFileFromContainerAsync(containerFile: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.ProtectedContainerImportResult>;
+    LoadFileFromContainerAsync(containerFile: Windows.Storage.IStorageFile, target: Windows.Storage.IStorageItem): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.ProtectedContainerImportResult>;
+    ProtectAsync(target: Windows.Storage.IStorageItem, identity: string): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.FileProtectionInfo>;
+    SaveFileAsContainerAsync(protectedFile: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.ProtectedContainerExportResult>;
+  }
+  var IFileProtectionManagerStatics: abstract new (...args: any[]) => IFileProtectionManagerStatics;
+
+  interface IFileProtectionManagerStatics2 {
+    IsContainerAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<boolean>;
+    LoadFileFromContainerAsync(containerFile: Windows.Storage.IStorageFile, target: Windows.Storage.IStorageItem, collisionOption: number): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.ProtectedContainerImportResult>;
+    SaveFileAsContainerAsync(protectedFile: Windows.Storage.IStorageFile, sharedWithIdentities: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.ProtectedContainerExportResult>;
+  }
+  var IFileProtectionManagerStatics2: abstract new (...args: any[]) => IFileProtectionManagerStatics2;
+
+  interface IFileProtectionManagerStatics3 {
+    UnprotectAsync(target: Windows.Storage.IStorageItem): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.FileProtectionInfo>;
+    UnprotectAsync(target: Windows.Storage.IStorageItem, options: Windows.Security.EnterpriseData.FileUnprotectOptions): Windows.Foundation.IAsyncOperation<Windows.Security.EnterpriseData.FileProtectionInfo>;
+  }
+  var IFileProtectionManagerStatics3: abstract new (...args: any[]) => IFileProtectionManagerStatics3;
+
+  interface IFileRevocationManagerStatics {
+    CopyProtectionAsync(sourceStorageItem: Windows.Storage.IStorageItem, targetStorageItem: Windows.Storage.IStorageItem): Windows.Foundation.IAsyncOperation<boolean>;
+    GetStatusAsync(storageItem: Windows.Storage.IStorageItem): Windows.Foundation.IAsyncOperation<number>;
+    ProtectAsync(storageItem: Windows.Storage.IStorageItem, enterpriseIdentity: string): Windows.Foundation.IAsyncOperation<number>;
+    Revoke(enterpriseIdentity: string): void;
+  }
+  var IFileRevocationManagerStatics: abstract new (...args: any[]) => IFileRevocationManagerStatics;
+
+  interface IFileUnprotectOptions {
+    Audit: boolean;
+  }
+  var IFileUnprotectOptions: abstract new (...args: any[]) => IFileUnprotectOptions;
+
+  interface IFileUnprotectOptionsFactory {
+    Create(audit: boolean): Windows.Security.EnterpriseData.FileUnprotectOptions;
+  }
+  var IFileUnprotectOptionsFactory: abstract new (...args: any[]) => IFileUnprotectOptionsFactory;
+
+  interface IProtectedAccessResumedEventArgs {
+    readonly Identities: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var IProtectedAccessResumedEventArgs: abstract new (...args: any[]) => IProtectedAccessResumedEventArgs;
+
+  interface IProtectedAccessSuspendingEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Deadline: Windows.Foundation.DateTime;
+    readonly Identities: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var IProtectedAccessSuspendingEventArgs: abstract new (...args: any[]) => IProtectedAccessSuspendingEventArgs;
+
+  interface IProtectedContainerExportResult {
+    readonly File: Windows.Storage.StorageFile;
+    readonly Status: number;
+  }
+  var IProtectedContainerExportResult: abstract new (...args: any[]) => IProtectedContainerExportResult;
+
+  interface IProtectedContainerImportResult {
+    readonly File: Windows.Storage.StorageFile;
+    readonly Status: number;
+  }
+  var IProtectedContainerImportResult: abstract new (...args: any[]) => IProtectedContainerImportResult;
+
+  interface IProtectedContentRevokedEventArgs {
+    readonly Identities: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var IProtectedContentRevokedEventArgs: abstract new (...args: any[]) => IProtectedContentRevokedEventArgs;
+
+  interface IProtectedFileCreateResult {
+    readonly File: Windows.Storage.StorageFile;
+    readonly ProtectionInfo: Windows.Security.EnterpriseData.FileProtectionInfo;
+    readonly Stream: Windows.Storage.Streams.IRandomAccessStream;
+  }
+  var IProtectedFileCreateResult: abstract new (...args: any[]) => IProtectedFileCreateResult;
+
+  interface IProtectionPolicyAuditInfo {
+    Action: number;
+    DataDescription: string;
+    SourceDescription: string;
+    TargetDescription: string;
+  }
+  var IProtectionPolicyAuditInfo: abstract new (...args: any[]) => IProtectionPolicyAuditInfo;
+
+  interface IProtectionPolicyAuditInfoFactory {
+    Create(action: number, dataDescription: string, sourceDescription: string, targetDescription: string): Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo;
+    CreateWithActionAndDataDescription(action: number, dataDescription: string): Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo;
+  }
+  var IProtectionPolicyAuditInfoFactory: abstract new (...args: any[]) => IProtectionPolicyAuditInfoFactory;
+
+  interface IProtectionPolicyManager {
+    Identity: string;
+  }
+  var IProtectionPolicyManager: abstract new (...args: any[]) => IProtectionPolicyManager;
+
+  interface IProtectionPolicyManager2 {
+    ShowEnterpriseIndicator: boolean;
+  }
+  var IProtectionPolicyManager2: abstract new (...args: any[]) => IProtectionPolicyManager2;
+
+  interface IProtectionPolicyManagerStatics {
+    CheckAccess(sourceIdentity: string, targetIdentity: string): number;
+    ClearProcessUIPolicy(): void;
+    CreateCurrentThreadNetworkContext(identity: string): Windows.Security.EnterpriseData.ThreadNetworkContext;
+    GetForCurrentView(): Windows.Security.EnterpriseData.ProtectionPolicyManager;
+    GetPrimaryManagedIdentityForNetworkEndpointAsync(endpointHost: Windows.Networking.HostName): Windows.Foundation.IAsyncOperation<string>;
+    IsIdentityManaged(identity: string): boolean;
+    RequestAccessAsync(sourceIdentity: string, targetIdentity: string): Windows.Foundation.IAsyncOperation<number>;
+    RevokeContent(identity: string): void;
+    TryApplyProcessUIPolicy(identity: string): boolean;
+    ProtectedAccessResumed: Windows.Foundation.EventHandler<Windows.Security.EnterpriseData.ProtectedAccessResumedEventArgs> | null;
+    ProtectedAccessSuspending: Windows.Foundation.EventHandler<Windows.Security.EnterpriseData.ProtectedAccessSuspendingEventArgs> | null;
+    ProtectedContentRevoked: Windows.Foundation.EventHandler<Windows.Security.EnterpriseData.ProtectedContentRevokedEventArgs> | null;
+  }
+  var IProtectionPolicyManagerStatics: abstract new (...args: any[]) => IProtectionPolicyManagerStatics;
+
+  interface IProtectionPolicyManagerStatics2 {
+    CheckAccessForApp(sourceIdentity: string, appPackageFamilyName: string): number;
+    GetEnforcementLevel(identity: string): number;
+    HasContentBeenRevokedSince(identity: string, since: Windows.Foundation.DateTime): boolean;
+    IsProtectionUnderLockRequired(identity: string): boolean;
+    IsUserDecryptionAllowed(identity: string): boolean;
+    RequestAccessForAppAsync(sourceIdentity: string, appPackageFamilyName: string): Windows.Foundation.IAsyncOperation<number>;
+    readonly IsProtectionEnabled: boolean;
+    PolicyChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IProtectionPolicyManagerStatics2: abstract new (...args: any[]) => IProtectionPolicyManagerStatics2;
+
+  interface IProtectionPolicyManagerStatics3 {
+    LogAuditEvent(sourceIdentity: string, targetIdentity: string, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo): void;
+    RequestAccessAsync(sourceIdentity: string, targetIdentity: string, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo): Windows.Foundation.IAsyncOperation<number>;
+    RequestAccessAsync(sourceIdentity: string, targetIdentity: string, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo, messageFromApp: string): Windows.Foundation.IAsyncOperation<number>;
+    RequestAccessForAppAsync(sourceIdentity: string, appPackageFamilyName: string, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo): Windows.Foundation.IAsyncOperation<number>;
+    RequestAccessForAppAsync(sourceIdentity: string, appPackageFamilyName: string, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo, messageFromApp: string): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IProtectionPolicyManagerStatics3: abstract new (...args: any[]) => IProtectionPolicyManagerStatics3;
+
+  interface IProtectionPolicyManagerStatics4 {
+    GetPrimaryManagedIdentityForIdentity(identity: string): string;
+    IsFileProtectionRequiredAsync(target: Windows.Storage.IStorageItem, identity: string): Windows.Foundation.IAsyncOperation<boolean>;
+    IsFileProtectionRequiredForNewFileAsync(parentFolder: Windows.Storage.IStorageFolder, identity: string, desiredName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    IsRoamableProtectionEnabled(identity: string): boolean;
+    RequestAccessAsync(sourceIdentity: string, targetIdentity: string, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo, messageFromApp: string, behavior: number): Windows.Foundation.IAsyncOperation<number>;
+    RequestAccessForAppAsync(sourceIdentity: string, appPackageFamilyName: string, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo, messageFromApp: string, behavior: number): Windows.Foundation.IAsyncOperation<number>;
+    RequestAccessToFilesForAppAsync(sourceItemList: Windows.Foundation.Collections.IIterable<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[], appPackageFamilyName: string, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo): Windows.Foundation.IAsyncOperation<number>;
+    RequestAccessToFilesForAppAsync(sourceItemList: Windows.Foundation.Collections.IIterable<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[], appPackageFamilyName: string, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo, messageFromApp: string, behavior: number): Windows.Foundation.IAsyncOperation<number>;
+    RequestAccessToFilesForProcessAsync(sourceItemList: Windows.Foundation.Collections.IIterable<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[], processId: number, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo): Windows.Foundation.IAsyncOperation<number>;
+    RequestAccessToFilesForProcessAsync(sourceItemList: Windows.Foundation.Collections.IIterable<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[], processId: number, auditInfo: Windows.Security.EnterpriseData.ProtectionPolicyAuditInfo, messageFromApp: string, behavior: number): Windows.Foundation.IAsyncOperation<number>;
+    readonly PrimaryManagedIdentity: string;
+  }
+  var IProtectionPolicyManagerStatics4: abstract new (...args: any[]) => IProtectionPolicyManagerStatics4;
+
+  interface IThreadNetworkContext {
+  }
+  var IThreadNetworkContext: abstract new (...args: any[]) => IThreadNetworkContext;
+
+}
+
+declare namespace Windows.Security.ExchangeActiveSyncProvisioning {
+  class EasClientDeviceInformation implements Windows.Security.ExchangeActiveSyncProvisioning.IEasClientDeviceInformation, Windows.Security.ExchangeActiveSyncProvisioning.IEasClientDeviceInformation2 {
+    constructor();
+    readonly FriendlyName: string;
+    readonly Id: Guid;
+    readonly OperatingSystem: string;
+    readonly SystemFirmwareVersion: string;
+    readonly SystemHardwareVersion: string;
+    readonly SystemManufacturer: string;
+    readonly SystemProductName: string;
+    readonly SystemSku: string;
+  }
+
+  class EasClientSecurityPolicy implements Windows.Security.ExchangeActiveSyncProvisioning.IEasClientSecurityPolicy {
+    constructor();
+    ApplyAsync(): Windows.Foundation.IAsyncOperation<Windows.Security.ExchangeActiveSyncProvisioning.EasComplianceResults>;
+    CheckCompliance(): Windows.Security.ExchangeActiveSyncProvisioning.EasComplianceResults;
+    DisallowConvenienceLogon: boolean;
+    MaxInactivityTimeLock: Windows.Foundation.TimeSpan;
+    MaxPasswordFailedAttempts: number;
+    MinPasswordComplexCharacters: number;
+    MinPasswordLength: number;
+    PasswordExpiration: Windows.Foundation.TimeSpan;
+    PasswordHistory: number;
+    RequireEncryption: boolean;
+  }
+
+  class EasComplianceResults implements Windows.Security.ExchangeActiveSyncProvisioning.IEasComplianceResults, Windows.Security.ExchangeActiveSyncProvisioning.IEasComplianceResults2 {
+    readonly Compliant: boolean;
+    readonly DisallowConvenienceLogonResult: number;
+    readonly EncryptionProviderType: number;
+    readonly MaxInactivityTimeLockResult: number;
+    readonly MaxPasswordFailedAttemptsResult: number;
+    readonly MinPasswordComplexCharactersResult: number;
+    readonly MinPasswordLengthResult: number;
+    readonly PasswordExpirationResult: number;
+    readonly PasswordHistoryResult: number;
+    readonly RequireEncryptionResult: number;
+  }
+
+  enum EasDisallowConvenienceLogonResult {
+    NotEvaluated = 0,
+    Compliant = 1,
+    CanBeCompliant = 2,
+    RequestedPolicyIsStricter = 3,
+  }
+
+  enum EasEncryptionProviderType {
+    NotEvaluated = 0,
+    WindowsEncryption = 1,
+    OtherEncryption = 2,
+  }
+
+  enum EasMaxInactivityTimeLockResult {
+    NotEvaluated = 0,
+    Compliant = 1,
+    CanBeCompliant = 2,
+    RequestedPolicyIsStricter = 3,
+    InvalidParameter = 4,
+  }
+
+  enum EasMaxPasswordFailedAttemptsResult {
+    NotEvaluated = 0,
+    Compliant = 1,
+    CanBeCompliant = 2,
+    RequestedPolicyIsStricter = 3,
+    InvalidParameter = 4,
+  }
+
+  enum EasMinPasswordComplexCharactersResult {
+    NotEvaluated = 0,
+    Compliant = 1,
+    CanBeCompliant = 2,
+    RequestedPolicyIsStricter = 3,
+    RequestedPolicyNotEnforceable = 4,
+    InvalidParameter = 5,
+    CurrentUserHasBlankPassword = 6,
+    AdminsHaveBlankPassword = 7,
+    UserCannotChangePassword = 8,
+    AdminsCannotChangePassword = 9,
+    LocalControlledUsersCannotChangePassword = 10,
+    ConnectedAdminsProviderPolicyIsWeak = 11,
+    ConnectedUserProviderPolicyIsWeak = 12,
+    ChangeConnectedAdminsPassword = 13,
+    ChangeConnectedUserPassword = 14,
+  }
+
+  enum EasMinPasswordLengthResult {
+    NotEvaluated = 0,
+    Compliant = 1,
+    CanBeCompliant = 2,
+    RequestedPolicyIsStricter = 3,
+    RequestedPolicyNotEnforceable = 4,
+    InvalidParameter = 5,
+    CurrentUserHasBlankPassword = 6,
+    AdminsHaveBlankPassword = 7,
+    UserCannotChangePassword = 8,
+    AdminsCannotChangePassword = 9,
+    LocalControlledUsersCannotChangePassword = 10,
+    ConnectedAdminsProviderPolicyIsWeak = 11,
+    ConnectedUserProviderPolicyIsWeak = 12,
+    ChangeConnectedAdminsPassword = 13,
+    ChangeConnectedUserPassword = 14,
+  }
+
+  enum EasPasswordExpirationResult {
+    NotEvaluated = 0,
+    Compliant = 1,
+    CanBeCompliant = 2,
+    RequestedPolicyIsStricter = 3,
+    RequestedExpirationIncompatible = 4,
+    InvalidParameter = 5,
+    UserCannotChangePassword = 6,
+    AdminsCannotChangePassword = 7,
+    LocalControlledUsersCannotChangePassword = 8,
+  }
+
+  enum EasPasswordHistoryResult {
+    NotEvaluated = 0,
+    Compliant = 1,
+    CanBeCompliant = 2,
+    RequestedPolicyIsStricter = 3,
+    InvalidParameter = 4,
+  }
+
+  enum EasRequireEncryptionResult {
+    NotEvaluated = 0,
+    Compliant = 1,
+    CanBeCompliant = 2,
+    NotProvisionedOnAllVolumes = 3,
+    DeFixedDataNotSupported = 4,
+    FixedDataNotSupported = 4,
+    DeHardwareNotCompliant = 5,
+    HardwareNotCompliant = 5,
+    DeWinReNotConfigured = 6,
+    LockNotConfigured = 6,
+    DeProtectionSuspended = 7,
+    ProtectionSuspended = 7,
+    DeOsVolumeNotProtected = 8,
+    OsVolumeNotProtected = 8,
+    DeProtectionNotYetEnabled = 9,
+    ProtectionNotYetEnabled = 9,
+    NoFeatureLicense = 10,
+    OsNotProtected = 11,
+    UnexpectedFailure = 12,
+  }
+
+  interface EasContract {
+  }
+  var EasContract: {
+    new(fields: {  }): EasContract;
+  };
+
+  interface IEasClientDeviceInformation {
+    readonly FriendlyName: string;
+    readonly Id: Guid;
+    readonly OperatingSystem: string;
+    readonly SystemManufacturer: string;
+    readonly SystemProductName: string;
+    readonly SystemSku: string;
+  }
+  var IEasClientDeviceInformation: abstract new (...args: any[]) => IEasClientDeviceInformation;
+
+  interface IEasClientDeviceInformation2 extends Windows.Security.ExchangeActiveSyncProvisioning.IEasClientDeviceInformation {
+    readonly SystemFirmwareVersion: string;
+    readonly SystemHardwareVersion: string;
+  }
+  var IEasClientDeviceInformation2: abstract new (...args: any[]) => IEasClientDeviceInformation2;
+
+  interface IEasClientSecurityPolicy {
+    ApplyAsync(): Windows.Foundation.IAsyncOperation<Windows.Security.ExchangeActiveSyncProvisioning.EasComplianceResults>;
+    CheckCompliance(): Windows.Security.ExchangeActiveSyncProvisioning.EasComplianceResults;
+    DisallowConvenienceLogon: boolean;
+    MaxInactivityTimeLock: Windows.Foundation.TimeSpan;
+    MaxPasswordFailedAttempts: number;
+    MinPasswordComplexCharacters: number;
+    MinPasswordLength: number;
+    PasswordExpiration: Windows.Foundation.TimeSpan;
+    PasswordHistory: number;
+    RequireEncryption: boolean;
+  }
+  var IEasClientSecurityPolicy: abstract new (...args: any[]) => IEasClientSecurityPolicy;
+
+  interface IEasComplianceResults {
+    readonly Compliant: boolean;
+    readonly DisallowConvenienceLogonResult: number;
+    readonly MaxInactivityTimeLockResult: number;
+    readonly MaxPasswordFailedAttemptsResult: number;
+    readonly MinPasswordComplexCharactersResult: number;
+    readonly MinPasswordLengthResult: number;
+    readonly PasswordExpirationResult: number;
+    readonly PasswordHistoryResult: number;
+    readonly RequireEncryptionResult: number;
+  }
+  var IEasComplianceResults: abstract new (...args: any[]) => IEasComplianceResults;
+
+  interface IEasComplianceResults2 extends Windows.Security.ExchangeActiveSyncProvisioning.IEasComplianceResults {
+    readonly EncryptionProviderType: number;
+  }
+  var IEasComplianceResults2: abstract new (...args: any[]) => IEasComplianceResults2;
+
+}
+
+declare namespace Windows.Security.Isolation {
+  class IsolatedWindowsEnvironment implements Windows.Security.Isolation.IIsolatedWindowsEnvironment, Windows.Security.Isolation.IIsolatedWindowsEnvironment2, Windows.Security.Isolation.IIsolatedWindowsEnvironment3, Windows.Security.Isolation.IIsolatedWindowsEnvironment4 {
+    ChangePriority(Priority: number): void;
+    static CreateAsync(options: Windows.Security.Isolation.IsolatedWindowsEnvironmentOptions): Windows.Foundation.IAsyncOperationWithProgress<Windows.Security.Isolation.IsolatedWindowsEnvironmentCreateResult, Windows.Security.Isolation.IsolatedWindowsEnvironmentCreateProgress>;
+    static CreateAsync(options: Windows.Security.Isolation.IsolatedWindowsEnvironmentOptions, telemetryParameters: Windows.Security.Isolation.IsolatedWindowsEnvironmentTelemetryParameters): Windows.Foundation.IAsyncOperationWithProgress<Windows.Security.Isolation.IsolatedWindowsEnvironmentCreateResult, Windows.Security.Isolation.IsolatedWindowsEnvironmentCreateProgress>;
+    static FindByOwnerId(environmentOwnerId: string): Windows.Foundation.Collections.IVectorView<Windows.Security.Isolation.IsolatedWindowsEnvironment> | Windows.Security.Isolation.IsolatedWindowsEnvironment[];
+    static GetById(environmentId: string): Windows.Security.Isolation.IsolatedWindowsEnvironment;
+    GetUserInfo(): Windows.Security.Isolation.IsolatedWindowsEnvironmentUserInfo;
+    LaunchFileWithUIAsync(appExePath: string, argumentsTemplate: string, filePath: string): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentLaunchFileResult>;
+    LaunchFileWithUIAsync(appExePath: string, argumentsTemplate: string, filePath: string, telemetryParameters: Windows.Security.Isolation.IsolatedWindowsEnvironmentTelemetryParameters): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentLaunchFileResult>;
+    PostMessageToReceiverAsync(receiverId: Guid, message: Windows.Foundation.Collections.IIterable<Object> | Object[]): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentPostMessageResult>;
+    PostMessageToReceiverAsync(receiverId: Guid, message: Windows.Foundation.Collections.IIterable<Object> | Object[], telemetryParameters: Windows.Security.Isolation.IsolatedWindowsEnvironmentTelemetryParameters): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentPostMessageResult>;
+    RegisterMessageReceiver(receiverId: Guid, messageReceivedCallback: Windows.Security.Isolation.MessageReceivedCallback): void;
+    ShareFileAsync(filePath: string, options: Windows.Security.Isolation.IsolatedWindowsEnvironmentShareFileRequestOptions): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentShareFileResult>;
+    ShareFileAsync(filePath: string, options: Windows.Security.Isolation.IsolatedWindowsEnvironmentShareFileRequestOptions, telemetryParameters: Windows.Security.Isolation.IsolatedWindowsEnvironmentTelemetryParameters): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentShareFileResult>;
+    ShareFolderAsync(hostFolder: string, requestOptions: Windows.Security.Isolation.IsolatedWindowsEnvironmentShareFolderRequestOptions): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentShareFolderResult>;
+    ShareFolderAsync(hostFolder: string, requestOptions: Windows.Security.Isolation.IsolatedWindowsEnvironmentShareFolderRequestOptions, telemetryParameters: Windows.Security.Isolation.IsolatedWindowsEnvironmentTelemetryParameters): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentShareFolderResult>;
+    StartProcessSilentlyAsync(hostExePath: string, arguments_: string, activator: number): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentStartProcessResult>;
+    StartProcessSilentlyAsync(hostExePath: string, arguments_: string, activator: number, telemetryParameters: Windows.Security.Isolation.IsolatedWindowsEnvironmentTelemetryParameters): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentStartProcessResult>;
+    TerminateAsync(): Windows.Foundation.IAsyncAction;
+    TerminateAsync(telemetryParameters: Windows.Security.Isolation.IsolatedWindowsEnvironmentTelemetryParameters): Windows.Foundation.IAsyncAction;
+    UnregisterMessageReceiver(receiverId: Guid): void;
+    readonly Id: string;
+  }
+
+  class IsolatedWindowsEnvironmentCreateResult implements Windows.Security.Isolation.IIsolatedWindowsEnvironmentCreateResult, Windows.Security.Isolation.IIsolatedWindowsEnvironmentCreateResult2 {
+    ChangeCreationPriority(priority: number): void;
+    readonly Environment: Windows.Security.Isolation.IsolatedWindowsEnvironment;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+
+  class IsolatedWindowsEnvironmentFile implements Windows.Security.Isolation.IIsolatedWindowsEnvironmentFile, Windows.Security.Isolation.IIsolatedWindowsEnvironmentFile2 {
+    Close(): void;
+    readonly GuestPath: string;
+    readonly HostPath: string;
+    readonly Id: Guid;
+    readonly IsReadOnly: boolean;
+  }
+
+  class IsolatedWindowsEnvironmentHost {
+    static readonly HostErrors: Windows.Foundation.Collections.IVectorView<number> | number[];
+    static readonly IsReady: boolean;
+  }
+
+  class IsolatedWindowsEnvironmentLaunchFileResult implements Windows.Security.Isolation.IIsolatedWindowsEnvironmentLaunchFileResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly File: Windows.Security.Isolation.IsolatedWindowsEnvironmentFile;
+    readonly Status: number;
+  }
+
+  class IsolatedWindowsEnvironmentOptions implements Windows.Security.Isolation.IIsolatedWindowsEnvironmentOptions, Windows.Security.Isolation.IIsolatedWindowsEnvironmentOptions2, Windows.Security.Isolation.IIsolatedWindowsEnvironmentOptions3 {
+    constructor();
+    ShareHostFolderForUntrustedItems(SharedHostFolderPath: string, ShareFolderNameInEnvironment: string): void;
+    AllowCameraAndMicrophoneAccess: boolean;
+    AllowGraphicsHardwareAcceleration: boolean;
+    AllowedClipboardFormats: number;
+    AllowedClipboardFormatsToEnvironment: number;
+    AllowedClipboardFormatsToHost: number;
+    AvailablePrinters: number;
+    ClipboardCopyPasteDirections: number;
+    CreationPriority: number;
+    EnvironmentOwnerId: string;
+    PersistUserProfile: boolean;
+    readonly SharedFolderNameInEnvironment: string;
+    readonly SharedHostFolderPath: string;
+    WindowAnnotationOverride: string;
+  }
+
+  class IsolatedWindowsEnvironmentOwnerRegistration {
+    static Register(ownerName: string, ownerRegistrationData: Windows.Security.Isolation.IsolatedWindowsEnvironmentOwnerRegistrationData): Windows.Security.Isolation.IsolatedWindowsEnvironmentOwnerRegistrationResult;
+    static Unregister(ownerName: string): void;
+  }
+
+  class IsolatedWindowsEnvironmentOwnerRegistrationData implements Windows.Security.Isolation.IIsolatedWindowsEnvironmentOwnerRegistrationData {
+    constructor();
+    readonly ActivationFileExtensions: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly ProcessesRunnableAsSystem: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly ProcessesRunnableAsUser: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly ShareableFolders: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+
+  class IsolatedWindowsEnvironmentOwnerRegistrationResult implements Windows.Security.Isolation.IIsolatedWindowsEnvironmentOwnerRegistrationResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+
+  class IsolatedWindowsEnvironmentPostMessageResult implements Windows.Security.Isolation.IIsolatedWindowsEnvironmentPostMessageResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+
+  class IsolatedWindowsEnvironmentProcess implements Windows.Security.Isolation.IIsolatedWindowsEnvironmentProcess {
+    WaitForExit(): void;
+    WaitForExitAsync(): Windows.Foundation.IAsyncAction;
+    WaitForExitWithTimeout(timeoutMilliseconds: number): void;
+    readonly ExitCode: number;
+    readonly State: number;
+  }
+
+  class IsolatedWindowsEnvironmentShareFileRequestOptions implements Windows.Security.Isolation.IIsolatedWindowsEnvironmentShareFileRequestOptions {
+    constructor();
+    AllowWrite: boolean;
+  }
+
+  class IsolatedWindowsEnvironmentShareFileResult implements Windows.Security.Isolation.IIsolatedWindowsEnvironmentShareFileResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly File: Windows.Security.Isolation.IsolatedWindowsEnvironmentFile;
+    readonly Status: number;
+  }
+
+  class IsolatedWindowsEnvironmentShareFolderRequestOptions implements Windows.Security.Isolation.IIsolatedWindowsEnvironmentShareFolderRequestOptions {
+    constructor();
+    AllowWrite: boolean;
+  }
+
+  class IsolatedWindowsEnvironmentShareFolderResult implements Windows.Security.Isolation.IIsolatedWindowsEnvironmentShareFolderResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+
+  class IsolatedWindowsEnvironmentStartProcessResult implements Windows.Security.Isolation.IIsolatedWindowsEnvironmentStartProcessResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Process: Windows.Security.Isolation.IsolatedWindowsEnvironmentProcess;
+    readonly Status: number;
+  }
+
+  class IsolatedWindowsEnvironmentTelemetryParameters implements Windows.Security.Isolation.IIsolatedWindowsEnvironmentTelemetryParameters {
+    constructor();
+    CorrelationId: Guid;
+  }
+
+  class IsolatedWindowsEnvironmentUserInfo implements Windows.Security.Isolation.IIsolatedWindowsEnvironmentUserInfo, Windows.Security.Isolation.IIsolatedWindowsEnvironmentUserInfo2 {
+    TryWaitForSignInAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryWaitForSignInWithProgressAsync(): Windows.Foundation.IAsyncOperationWithProgress<boolean, number>;
+    readonly EnvironmentUserName: string;
+    readonly EnvironmentUserSid: string;
+  }
+
+  class IsolatedWindowsHostMessenger {
+    static GetFileId(filePath: string): Guid;
+    static PostMessageToReceiver(receiverId: Guid, message: Windows.Foundation.Collections.IVectorView<Object> | Object[]): void;
+    static RegisterHostMessageReceiver(receiverId: Guid, hostMessageReceivedCallback: Windows.Security.Isolation.HostMessageReceivedCallback): void;
+    static UnregisterHostMessageReceiver(receiverId: Guid): void;
+  }
+
+  enum IsolatedWindowsEnvironmentActivator {
+    System = 0,
+    User = 1,
+  }
+
+  enum IsolatedWindowsEnvironmentAllowedClipboardFormats {
+    None = 0,
+    Text = 1,
+    Image = 2,
+    Rtf = 4,
+  }
+
+  enum IsolatedWindowsEnvironmentAvailablePrinters {
+    None = 0,
+    Local = 1,
+    Network = 2,
+    SystemPrintToPdf = 4,
+    SystemPrintToXps = 8,
+  }
+
+  enum IsolatedWindowsEnvironmentClipboardCopyPasteDirections {
+    None = 0,
+    HostToIsolatedWindowsEnvironment = 1,
+    IsolatedWindowsEnvironmentToHost = 2,
+  }
+
+  enum IsolatedWindowsEnvironmentCreateStatus {
+    Success = 0,
+    FailureByPolicy = 1,
+    UnknownFailure = 2,
+  }
+
+  enum IsolatedWindowsEnvironmentCreationPriority {
+    Low = 0,
+    Normal = 1,
+  }
+
+  enum IsolatedWindowsEnvironmentHostError {
+    AdminPolicyIsDisabledOrNotPresent = 0,
+    FeatureNotInstalled = 1,
+    HardwareRequirementsNotMet = 2,
+    RebootRequired = 3,
+    UnknownError = 4,
+  }
+
+  enum IsolatedWindowsEnvironmentLaunchFileStatus {
+    Success = 0,
+    UnknownFailure = 1,
+    EnvironmentUnavailable = 2,
+    FileNotFound = 3,
+    TimedOut = 4,
+    AlreadySharedWithConflictingOptions = 5,
+  }
+
+  enum IsolatedWindowsEnvironmentOwnerRegistrationStatus {
+    Success = 0,
+    InvalidArgument = 1,
+    AccessDenied = 2,
+    InsufficientMemory = 3,
+    UnknownFailure = 4,
+  }
+
+  enum IsolatedWindowsEnvironmentPostMessageStatus {
+    Success = 0,
+    UnknownFailure = 1,
+    EnvironmentUnavailable = 2,
+  }
+
+  enum IsolatedWindowsEnvironmentProcessState {
+    Running = 1,
+    Aborted = 2,
+    Completed = 3,
+  }
+
+  enum IsolatedWindowsEnvironmentProgressState {
+    Queued = 0,
+    Processing = 1,
+    Completed = 2,
+    Creating = 3,
+    Retrying = 4,
+    Starting = 5,
+    Finalizing = 6,
+  }
+
+  enum IsolatedWindowsEnvironmentShareFileStatus {
+    Success = 0,
+    UnknownFailure = 1,
+    EnvironmentUnavailable = 2,
+    AlreadySharedWithConflictingOptions = 3,
+    FileNotFound = 4,
+    AccessDenied = 5,
+  }
+
+  enum IsolatedWindowsEnvironmentShareFolderStatus {
+    Success = 0,
+    UnknownFailure = 1,
+    EnvironmentUnavailable = 2,
+    FolderNotFound = 3,
+    AccessDenied = 4,
+  }
+
+  enum IsolatedWindowsEnvironmentSignInProgress {
+    Connecting = 0,
+    Connected = 1,
+    Authenticating = 2,
+    SettingUpAccount = 3,
+    Finalizing = 4,
+    Completed = 5,
+  }
+
+  enum IsolatedWindowsEnvironmentStartProcessStatus {
+    Success = 0,
+    UnknownFailure = 1,
+    EnvironmentUnavailable = 2,
+    FileNotFound = 3,
+    AppNotRegistered = 4,
+  }
+
+  interface HostMessageReceivedCallback {
+    (receiverId: Guid, message: Windows.Foundation.Collections.IVectorView<Object> | Object[]): void;
+  }
+  var HostMessageReceivedCallback: {
+    new(callback: (receiverId: Guid, message: Windows.Foundation.Collections.IVectorView<Object> | Object[]) => void): HostMessageReceivedCallback;
+  };
+
+  interface IIsolatedWindowsEnvironment {
+    LaunchFileWithUIAsync(appExePath: string, argumentsTemplate: string, filePath: string): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentLaunchFileResult>;
+    LaunchFileWithUIAsync(appExePath: string, argumentsTemplate: string, filePath: string, telemetryParameters: Windows.Security.Isolation.IsolatedWindowsEnvironmentTelemetryParameters): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentLaunchFileResult>;
+    RegisterMessageReceiver(receiverId: Guid, messageReceivedCallback: Windows.Security.Isolation.MessageReceivedCallback): void;
+    ShareFolderAsync(hostFolder: string, requestOptions: Windows.Security.Isolation.IsolatedWindowsEnvironmentShareFolderRequestOptions): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentShareFolderResult>;
+    ShareFolderAsync(hostFolder: string, requestOptions: Windows.Security.Isolation.IsolatedWindowsEnvironmentShareFolderRequestOptions, telemetryParameters: Windows.Security.Isolation.IsolatedWindowsEnvironmentTelemetryParameters): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentShareFolderResult>;
+    StartProcessSilentlyAsync(hostExePath: string, arguments_: string, activator: number): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentStartProcessResult>;
+    StartProcessSilentlyAsync(hostExePath: string, arguments_: string, activator: number, telemetryParameters: Windows.Security.Isolation.IsolatedWindowsEnvironmentTelemetryParameters): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentStartProcessResult>;
+    TerminateAsync(): Windows.Foundation.IAsyncAction;
+    TerminateAsync(telemetryParameters: Windows.Security.Isolation.IsolatedWindowsEnvironmentTelemetryParameters): Windows.Foundation.IAsyncAction;
+    UnregisterMessageReceiver(receiverId: Guid): void;
+    readonly Id: string;
+  }
+  var IIsolatedWindowsEnvironment: abstract new (...args: any[]) => IIsolatedWindowsEnvironment;
+
+  interface IIsolatedWindowsEnvironment2 {
+    PostMessageToReceiverAsync(receiverId: Guid, message: Windows.Foundation.Collections.IIterable<Object> | Object[]): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentPostMessageResult>;
+    PostMessageToReceiverAsync(receiverId: Guid, message: Windows.Foundation.Collections.IIterable<Object> | Object[], telemetryParameters: Windows.Security.Isolation.IsolatedWindowsEnvironmentTelemetryParameters): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentPostMessageResult>;
+  }
+  var IIsolatedWindowsEnvironment2: abstract new (...args: any[]) => IIsolatedWindowsEnvironment2;
+
+  interface IIsolatedWindowsEnvironment3 {
+    GetUserInfo(): Windows.Security.Isolation.IsolatedWindowsEnvironmentUserInfo;
+    ShareFileAsync(filePath: string, options: Windows.Security.Isolation.IsolatedWindowsEnvironmentShareFileRequestOptions): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentShareFileResult>;
+    ShareFileAsync(filePath: string, options: Windows.Security.Isolation.IsolatedWindowsEnvironmentShareFileRequestOptions, telemetryParameters: Windows.Security.Isolation.IsolatedWindowsEnvironmentTelemetryParameters): Windows.Foundation.IAsyncOperation<Windows.Security.Isolation.IsolatedWindowsEnvironmentShareFileResult>;
+  }
+  var IIsolatedWindowsEnvironment3: abstract new (...args: any[]) => IIsolatedWindowsEnvironment3;
+
+  interface IIsolatedWindowsEnvironment4 {
+    ChangePriority(Priority: number): void;
+  }
+  var IIsolatedWindowsEnvironment4: abstract new (...args: any[]) => IIsolatedWindowsEnvironment4;
+
+  interface IIsolatedWindowsEnvironmentCreateResult {
+    readonly Environment: Windows.Security.Isolation.IsolatedWindowsEnvironment;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+  var IIsolatedWindowsEnvironmentCreateResult: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentCreateResult;
+
+  interface IIsolatedWindowsEnvironmentCreateResult2 {
+    ChangeCreationPriority(priority: number): void;
+  }
+  var IIsolatedWindowsEnvironmentCreateResult2: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentCreateResult2;
+
+  interface IIsolatedWindowsEnvironmentFactory {
+    CreateAsync(options: Windows.Security.Isolation.IsolatedWindowsEnvironmentOptions): Windows.Foundation.IAsyncOperationWithProgress<Windows.Security.Isolation.IsolatedWindowsEnvironmentCreateResult, Windows.Security.Isolation.IsolatedWindowsEnvironmentCreateProgress>;
+    CreateAsync(options: Windows.Security.Isolation.IsolatedWindowsEnvironmentOptions, telemetryParameters: Windows.Security.Isolation.IsolatedWindowsEnvironmentTelemetryParameters): Windows.Foundation.IAsyncOperationWithProgress<Windows.Security.Isolation.IsolatedWindowsEnvironmentCreateResult, Windows.Security.Isolation.IsolatedWindowsEnvironmentCreateProgress>;
+    FindByOwnerId(environmentOwnerId: string): Windows.Foundation.Collections.IVectorView<Windows.Security.Isolation.IsolatedWindowsEnvironment> | Windows.Security.Isolation.IsolatedWindowsEnvironment[];
+    GetById(environmentId: string): Windows.Security.Isolation.IsolatedWindowsEnvironment;
+  }
+  var IIsolatedWindowsEnvironmentFactory: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentFactory;
+
+  interface IIsolatedWindowsEnvironmentFile {
+    Close(): void;
+    readonly HostPath: string;
+    readonly Id: Guid;
+  }
+  var IIsolatedWindowsEnvironmentFile: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentFile;
+
+  interface IIsolatedWindowsEnvironmentFile2 {
+    readonly GuestPath: string;
+    readonly IsReadOnly: boolean;
+  }
+  var IIsolatedWindowsEnvironmentFile2: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentFile2;
+
+  interface IIsolatedWindowsEnvironmentHostStatics {
+    readonly HostErrors: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly IsReady: boolean;
+  }
+  var IIsolatedWindowsEnvironmentHostStatics: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentHostStatics;
+
+  interface IIsolatedWindowsEnvironmentLaunchFileResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly File: Windows.Security.Isolation.IsolatedWindowsEnvironmentFile;
+    readonly Status: number;
+  }
+  var IIsolatedWindowsEnvironmentLaunchFileResult: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentLaunchFileResult;
+
+  interface IIsolatedWindowsEnvironmentOptions {
+    ShareHostFolderForUntrustedItems(SharedHostFolderPath: string, ShareFolderNameInEnvironment: string): void;
+    AllowCameraAndMicrophoneAccess: boolean;
+    AllowGraphicsHardwareAcceleration: boolean;
+    AllowedClipboardFormats: number;
+    AvailablePrinters: number;
+    ClipboardCopyPasteDirections: number;
+    EnvironmentOwnerId: string;
+    PersistUserProfile: boolean;
+    readonly SharedFolderNameInEnvironment: string;
+    readonly SharedHostFolderPath: string;
+  }
+  var IIsolatedWindowsEnvironmentOptions: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentOptions;
+
+  interface IIsolatedWindowsEnvironmentOptions2 {
+    WindowAnnotationOverride: string;
+  }
+  var IIsolatedWindowsEnvironmentOptions2: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentOptions2;
+
+  interface IIsolatedWindowsEnvironmentOptions3 {
+    AllowedClipboardFormatsToEnvironment: number;
+    AllowedClipboardFormatsToHost: number;
+    CreationPriority: number;
+  }
+  var IIsolatedWindowsEnvironmentOptions3: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentOptions3;
+
+  interface IIsolatedWindowsEnvironmentOwnerRegistrationData {
+    readonly ActivationFileExtensions: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly ProcessesRunnableAsSystem: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly ProcessesRunnableAsUser: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly ShareableFolders: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var IIsolatedWindowsEnvironmentOwnerRegistrationData: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentOwnerRegistrationData;
+
+  interface IIsolatedWindowsEnvironmentOwnerRegistrationResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+  var IIsolatedWindowsEnvironmentOwnerRegistrationResult: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentOwnerRegistrationResult;
+
+  interface IIsolatedWindowsEnvironmentOwnerRegistrationStatics {
+    Register(ownerName: string, ownerRegistrationData: Windows.Security.Isolation.IsolatedWindowsEnvironmentOwnerRegistrationData): Windows.Security.Isolation.IsolatedWindowsEnvironmentOwnerRegistrationResult;
+    Unregister(ownerName: string): void;
+  }
+  var IIsolatedWindowsEnvironmentOwnerRegistrationStatics: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentOwnerRegistrationStatics;
+
+  interface IIsolatedWindowsEnvironmentPostMessageResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+  var IIsolatedWindowsEnvironmentPostMessageResult: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentPostMessageResult;
+
+  interface IIsolatedWindowsEnvironmentProcess {
+    WaitForExit(): void;
+    WaitForExitAsync(): Windows.Foundation.IAsyncAction;
+    WaitForExitWithTimeout(timeoutMilliseconds: number): void;
+    readonly ExitCode: number;
+    readonly State: number;
+  }
+  var IIsolatedWindowsEnvironmentProcess: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentProcess;
+
+  interface IIsolatedWindowsEnvironmentShareFileRequestOptions {
+    AllowWrite: boolean;
+  }
+  var IIsolatedWindowsEnvironmentShareFileRequestOptions: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentShareFileRequestOptions;
+
+  interface IIsolatedWindowsEnvironmentShareFileResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly File: Windows.Security.Isolation.IsolatedWindowsEnvironmentFile;
+    readonly Status: number;
+  }
+  var IIsolatedWindowsEnvironmentShareFileResult: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentShareFileResult;
+
+  interface IIsolatedWindowsEnvironmentShareFolderRequestOptions {
+    AllowWrite: boolean;
+  }
+  var IIsolatedWindowsEnvironmentShareFolderRequestOptions: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentShareFolderRequestOptions;
+
+  interface IIsolatedWindowsEnvironmentShareFolderResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+  var IIsolatedWindowsEnvironmentShareFolderResult: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentShareFolderResult;
+
+  interface IIsolatedWindowsEnvironmentStartProcessResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Process: Windows.Security.Isolation.IsolatedWindowsEnvironmentProcess;
+    readonly Status: number;
+  }
+  var IIsolatedWindowsEnvironmentStartProcessResult: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentStartProcessResult;
+
+  interface IIsolatedWindowsEnvironmentTelemetryParameters {
+    CorrelationId: Guid;
+  }
+  var IIsolatedWindowsEnvironmentTelemetryParameters: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentTelemetryParameters;
+
+  interface IIsolatedWindowsEnvironmentUserInfo {
+    TryWaitForSignInAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly EnvironmentUserName: string;
+    readonly EnvironmentUserSid: string;
+  }
+  var IIsolatedWindowsEnvironmentUserInfo: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentUserInfo;
+
+  interface IIsolatedWindowsEnvironmentUserInfo2 {
+    TryWaitForSignInWithProgressAsync(): Windows.Foundation.IAsyncOperationWithProgress<boolean, number>;
+  }
+  var IIsolatedWindowsEnvironmentUserInfo2: abstract new (...args: any[]) => IIsolatedWindowsEnvironmentUserInfo2;
+
+  interface IIsolatedWindowsHostMessengerStatics {
+    GetFileId(filePath: string): Guid;
+    PostMessageToReceiver(receiverId: Guid, message: Windows.Foundation.Collections.IVectorView<Object> | Object[]): void;
+  }
+  var IIsolatedWindowsHostMessengerStatics: abstract new (...args: any[]) => IIsolatedWindowsHostMessengerStatics;
+
+  interface IIsolatedWindowsHostMessengerStatics2 {
+    RegisterHostMessageReceiver(receiverId: Guid, hostMessageReceivedCallback: Windows.Security.Isolation.HostMessageReceivedCallback): void;
+    UnregisterHostMessageReceiver(receiverId: Guid): void;
+  }
+  var IIsolatedWindowsHostMessengerStatics2: abstract new (...args: any[]) => IIsolatedWindowsHostMessengerStatics2;
+
+  interface IsolatedWindowsEnvironmentContract {
+  }
+  var IsolatedWindowsEnvironmentContract: {
+    new(fields: {  }): IsolatedWindowsEnvironmentContract;
+  };
+
+  interface IsolatedWindowsEnvironmentCreateProgress {
+    State: number;
+    PercentComplete: number;
+  }
+  var IsolatedWindowsEnvironmentCreateProgress: {
+    new(state: number, percentComplete: number): IsolatedWindowsEnvironmentCreateProgress;
+    new(fields: { State?: number; PercentComplete?: number }): IsolatedWindowsEnvironmentCreateProgress;
+  };
+
+  interface MessageReceivedCallback {
+    (receiverId: Guid, message: Windows.Foundation.Collections.IVectorView<Object> | Object[]): void;
+  }
+  var MessageReceivedCallback: {
+    new(callback: (receiverId: Guid, message: Windows.Foundation.Collections.IVectorView<Object> | Object[]) => void): MessageReceivedCallback;
+  };
+
+}
+
+declare namespace Windows.Services.Cortana {
+  class CortanaActionableInsights implements Windows.Services.Cortana.ICortanaActionableInsights {
+    static GetDefault(): Windows.Services.Cortana.CortanaActionableInsights;
+    static GetForUser(user: Windows.System.User): Windows.Services.Cortana.CortanaActionableInsights;
+    IsAvailableAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowInsightsAsync(datapackage: Windows.ApplicationModel.DataTransfer.DataPackage): Windows.Foundation.IAsyncAction;
+    ShowInsightsAsync(datapackage: Windows.ApplicationModel.DataTransfer.DataPackage, options: Windows.Services.Cortana.CortanaActionableInsightsOptions): Windows.Foundation.IAsyncAction;
+    ShowInsightsForImageAsync(imageStream: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncAction;
+    ShowInsightsForImageAsync(imageStream: Windows.Storage.Streams.IRandomAccessStreamReference, options: Windows.Services.Cortana.CortanaActionableInsightsOptions): Windows.Foundation.IAsyncAction;
+    ShowInsightsForTextAsync(text: string): Windows.Foundation.IAsyncAction;
+    ShowInsightsForTextAsync(text: string, options: Windows.Services.Cortana.CortanaActionableInsightsOptions): Windows.Foundation.IAsyncAction;
+    readonly User: Windows.System.User;
+  }
+
+  class CortanaActionableInsightsOptions implements Windows.Services.Cortana.ICortanaActionableInsightsOptions {
+    constructor();
+    ContentSourceWebLink: Windows.Foundation.Uri;
+    SurroundingText: string;
+  }
+
+  class CortanaPermissionsManager implements Windows.Services.Cortana.ICortanaPermissionsManager {
+    ArePermissionsGrantedAsync(permissions: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.Foundation.IAsyncOperation<boolean>;
+    static GetDefault(): Windows.Services.Cortana.CortanaPermissionsManager;
+    GrantPermissionsAsync(permissions: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.Foundation.IAsyncOperation<number>;
+    IsSupported(): boolean;
+    RevokePermissionsAsync(permissions: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.Foundation.IAsyncOperation<number>;
+  }
+
+  class CortanaSettings implements Windows.Services.Cortana.ICortanaSettings {
+    static GetDefault(): Windows.Services.Cortana.CortanaSettings;
+    static IsSupported(): boolean;
+    readonly HasUserConsentToVoiceActivation: boolean;
+    IsVoiceActivationEnabled: boolean;
+  }
+
+  enum CortanaPermission {
+    BrowsingHistory = 0,
+    Calendar = 1,
+    CallHistory = 2,
+    Contacts = 3,
+    Email = 4,
+    InputPersonalization = 5,
+    Location = 6,
+    Messaging = 7,
+    Microphone = 8,
+    Personalization = 9,
+    PhoneCall = 10,
+  }
+
+  enum CortanaPermissionsChangeResult {
+    Success = 0,
+    Unavailable = 1,
+    DisabledByPolicy = 2,
+  }
+
+  interface ICortanaActionableInsights {
+    IsAvailableAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    ShowInsightsAsync(datapackage: Windows.ApplicationModel.DataTransfer.DataPackage): Windows.Foundation.IAsyncAction;
+    ShowInsightsAsync(datapackage: Windows.ApplicationModel.DataTransfer.DataPackage, options: Windows.Services.Cortana.CortanaActionableInsightsOptions): Windows.Foundation.IAsyncAction;
+    ShowInsightsForImageAsync(imageStream: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncAction;
+    ShowInsightsForImageAsync(imageStream: Windows.Storage.Streams.IRandomAccessStreamReference, options: Windows.Services.Cortana.CortanaActionableInsightsOptions): Windows.Foundation.IAsyncAction;
+    ShowInsightsForTextAsync(text: string): Windows.Foundation.IAsyncAction;
+    ShowInsightsForTextAsync(text: string, options: Windows.Services.Cortana.CortanaActionableInsightsOptions): Windows.Foundation.IAsyncAction;
+    readonly User: Windows.System.User;
+  }
+  var ICortanaActionableInsights: abstract new (...args: any[]) => ICortanaActionableInsights;
+
+  interface ICortanaActionableInsightsOptions {
+    ContentSourceWebLink: Windows.Foundation.Uri;
+    SurroundingText: string;
+  }
+  var ICortanaActionableInsightsOptions: abstract new (...args: any[]) => ICortanaActionableInsightsOptions;
+
+  interface ICortanaActionableInsightsStatics {
+    GetDefault(): Windows.Services.Cortana.CortanaActionableInsights;
+    GetForUser(user: Windows.System.User): Windows.Services.Cortana.CortanaActionableInsights;
+  }
+  var ICortanaActionableInsightsStatics: abstract new (...args: any[]) => ICortanaActionableInsightsStatics;
+
+  interface ICortanaPermissionsManager {
+    ArePermissionsGrantedAsync(permissions: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.Foundation.IAsyncOperation<boolean>;
+    GrantPermissionsAsync(permissions: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.Foundation.IAsyncOperation<number>;
+    IsSupported(): boolean;
+    RevokePermissionsAsync(permissions: Windows.Foundation.Collections.IIterable<number> | number[]): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var ICortanaPermissionsManager: abstract new (...args: any[]) => ICortanaPermissionsManager;
+
+  interface ICortanaPermissionsManagerStatics {
+    GetDefault(): Windows.Services.Cortana.CortanaPermissionsManager;
+  }
+  var ICortanaPermissionsManagerStatics: abstract new (...args: any[]) => ICortanaPermissionsManagerStatics;
+
+  interface ICortanaSettings {
+    readonly HasUserConsentToVoiceActivation: boolean;
+    IsVoiceActivationEnabled: boolean;
+  }
+  var ICortanaSettings: abstract new (...args: any[]) => ICortanaSettings;
+
+  interface ICortanaSettingsStatics {
+    GetDefault(): Windows.Services.Cortana.CortanaSettings;
+    IsSupported(): boolean;
+  }
+  var ICortanaSettingsStatics: abstract new (...args: any[]) => ICortanaSettingsStatics;
+
+}
+
+declare namespace Windows.Services.Maps {
+  class EnhancedWaypoint implements Windows.Services.Maps.IEnhancedWaypoint {
+    constructor(point: Windows.Devices.Geolocation.Geopoint, kind: number);
+    readonly Kind: number;
+    readonly Point: Windows.Devices.Geolocation.Geopoint;
+  }
+
+  class ManeuverWarning implements Windows.Services.Maps.IManeuverWarning {
+    readonly Kind: number;
+    readonly Severity: number;
+  }
+
+  class MapAddress implements Windows.Services.Maps.IMapAddress, Windows.Services.Maps.IMapAddress2 {
+    readonly BuildingFloor: string;
+    readonly BuildingName: string;
+    readonly BuildingRoom: string;
+    readonly BuildingWing: string;
+    readonly Continent: string;
+    readonly Country: string;
+    readonly CountryCode: string;
+    readonly District: string;
+    readonly FormattedAddress: string;
+    readonly Neighborhood: string;
+    readonly PostCode: string;
+    readonly Region: string;
+    readonly RegionCode: string;
+    readonly Street: string;
+    readonly StreetNumber: string;
+    readonly Town: string;
+  }
+
+  class MapLocation implements Windows.Services.Maps.IMapLocation {
+    readonly Address: Windows.Services.Maps.MapAddress;
+    readonly Description: string;
+    readonly DisplayName: string;
+    readonly Point: Windows.Devices.Geolocation.Geopoint;
+  }
+
+  class MapLocationFinder {
+    static FindLocationsAsync(searchText: string, referencePoint: Windows.Devices.Geolocation.Geopoint): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapLocationFinderResult>;
+    static FindLocationsAsync(searchText: string, referencePoint: Windows.Devices.Geolocation.Geopoint, maxCount: number): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapLocationFinderResult>;
+    static FindLocationsAtAsync(queryPoint: Windows.Devices.Geolocation.Geopoint, accuracy: number): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapLocationFinderResult>;
+    static FindLocationsAtAsync(queryPoint: Windows.Devices.Geolocation.Geopoint): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapLocationFinderResult>;
+  }
+
+  class MapLocationFinderResult implements Windows.Services.Maps.IMapLocationFinderResult {
+    readonly Locations: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.MapLocation> | Windows.Services.Maps.MapLocation[];
+    readonly Status: number;
+  }
+
+  class MapManager {
+    static ShowDownloadedMapsUI(): void;
+    static ShowMapsUpdateUI(): void;
+  }
+
+  class MapRoute implements Windows.Services.Maps.IMapRoute, Windows.Services.Maps.IMapRoute2, Windows.Services.Maps.IMapRoute3, Windows.Services.Maps.IMapRoute4 {
+    readonly BoundingBox: Windows.Devices.Geolocation.GeoboundingBox;
+    readonly DurationWithoutTraffic: Windows.Foundation.TimeSpan;
+    readonly EstimatedDuration: Windows.Foundation.TimeSpan;
+    readonly HasBlockedRoads: boolean;
+    readonly IsScenic: boolean;
+    readonly IsTrafficBased: boolean;
+    readonly Legs: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.MapRouteLeg> | Windows.Services.Maps.MapRouteLeg[];
+    readonly LengthInMeters: number;
+    readonly Path: Windows.Devices.Geolocation.Geopath;
+    readonly TrafficCongestion: number;
+    readonly ViolatedRestrictions: number;
+  }
+
+  class MapRouteDrivingOptions implements Windows.Services.Maps.IMapRouteDrivingOptions, Windows.Services.Maps.IMapRouteDrivingOptions2 {
+    constructor();
+    DepartureTime: Windows.Foundation.DateTime | null;
+    InitialHeading: number | null;
+    MaxAlternateRouteCount: number;
+    RouteOptimization: number;
+    RouteRestrictions: number;
+  }
+
+  class MapRouteFinder {
+    static GetDrivingRouteAsync(startPoint: Windows.Devices.Geolocation.Geopoint, endPoint: Windows.Devices.Geolocation.Geopoint, options: Windows.Services.Maps.MapRouteDrivingOptions): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    static GetDrivingRouteAsync(startPoint: Windows.Devices.Geolocation.Geopoint, endPoint: Windows.Devices.Geolocation.Geopoint): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    static GetDrivingRouteAsync(startPoint: Windows.Devices.Geolocation.Geopoint, endPoint: Windows.Devices.Geolocation.Geopoint, optimization: number, restrictions: number): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    static GetDrivingRouteAsync(startPoint: Windows.Devices.Geolocation.Geopoint, endPoint: Windows.Devices.Geolocation.Geopoint, optimization: number, restrictions: number, headingInDegrees: number): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    static GetDrivingRouteFromEnhancedWaypointsAsync(waypoints: Windows.Foundation.Collections.IIterable<Windows.Services.Maps.EnhancedWaypoint> | Windows.Services.Maps.EnhancedWaypoint[]): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    static GetDrivingRouteFromEnhancedWaypointsAsync(waypoints: Windows.Foundation.Collections.IIterable<Windows.Services.Maps.EnhancedWaypoint> | Windows.Services.Maps.EnhancedWaypoint[], options: Windows.Services.Maps.MapRouteDrivingOptions): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    static GetDrivingRouteFromWaypointsAsync(wayPoints: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.Geopoint> | Windows.Devices.Geolocation.Geopoint[]): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    static GetDrivingRouteFromWaypointsAsync(wayPoints: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.Geopoint> | Windows.Devices.Geolocation.Geopoint[], optimization: number): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    static GetDrivingRouteFromWaypointsAsync(wayPoints: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.Geopoint> | Windows.Devices.Geolocation.Geopoint[], optimization: number, restrictions: number): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    static GetDrivingRouteFromWaypointsAsync(wayPoints: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.Geopoint> | Windows.Devices.Geolocation.Geopoint[], optimization: number, restrictions: number, headingInDegrees: number): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    static GetWalkingRouteAsync(startPoint: Windows.Devices.Geolocation.Geopoint, endPoint: Windows.Devices.Geolocation.Geopoint): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    static GetWalkingRouteFromWaypointsAsync(wayPoints: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.Geopoint> | Windows.Devices.Geolocation.Geopoint[]): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+  }
+
+  class MapRouteFinderResult implements Windows.Services.Maps.IMapRouteFinderResult, Windows.Services.Maps.IMapRouteFinderResult2 {
+    readonly AlternateRoutes: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.MapRoute> | Windows.Services.Maps.MapRoute[];
+    readonly Route: Windows.Services.Maps.MapRoute;
+    readonly Status: number;
+  }
+
+  class MapRouteLeg implements Windows.Services.Maps.IMapRouteLeg, Windows.Services.Maps.IMapRouteLeg2 {
+    readonly BoundingBox: Windows.Devices.Geolocation.GeoboundingBox;
+    readonly DurationWithoutTraffic: Windows.Foundation.TimeSpan;
+    readonly EstimatedDuration: Windows.Foundation.TimeSpan;
+    readonly LengthInMeters: number;
+    readonly Maneuvers: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.MapRouteManeuver> | Windows.Services.Maps.MapRouteManeuver[];
+    readonly Path: Windows.Devices.Geolocation.Geopath;
+    readonly TrafficCongestion: number;
+  }
+
+  class MapRouteManeuver implements Windows.Services.Maps.IMapRouteManeuver, Windows.Services.Maps.IMapRouteManeuver2, Windows.Services.Maps.IMapRouteManeuver3 {
+    readonly EndHeading: number;
+    readonly ExitNumber: string;
+    readonly InstructionText: string;
+    readonly Kind: number;
+    readonly LengthInMeters: number;
+    readonly ManeuverNotices: number;
+    readonly StartHeading: number;
+    readonly StartingPoint: Windows.Devices.Geolocation.Geopoint;
+    readonly StreetName: string;
+    readonly Warnings: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.ManeuverWarning> | Windows.Services.Maps.ManeuverWarning[];
+  }
+
+  class MapService {
+    static readonly DataAttributions: string;
+    static DataUsagePreference: number;
+    static ServiceToken: string;
+    static readonly WorldViewRegionCode: string;
+  }
+
+  class PlaceInfo implements Windows.Services.Maps.IPlaceInfo {
+    static Create(referencePoint: Windows.Devices.Geolocation.Geopoint): Windows.Services.Maps.PlaceInfo;
+    static Create(referencePoint: Windows.Devices.Geolocation.Geopoint, options: Windows.Services.Maps.PlaceInfoCreateOptions): Windows.Services.Maps.PlaceInfo;
+    static CreateFromAddress(displayAddress: string): Windows.Services.Maps.PlaceInfo;
+    static CreateFromAddress(displayAddress: string, displayName: string): Windows.Services.Maps.PlaceInfo;
+    static CreateFromIdentifier(identifier: string): Windows.Services.Maps.PlaceInfo;
+    static CreateFromIdentifier(identifier: string, defaultPoint: Windows.Devices.Geolocation.Geopoint, options: Windows.Services.Maps.PlaceInfoCreateOptions): Windows.Services.Maps.PlaceInfo;
+    static CreateFromMapLocation(location: Windows.Services.Maps.MapLocation): Windows.Services.Maps.PlaceInfo;
+    Show(selection: Windows.Foundation.Rect): void;
+    Show(selection: Windows.Foundation.Rect, preferredPlacement: number): void;
+    readonly DisplayAddress: string;
+    readonly DisplayName: string;
+    readonly Geoshape: Windows.Devices.Geolocation.IGeoshape;
+    readonly Identifier: string;
+    static readonly IsShowSupported: boolean;
+  }
+
+  class PlaceInfoCreateOptions implements Windows.Services.Maps.IPlaceInfoCreateOptions {
+    constructor();
+    DisplayAddress: string;
+    DisplayName: string;
+  }
+
+  enum ManeuverWarningKind {
+    None = 0,
+    Accident = 1,
+    AdministrativeDivisionChange = 2,
+    Alert = 3,
+    BlockedRoad = 4,
+    CheckTimetable = 5,
+    Congestion = 6,
+    Construction = 7,
+    CountryChange = 8,
+    DisabledVehicle = 9,
+    GateAccess = 10,
+    GetOffTransit = 11,
+    GetOnTransit = 12,
+    IllegalUTurn = 13,
+    MassTransit = 14,
+    Miscellaneous = 15,
+    NoIncident = 16,
+    Other = 17,
+    OtherNews = 18,
+    OtherTrafficIncidents = 19,
+    PlannedEvent = 20,
+    PrivateRoad = 21,
+    RestrictedTurn = 22,
+    RoadClosures = 23,
+    RoadHazard = 24,
+    ScheduledConstruction = 25,
+    SeasonalClosures = 26,
+    Tollbooth = 27,
+    TollRoad = 28,
+    TollZoneEnter = 29,
+    TollZoneExit = 30,
+    TrafficFlow = 31,
+    TransitLineChange = 32,
+    UnpavedRoad = 33,
+    UnscheduledConstruction = 34,
+    Weather = 35,
+  }
+
+  enum ManeuverWarningSeverity {
+    None = 0,
+    LowImpact = 1,
+    Minor = 2,
+    Moderate = 3,
+    Serious = 4,
+  }
+
+  enum MapLocationDesiredAccuracy {
+    High = 0,
+    Low = 1,
+  }
+
+  enum MapLocationFinderStatus {
+    Success = 0,
+    UnknownError = 1,
+    InvalidCredentials = 2,
+    BadLocation = 3,
+    IndexFailure = 4,
+    NetworkFailure = 5,
+    NotSupported = 6,
+  }
+
+  enum MapManeuverNotices {
+    None = 0,
+    Toll = 1,
+    Unpaved = 2,
+  }
+
+  enum MapRouteFinderStatus {
+    Success = 0,
+    UnknownError = 1,
+    InvalidCredentials = 2,
+    NoRouteFound = 3,
+    NoRouteFoundWithGivenOptions = 4,
+    StartPointNotFound = 5,
+    EndPointNotFound = 6,
+    NoPedestrianRouteFound = 7,
+    NetworkFailure = 8,
+    NotSupported = 9,
+  }
+
+  enum MapRouteManeuverKind {
+    None = 0,
+    Start = 1,
+    Stopover = 2,
+    StopoverResume = 3,
+    End = 4,
+    GoStraight = 5,
+    UTurnLeft = 6,
+    UTurnRight = 7,
+    TurnKeepLeft = 8,
+    TurnKeepRight = 9,
+    TurnLightLeft = 10,
+    TurnLightRight = 11,
+    TurnLeft = 12,
+    TurnRight = 13,
+    TurnHardLeft = 14,
+    TurnHardRight = 15,
+    FreewayEnterLeft = 16,
+    FreewayEnterRight = 17,
+    FreewayLeaveLeft = 18,
+    FreewayLeaveRight = 19,
+    FreewayContinueLeft = 20,
+    FreewayContinueRight = 21,
+    TrafficCircleLeft = 22,
+    TrafficCircleRight = 23,
+    TakeFerry = 24,
+  }
+
+  enum MapRouteOptimization {
+    Time = 0,
+    Distance = 1,
+    TimeWithTraffic = 2,
+    Scenic = 3,
+  }
+
+  enum MapRouteRestrictions {
+    None = 0,
+    Highways = 1,
+    TollRoads = 2,
+    Ferries = 4,
+    Tunnels = 8,
+    DirtRoads = 16,
+    Motorail = 32,
+  }
+
+  enum MapServiceDataUsagePreference {
+    Default = 0,
+    OfflineMapDataOnly = 1,
+  }
+
+  enum TrafficCongestion {
+    Unknown = 0,
+    Light = 1,
+    Mild = 2,
+    Medium = 3,
+    Heavy = 4,
+  }
+
+  enum WaypointKind {
+    Stop = 0,
+    Via = 1,
+  }
+
+  interface GuidanceContract {
+  }
+  var GuidanceContract: {
+    new(fields: {  }): GuidanceContract;
+  };
+
+  interface IEnhancedWaypoint {
+    readonly Kind: number;
+    readonly Point: Windows.Devices.Geolocation.Geopoint;
+  }
+  var IEnhancedWaypoint: abstract new (...args: any[]) => IEnhancedWaypoint;
+
+  interface IEnhancedWaypointFactory {
+    Create(point: Windows.Devices.Geolocation.Geopoint, kind: number): Windows.Services.Maps.EnhancedWaypoint;
+  }
+  var IEnhancedWaypointFactory: abstract new (...args: any[]) => IEnhancedWaypointFactory;
+
+  interface IManeuverWarning {
+    readonly Kind: number;
+    readonly Severity: number;
+  }
+  var IManeuverWarning: abstract new (...args: any[]) => IManeuverWarning;
+
+  interface IMapAddress {
+    readonly BuildingFloor: string;
+    readonly BuildingName: string;
+    readonly BuildingRoom: string;
+    readonly BuildingWing: string;
+    readonly Continent: string;
+    readonly Country: string;
+    readonly CountryCode: string;
+    readonly District: string;
+    readonly Neighborhood: string;
+    readonly PostCode: string;
+    readonly Region: string;
+    readonly RegionCode: string;
+    readonly Street: string;
+    readonly StreetNumber: string;
+    readonly Town: string;
+  }
+  var IMapAddress: abstract new (...args: any[]) => IMapAddress;
+
+  interface IMapAddress2 {
+    readonly FormattedAddress: string;
+  }
+  var IMapAddress2: abstract new (...args: any[]) => IMapAddress2;
+
+  interface IMapLocation {
+    readonly Address: Windows.Services.Maps.MapAddress;
+    readonly Description: string;
+    readonly DisplayName: string;
+    readonly Point: Windows.Devices.Geolocation.Geopoint;
+  }
+  var IMapLocation: abstract new (...args: any[]) => IMapLocation;
+
+  interface IMapLocationFinderResult {
+    readonly Locations: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.MapLocation> | Windows.Services.Maps.MapLocation[];
+    readonly Status: number;
+  }
+  var IMapLocationFinderResult: abstract new (...args: any[]) => IMapLocationFinderResult;
+
+  interface IMapLocationFinderStatics {
+    FindLocationsAsync(searchText: string, referencePoint: Windows.Devices.Geolocation.Geopoint): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapLocationFinderResult>;
+    FindLocationsAsync(searchText: string, referencePoint: Windows.Devices.Geolocation.Geopoint, maxCount: number): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapLocationFinderResult>;
+    FindLocationsAtAsync(queryPoint: Windows.Devices.Geolocation.Geopoint): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapLocationFinderResult>;
+  }
+  var IMapLocationFinderStatics: abstract new (...args: any[]) => IMapLocationFinderStatics;
+
+  interface IMapLocationFinderStatics2 {
+    FindLocationsAtAsync(queryPoint: Windows.Devices.Geolocation.Geopoint, accuracy: number): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapLocationFinderResult>;
+  }
+  var IMapLocationFinderStatics2: abstract new (...args: any[]) => IMapLocationFinderStatics2;
+
+  interface IMapManagerStatics {
+    ShowDownloadedMapsUI(): void;
+    ShowMapsUpdateUI(): void;
+  }
+  var IMapManagerStatics: abstract new (...args: any[]) => IMapManagerStatics;
+
+  interface IMapRoute {
+    readonly BoundingBox: Windows.Devices.Geolocation.GeoboundingBox;
+    readonly EstimatedDuration: Windows.Foundation.TimeSpan;
+    readonly IsTrafficBased: boolean;
+    readonly Legs: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.MapRouteLeg> | Windows.Services.Maps.MapRouteLeg[];
+    readonly LengthInMeters: number;
+    readonly Path: Windows.Devices.Geolocation.Geopath;
+  }
+  var IMapRoute: abstract new (...args: any[]) => IMapRoute;
+
+  interface IMapRoute2 {
+    readonly HasBlockedRoads: boolean;
+    readonly ViolatedRestrictions: number;
+  }
+  var IMapRoute2: abstract new (...args: any[]) => IMapRoute2;
+
+  interface IMapRoute3 {
+    readonly DurationWithoutTraffic: Windows.Foundation.TimeSpan;
+    readonly TrafficCongestion: number;
+  }
+  var IMapRoute3: abstract new (...args: any[]) => IMapRoute3;
+
+  interface IMapRoute4 {
+    readonly IsScenic: boolean;
+  }
+  var IMapRoute4: abstract new (...args: any[]) => IMapRoute4;
+
+  interface IMapRouteDrivingOptions {
+    InitialHeading: number | null;
+    MaxAlternateRouteCount: number;
+    RouteOptimization: number;
+    RouteRestrictions: number;
+  }
+  var IMapRouteDrivingOptions: abstract new (...args: any[]) => IMapRouteDrivingOptions;
+
+  interface IMapRouteDrivingOptions2 {
+    DepartureTime: Windows.Foundation.DateTime | null;
+  }
+  var IMapRouteDrivingOptions2: abstract new (...args: any[]) => IMapRouteDrivingOptions2;
+
+  interface IMapRouteFinderResult {
+    readonly Route: Windows.Services.Maps.MapRoute;
+    readonly Status: number;
+  }
+  var IMapRouteFinderResult: abstract new (...args: any[]) => IMapRouteFinderResult;
+
+  interface IMapRouteFinderResult2 {
+    readonly AlternateRoutes: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.MapRoute> | Windows.Services.Maps.MapRoute[];
+  }
+  var IMapRouteFinderResult2: abstract new (...args: any[]) => IMapRouteFinderResult2;
+
+  interface IMapRouteFinderStatics {
+    GetDrivingRouteAsync(startPoint: Windows.Devices.Geolocation.Geopoint, endPoint: Windows.Devices.Geolocation.Geopoint): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    GetDrivingRouteAsync(startPoint: Windows.Devices.Geolocation.Geopoint, endPoint: Windows.Devices.Geolocation.Geopoint, optimization: number): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    GetDrivingRouteAsync(startPoint: Windows.Devices.Geolocation.Geopoint, endPoint: Windows.Devices.Geolocation.Geopoint, optimization: number, restrictions: number): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    GetDrivingRouteAsync(startPoint: Windows.Devices.Geolocation.Geopoint, endPoint: Windows.Devices.Geolocation.Geopoint, optimization: number, restrictions: number, headingInDegrees: number): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    GetDrivingRouteFromWaypointsAsync(wayPoints: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.Geopoint> | Windows.Devices.Geolocation.Geopoint[]): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    GetDrivingRouteFromWaypointsAsync(wayPoints: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.Geopoint> | Windows.Devices.Geolocation.Geopoint[], optimization: number): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    GetDrivingRouteFromWaypointsAsync(wayPoints: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.Geopoint> | Windows.Devices.Geolocation.Geopoint[], optimization: number, restrictions: number): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    GetDrivingRouteFromWaypointsAsync(wayPoints: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.Geopoint> | Windows.Devices.Geolocation.Geopoint[], optimization: number, restrictions: number, headingInDegrees: number): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    GetWalkingRouteAsync(startPoint: Windows.Devices.Geolocation.Geopoint, endPoint: Windows.Devices.Geolocation.Geopoint): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    GetWalkingRouteFromWaypointsAsync(wayPoints: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.Geopoint> | Windows.Devices.Geolocation.Geopoint[]): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+  }
+  var IMapRouteFinderStatics: abstract new (...args: any[]) => IMapRouteFinderStatics;
+
+  interface IMapRouteFinderStatics2 {
+    GetDrivingRouteAsync(startPoint: Windows.Devices.Geolocation.Geopoint, endPoint: Windows.Devices.Geolocation.Geopoint, options: Windows.Services.Maps.MapRouteDrivingOptions): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+  }
+  var IMapRouteFinderStatics2: abstract new (...args: any[]) => IMapRouteFinderStatics2;
+
+  interface IMapRouteFinderStatics3 {
+    GetDrivingRouteFromEnhancedWaypointsAsync(waypoints: Windows.Foundation.Collections.IIterable<Windows.Services.Maps.EnhancedWaypoint> | Windows.Services.Maps.EnhancedWaypoint[]): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+    GetDrivingRouteFromEnhancedWaypointsAsync(waypoints: Windows.Foundation.Collections.IIterable<Windows.Services.Maps.EnhancedWaypoint> | Windows.Services.Maps.EnhancedWaypoint[], options: Windows.Services.Maps.MapRouteDrivingOptions): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.MapRouteFinderResult>;
+  }
+  var IMapRouteFinderStatics3: abstract new (...args: any[]) => IMapRouteFinderStatics3;
+
+  interface IMapRouteLeg {
+    readonly BoundingBox: Windows.Devices.Geolocation.GeoboundingBox;
+    readonly EstimatedDuration: Windows.Foundation.TimeSpan;
+    readonly LengthInMeters: number;
+    readonly Maneuvers: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.MapRouteManeuver> | Windows.Services.Maps.MapRouteManeuver[];
+    readonly Path: Windows.Devices.Geolocation.Geopath;
+  }
+  var IMapRouteLeg: abstract new (...args: any[]) => IMapRouteLeg;
+
+  interface IMapRouteLeg2 {
+    readonly DurationWithoutTraffic: Windows.Foundation.TimeSpan;
+    readonly TrafficCongestion: number;
+  }
+  var IMapRouteLeg2: abstract new (...args: any[]) => IMapRouteLeg2;
+
+  interface IMapRouteManeuver {
+    readonly ExitNumber: string;
+    readonly InstructionText: string;
+    readonly Kind: number;
+    readonly LengthInMeters: number;
+    readonly ManeuverNotices: number;
+    readonly StartingPoint: Windows.Devices.Geolocation.Geopoint;
+  }
+  var IMapRouteManeuver: abstract new (...args: any[]) => IMapRouteManeuver;
+
+  interface IMapRouteManeuver2 {
+    readonly EndHeading: number;
+    readonly StartHeading: number;
+    readonly StreetName: string;
+  }
+  var IMapRouteManeuver2: abstract new (...args: any[]) => IMapRouteManeuver2;
+
+  interface IMapRouteManeuver3 {
+    readonly Warnings: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.ManeuverWarning> | Windows.Services.Maps.ManeuverWarning[];
+  }
+  var IMapRouteManeuver3: abstract new (...args: any[]) => IMapRouteManeuver3;
+
+  interface IMapServiceStatics {
+    ServiceToken: string;
+  }
+  var IMapServiceStatics: abstract new (...args: any[]) => IMapServiceStatics;
+
+  interface IMapServiceStatics2 {
+    readonly WorldViewRegionCode: string;
+  }
+  var IMapServiceStatics2: abstract new (...args: any[]) => IMapServiceStatics2;
+
+  interface IMapServiceStatics3 {
+    readonly DataAttributions: string;
+  }
+  var IMapServiceStatics3: abstract new (...args: any[]) => IMapServiceStatics3;
+
+  interface IMapServiceStatics4 {
+    DataUsagePreference: number;
+  }
+  var IMapServiceStatics4: abstract new (...args: any[]) => IMapServiceStatics4;
+
+  interface IPlaceInfo {
+    Show(selection: Windows.Foundation.Rect): void;
+    Show(selection: Windows.Foundation.Rect, preferredPlacement: number): void;
+    readonly DisplayAddress: string;
+    readonly DisplayName: string;
+    readonly Geoshape: Windows.Devices.Geolocation.IGeoshape;
+    readonly Identifier: string;
+  }
+  var IPlaceInfo: abstract new (...args: any[]) => IPlaceInfo;
+
+  interface IPlaceInfoCreateOptions {
+    DisplayAddress: string;
+    DisplayName: string;
+  }
+  var IPlaceInfoCreateOptions: abstract new (...args: any[]) => IPlaceInfoCreateOptions;
+
+  interface IPlaceInfoStatics {
+    Create(referencePoint: Windows.Devices.Geolocation.Geopoint): Windows.Services.Maps.PlaceInfo;
+    Create(referencePoint: Windows.Devices.Geolocation.Geopoint, options: Windows.Services.Maps.PlaceInfoCreateOptions): Windows.Services.Maps.PlaceInfo;
+    CreateFromIdentifier(identifier: string): Windows.Services.Maps.PlaceInfo;
+    CreateFromIdentifier(identifier: string, defaultPoint: Windows.Devices.Geolocation.Geopoint, options: Windows.Services.Maps.PlaceInfoCreateOptions): Windows.Services.Maps.PlaceInfo;
+    CreateFromMapLocation(location: Windows.Services.Maps.MapLocation): Windows.Services.Maps.PlaceInfo;
+    readonly IsShowSupported: boolean;
+  }
+  var IPlaceInfoStatics: abstract new (...args: any[]) => IPlaceInfoStatics;
+
+  interface IPlaceInfoStatics2 {
+    CreateFromAddress(displayAddress: string): Windows.Services.Maps.PlaceInfo;
+    CreateFromAddress(displayAddress: string, displayName: string): Windows.Services.Maps.PlaceInfo;
+  }
+  var IPlaceInfoStatics2: abstract new (...args: any[]) => IPlaceInfoStatics2;
+
+  interface LocalSearchContract {
+  }
+  var LocalSearchContract: {
+    new(fields: {  }): LocalSearchContract;
+  };
+
+}
+
+declare namespace Windows.Services.Maps.Guidance {
+  class GuidanceAudioNotificationRequestedEventArgs implements Windows.Services.Maps.Guidance.IGuidanceAudioNotificationRequestedEventArgs {
+    readonly AudioFilePaths: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly AudioNotification: number;
+    readonly AudioText: string;
+  }
+
+  class GuidanceLaneInfo implements Windows.Services.Maps.Guidance.IGuidanceLaneInfo {
+    readonly IsOnRoute: boolean;
+    readonly LaneMarkers: number;
+  }
+
+  class GuidanceManeuver implements Windows.Services.Maps.Guidance.IGuidanceManeuver {
+    readonly DepartureRoadName: string;
+    readonly DepartureShortRoadName: string;
+    readonly DistanceFromPreviousManeuver: number;
+    readonly DistanceFromRouteStart: number;
+    readonly EndAngle: number;
+    readonly InstructionText: string;
+    readonly Kind: number;
+    readonly NextRoadName: string;
+    readonly NextShortRoadName: string;
+    readonly RoadSignpost: Windows.Services.Maps.Guidance.GuidanceRoadSignpost;
+    readonly StartAngle: number;
+    readonly StartLocation: Windows.Devices.Geolocation.Geopoint;
+  }
+
+  class GuidanceMapMatchedCoordinate implements Windows.Services.Maps.Guidance.IGuidanceMapMatchedCoordinate {
+    readonly CurrentHeading: number;
+    readonly CurrentSpeed: number;
+    readonly IsOnStreet: boolean;
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly Road: Windows.Services.Maps.Guidance.GuidanceRoadSegment;
+  }
+
+  class GuidanceNavigator implements Windows.Services.Maps.Guidance.IGuidanceNavigator, Windows.Services.Maps.Guidance.IGuidanceNavigator2 {
+    static GetCurrent(): Windows.Services.Maps.Guidance.GuidanceNavigator;
+    Pause(): void;
+    RepeatLastAudioNotification(): void;
+    Resume(): void;
+    SetGuidanceVoice(voiceId: number, voiceFolder: string): void;
+    StartNavigating(route: Windows.Services.Maps.Guidance.GuidanceRoute): void;
+    StartSimulating(route: Windows.Services.Maps.Guidance.GuidanceRoute, speedInMetersPerSecond: number): void;
+    StartTracking(): void;
+    Stop(): void;
+    UpdateUserLocation(userLocation: Windows.Devices.Geolocation.Geocoordinate): void;
+    UpdateUserLocation(userLocation: Windows.Devices.Geolocation.Geocoordinate, positionOverride: Windows.Devices.Geolocation.BasicGeoposition): void;
+    AudioMeasurementSystem: number;
+    AudioNotifications: number;
+    IsGuidanceAudioMuted: boolean;
+    static readonly UseAppProvidedVoice: boolean;
+    DestinationReached: Windows.Foundation.TypedEventHandler<Windows.Services.Maps.Guidance.GuidanceNavigator, Object> | null;
+    GuidanceUpdated: Windows.Foundation.TypedEventHandler<Windows.Services.Maps.Guidance.GuidanceNavigator, Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs> | null;
+    RerouteFailed: Windows.Foundation.TypedEventHandler<Windows.Services.Maps.Guidance.GuidanceNavigator, Object> | null;
+    Rerouted: Windows.Foundation.TypedEventHandler<Windows.Services.Maps.Guidance.GuidanceNavigator, Windows.Services.Maps.Guidance.GuidanceReroutedEventArgs> | null;
+    Rerouting: Windows.Foundation.TypedEventHandler<Windows.Services.Maps.Guidance.GuidanceNavigator, Object> | null;
+    UserLocationLost: Windows.Foundation.TypedEventHandler<Windows.Services.Maps.Guidance.GuidanceNavigator, Object> | null;
+    UserLocationRestored: Windows.Foundation.TypedEventHandler<Windows.Services.Maps.Guidance.GuidanceNavigator, Object> | null;
+    AudioNotificationRequested: Windows.Foundation.TypedEventHandler<Windows.Services.Maps.Guidance.GuidanceNavigator, Windows.Services.Maps.Guidance.GuidanceAudioNotificationRequestedEventArgs> | null;
+  }
+
+  class GuidanceReroutedEventArgs implements Windows.Services.Maps.Guidance.IGuidanceReroutedEventArgs {
+    readonly Route: Windows.Services.Maps.Guidance.GuidanceRoute;
+  }
+
+  class GuidanceRoadSegment implements Windows.Services.Maps.Guidance.IGuidanceRoadSegment, Windows.Services.Maps.Guidance.IGuidanceRoadSegment2 {
+    readonly Id: string;
+    readonly IsHighway: boolean;
+    readonly IsScenic: boolean;
+    readonly IsTollRoad: boolean;
+    readonly IsTunnel: boolean;
+    readonly Path: Windows.Devices.Geolocation.Geopath;
+    readonly RoadName: string;
+    readonly ShortRoadName: string;
+    readonly SpeedLimit: number;
+    readonly TravelTime: Windows.Foundation.TimeSpan;
+  }
+
+  class GuidanceRoadSignpost implements Windows.Services.Maps.Guidance.IGuidanceRoadSignpost {
+    readonly BackgroundColor: Windows.UI.Color;
+    readonly Exit: string;
+    readonly ExitDirections: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly ExitNumber: string;
+    readonly ForegroundColor: Windows.UI.Color;
+  }
+
+  class GuidanceRoute implements Windows.Services.Maps.Guidance.IGuidanceRoute {
+    static CanCreateFromMapRoute(mapRoute: Windows.Services.Maps.MapRoute): boolean;
+    ConvertToMapRoute(): Windows.Services.Maps.MapRoute;
+    static TryCreateFromMapRoute(mapRoute: Windows.Services.Maps.MapRoute): Windows.Services.Maps.Guidance.GuidanceRoute;
+    readonly BoundingBox: Windows.Devices.Geolocation.GeoboundingBox;
+    readonly Distance: number;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly Maneuvers: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.Guidance.GuidanceManeuver> | Windows.Services.Maps.Guidance.GuidanceManeuver[];
+    readonly Path: Windows.Devices.Geolocation.Geopath;
+    readonly RoadSegments: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.Guidance.GuidanceRoadSegment> | Windows.Services.Maps.Guidance.GuidanceRoadSegment[];
+  }
+
+  class GuidanceTelemetryCollector implements Windows.Services.Maps.Guidance.IGuidanceTelemetryCollector {
+    ClearLocalData(): void;
+    static GetCurrent(): Windows.Services.Maps.Guidance.GuidanceTelemetryCollector;
+    Enabled: boolean;
+    SpeedTrigger: number;
+    UploadFrequency: number;
+  }
+
+  class GuidanceUpdatedEventArgs implements Windows.Services.Maps.Guidance.IGuidanceUpdatedEventArgs {
+    readonly AfterNextManeuver: Windows.Services.Maps.Guidance.GuidanceManeuver;
+    readonly AfterNextManeuverDistance: number;
+    readonly CurrentLocation: Windows.Services.Maps.Guidance.GuidanceMapMatchedCoordinate;
+    readonly DistanceToDestination: number;
+    readonly ElapsedDistance: number;
+    readonly ElapsedTime: Windows.Foundation.TimeSpan;
+    readonly IsNewManeuver: boolean;
+    readonly LaneInfo: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.Guidance.GuidanceLaneInfo> | Windows.Services.Maps.Guidance.GuidanceLaneInfo[];
+    readonly Mode: number;
+    readonly NextManeuver: Windows.Services.Maps.Guidance.GuidanceManeuver;
+    readonly NextManeuverDistance: number;
+    readonly RoadName: string;
+    readonly Route: Windows.Services.Maps.Guidance.GuidanceRoute;
+    readonly TimeToDestination: Windows.Foundation.TimeSpan;
+  }
+
+  enum GuidanceAudioMeasurementSystem {
+    Meters = 0,
+    MilesAndYards = 1,
+    MilesAndFeet = 2,
+  }
+
+  enum GuidanceAudioNotificationKind {
+    Maneuver = 0,
+    Route = 1,
+    Gps = 2,
+    SpeedLimit = 3,
+    Traffic = 4,
+    TrafficCamera = 5,
+  }
+
+  enum GuidanceAudioNotifications {
+    None = 0,
+    Maneuver = 1,
+    Route = 2,
+    Gps = 4,
+    SpeedLimit = 8,
+    Traffic = 16,
+    TrafficCamera = 32,
+  }
+
+  enum GuidanceLaneMarkers {
+    None = 0,
+    LightRight = 1,
+    Right = 2,
+    HardRight = 4,
+    Straight = 8,
+    UTurnLeft = 16,
+    HardLeft = 32,
+    Left = 64,
+    LightLeft = 128,
+    UTurnRight = 256,
+    Unknown = 4294967295,
+  }
+
+  enum GuidanceManeuverKind {
+    None = 0,
+    GoStraight = 1,
+    UTurnRight = 2,
+    UTurnLeft = 3,
+    TurnKeepRight = 4,
+    TurnLightRight = 5,
+    TurnRight = 6,
+    TurnHardRight = 7,
+    KeepMiddle = 8,
+    TurnKeepLeft = 9,
+    TurnLightLeft = 10,
+    TurnLeft = 11,
+    TurnHardLeft = 12,
+    FreewayEnterRight = 13,
+    FreewayEnterLeft = 14,
+    FreewayLeaveRight = 15,
+    FreewayLeaveLeft = 16,
+    FreewayKeepRight = 17,
+    FreewayKeepLeft = 18,
+    TrafficCircleRight1 = 19,
+    TrafficCircleRight2 = 20,
+    TrafficCircleRight3 = 21,
+    TrafficCircleRight4 = 22,
+    TrafficCircleRight5 = 23,
+    TrafficCircleRight6 = 24,
+    TrafficCircleRight7 = 25,
+    TrafficCircleRight8 = 26,
+    TrafficCircleRight9 = 27,
+    TrafficCircleRight10 = 28,
+    TrafficCircleRight11 = 29,
+    TrafficCircleRight12 = 30,
+    TrafficCircleLeft1 = 31,
+    TrafficCircleLeft2 = 32,
+    TrafficCircleLeft3 = 33,
+    TrafficCircleLeft4 = 34,
+    TrafficCircleLeft5 = 35,
+    TrafficCircleLeft6 = 36,
+    TrafficCircleLeft7 = 37,
+    TrafficCircleLeft8 = 38,
+    TrafficCircleLeft9 = 39,
+    TrafficCircleLeft10 = 40,
+    TrafficCircleLeft11 = 41,
+    TrafficCircleLeft12 = 42,
+    Start = 43,
+    End = 44,
+    TakeFerry = 45,
+    PassTransitStation = 46,
+    LeaveTransitStation = 47,
+  }
+
+  enum GuidanceMode {
+    None = 0,
+    Simulation = 1,
+    Navigation = 2,
+    Tracking = 3,
+  }
+
+  interface IGuidanceAudioNotificationRequestedEventArgs {
+    readonly AudioFilePaths: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly AudioNotification: number;
+    readonly AudioText: string;
+  }
+  var IGuidanceAudioNotificationRequestedEventArgs: abstract new (...args: any[]) => IGuidanceAudioNotificationRequestedEventArgs;
+
+  interface IGuidanceLaneInfo {
+    readonly IsOnRoute: boolean;
+    readonly LaneMarkers: number;
+  }
+  var IGuidanceLaneInfo: abstract new (...args: any[]) => IGuidanceLaneInfo;
+
+  interface IGuidanceManeuver {
+    readonly DepartureRoadName: string;
+    readonly DepartureShortRoadName: string;
+    readonly DistanceFromPreviousManeuver: number;
+    readonly DistanceFromRouteStart: number;
+    readonly EndAngle: number;
+    readonly InstructionText: string;
+    readonly Kind: number;
+    readonly NextRoadName: string;
+    readonly NextShortRoadName: string;
+    readonly RoadSignpost: Windows.Services.Maps.Guidance.GuidanceRoadSignpost;
+    readonly StartAngle: number;
+    readonly StartLocation: Windows.Devices.Geolocation.Geopoint;
+  }
+  var IGuidanceManeuver: abstract new (...args: any[]) => IGuidanceManeuver;
+
+  interface IGuidanceMapMatchedCoordinate {
+    readonly CurrentHeading: number;
+    readonly CurrentSpeed: number;
+    readonly IsOnStreet: boolean;
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly Road: Windows.Services.Maps.Guidance.GuidanceRoadSegment;
+  }
+  var IGuidanceMapMatchedCoordinate: abstract new (...args: any[]) => IGuidanceMapMatchedCoordinate;
+
+  interface IGuidanceNavigator {
+    Pause(): void;
+    RepeatLastAudioNotification(): void;
+    Resume(): void;
+    SetGuidanceVoice(voiceId: number, voiceFolder: string): void;
+    StartNavigating(route: Windows.Services.Maps.Guidance.GuidanceRoute): void;
+    StartSimulating(route: Windows.Services.Maps.Guidance.GuidanceRoute, speedInMetersPerSecond: number): void;
+    StartTracking(): void;
+    Stop(): void;
+    UpdateUserLocation(userLocation: Windows.Devices.Geolocation.Geocoordinate): void;
+    UpdateUserLocation(userLocation: Windows.Devices.Geolocation.Geocoordinate, positionOverride: Windows.Devices.Geolocation.BasicGeoposition): void;
+    AudioMeasurementSystem: number;
+    AudioNotifications: number;
+    DestinationReached: Windows.Foundation.TypedEventHandler<Windows.Services.Maps.Guidance.GuidanceNavigator, Object> | null;
+    GuidanceUpdated: Windows.Foundation.TypedEventHandler<Windows.Services.Maps.Guidance.GuidanceNavigator, Windows.Services.Maps.Guidance.GuidanceUpdatedEventArgs> | null;
+    RerouteFailed: Windows.Foundation.TypedEventHandler<Windows.Services.Maps.Guidance.GuidanceNavigator, Object> | null;
+    Rerouted: Windows.Foundation.TypedEventHandler<Windows.Services.Maps.Guidance.GuidanceNavigator, Windows.Services.Maps.Guidance.GuidanceReroutedEventArgs> | null;
+    Rerouting: Windows.Foundation.TypedEventHandler<Windows.Services.Maps.Guidance.GuidanceNavigator, Object> | null;
+    UserLocationLost: Windows.Foundation.TypedEventHandler<Windows.Services.Maps.Guidance.GuidanceNavigator, Object> | null;
+    UserLocationRestored: Windows.Foundation.TypedEventHandler<Windows.Services.Maps.Guidance.GuidanceNavigator, Object> | null;
+  }
+  var IGuidanceNavigator: abstract new (...args: any[]) => IGuidanceNavigator;
+
+  interface IGuidanceNavigator2 {
+    IsGuidanceAudioMuted: boolean;
+    AudioNotificationRequested: Windows.Foundation.TypedEventHandler<Windows.Services.Maps.Guidance.GuidanceNavigator, Windows.Services.Maps.Guidance.GuidanceAudioNotificationRequestedEventArgs> | null;
+  }
+  var IGuidanceNavigator2: abstract new (...args: any[]) => IGuidanceNavigator2;
+
+  interface IGuidanceNavigatorStatics {
+    GetCurrent(): Windows.Services.Maps.Guidance.GuidanceNavigator;
+  }
+  var IGuidanceNavigatorStatics: abstract new (...args: any[]) => IGuidanceNavigatorStatics;
+
+  interface IGuidanceNavigatorStatics2 {
+    readonly UseAppProvidedVoice: boolean;
+  }
+  var IGuidanceNavigatorStatics2: abstract new (...args: any[]) => IGuidanceNavigatorStatics2;
+
+  interface IGuidanceReroutedEventArgs {
+    readonly Route: Windows.Services.Maps.Guidance.GuidanceRoute;
+  }
+  var IGuidanceReroutedEventArgs: abstract new (...args: any[]) => IGuidanceReroutedEventArgs;
+
+  interface IGuidanceRoadSegment {
+    readonly Id: string;
+    readonly IsHighway: boolean;
+    readonly IsTollRoad: boolean;
+    readonly IsTunnel: boolean;
+    readonly Path: Windows.Devices.Geolocation.Geopath;
+    readonly RoadName: string;
+    readonly ShortRoadName: string;
+    readonly SpeedLimit: number;
+    readonly TravelTime: Windows.Foundation.TimeSpan;
+  }
+  var IGuidanceRoadSegment: abstract new (...args: any[]) => IGuidanceRoadSegment;
+
+  interface IGuidanceRoadSegment2 {
+    readonly IsScenic: boolean;
+  }
+  var IGuidanceRoadSegment2: abstract new (...args: any[]) => IGuidanceRoadSegment2;
+
+  interface IGuidanceRoadSignpost {
+    readonly BackgroundColor: Windows.UI.Color;
+    readonly Exit: string;
+    readonly ExitDirections: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly ExitNumber: string;
+    readonly ForegroundColor: Windows.UI.Color;
+  }
+  var IGuidanceRoadSignpost: abstract new (...args: any[]) => IGuidanceRoadSignpost;
+
+  interface IGuidanceRoute {
+    ConvertToMapRoute(): Windows.Services.Maps.MapRoute;
+    readonly BoundingBox: Windows.Devices.Geolocation.GeoboundingBox;
+    readonly Distance: number;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly Maneuvers: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.Guidance.GuidanceManeuver> | Windows.Services.Maps.Guidance.GuidanceManeuver[];
+    readonly Path: Windows.Devices.Geolocation.Geopath;
+    readonly RoadSegments: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.Guidance.GuidanceRoadSegment> | Windows.Services.Maps.Guidance.GuidanceRoadSegment[];
+  }
+  var IGuidanceRoute: abstract new (...args: any[]) => IGuidanceRoute;
+
+  interface IGuidanceRouteStatics {
+    CanCreateFromMapRoute(mapRoute: Windows.Services.Maps.MapRoute): boolean;
+    TryCreateFromMapRoute(mapRoute: Windows.Services.Maps.MapRoute): Windows.Services.Maps.Guidance.GuidanceRoute;
+  }
+  var IGuidanceRouteStatics: abstract new (...args: any[]) => IGuidanceRouteStatics;
+
+  interface IGuidanceTelemetryCollector {
+    ClearLocalData(): void;
+    Enabled: boolean;
+    SpeedTrigger: number;
+    UploadFrequency: number;
+  }
+  var IGuidanceTelemetryCollector: abstract new (...args: any[]) => IGuidanceTelemetryCollector;
+
+  interface IGuidanceTelemetryCollectorStatics {
+    GetCurrent(): Windows.Services.Maps.Guidance.GuidanceTelemetryCollector;
+  }
+  var IGuidanceTelemetryCollectorStatics: abstract new (...args: any[]) => IGuidanceTelemetryCollectorStatics;
+
+  interface IGuidanceUpdatedEventArgs {
+    readonly AfterNextManeuver: Windows.Services.Maps.Guidance.GuidanceManeuver;
+    readonly AfterNextManeuverDistance: number;
+    readonly CurrentLocation: Windows.Services.Maps.Guidance.GuidanceMapMatchedCoordinate;
+    readonly DistanceToDestination: number;
+    readonly ElapsedDistance: number;
+    readonly ElapsedTime: Windows.Foundation.TimeSpan;
+    readonly IsNewManeuver: boolean;
+    readonly LaneInfo: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.Guidance.GuidanceLaneInfo> | Windows.Services.Maps.Guidance.GuidanceLaneInfo[];
+    readonly Mode: number;
+    readonly NextManeuver: Windows.Services.Maps.Guidance.GuidanceManeuver;
+    readonly NextManeuverDistance: number;
+    readonly RoadName: string;
+    readonly Route: Windows.Services.Maps.Guidance.GuidanceRoute;
+    readonly TimeToDestination: Windows.Foundation.TimeSpan;
+  }
+  var IGuidanceUpdatedEventArgs: abstract new (...args: any[]) => IGuidanceUpdatedEventArgs;
+
+}
+
+declare namespace Windows.Services.Maps.LocalSearch {
+  class LocalCategories {
+    static readonly All: string;
+    static readonly BankAndCreditUnions: string;
+    static readonly EatDrink: string;
+    static readonly Hospitals: string;
+    static readonly HotelsAndMotels: string;
+    static readonly Parking: string;
+    static readonly SeeDo: string;
+    static readonly Shop: string;
+  }
+
+  class LocalLocation implements Windows.Services.Maps.LocalSearch.ILocalLocation, Windows.Services.Maps.LocalSearch.ILocalLocation2 {
+    readonly Address: Windows.Services.Maps.MapAddress;
+    readonly Category: string;
+    readonly DataAttribution: string;
+    readonly Description: string;
+    readonly DisplayName: string;
+    readonly HoursOfOperation: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.LocalSearch.LocalLocationHoursOfOperationItem> | Windows.Services.Maps.LocalSearch.LocalLocationHoursOfOperationItem[];
+    readonly Identifier: string;
+    readonly PhoneNumber: string;
+    readonly Point: Windows.Devices.Geolocation.Geopoint;
+    readonly RatingInfo: Windows.Services.Maps.LocalSearch.LocalLocationRatingInfo;
+  }
+
+  class LocalLocationFinder {
+    static FindLocalLocationsAsync(searchTerm: string, searchArea: Windows.Devices.Geolocation.Geocircle, localCategory: string, maxResults: number): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.LocalSearch.LocalLocationFinderResult>;
+  }
+
+  class LocalLocationFinderResult implements Windows.Services.Maps.LocalSearch.ILocalLocationFinderResult {
+    readonly LocalLocations: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.LocalSearch.LocalLocation> | Windows.Services.Maps.LocalSearch.LocalLocation[];
+    readonly Status: number;
+  }
+
+  class LocalLocationHoursOfOperationItem implements Windows.Services.Maps.LocalSearch.ILocalLocationHoursOfOperationItem {
+    readonly Day: number;
+    readonly Span: Windows.Foundation.TimeSpan;
+    readonly Start: Windows.Foundation.TimeSpan;
+  }
+
+  class LocalLocationRatingInfo implements Windows.Services.Maps.LocalSearch.ILocalLocationRatingInfo {
+    readonly AggregateRating: number | null;
+    readonly ProviderIdentifier: string;
+    readonly RatingCount: number | null;
+  }
+
+  class PlaceInfoHelper {
+    static CreateFromLocalLocation(location: Windows.Services.Maps.LocalSearch.LocalLocation): Windows.Services.Maps.PlaceInfo;
+  }
+
+  enum LocalLocationFinderStatus {
+    Success = 0,
+    UnknownError = 1,
+    InvalidCredentials = 2,
+    InvalidCategory = 3,
+    InvalidSearchTerm = 4,
+    InvalidSearchArea = 5,
+    NetworkFailure = 6,
+    NotSupported = 7,
+  }
+
+  interface ILocalCategoriesStatics {
+    readonly All: string;
+    readonly BankAndCreditUnions: string;
+    readonly EatDrink: string;
+    readonly Hospitals: string;
+    readonly HotelsAndMotels: string;
+    readonly Parking: string;
+    readonly SeeDo: string;
+    readonly Shop: string;
+  }
+  var ILocalCategoriesStatics: abstract new (...args: any[]) => ILocalCategoriesStatics;
+
+  interface ILocalLocation {
+    readonly Address: Windows.Services.Maps.MapAddress;
+    readonly DataAttribution: string;
+    readonly Description: string;
+    readonly DisplayName: string;
+    readonly Identifier: string;
+    readonly PhoneNumber: string;
+    readonly Point: Windows.Devices.Geolocation.Geopoint;
+  }
+  var ILocalLocation: abstract new (...args: any[]) => ILocalLocation;
+
+  interface ILocalLocation2 {
+    readonly Category: string;
+    readonly HoursOfOperation: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.LocalSearch.LocalLocationHoursOfOperationItem> | Windows.Services.Maps.LocalSearch.LocalLocationHoursOfOperationItem[];
+    readonly RatingInfo: Windows.Services.Maps.LocalSearch.LocalLocationRatingInfo;
+  }
+  var ILocalLocation2: abstract new (...args: any[]) => ILocalLocation2;
+
+  interface ILocalLocationFinderResult {
+    readonly LocalLocations: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.LocalSearch.LocalLocation> | Windows.Services.Maps.LocalSearch.LocalLocation[];
+    readonly Status: number;
+  }
+  var ILocalLocationFinderResult: abstract new (...args: any[]) => ILocalLocationFinderResult;
+
+  interface ILocalLocationFinderStatics {
+    FindLocalLocationsAsync(searchTerm: string, searchArea: Windows.Devices.Geolocation.Geocircle, localCategory: string, maxResults: number): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.LocalSearch.LocalLocationFinderResult>;
+  }
+  var ILocalLocationFinderStatics: abstract new (...args: any[]) => ILocalLocationFinderStatics;
+
+  interface ILocalLocationHoursOfOperationItem {
+    readonly Day: number;
+    readonly Span: Windows.Foundation.TimeSpan;
+    readonly Start: Windows.Foundation.TimeSpan;
+  }
+  var ILocalLocationHoursOfOperationItem: abstract new (...args: any[]) => ILocalLocationHoursOfOperationItem;
+
+  interface ILocalLocationRatingInfo {
+    readonly AggregateRating: number | null;
+    readonly ProviderIdentifier: string;
+    readonly RatingCount: number | null;
+  }
+  var ILocalLocationRatingInfo: abstract new (...args: any[]) => ILocalLocationRatingInfo;
+
+  interface IPlaceInfoHelperStatics {
+    CreateFromLocalLocation(location: Windows.Services.Maps.LocalSearch.LocalLocation): Windows.Services.Maps.PlaceInfo;
+  }
+  var IPlaceInfoHelperStatics: abstract new (...args: any[]) => IPlaceInfoHelperStatics;
+
+}
+
+declare namespace Windows.Services.Maps.OfflineMaps {
+  class OfflineMapPackage implements Windows.Services.Maps.OfflineMaps.IOfflineMapPackage {
+    static FindPackagesAsync(queryPoint: Windows.Devices.Geolocation.Geopoint): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.OfflineMaps.OfflineMapPackageQueryResult>;
+    static FindPackagesInBoundingBoxAsync(queryBoundingBox: Windows.Devices.Geolocation.GeoboundingBox): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.OfflineMaps.OfflineMapPackageQueryResult>;
+    static FindPackagesInGeocircleAsync(queryCircle: Windows.Devices.Geolocation.Geocircle): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.OfflineMaps.OfflineMapPackageQueryResult>;
+    RequestStartDownloadAsync(): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.OfflineMaps.OfflineMapPackageStartDownloadResult>;
+    readonly DisplayName: string;
+    readonly EnclosingRegionName: string;
+    readonly EstimatedSizeInBytes: number | bigint;
+    readonly Status: number;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.Services.Maps.OfflineMaps.OfflineMapPackage, Object> | null;
+  }
+
+  class OfflineMapPackageQueryResult implements Windows.Services.Maps.OfflineMaps.IOfflineMapPackageQueryResult {
+    readonly Packages: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.OfflineMaps.OfflineMapPackage> | Windows.Services.Maps.OfflineMaps.OfflineMapPackage[];
+    readonly Status: number;
+  }
+
+  class OfflineMapPackageStartDownloadResult implements Windows.Services.Maps.OfflineMaps.IOfflineMapPackageStartDownloadResult {
+    readonly Status: number;
+  }
+
+  enum OfflineMapPackageQueryStatus {
+    Success = 0,
+    UnknownError = 1,
+    InvalidCredentials = 2,
+    NetworkFailure = 3,
+  }
+
+  enum OfflineMapPackageStartDownloadStatus {
+    Success = 0,
+    UnknownError = 1,
+    InvalidCredentials = 2,
+    DeniedWithoutCapability = 3,
+  }
+
+  enum OfflineMapPackageStatus {
+    NotDownloaded = 0,
+    Downloading = 1,
+    Downloaded = 2,
+    Deleting = 3,
+  }
+
+  interface IOfflineMapPackage {
+    RequestStartDownloadAsync(): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.OfflineMaps.OfflineMapPackageStartDownloadResult>;
+    readonly DisplayName: string;
+    readonly EnclosingRegionName: string;
+    readonly EstimatedSizeInBytes: number | bigint;
+    readonly Status: number;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.Services.Maps.OfflineMaps.OfflineMapPackage, Object> | null;
+  }
+  var IOfflineMapPackage: abstract new (...args: any[]) => IOfflineMapPackage;
+
+  interface IOfflineMapPackageQueryResult {
+    readonly Packages: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.OfflineMaps.OfflineMapPackage> | Windows.Services.Maps.OfflineMaps.OfflineMapPackage[];
+    readonly Status: number;
+  }
+  var IOfflineMapPackageQueryResult: abstract new (...args: any[]) => IOfflineMapPackageQueryResult;
+
+  interface IOfflineMapPackageStartDownloadResult {
+    readonly Status: number;
+  }
+  var IOfflineMapPackageStartDownloadResult: abstract new (...args: any[]) => IOfflineMapPackageStartDownloadResult;
+
+  interface IOfflineMapPackageStatics {
+    FindPackagesAsync(queryPoint: Windows.Devices.Geolocation.Geopoint): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.OfflineMaps.OfflineMapPackageQueryResult>;
+    FindPackagesInBoundingBoxAsync(queryBoundingBox: Windows.Devices.Geolocation.GeoboundingBox): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.OfflineMaps.OfflineMapPackageQueryResult>;
+    FindPackagesInGeocircleAsync(queryCircle: Windows.Devices.Geolocation.Geocircle): Windows.Foundation.IAsyncOperation<Windows.Services.Maps.OfflineMaps.OfflineMapPackageQueryResult>;
+  }
+  var IOfflineMapPackageStatics: abstract new (...args: any[]) => IOfflineMapPackageStatics;
+
+}
+
+declare namespace Windows.Services.Store {
+  class StoreAcquireLicenseResult implements Windows.Services.Store.IStoreAcquireLicenseResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly StorePackageLicense: Windows.Services.Store.StorePackageLicense;
+  }
+
+  class StoreAppLicense implements Windows.Services.Store.IStoreAppLicense, Windows.Services.Store.IStoreAppLicense2 {
+    readonly AddOnLicenses: Windows.Foundation.Collections.IMapView<string, Windows.Services.Store.StoreLicense>;
+    readonly ExpirationDate: Windows.Foundation.DateTime;
+    readonly ExtendedJsonData: string;
+    readonly IsActive: boolean;
+    readonly IsDiscLicense: boolean;
+    readonly IsTrial: boolean;
+    readonly IsTrialOwnedByThisUser: boolean;
+    readonly SkuStoreId: string;
+    readonly TrialTimeRemaining: Windows.Foundation.TimeSpan;
+    readonly TrialUniqueId: string;
+  }
+
+  class StoreAvailability implements Windows.Services.Store.IStoreAvailability {
+    RequestPurchaseAsync(): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StorePurchaseResult>;
+    RequestPurchaseAsync(storePurchaseProperties: Windows.Services.Store.StorePurchaseProperties): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StorePurchaseResult>;
+    readonly EndDate: Windows.Foundation.DateTime;
+    readonly ExtendedJsonData: string;
+    readonly Price: Windows.Services.Store.StorePrice;
+    readonly StoreId: string;
+  }
+
+  class StoreCanAcquireLicenseResult implements Windows.Services.Store.IStoreCanAcquireLicenseResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly LicensableSku: string;
+    readonly Status: number;
+  }
+
+  class StoreCollectionData implements Windows.Services.Store.IStoreCollectionData {
+    readonly AcquiredDate: Windows.Foundation.DateTime;
+    readonly CampaignId: string;
+    readonly DeveloperOfferId: string;
+    readonly EndDate: Windows.Foundation.DateTime;
+    readonly ExtendedJsonData: string;
+    readonly IsTrial: boolean;
+    readonly StartDate: Windows.Foundation.DateTime;
+    readonly TrialTimeRemaining: Windows.Foundation.TimeSpan;
+  }
+
+  class StoreConsumableResult implements Windows.Services.Store.IStoreConsumableResult {
+    readonly BalanceRemaining: number;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+    readonly TrackingId: Guid;
+  }
+
+  class StoreContext implements Windows.Services.Store.IStoreContext, Windows.Services.Store.IStoreContext2, Windows.Services.Store.IStoreContext3, Windows.Services.Store.IStoreContext4, Windows.Services.Store.IStoreContext5 {
+    AcquireStoreLicenseForOptionalPackageAsync(optionalPackage: Windows.ApplicationModel.Package): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreAcquireLicenseResult>;
+    CanAcquireStoreLicenseAsync(productStoreId: string): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreCanAcquireLicenseResult>;
+    CanAcquireStoreLicenseForOptionalPackageAsync(optionalPackage: Windows.ApplicationModel.Package): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreCanAcquireLicenseResult>;
+    DownloadAndInstallStorePackagesAsync(storeIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Services.Store.StorePackageUpdateResult, Windows.Services.Store.StorePackageUpdateStatus>;
+    FindStoreProductForPackageAsync(productKinds: Windows.Foundation.Collections.IIterable<string> | string[], package_: Windows.ApplicationModel.Package): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductResult>;
+    GetAppAndOptionalStorePackageUpdatesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StorePackageUpdate> | Windows.Services.Store.StorePackageUpdate[]>;
+    GetAppLicenseAsync(): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreAppLicense>;
+    GetAssociatedStoreProductsAsync(productKinds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductQueryResult>;
+    GetAssociatedStoreProductsByInAppOfferTokenAsync(inAppOfferTokens: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductQueryResult>;
+    GetAssociatedStoreProductsWithPagingAsync(productKinds: Windows.Foundation.Collections.IIterable<string> | string[], maxItemsToRetrievePerPage: number): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductPagedQueryResult>;
+    GetAssociatedStoreQueueItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreQueueItem> | Windows.Services.Store.StoreQueueItem[]>;
+    GetConsumableBalanceRemainingAsync(productStoreId: string): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreConsumableResult>;
+    GetCustomerCollectionsIdAsync(serviceTicket: string, publisherUserId: string): Windows.Foundation.IAsyncOperation<string>;
+    GetCustomerPurchaseIdAsync(serviceTicket: string, publisherUserId: string): Windows.Foundation.IAsyncOperation<string>;
+    static GetDefault(): Windows.Services.Store.StoreContext;
+    static GetForUser(user: Windows.System.User): Windows.Services.Store.StoreContext;
+    GetStoreProductForCurrentAppAsync(): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductResult>;
+    GetStoreProductsAsync(productKinds: Windows.Foundation.Collections.IIterable<string> | string[], storeIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductQueryResult>;
+    GetStoreProductsAsync(productKinds: Windows.Foundation.Collections.IIterable<string> | string[], storeIds: Windows.Foundation.Collections.IIterable<string> | string[], storeProductOptions: Windows.Services.Store.StoreProductOptions): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductQueryResult>;
+    GetStoreQueueItemsAsync(storeIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreQueueItem> | Windows.Services.Store.StoreQueueItem[]>;
+    GetUserCollectionAsync(productKinds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductQueryResult>;
+    GetUserCollectionWithPagingAsync(productKinds: Windows.Foundation.Collections.IIterable<string> | string[], maxItemsToRetrievePerPage: number): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductPagedQueryResult>;
+    GetUserPurchaseHistoryAsync(productKinds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductQueryResult>;
+    ReportConsumableFulfillmentAsync(productStoreId: string, quantity: number, trackingId: Guid): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreConsumableResult>;
+    RequestDownloadAndInstallStorePackageUpdatesAsync(storePackageUpdates: Windows.Foundation.Collections.IIterable<Windows.Services.Store.StorePackageUpdate> | Windows.Services.Store.StorePackageUpdate[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Services.Store.StorePackageUpdateResult, Windows.Services.Store.StorePackageUpdateStatus>;
+    RequestDownloadAndInstallStorePackagesAsync(storeIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Services.Store.StorePackageUpdateResult, Windows.Services.Store.StorePackageUpdateStatus>;
+    RequestDownloadAndInstallStorePackagesAsync(storeIds: Windows.Foundation.Collections.IIterable<string> | string[], storePackageInstallOptions: Windows.Services.Store.StorePackageInstallOptions): Windows.Foundation.IAsyncOperationWithProgress<Windows.Services.Store.StorePackageUpdateResult, Windows.Services.Store.StorePackageUpdateStatus>;
+    RequestDownloadStorePackageUpdatesAsync(storePackageUpdates: Windows.Foundation.Collections.IIterable<Windows.Services.Store.StorePackageUpdate> | Windows.Services.Store.StorePackageUpdate[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Services.Store.StorePackageUpdateResult, Windows.Services.Store.StorePackageUpdateStatus>;
+    RequestPurchaseAsync(storeId: string): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StorePurchaseResult>;
+    RequestPurchaseAsync(storeId: string, storePurchaseProperties: Windows.Services.Store.StorePurchaseProperties): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StorePurchaseResult>;
+    RequestPurchaseByInAppOfferTokenAsync(inAppOfferToken: string): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StorePurchaseResult>;
+    RequestRateAndReviewAppAsync(): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreRateAndReviewResult>;
+    RequestUninstallStorePackageAsync(package_: Windows.ApplicationModel.Package): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreUninstallStorePackageResult>;
+    RequestUninstallStorePackageByStoreIdAsync(storeId: string): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreUninstallStorePackageResult>;
+    SetInstallOrderForAssociatedStoreQueueItemsAsync(items: Windows.Foundation.Collections.IIterable<Windows.Services.Store.StoreQueueItem> | Windows.Services.Store.StoreQueueItem[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreQueueItem> | Windows.Services.Store.StoreQueueItem[]>;
+    TrySilentDownloadAndInstallStorePackageUpdatesAsync(storePackageUpdates: Windows.Foundation.Collections.IIterable<Windows.Services.Store.StorePackageUpdate> | Windows.Services.Store.StorePackageUpdate[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Services.Store.StorePackageUpdateResult, Windows.Services.Store.StorePackageUpdateStatus>;
+    TrySilentDownloadStorePackageUpdatesAsync(storePackageUpdates: Windows.Foundation.Collections.IIterable<Windows.Services.Store.StorePackageUpdate> | Windows.Services.Store.StorePackageUpdate[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Services.Store.StorePackageUpdateResult, Windows.Services.Store.StorePackageUpdateStatus>;
+    UninstallStorePackageAsync(package_: Windows.ApplicationModel.Package): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreUninstallStorePackageResult>;
+    UninstallStorePackageByStoreIdAsync(storeId: string): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreUninstallStorePackageResult>;
+    readonly CanSilentlyDownloadStorePackageUpdates: boolean;
+    readonly User: Windows.System.User;
+    OfflineLicensesChanged: Windows.Foundation.TypedEventHandler<Windows.Services.Store.StoreContext, Object> | null;
+  }
+
+  class StoreImage implements Windows.Services.Store.IStoreImage {
+    readonly Caption: string;
+    readonly Height: number;
+    readonly ImagePurposeTag: string;
+    readonly Uri: Windows.Foundation.Uri;
+    readonly Width: number;
+  }
+
+  class StoreLicense implements Windows.Services.Store.IStoreLicense {
+    readonly ExpirationDate: Windows.Foundation.DateTime;
+    readonly ExtendedJsonData: string;
+    readonly InAppOfferToken: string;
+    readonly IsActive: boolean;
+    readonly SkuStoreId: string;
+  }
+
+  class StorePackageInstallOptions implements Windows.Services.Store.IStorePackageInstallOptions {
+    constructor();
+    AllowForcedAppRestart: boolean;
+  }
+
+  class StorePackageLicense implements Windows.Foundation.IClosable, Windows.Services.Store.IStorePackageLicense {
+    Close(): void;
+    ReleaseLicense(): void;
+    readonly IsValid: boolean;
+    readonly Package: Windows.ApplicationModel.Package;
+    LicenseLost: Windows.Foundation.TypedEventHandler<Windows.Services.Store.StorePackageLicense, Object> | null;
+  }
+
+  class StorePackageUpdate implements Windows.Services.Store.IStorePackageUpdate {
+    readonly Mandatory: boolean;
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+
+  class StorePackageUpdateResult implements Windows.Services.Store.IStorePackageUpdateResult, Windows.Services.Store.IStorePackageUpdateResult2 {
+    readonly OverallState: number;
+    readonly StorePackageUpdateStatuses: Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StorePackageUpdateStatus> | Windows.Services.Store.StorePackageUpdateStatus[];
+    readonly StoreQueueItems: Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreQueueItem> | Windows.Services.Store.StoreQueueItem[];
+  }
+
+  class StorePrice implements Windows.Services.Store.IStorePrice, Windows.Services.Store.IStorePrice2 {
+    readonly CurrencyCode: string;
+    readonly FormattedBasePrice: string;
+    readonly FormattedPrice: string;
+    readonly FormattedRecurrencePrice: string;
+    readonly IsOnSale: boolean;
+    readonly SaleEndDate: Windows.Foundation.DateTime;
+    readonly UnformattedBasePrice: string;
+    readonly UnformattedPrice: string;
+    readonly UnformattedRecurrencePrice: string;
+  }
+
+  class StoreProduct implements Windows.Services.Store.IStoreProduct {
+    GetIsAnySkuInstalledAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestPurchaseAsync(): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StorePurchaseResult>;
+    RequestPurchaseAsync(storePurchaseProperties: Windows.Services.Store.StorePurchaseProperties): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StorePurchaseResult>;
+    readonly Description: string;
+    readonly ExtendedJsonData: string;
+    readonly HasDigitalDownload: boolean;
+    readonly Images: Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreImage> | Windows.Services.Store.StoreImage[];
+    readonly InAppOfferToken: string;
+    readonly IsInUserCollection: boolean;
+    readonly Keywords: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Language: string;
+    readonly LinkUri: Windows.Foundation.Uri;
+    readonly Price: Windows.Services.Store.StorePrice;
+    readonly ProductKind: string;
+    readonly Skus: Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreSku> | Windows.Services.Store.StoreSku[];
+    readonly StoreId: string;
+    readonly Title: string;
+    readonly Videos: Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreVideo> | Windows.Services.Store.StoreVideo[];
+  }
+
+  class StoreProductOptions implements Windows.Services.Store.IStoreProductOptions {
+    constructor();
+    readonly ActionFilters: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+
+  class StoreProductPagedQueryResult implements Windows.Services.Store.IStoreProductPagedQueryResult {
+    GetNextAsync(): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductPagedQueryResult>;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly HasMoreResults: boolean;
+    readonly Products: Windows.Foundation.Collections.IMapView<string, Windows.Services.Store.StoreProduct>;
+  }
+
+  class StoreProductQueryResult implements Windows.Services.Store.IStoreProductQueryResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Products: Windows.Foundation.Collections.IMapView<string, Windows.Services.Store.StoreProduct>;
+  }
+
+  class StoreProductResult implements Windows.Services.Store.IStoreProductResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Product: Windows.Services.Store.StoreProduct;
+  }
+
+  class StorePurchaseProperties implements Windows.Services.Store.IStorePurchaseProperties {
+    constructor(name: string);
+    constructor();
+    ExtendedJsonData: string;
+    Name: string;
+  }
+
+  class StorePurchaseResult implements Windows.Services.Store.IStorePurchaseResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+
+  class StoreQueueItem implements Windows.Services.Store.IStoreQueueItem, Windows.Services.Store.IStoreQueueItem2 {
+    CancelInstallAsync(): Windows.Foundation.IAsyncAction;
+    GetCurrentStatus(): Windows.Services.Store.StoreQueueItemStatus;
+    PauseInstallAsync(): Windows.Foundation.IAsyncAction;
+    ResumeInstallAsync(): Windows.Foundation.IAsyncAction;
+    readonly InstallKind: number;
+    readonly PackageFamilyName: string;
+    readonly ProductId: string;
+    Completed: Windows.Foundation.TypedEventHandler<Windows.Services.Store.StoreQueueItem, Windows.Services.Store.StoreQueueItemCompletedEventArgs> | null;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.Services.Store.StoreQueueItem, Object> | null;
+  }
+
+  class StoreQueueItemCompletedEventArgs implements Windows.Services.Store.IStoreQueueItemCompletedEventArgs {
+    readonly Status: Windows.Services.Store.StoreQueueItemStatus;
+  }
+
+  class StoreQueueItemStatus implements Windows.Services.Store.IStoreQueueItemStatus {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly PackageInstallExtendedState: number;
+    readonly PackageInstallState: number;
+    readonly UpdateStatus: Windows.Services.Store.StorePackageUpdateStatus;
+  }
+
+  class StoreRateAndReviewResult implements Windows.Services.Store.IStoreRateAndReviewResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly ExtendedJsonData: string;
+    readonly Status: number;
+    readonly WasUpdated: boolean;
+  }
+
+  class StoreRequestHelper {
+    static SendRequestAsync(context: Windows.Services.Store.StoreContext, requestKind: number, parametersAsJson: string): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreSendRequestResult>;
+  }
+
+  class StoreSendRequestResult implements Windows.Services.Store.IStoreSendRequestResult, Windows.Services.Store.IStoreSendRequestResult2 {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly HttpStatusCode: number;
+    readonly Response: string;
+  }
+
+  class StoreSku implements Windows.Services.Store.IStoreSku {
+    GetIsInstalledAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestPurchaseAsync(): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StorePurchaseResult>;
+    RequestPurchaseAsync(storePurchaseProperties: Windows.Services.Store.StorePurchaseProperties): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StorePurchaseResult>;
+    readonly Availabilities: Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreAvailability> | Windows.Services.Store.StoreAvailability[];
+    readonly BundledSkus: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly CollectionData: Windows.Services.Store.StoreCollectionData;
+    readonly CustomDeveloperData: string;
+    readonly Description: string;
+    readonly ExtendedJsonData: string;
+    readonly Images: Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreImage> | Windows.Services.Store.StoreImage[];
+    readonly IsInUserCollection: boolean;
+    readonly IsSubscription: boolean;
+    readonly IsTrial: boolean;
+    readonly Language: string;
+    readonly Price: Windows.Services.Store.StorePrice;
+    readonly StoreId: string;
+    readonly SubscriptionInfo: Windows.Services.Store.StoreSubscriptionInfo;
+    readonly Title: string;
+    readonly Videos: Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreVideo> | Windows.Services.Store.StoreVideo[];
+  }
+
+  class StoreSubscriptionInfo implements Windows.Services.Store.IStoreSubscriptionInfo {
+    readonly BillingPeriod: number;
+    readonly BillingPeriodUnit: number;
+    readonly HasTrialPeriod: boolean;
+    readonly TrialPeriod: number;
+    readonly TrialPeriodUnit: number;
+  }
+
+  class StoreUninstallStorePackageResult implements Windows.Services.Store.IStoreUninstallStorePackageResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+
+  class StoreVideo implements Windows.Services.Store.IStoreVideo {
+    readonly Caption: string;
+    readonly Height: number;
+    readonly PreviewImage: Windows.Services.Store.StoreImage;
+    readonly Uri: Windows.Foundation.Uri;
+    readonly VideoPurposeTag: string;
+    readonly Width: number;
+  }
+
+  enum StoreCanLicenseStatus {
+    NotLicensableToUser = 0,
+    Licensable = 1,
+    LicenseActionNotApplicableToProduct = 2,
+    NetworkError = 3,
+    ServerError = 4,
+  }
+
+  enum StoreConsumableStatus {
+    Succeeded = 0,
+    InsufficentQuantity = 1,
+    NetworkError = 2,
+    ServerError = 3,
+  }
+
+  enum StoreDurationUnit {
+    Minute = 0,
+    Hour = 1,
+    Day = 2,
+    Week = 3,
+    Month = 4,
+    Year = 5,
+  }
+
+  enum StorePackageUpdateState {
+    Pending = 0,
+    Downloading = 1,
+    Deploying = 2,
+    Completed = 3,
+    Canceled = 4,
+    OtherError = 5,
+    ErrorLowBattery = 6,
+    ErrorWiFiRecommended = 7,
+    ErrorWiFiRequired = 8,
+  }
+
+  enum StorePurchaseStatus {
+    Succeeded = 0,
+    AlreadyPurchased = 1,
+    NotPurchased = 2,
+    NetworkError = 3,
+    ServerError = 4,
+  }
+
+  enum StoreQueueItemExtendedState {
+    ActivePending = 0,
+    ActiveStarting = 1,
+    ActiveAcquiringLicense = 2,
+    ActiveDownloading = 3,
+    ActiveRestoringData = 4,
+    ActiveInstalling = 5,
+    Completed = 6,
+    Canceled = 7,
+    Paused = 8,
+    Error = 9,
+    PausedPackagesInUse = 10,
+    PausedLowBattery = 11,
+    PausedWiFiRecommended = 12,
+    PausedWiFiRequired = 13,
+    PausedReadyToInstall = 14,
+  }
+
+  enum StoreQueueItemKind {
+    Install = 0,
+    Update = 1,
+    Repair = 2,
+  }
+
+  enum StoreQueueItemState {
+    Active = 0,
+    Completed = 1,
+    Canceled = 2,
+    Error = 3,
+    Paused = 4,
+  }
+
+  enum StoreRateAndReviewStatus {
+    Succeeded = 0,
+    CanceledByUser = 1,
+    NetworkError = 2,
+    Error = 3,
+  }
+
+  enum StoreUninstallStorePackageStatus {
+    Succeeded = 0,
+    CanceledByUser = 1,
+    NetworkError = 2,
+    UninstallNotApplicable = 3,
+    Error = 4,
+  }
+
+  interface IStoreAcquireLicenseResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly StorePackageLicense: Windows.Services.Store.StorePackageLicense;
+  }
+  var IStoreAcquireLicenseResult: abstract new (...args: any[]) => IStoreAcquireLicenseResult;
+
+  interface IStoreAppLicense {
+    readonly AddOnLicenses: Windows.Foundation.Collections.IMapView<string, Windows.Services.Store.StoreLicense>;
+    readonly ExpirationDate: Windows.Foundation.DateTime;
+    readonly ExtendedJsonData: string;
+    readonly IsActive: boolean;
+    readonly IsTrial: boolean;
+    readonly IsTrialOwnedByThisUser: boolean;
+    readonly SkuStoreId: string;
+    readonly TrialTimeRemaining: Windows.Foundation.TimeSpan;
+    readonly TrialUniqueId: string;
+  }
+  var IStoreAppLicense: abstract new (...args: any[]) => IStoreAppLicense;
+
+  interface IStoreAppLicense2 {
+    readonly IsDiscLicense: boolean;
+  }
+  var IStoreAppLicense2: abstract new (...args: any[]) => IStoreAppLicense2;
+
+  interface IStoreAvailability {
+    RequestPurchaseAsync(): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StorePurchaseResult>;
+    RequestPurchaseAsync(storePurchaseProperties: Windows.Services.Store.StorePurchaseProperties): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StorePurchaseResult>;
+    readonly EndDate: Windows.Foundation.DateTime;
+    readonly ExtendedJsonData: string;
+    readonly Price: Windows.Services.Store.StorePrice;
+    readonly StoreId: string;
+  }
+  var IStoreAvailability: abstract new (...args: any[]) => IStoreAvailability;
+
+  interface IStoreCanAcquireLicenseResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly LicensableSku: string;
+    readonly Status: number;
+  }
+  var IStoreCanAcquireLicenseResult: abstract new (...args: any[]) => IStoreCanAcquireLicenseResult;
+
+  interface IStoreCollectionData {
+    readonly AcquiredDate: Windows.Foundation.DateTime;
+    readonly CampaignId: string;
+    readonly DeveloperOfferId: string;
+    readonly EndDate: Windows.Foundation.DateTime;
+    readonly ExtendedJsonData: string;
+    readonly IsTrial: boolean;
+    readonly StartDate: Windows.Foundation.DateTime;
+    readonly TrialTimeRemaining: Windows.Foundation.TimeSpan;
+  }
+  var IStoreCollectionData: abstract new (...args: any[]) => IStoreCollectionData;
+
+  interface IStoreConsumableResult {
+    readonly BalanceRemaining: number;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+    readonly TrackingId: Guid;
+  }
+  var IStoreConsumableResult: abstract new (...args: any[]) => IStoreConsumableResult;
+
+  interface IStoreContext {
+    AcquireStoreLicenseForOptionalPackageAsync(optionalPackage: Windows.ApplicationModel.Package): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreAcquireLicenseResult>;
+    GetAppAndOptionalStorePackageUpdatesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StorePackageUpdate> | Windows.Services.Store.StorePackageUpdate[]>;
+    GetAppLicenseAsync(): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreAppLicense>;
+    GetAssociatedStoreProductsAsync(productKinds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductQueryResult>;
+    GetAssociatedStoreProductsWithPagingAsync(productKinds: Windows.Foundation.Collections.IIterable<string> | string[], maxItemsToRetrievePerPage: number): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductPagedQueryResult>;
+    GetConsumableBalanceRemainingAsync(productStoreId: string): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreConsumableResult>;
+    GetCustomerCollectionsIdAsync(serviceTicket: string, publisherUserId: string): Windows.Foundation.IAsyncOperation<string>;
+    GetCustomerPurchaseIdAsync(serviceTicket: string, publisherUserId: string): Windows.Foundation.IAsyncOperation<string>;
+    GetStoreProductForCurrentAppAsync(): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductResult>;
+    GetStoreProductsAsync(productKinds: Windows.Foundation.Collections.IIterable<string> | string[], storeIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductQueryResult>;
+    GetUserCollectionAsync(productKinds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductQueryResult>;
+    GetUserCollectionWithPagingAsync(productKinds: Windows.Foundation.Collections.IIterable<string> | string[], maxItemsToRetrievePerPage: number): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductPagedQueryResult>;
+    ReportConsumableFulfillmentAsync(productStoreId: string, quantity: number, trackingId: Guid): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreConsumableResult>;
+    RequestDownloadAndInstallStorePackageUpdatesAsync(storePackageUpdates: Windows.Foundation.Collections.IIterable<Windows.Services.Store.StorePackageUpdate> | Windows.Services.Store.StorePackageUpdate[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Services.Store.StorePackageUpdateResult, Windows.Services.Store.StorePackageUpdateStatus>;
+    RequestDownloadAndInstallStorePackagesAsync(storeIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Services.Store.StorePackageUpdateResult, Windows.Services.Store.StorePackageUpdateStatus>;
+    RequestDownloadStorePackageUpdatesAsync(storePackageUpdates: Windows.Foundation.Collections.IIterable<Windows.Services.Store.StorePackageUpdate> | Windows.Services.Store.StorePackageUpdate[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Services.Store.StorePackageUpdateResult, Windows.Services.Store.StorePackageUpdateStatus>;
+    RequestPurchaseAsync(storeId: string): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StorePurchaseResult>;
+    RequestPurchaseAsync(storeId: string, storePurchaseProperties: Windows.Services.Store.StorePurchaseProperties): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StorePurchaseResult>;
+    readonly User: Windows.System.User;
+    OfflineLicensesChanged: Windows.Foundation.TypedEventHandler<Windows.Services.Store.StoreContext, Object> | null;
+  }
+  var IStoreContext: abstract new (...args: any[]) => IStoreContext;
+
+  interface IStoreContext2 {
+    FindStoreProductForPackageAsync(productKinds: Windows.Foundation.Collections.IIterable<string> | string[], package_: Windows.ApplicationModel.Package): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductResult>;
+  }
+  var IStoreContext2: abstract new (...args: any[]) => IStoreContext2;
+
+  interface IStoreContext3 {
+    CanAcquireStoreLicenseAsync(productStoreId: string): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreCanAcquireLicenseResult>;
+    CanAcquireStoreLicenseForOptionalPackageAsync(optionalPackage: Windows.ApplicationModel.Package): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreCanAcquireLicenseResult>;
+    DownloadAndInstallStorePackagesAsync(storeIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Services.Store.StorePackageUpdateResult, Windows.Services.Store.StorePackageUpdateStatus>;
+    GetAssociatedStoreQueueItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreQueueItem> | Windows.Services.Store.StoreQueueItem[]>;
+    GetStoreProductsAsync(productKinds: Windows.Foundation.Collections.IIterable<string> | string[], storeIds: Windows.Foundation.Collections.IIterable<string> | string[], storeProductOptions: Windows.Services.Store.StoreProductOptions): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductQueryResult>;
+    GetStoreQueueItemsAsync(storeIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreQueueItem> | Windows.Services.Store.StoreQueueItem[]>;
+    RequestDownloadAndInstallStorePackagesAsync(storeIds: Windows.Foundation.Collections.IIterable<string> | string[], storePackageInstallOptions: Windows.Services.Store.StorePackageInstallOptions): Windows.Foundation.IAsyncOperationWithProgress<Windows.Services.Store.StorePackageUpdateResult, Windows.Services.Store.StorePackageUpdateStatus>;
+    RequestUninstallStorePackageAsync(package_: Windows.ApplicationModel.Package): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreUninstallStorePackageResult>;
+    RequestUninstallStorePackageByStoreIdAsync(storeId: string): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreUninstallStorePackageResult>;
+    TrySilentDownloadAndInstallStorePackageUpdatesAsync(storePackageUpdates: Windows.Foundation.Collections.IIterable<Windows.Services.Store.StorePackageUpdate> | Windows.Services.Store.StorePackageUpdate[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Services.Store.StorePackageUpdateResult, Windows.Services.Store.StorePackageUpdateStatus>;
+    TrySilentDownloadStorePackageUpdatesAsync(storePackageUpdates: Windows.Foundation.Collections.IIterable<Windows.Services.Store.StorePackageUpdate> | Windows.Services.Store.StorePackageUpdate[]): Windows.Foundation.IAsyncOperationWithProgress<Windows.Services.Store.StorePackageUpdateResult, Windows.Services.Store.StorePackageUpdateStatus>;
+    UninstallStorePackageAsync(package_: Windows.ApplicationModel.Package): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreUninstallStorePackageResult>;
+    UninstallStorePackageByStoreIdAsync(storeId: string): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreUninstallStorePackageResult>;
+    readonly CanSilentlyDownloadStorePackageUpdates: boolean;
+  }
+  var IStoreContext3: abstract new (...args: any[]) => IStoreContext3;
+
+  interface IStoreContext4 {
+    RequestRateAndReviewAppAsync(): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreRateAndReviewResult>;
+    SetInstallOrderForAssociatedStoreQueueItemsAsync(items: Windows.Foundation.Collections.IIterable<Windows.Services.Store.StoreQueueItem> | Windows.Services.Store.StoreQueueItem[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreQueueItem> | Windows.Services.Store.StoreQueueItem[]>;
+  }
+  var IStoreContext4: abstract new (...args: any[]) => IStoreContext4;
+
+  interface IStoreContext5 {
+    GetAssociatedStoreProductsByInAppOfferTokenAsync(inAppOfferTokens: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductQueryResult>;
+    GetUserPurchaseHistoryAsync(productKinds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductQueryResult>;
+    RequestPurchaseByInAppOfferTokenAsync(inAppOfferToken: string): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StorePurchaseResult>;
+  }
+  var IStoreContext5: abstract new (...args: any[]) => IStoreContext5;
+
+  interface IStoreContextStatics {
+    GetDefault(): Windows.Services.Store.StoreContext;
+    GetForUser(user: Windows.System.User): Windows.Services.Store.StoreContext;
+  }
+  var IStoreContextStatics: abstract new (...args: any[]) => IStoreContextStatics;
+
+  interface IStoreImage {
+    readonly Caption: string;
+    readonly Height: number;
+    readonly ImagePurposeTag: string;
+    readonly Uri: Windows.Foundation.Uri;
+    readonly Width: number;
+  }
+  var IStoreImage: abstract new (...args: any[]) => IStoreImage;
+
+  interface IStoreLicense {
+    readonly ExpirationDate: Windows.Foundation.DateTime;
+    readonly ExtendedJsonData: string;
+    readonly InAppOfferToken: string;
+    readonly IsActive: boolean;
+    readonly SkuStoreId: string;
+  }
+  var IStoreLicense: abstract new (...args: any[]) => IStoreLicense;
+
+  interface IStorePackageInstallOptions {
+    AllowForcedAppRestart: boolean;
+  }
+  var IStorePackageInstallOptions: abstract new (...args: any[]) => IStorePackageInstallOptions;
+
+  interface IStorePackageLicense extends Windows.Foundation.IClosable {
+    Close(): void;
+    ReleaseLicense(): void;
+    readonly IsValid: boolean;
+    readonly Package: Windows.ApplicationModel.Package;
+    LicenseLost: Windows.Foundation.TypedEventHandler<Windows.Services.Store.StorePackageLicense, Object> | null;
+  }
+  var IStorePackageLicense: abstract new (...args: any[]) => IStorePackageLicense;
+
+  interface IStorePackageUpdate {
+    readonly Mandatory: boolean;
+    readonly Package: Windows.ApplicationModel.Package;
+  }
+  var IStorePackageUpdate: abstract new (...args: any[]) => IStorePackageUpdate;
+
+  interface IStorePackageUpdateResult {
+    readonly OverallState: number;
+    readonly StorePackageUpdateStatuses: Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StorePackageUpdateStatus> | Windows.Services.Store.StorePackageUpdateStatus[];
+  }
+  var IStorePackageUpdateResult: abstract new (...args: any[]) => IStorePackageUpdateResult;
+
+  interface IStorePackageUpdateResult2 {
+    readonly StoreQueueItems: Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreQueueItem> | Windows.Services.Store.StoreQueueItem[];
+  }
+  var IStorePackageUpdateResult2: abstract new (...args: any[]) => IStorePackageUpdateResult2;
+
+  interface IStorePrice {
+    readonly CurrencyCode: string;
+    readonly FormattedBasePrice: string;
+    readonly FormattedPrice: string;
+    readonly FormattedRecurrencePrice: string;
+    readonly IsOnSale: boolean;
+    readonly SaleEndDate: Windows.Foundation.DateTime;
+  }
+  var IStorePrice: abstract new (...args: any[]) => IStorePrice;
+
+  interface IStorePrice2 {
+    readonly UnformattedBasePrice: string;
+    readonly UnformattedPrice: string;
+    readonly UnformattedRecurrencePrice: string;
+  }
+  var IStorePrice2: abstract new (...args: any[]) => IStorePrice2;
+
+  interface IStoreProduct {
+    GetIsAnySkuInstalledAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestPurchaseAsync(): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StorePurchaseResult>;
+    RequestPurchaseAsync(storePurchaseProperties: Windows.Services.Store.StorePurchaseProperties): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StorePurchaseResult>;
+    readonly Description: string;
+    readonly ExtendedJsonData: string;
+    readonly HasDigitalDownload: boolean;
+    readonly Images: Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreImage> | Windows.Services.Store.StoreImage[];
+    readonly InAppOfferToken: string;
+    readonly IsInUserCollection: boolean;
+    readonly Keywords: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Language: string;
+    readonly LinkUri: Windows.Foundation.Uri;
+    readonly Price: Windows.Services.Store.StorePrice;
+    readonly ProductKind: string;
+    readonly Skus: Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreSku> | Windows.Services.Store.StoreSku[];
+    readonly StoreId: string;
+    readonly Title: string;
+    readonly Videos: Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreVideo> | Windows.Services.Store.StoreVideo[];
+  }
+  var IStoreProduct: abstract new (...args: any[]) => IStoreProduct;
+
+  interface IStoreProductOptions {
+    readonly ActionFilters: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var IStoreProductOptions: abstract new (...args: any[]) => IStoreProductOptions;
+
+  interface IStoreProductPagedQueryResult {
+    GetNextAsync(): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreProductPagedQueryResult>;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly HasMoreResults: boolean;
+    readonly Products: Windows.Foundation.Collections.IMapView<string, Windows.Services.Store.StoreProduct>;
+  }
+  var IStoreProductPagedQueryResult: abstract new (...args: any[]) => IStoreProductPagedQueryResult;
+
+  interface IStoreProductQueryResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Products: Windows.Foundation.Collections.IMapView<string, Windows.Services.Store.StoreProduct>;
+  }
+  var IStoreProductQueryResult: abstract new (...args: any[]) => IStoreProductQueryResult;
+
+  interface IStoreProductResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Product: Windows.Services.Store.StoreProduct;
+  }
+  var IStoreProductResult: abstract new (...args: any[]) => IStoreProductResult;
+
+  interface IStorePurchaseProperties {
+    ExtendedJsonData: string;
+    Name: string;
+  }
+  var IStorePurchaseProperties: abstract new (...args: any[]) => IStorePurchaseProperties;
+
+  interface IStorePurchasePropertiesFactory {
+    Create(name: string): Windows.Services.Store.StorePurchaseProperties;
+  }
+  var IStorePurchasePropertiesFactory: abstract new (...args: any[]) => IStorePurchasePropertiesFactory;
+
+  interface IStorePurchaseResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+  var IStorePurchaseResult: abstract new (...args: any[]) => IStorePurchaseResult;
+
+  interface IStoreQueueItem {
+    GetCurrentStatus(): Windows.Services.Store.StoreQueueItemStatus;
+    readonly InstallKind: number;
+    readonly PackageFamilyName: string;
+    readonly ProductId: string;
+    Completed: Windows.Foundation.TypedEventHandler<Windows.Services.Store.StoreQueueItem, Windows.Services.Store.StoreQueueItemCompletedEventArgs> | null;
+    StatusChanged: Windows.Foundation.TypedEventHandler<Windows.Services.Store.StoreQueueItem, Object> | null;
+  }
+  var IStoreQueueItem: abstract new (...args: any[]) => IStoreQueueItem;
+
+  interface IStoreQueueItem2 {
+    CancelInstallAsync(): Windows.Foundation.IAsyncAction;
+    PauseInstallAsync(): Windows.Foundation.IAsyncAction;
+    ResumeInstallAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var IStoreQueueItem2: abstract new (...args: any[]) => IStoreQueueItem2;
+
+  interface IStoreQueueItemCompletedEventArgs {
+    readonly Status: Windows.Services.Store.StoreQueueItemStatus;
+  }
+  var IStoreQueueItemCompletedEventArgs: abstract new (...args: any[]) => IStoreQueueItemCompletedEventArgs;
+
+  interface IStoreQueueItemStatus {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly PackageInstallExtendedState: number;
+    readonly PackageInstallState: number;
+    readonly UpdateStatus: Windows.Services.Store.StorePackageUpdateStatus;
+  }
+  var IStoreQueueItemStatus: abstract new (...args: any[]) => IStoreQueueItemStatus;
+
+  interface IStoreRateAndReviewResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly ExtendedJsonData: string;
+    readonly Status: number;
+    readonly WasUpdated: boolean;
+  }
+  var IStoreRateAndReviewResult: abstract new (...args: any[]) => IStoreRateAndReviewResult;
+
+  interface IStoreRequestHelperStatics {
+    SendRequestAsync(context: Windows.Services.Store.StoreContext, requestKind: number, parametersAsJson: string): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StoreSendRequestResult>;
+  }
+  var IStoreRequestHelperStatics: abstract new (...args: any[]) => IStoreRequestHelperStatics;
+
+  interface IStoreSendRequestResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Response: string;
+  }
+  var IStoreSendRequestResult: abstract new (...args: any[]) => IStoreSendRequestResult;
+
+  interface IStoreSendRequestResult2 {
+    readonly HttpStatusCode: number;
+  }
+  var IStoreSendRequestResult2: abstract new (...args: any[]) => IStoreSendRequestResult2;
+
+  interface IStoreSku {
+    GetIsInstalledAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestPurchaseAsync(): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StorePurchaseResult>;
+    RequestPurchaseAsync(storePurchaseProperties: Windows.Services.Store.StorePurchaseProperties): Windows.Foundation.IAsyncOperation<Windows.Services.Store.StorePurchaseResult>;
+    readonly Availabilities: Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreAvailability> | Windows.Services.Store.StoreAvailability[];
+    readonly BundledSkus: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly CollectionData: Windows.Services.Store.StoreCollectionData;
+    readonly CustomDeveloperData: string;
+    readonly Description: string;
+    readonly ExtendedJsonData: string;
+    readonly Images: Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreImage> | Windows.Services.Store.StoreImage[];
+    readonly IsInUserCollection: boolean;
+    readonly IsSubscription: boolean;
+    readonly IsTrial: boolean;
+    readonly Language: string;
+    readonly Price: Windows.Services.Store.StorePrice;
+    readonly StoreId: string;
+    readonly SubscriptionInfo: Windows.Services.Store.StoreSubscriptionInfo;
+    readonly Title: string;
+    readonly Videos: Windows.Foundation.Collections.IVectorView<Windows.Services.Store.StoreVideo> | Windows.Services.Store.StoreVideo[];
+  }
+  var IStoreSku: abstract new (...args: any[]) => IStoreSku;
+
+  interface IStoreSubscriptionInfo {
+    readonly BillingPeriod: number;
+    readonly BillingPeriodUnit: number;
+    readonly HasTrialPeriod: boolean;
+    readonly TrialPeriod: number;
+    readonly TrialPeriodUnit: number;
+  }
+  var IStoreSubscriptionInfo: abstract new (...args: any[]) => IStoreSubscriptionInfo;
+
+  interface IStoreUninstallStorePackageResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+  var IStoreUninstallStorePackageResult: abstract new (...args: any[]) => IStoreUninstallStorePackageResult;
+
+  interface IStoreVideo {
+    readonly Caption: string;
+    readonly Height: number;
+    readonly PreviewImage: Windows.Services.Store.StoreImage;
+    readonly Uri: Windows.Foundation.Uri;
+    readonly VideoPurposeTag: string;
+    readonly Width: number;
+  }
+  var IStoreVideo: abstract new (...args: any[]) => IStoreVideo;
+
+  interface StoreContract {
+  }
+  var StoreContract: {
+    new(fields: {  }): StoreContract;
+  };
+
+  interface StorePackageUpdateStatus {
+    PackageFamilyName: string;
+    PackageDownloadSizeInBytes: number | bigint;
+    PackageBytesDownloaded: number | bigint;
+    PackageDownloadProgress: number;
+    TotalDownloadProgress: number;
+    PackageUpdateState: number;
+  }
+  var StorePackageUpdateStatus: {
+    new(packageFamilyName: string, packageDownloadSizeInBytes: number | bigint, packageBytesDownloaded: number | bigint, packageDownloadProgress: number, totalDownloadProgress: number, packageUpdateState: number): StorePackageUpdateStatus;
+    new(fields: { PackageFamilyName?: string; PackageDownloadSizeInBytes?: number | bigint; PackageBytesDownloaded?: number | bigint; PackageDownloadProgress?: number; TotalDownloadProgress?: number; PackageUpdateState?: number }): StorePackageUpdateStatus;
+  };
+
+}
+
+declare namespace Windows.Services.TargetedContent {
+  class TargetedContentAction implements Windows.Services.TargetedContent.ITargetedContentAction {
+    InvokeAsync(): Windows.Foundation.IAsyncAction;
+  }
+
+  class TargetedContentAvailabilityChangedEventArgs implements Windows.Services.TargetedContent.ITargetedContentAvailabilityChangedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+
+  class TargetedContentChangedEventArgs implements Windows.Services.TargetedContent.ITargetedContentChangedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly HasPreviousContentExpired: boolean;
+  }
+
+  class TargetedContentCollection implements Windows.Services.TargetedContent.ITargetedContentCollection {
+    ReportCustomInteraction(customInteractionName: string): void;
+    ReportInteraction(interaction: number): void;
+    readonly Collections: Windows.Foundation.Collections.IVectorView<Windows.Services.TargetedContent.TargetedContentCollection> | Windows.Services.TargetedContent.TargetedContentCollection[];
+    readonly Id: string;
+    readonly Items: Windows.Foundation.Collections.IVectorView<Windows.Services.TargetedContent.TargetedContentItem> | Windows.Services.TargetedContent.TargetedContentItem[];
+    readonly Path: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Windows.Services.TargetedContent.TargetedContentValue>;
+  }
+
+  class TargetedContentContainer implements Windows.Services.TargetedContent.ITargetedContentContainer {
+    static GetAsync(contentId: string): Windows.Foundation.IAsyncOperation<Windows.Services.TargetedContent.TargetedContentContainer>;
+    SelectSingleObject(path: string): Windows.Services.TargetedContent.TargetedContentObject;
+    readonly Availability: number;
+    readonly Content: Windows.Services.TargetedContent.TargetedContentCollection;
+    readonly Id: string;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class TargetedContentFile implements Windows.Storage.Streams.IRandomAccessStreamReference {
+    OpenReadAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamWithContentType>;
+  }
+
+  class TargetedContentImage implements Windows.Services.TargetedContent.ITargetedContentImage, Windows.Storage.Streams.IRandomAccessStreamReference {
+    OpenReadAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamWithContentType>;
+    readonly Height: number;
+    readonly Width: number;
+  }
+
+  class TargetedContentItem implements Windows.Services.TargetedContent.ITargetedContentItem {
+    ReportCustomInteraction(customInteractionName: string): void;
+    ReportInteraction(interaction: number): void;
+    readonly Collections: Windows.Foundation.Collections.IVectorView<Windows.Services.TargetedContent.TargetedContentCollection> | Windows.Services.TargetedContent.TargetedContentCollection[];
+    readonly Path: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Windows.Services.TargetedContent.TargetedContentValue>;
+    readonly State: Windows.Services.TargetedContent.TargetedContentItemState;
+  }
+
+  class TargetedContentItemState implements Windows.Services.TargetedContent.ITargetedContentItemState {
+    readonly AppInstallationState: number;
+    readonly ShouldDisplay: boolean;
+  }
+
+  class TargetedContentObject implements Windows.Services.TargetedContent.ITargetedContentObject {
+    readonly Collection: Windows.Services.TargetedContent.TargetedContentCollection;
+    readonly Item: Windows.Services.TargetedContent.TargetedContentItem;
+    readonly ObjectKind: number;
+    readonly Value: Windows.Services.TargetedContent.TargetedContentValue;
+  }
+
+  class TargetedContentStateChangedEventArgs implements Windows.Services.TargetedContent.ITargetedContentStateChangedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+
+  class TargetedContentSubscription implements Windows.Services.TargetedContent.ITargetedContentSubscription {
+    static GetAsync(subscriptionId: string): Windows.Foundation.IAsyncOperation<Windows.Services.TargetedContent.TargetedContentSubscription>;
+    GetContentContainerAsync(): Windows.Foundation.IAsyncOperation<Windows.Services.TargetedContent.TargetedContentContainer>;
+    static GetOptions(subscriptionId: string): Windows.Services.TargetedContent.TargetedContentSubscriptionOptions;
+    readonly Id: string;
+    AvailabilityChanged: Windows.Foundation.TypedEventHandler<Windows.Services.TargetedContent.TargetedContentSubscription, Windows.Services.TargetedContent.TargetedContentAvailabilityChangedEventArgs> | null;
+    ContentChanged: Windows.Foundation.TypedEventHandler<Windows.Services.TargetedContent.TargetedContentSubscription, Windows.Services.TargetedContent.TargetedContentChangedEventArgs> | null;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Services.TargetedContent.TargetedContentSubscription, Windows.Services.TargetedContent.TargetedContentStateChangedEventArgs> | null;
+  }
+
+  class TargetedContentSubscriptionOptions implements Windows.Services.TargetedContent.ITargetedContentSubscriptionOptions {
+    Update(): void;
+    AllowPartialContentAvailability: boolean;
+    readonly CloudQueryParameters: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    readonly LocalFilters: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly SubscriptionId: string;
+  }
+
+  class TargetedContentValue implements Windows.Services.TargetedContent.ITargetedContentValue {
+    readonly Action: Windows.Services.TargetedContent.TargetedContentAction;
+    readonly Actions: Windows.Foundation.Collections.IVectorView<Windows.Services.TargetedContent.TargetedContentAction> | Windows.Services.TargetedContent.TargetedContentAction[];
+    readonly Boolean: boolean;
+    readonly Booleans: Windows.Foundation.Collections.IVectorView<boolean> | boolean[];
+    readonly File: Windows.Services.TargetedContent.TargetedContentFile;
+    readonly Files: Windows.Foundation.Collections.IVectorView<Windows.Services.TargetedContent.TargetedContentFile> | Windows.Services.TargetedContent.TargetedContentFile[];
+    readonly ImageFile: Windows.Services.TargetedContent.TargetedContentImage;
+    readonly ImageFiles: Windows.Foundation.Collections.IVectorView<Windows.Services.TargetedContent.TargetedContentImage> | Windows.Services.TargetedContent.TargetedContentImage[];
+    readonly Number: number;
+    readonly Numbers: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Path: string;
+    readonly String: string;
+    readonly Strings: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Uri: Windows.Foundation.Uri;
+    readonly Uris: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly ValueKind: number;
+  }
+
+  enum TargetedContentAppInstallationState {
+    NotApplicable = 0,
+    NotInstalled = 1,
+    Installed = 2,
+  }
+
+  enum TargetedContentAvailability {
+    None = 0,
+    Partial = 1,
+    All = 2,
+  }
+
+  enum TargetedContentInteraction {
+    Impression = 0,
+    ClickThrough = 1,
+    Hover = 2,
+    Like = 3,
+    Dislike = 4,
+    Dismiss = 5,
+    Ineligible = 6,
+    Accept = 7,
+    Decline = 8,
+    Defer = 9,
+    Canceled = 10,
+    Conversion = 11,
+    Opportunity = 12,
+  }
+
+  enum TargetedContentObjectKind {
+    Collection = 0,
+    Item = 1,
+    Value = 2,
+  }
+
+  enum TargetedContentValueKind {
+    String = 0,
+    Uri = 1,
+    Number = 2,
+    Boolean = 3,
+    File = 4,
+    ImageFile = 5,
+    Action = 6,
+    Strings = 7,
+    Uris = 8,
+    Numbers = 9,
+    Booleans = 10,
+    Files = 11,
+    ImageFiles = 12,
+    Actions = 13,
+  }
+
+  interface ITargetedContentAction {
+    InvokeAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var ITargetedContentAction: abstract new (...args: any[]) => ITargetedContentAction;
+
+  interface ITargetedContentAvailabilityChangedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+  var ITargetedContentAvailabilityChangedEventArgs: abstract new (...args: any[]) => ITargetedContentAvailabilityChangedEventArgs;
+
+  interface ITargetedContentChangedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly HasPreviousContentExpired: boolean;
+  }
+  var ITargetedContentChangedEventArgs: abstract new (...args: any[]) => ITargetedContentChangedEventArgs;
+
+  interface ITargetedContentCollection {
+    ReportCustomInteraction(customInteractionName: string): void;
+    ReportInteraction(interaction: number): void;
+    readonly Collections: Windows.Foundation.Collections.IVectorView<Windows.Services.TargetedContent.TargetedContentCollection> | Windows.Services.TargetedContent.TargetedContentCollection[];
+    readonly Id: string;
+    readonly Items: Windows.Foundation.Collections.IVectorView<Windows.Services.TargetedContent.TargetedContentItem> | Windows.Services.TargetedContent.TargetedContentItem[];
+    readonly Path: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Windows.Services.TargetedContent.TargetedContentValue>;
+  }
+  var ITargetedContentCollection: abstract new (...args: any[]) => ITargetedContentCollection;
+
+  interface ITargetedContentContainer {
+    SelectSingleObject(path: string): Windows.Services.TargetedContent.TargetedContentObject;
+    readonly Availability: number;
+    readonly Content: Windows.Services.TargetedContent.TargetedContentCollection;
+    readonly Id: string;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var ITargetedContentContainer: abstract new (...args: any[]) => ITargetedContentContainer;
+
+  interface ITargetedContentContainerStatics {
+    GetAsync(contentId: string): Windows.Foundation.IAsyncOperation<Windows.Services.TargetedContent.TargetedContentContainer>;
+  }
+  var ITargetedContentContainerStatics: abstract new (...args: any[]) => ITargetedContentContainerStatics;
+
+  interface ITargetedContentImage extends Windows.Storage.Streams.IRandomAccessStreamReference {
+    OpenReadAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamWithContentType>;
+    readonly Height: number;
+    readonly Width: number;
+  }
+  var ITargetedContentImage: abstract new (...args: any[]) => ITargetedContentImage;
+
+  interface ITargetedContentItem {
+    ReportCustomInteraction(customInteractionName: string): void;
+    ReportInteraction(interaction: number): void;
+    readonly Collections: Windows.Foundation.Collections.IVectorView<Windows.Services.TargetedContent.TargetedContentCollection> | Windows.Services.TargetedContent.TargetedContentCollection[];
+    readonly Path: string;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Windows.Services.TargetedContent.TargetedContentValue>;
+    readonly State: Windows.Services.TargetedContent.TargetedContentItemState;
+  }
+  var ITargetedContentItem: abstract new (...args: any[]) => ITargetedContentItem;
+
+  interface ITargetedContentItemState {
+    readonly AppInstallationState: number;
+    readonly ShouldDisplay: boolean;
+  }
+  var ITargetedContentItemState: abstract new (...args: any[]) => ITargetedContentItemState;
+
+  interface ITargetedContentObject {
+    readonly Collection: Windows.Services.TargetedContent.TargetedContentCollection;
+    readonly Item: Windows.Services.TargetedContent.TargetedContentItem;
+    readonly ObjectKind: number;
+    readonly Value: Windows.Services.TargetedContent.TargetedContentValue;
+  }
+  var ITargetedContentObject: abstract new (...args: any[]) => ITargetedContentObject;
+
+  interface ITargetedContentStateChangedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+  var ITargetedContentStateChangedEventArgs: abstract new (...args: any[]) => ITargetedContentStateChangedEventArgs;
+
+  interface ITargetedContentSubscription {
+    GetContentContainerAsync(): Windows.Foundation.IAsyncOperation<Windows.Services.TargetedContent.TargetedContentContainer>;
+    readonly Id: string;
+    AvailabilityChanged: Windows.Foundation.TypedEventHandler<Windows.Services.TargetedContent.TargetedContentSubscription, Windows.Services.TargetedContent.TargetedContentAvailabilityChangedEventArgs> | null;
+    ContentChanged: Windows.Foundation.TypedEventHandler<Windows.Services.TargetedContent.TargetedContentSubscription, Windows.Services.TargetedContent.TargetedContentChangedEventArgs> | null;
+    StateChanged: Windows.Foundation.TypedEventHandler<Windows.Services.TargetedContent.TargetedContentSubscription, Windows.Services.TargetedContent.TargetedContentStateChangedEventArgs> | null;
+  }
+  var ITargetedContentSubscription: abstract new (...args: any[]) => ITargetedContentSubscription;
+
+  interface ITargetedContentSubscriptionOptions {
+    Update(): void;
+    AllowPartialContentAvailability: boolean;
+    readonly CloudQueryParameters: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    readonly LocalFilters: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly SubscriptionId: string;
+  }
+  var ITargetedContentSubscriptionOptions: abstract new (...args: any[]) => ITargetedContentSubscriptionOptions;
+
+  interface ITargetedContentSubscriptionStatics {
+    GetAsync(subscriptionId: string): Windows.Foundation.IAsyncOperation<Windows.Services.TargetedContent.TargetedContentSubscription>;
+    GetOptions(subscriptionId: string): Windows.Services.TargetedContent.TargetedContentSubscriptionOptions;
+  }
+  var ITargetedContentSubscriptionStatics: abstract new (...args: any[]) => ITargetedContentSubscriptionStatics;
+
+  interface ITargetedContentValue {
+    readonly Action: Windows.Services.TargetedContent.TargetedContentAction;
+    readonly Actions: Windows.Foundation.Collections.IVectorView<Windows.Services.TargetedContent.TargetedContentAction> | Windows.Services.TargetedContent.TargetedContentAction[];
+    readonly Boolean: boolean;
+    readonly Booleans: Windows.Foundation.Collections.IVectorView<boolean> | boolean[];
+    readonly File: Windows.Services.TargetedContent.TargetedContentFile;
+    readonly Files: Windows.Foundation.Collections.IVectorView<Windows.Services.TargetedContent.TargetedContentFile> | Windows.Services.TargetedContent.TargetedContentFile[];
+    readonly ImageFile: Windows.Services.TargetedContent.TargetedContentImage;
+    readonly ImageFiles: Windows.Foundation.Collections.IVectorView<Windows.Services.TargetedContent.TargetedContentImage> | Windows.Services.TargetedContent.TargetedContentImage[];
+    readonly Number: number;
+    readonly Numbers: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Path: string;
+    readonly String: string;
+    readonly Strings: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Uri: Windows.Foundation.Uri;
+    readonly Uris: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly ValueKind: number;
+  }
+  var ITargetedContentValue: abstract new (...args: any[]) => ITargetedContentValue;
+
+  interface TargetedContentContract {
+  }
+  var TargetedContentContract: {
+    new(fields: {  }): TargetedContentContract;
+  };
+
+}
+
+declare namespace Windows.Storage {
+  class AppDataPaths implements Windows.Storage.IAppDataPaths {
+    static GetDefault(): Windows.Storage.AppDataPaths;
+    static GetForUser(user: Windows.System.User): Windows.Storage.AppDataPaths;
+    readonly Cookies: string;
+    readonly Desktop: string;
+    readonly Documents: string;
+    readonly Favorites: string;
+    readonly History: string;
+    readonly InternetCache: string;
+    readonly LocalAppData: string;
+    readonly ProgramData: string;
+    readonly RoamingAppData: string;
+  }
+
+  class ApplicationData implements Windows.Foundation.IClosable, Windows.Storage.IApplicationData, Windows.Storage.IApplicationData2, Windows.Storage.IApplicationData3 {
+    ClearAsync(): Windows.Foundation.IAsyncAction;
+    ClearAsync(locality: number): Windows.Foundation.IAsyncAction;
+    ClearPublisherCacheFolderAsync(folderName: string): Windows.Foundation.IAsyncAction;
+    Close(): void;
+    static GetForUserAsync(user: Windows.System.User): Windows.Foundation.IAsyncOperation<Windows.Storage.ApplicationData>;
+    GetPublisherCacheFolder(folderName: string): Windows.Storage.StorageFolder;
+    SetVersionAsync(desiredVersion: number, handler: Windows.Storage.ApplicationDataSetVersionHandler): Windows.Foundation.IAsyncAction;
+    SignalDataChanged(): void;
+    static readonly Current: Windows.Storage.ApplicationData;
+    readonly LocalCacheFolder: Windows.Storage.StorageFolder;
+    readonly LocalFolder: Windows.Storage.StorageFolder;
+    readonly LocalSettings: Windows.Storage.ApplicationDataContainer;
+    readonly RoamingFolder: Windows.Storage.StorageFolder;
+    readonly RoamingSettings: Windows.Storage.ApplicationDataContainer;
+    readonly RoamingStorageQuota: number | bigint;
+    readonly SharedLocalFolder: Windows.Storage.StorageFolder;
+    readonly TemporaryFolder: Windows.Storage.StorageFolder;
+    readonly Version: number;
+    DataChanged: Windows.Foundation.TypedEventHandler<Windows.Storage.ApplicationData, Object> | null;
+  }
+
+  class ApplicationDataCompositeValue implements Windows.Foundation.Collections.IPropertySet {
+    constructor();
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, Object>>;
+    GetView(): Windows.Foundation.Collections.IMapView<string, Object>;
+    HasKey(key: string): boolean;
+    Insert(key: string, value: Object): boolean;
+    Lookup(key: string): Object;
+    Remove(key: string): void;
+    readonly Size: number;
+    MapChanged: Windows.Foundation.Collections.MapChangedEventHandler<string, Object> | null;
+  }
+
+  class ApplicationDataContainer implements Windows.Foundation.IClosable, Windows.Storage.IApplicationDataContainer {
+    Close(): void;
+    CreateContainer(name: string, disposition: number): Windows.Storage.ApplicationDataContainer;
+    DeleteContainer(name: string): void;
+    readonly Containers: Windows.Foundation.Collections.IMapView<string, Windows.Storage.ApplicationDataContainer>;
+    readonly Locality: number;
+    readonly Name: string;
+    readonly Values: Windows.Foundation.Collections.IPropertySet;
+  }
+
+  class ApplicationDataContainerSettings implements Windows.Foundation.Collections.IPropertySet {
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, Object>>;
+    GetView(): Windows.Foundation.Collections.IMapView<string, Object>;
+    HasKey(key: string): boolean;
+    Insert(key: string, value: Object): boolean;
+    Lookup(key: string): Object;
+    Remove(key: string): void;
+    readonly Size: number;
+    MapChanged: Windows.Foundation.Collections.MapChangedEventHandler<string, Object> | null;
+  }
+
+  class CachedFileManager {
+    static CompleteUpdatesAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<number>;
+    static DeferUpdates(file: Windows.Storage.IStorageFile): void;
+  }
+
+  class DownloadsFolder {
+    static CreateFileAsync(desiredName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    static CreateFileAsync(desiredName: string, option: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    static CreateFileForUserAsync(user: Windows.System.User, desiredName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    static CreateFileForUserAsync(user: Windows.System.User, desiredName: string, option: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    static CreateFolderAsync(desiredName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    static CreateFolderAsync(desiredName: string, option: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    static CreateFolderForUserAsync(user: Windows.System.User, desiredName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    static CreateFolderForUserAsync(user: Windows.System.User, desiredName: string, option: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+  }
+
+  class FileIO {
+    static AppendLinesAsync(file: Windows.Storage.IStorageFile, lines: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    static AppendLinesAsync(file: Windows.Storage.IStorageFile, lines: Windows.Foundation.Collections.IIterable<string> | string[], encoding: number): Windows.Foundation.IAsyncAction;
+    static AppendTextAsync(file: Windows.Storage.IStorageFile, contents: string): Windows.Foundation.IAsyncAction;
+    static AppendTextAsync(file: Windows.Storage.IStorageFile, contents: string, encoding: number): Windows.Foundation.IAsyncAction;
+    static ReadBufferAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    static ReadLinesAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<string> | string[]>;
+    static ReadLinesAsync(file: Windows.Storage.IStorageFile, encoding: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<string> | string[]>;
+    static ReadTextAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<string>;
+    static ReadTextAsync(file: Windows.Storage.IStorageFile, encoding: number): Windows.Foundation.IAsyncOperation<string>;
+    static WriteBufferAsync(file: Windows.Storage.IStorageFile, buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncAction;
+    static WriteBytesAsync(file: Windows.Storage.IStorageFile, buffer: number[]): Windows.Foundation.IAsyncAction;
+    static WriteLinesAsync(file: Windows.Storage.IStorageFile, lines: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    static WriteLinesAsync(file: Windows.Storage.IStorageFile, lines: Windows.Foundation.Collections.IIterable<string> | string[], encoding: number): Windows.Foundation.IAsyncAction;
+    static WriteTextAsync(file: Windows.Storage.IStorageFile, contents: string): Windows.Foundation.IAsyncAction;
+    static WriteTextAsync(file: Windows.Storage.IStorageFile, contents: string, encoding: number): Windows.Foundation.IAsyncAction;
+  }
+
+  class KnownFolders {
+    static GetFolderAsync(folderId: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    static GetFolderForUserAsync(user: Windows.System.User, folderId: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    static RequestAccessAsync(folderId: number): Windows.Foundation.IAsyncOperation<number>;
+    static RequestAccessForUserAsync(user: Windows.System.User, folderId: number): Windows.Foundation.IAsyncOperation<number>;
+    static readonly AppCaptures: Windows.Storage.StorageFolder;
+    static readonly CameraRoll: Windows.Storage.StorageFolder;
+    static readonly DocumentsLibrary: Windows.Storage.StorageFolder;
+    static readonly HomeGroup: Windows.Storage.StorageFolder;
+    static readonly MediaServerDevices: Windows.Storage.StorageFolder;
+    static readonly MusicLibrary: Windows.Storage.StorageFolder;
+    static readonly Objects3D: Windows.Storage.StorageFolder;
+    static readonly PicturesLibrary: Windows.Storage.StorageFolder;
+    static readonly Playlists: Windows.Storage.StorageFolder;
+    static readonly RecordedCalls: Windows.Storage.StorageFolder;
+    static readonly RemovableDevices: Windows.Storage.StorageFolder;
+    static readonly SavedPictures: Windows.Storage.StorageFolder;
+    static readonly VideosLibrary: Windows.Storage.StorageFolder;
+  }
+
+  class PathIO {
+    static AppendLinesAsync(absolutePath: string, lines: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    static AppendLinesAsync(absolutePath: string, lines: Windows.Foundation.Collections.IIterable<string> | string[], encoding: number): Windows.Foundation.IAsyncAction;
+    static AppendTextAsync(absolutePath: string, contents: string): Windows.Foundation.IAsyncAction;
+    static AppendTextAsync(absolutePath: string, contents: string, encoding: number): Windows.Foundation.IAsyncAction;
+    static ReadBufferAsync(absolutePath: string): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    static ReadLinesAsync(absolutePath: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<string> | string[]>;
+    static ReadLinesAsync(absolutePath: string, encoding: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<string> | string[]>;
+    static ReadTextAsync(absolutePath: string): Windows.Foundation.IAsyncOperation<string>;
+    static ReadTextAsync(absolutePath: string, encoding: number): Windows.Foundation.IAsyncOperation<string>;
+    static WriteBufferAsync(absolutePath: string, buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncAction;
+    static WriteBytesAsync(absolutePath: string, buffer: number[]): Windows.Foundation.IAsyncAction;
+    static WriteLinesAsync(absolutePath: string, lines: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    static WriteLinesAsync(absolutePath: string, lines: Windows.Foundation.Collections.IIterable<string> | string[], encoding: number): Windows.Foundation.IAsyncAction;
+    static WriteTextAsync(absolutePath: string, contents: string): Windows.Foundation.IAsyncAction;
+    static WriteTextAsync(absolutePath: string, contents: string, encoding: number): Windows.Foundation.IAsyncAction;
+  }
+
+  class SetVersionDeferral implements Windows.Storage.ISetVersionDeferral {
+    Complete(): void;
+  }
+
+  class SetVersionRequest implements Windows.Storage.ISetVersionRequest {
+    GetDeferral(): Windows.Storage.SetVersionDeferral;
+    readonly CurrentVersion: number;
+    readonly DesiredVersion: number;
+  }
+
+  class StorageFile implements Windows.Storage.IStorageFile, Windows.Storage.IStorageFile2, Windows.Storage.IStorageFilePropertiesWithAvailability, Windows.Storage.IStorageItem, Windows.Storage.IStorageItem2, Windows.Storage.IStorageItemProperties, Windows.Storage.IStorageItemProperties2, Windows.Storage.IStorageItemPropertiesWithProvider, Windows.Storage.Streams.IInputStreamReference, Windows.Storage.Streams.IRandomAccessStreamReference {
+    CopyAndReplaceAsync(fileToReplace: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncAction;
+    CopyAsync(destinationFolder: Windows.Storage.IStorageFolder): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CopyAsync(destinationFolder: Windows.Storage.IStorageFolder, desiredNewName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CopyAsync(destinationFolder: Windows.Storage.IStorageFolder, desiredNewName: string, option: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    static CreateStreamedFileAsync(displayNameWithExtension: string, dataRequested: Windows.Storage.StreamedFileDataRequestedHandler, thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    static CreateStreamedFileFromUriAsync(displayNameWithExtension: string, uri: Windows.Foundation.Uri, thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    DeleteAsync(option: number): Windows.Foundation.IAsyncAction;
+    GetBasicPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.BasicProperties>;
+    static GetFileFromApplicationUriAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    static GetFileFromPathAsync(path: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    static GetFileFromPathForUserAsync(user: Windows.System.User, path: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    GetParentAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetScaledImageAsThumbnailAsync(mode: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetScaledImageAsThumbnailAsync(mode: number, requestedSize: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetScaledImageAsThumbnailAsync(mode: number, requestedSize: number, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetThumbnailAsync(mode: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetThumbnailAsync(mode: number, requestedSize: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetThumbnailAsync(mode: number, requestedSize: number, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    IsEqual(item: Windows.Storage.IStorageItem): boolean;
+    IsOfType(type: number): boolean;
+    MoveAndReplaceAsync(fileToReplace: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncAction;
+    MoveAsync(destinationFolder: Windows.Storage.IStorageFolder): Windows.Foundation.IAsyncAction;
+    MoveAsync(destinationFolder: Windows.Storage.IStorageFolder, desiredNewName: string): Windows.Foundation.IAsyncAction;
+    MoveAsync(destinationFolder: Windows.Storage.IStorageFolder, desiredNewName: string, option: number): Windows.Foundation.IAsyncAction;
+    OpenAsync(accessMode: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    OpenAsync(accessMode: number, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    OpenReadAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamWithContentType>;
+    OpenSequentialReadAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IInputStream>;
+    OpenTransactedWriteAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageStreamTransaction>;
+    OpenTransactedWriteAsync(options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageStreamTransaction>;
+    RenameAsync(desiredName: string): Windows.Foundation.IAsyncAction;
+    RenameAsync(desiredName: string, option: number): Windows.Foundation.IAsyncAction;
+    static ReplaceWithStreamedFileAsync(fileToReplace: Windows.Storage.IStorageFile, dataRequested: Windows.Storage.StreamedFileDataRequestedHandler, thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    static ReplaceWithStreamedFileFromUriAsync(fileToReplace: Windows.Storage.IStorageFile, uri: Windows.Foundation.Uri, thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    readonly Attributes: number;
+    readonly ContentType: string;
+    readonly DateCreated: Windows.Foundation.DateTime;
+    readonly DisplayName: string;
+    readonly DisplayType: string;
+    readonly FileType: string;
+    readonly FolderRelativeId: string;
+    readonly IsAvailable: boolean;
+    readonly Name: string;
+    readonly Path: string;
+    readonly Properties: Windows.Storage.FileProperties.StorageItemContentProperties;
+    readonly Provider: Windows.Storage.StorageProvider;
+  }
+
+  class StorageFolder implements Windows.Storage.IStorageFolder, Windows.Storage.IStorageFolder2, Windows.Storage.IStorageFolder3, Windows.Storage.IStorageItem, Windows.Storage.IStorageItem2, Windows.Storage.IStorageItemProperties, Windows.Storage.IStorageItemProperties2, Windows.Storage.IStorageItemPropertiesWithProvider, Windows.Storage.Search.IStorageFolderQueryOperations {
+    AreQueryOptionsSupported(queryOptions: Windows.Storage.Search.QueryOptions): boolean;
+    CreateFileAsync(desiredName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CreateFileAsync(desiredName: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CreateFileQuery(): Windows.Storage.Search.StorageFileQueryResult;
+    CreateFileQuery(query: number): Windows.Storage.Search.StorageFileQueryResult;
+    CreateFileQueryWithOptions(queryOptions: Windows.Storage.Search.QueryOptions): Windows.Storage.Search.StorageFileQueryResult;
+    CreateFolderAsync(desiredName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    CreateFolderAsync(desiredName: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    CreateFolderQuery(): Windows.Storage.Search.StorageFolderQueryResult;
+    CreateFolderQuery(query: number): Windows.Storage.Search.StorageFolderQueryResult;
+    CreateFolderQueryWithOptions(queryOptions: Windows.Storage.Search.QueryOptions): Windows.Storage.Search.StorageFolderQueryResult;
+    CreateItemQuery(): Windows.Storage.Search.StorageItemQueryResult;
+    CreateItemQueryWithOptions(queryOptions: Windows.Storage.Search.QueryOptions): Windows.Storage.Search.StorageItemQueryResult;
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    DeleteAsync(option: number): Windows.Foundation.IAsyncAction;
+    GetBasicPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.BasicProperties>;
+    GetFileAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    GetFilesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[]>;
+    GetFilesAsync(query: number, startIndex: number, maxItemsToRetrieve: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[]>;
+    GetFilesAsync(query: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[]>;
+    GetFolderAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    static GetFolderFromPathAsync(path: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    static GetFolderFromPathForUserAsync(user: Windows.System.User, path: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetFoldersAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFolder> | Windows.Storage.StorageFolder[]>;
+    GetFoldersAsync(query: number, startIndex: number, maxItemsToRetrieve: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFolder> | Windows.Storage.StorageFolder[]>;
+    GetFoldersAsync(query: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFolder> | Windows.Storage.StorageFolder[]>;
+    GetIndexedStateAsync(): Windows.Foundation.IAsyncOperation<number>;
+    GetItemAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>;
+    GetItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[]>;
+    GetItemsAsync(startIndex: number, maxItemsToRetrieve: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[]>;
+    GetParentAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetScaledImageAsThumbnailAsync(mode: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetScaledImageAsThumbnailAsync(mode: number, requestedSize: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetScaledImageAsThumbnailAsync(mode: number, requestedSize: number, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetThumbnailAsync(mode: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetThumbnailAsync(mode: number, requestedSize: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetThumbnailAsync(mode: number, requestedSize: number, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    IsCommonFileQuerySupported(query: number): boolean;
+    IsCommonFolderQuerySupported(query: number): boolean;
+    IsEqual(item: Windows.Storage.IStorageItem): boolean;
+    IsOfType(type: number): boolean;
+    RenameAsync(desiredName: string): Windows.Foundation.IAsyncAction;
+    RenameAsync(desiredName: string, option: number): Windows.Foundation.IAsyncAction;
+    TryGetChangeTracker(): Windows.Storage.StorageLibraryChangeTracker;
+    TryGetItemAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>;
+    readonly Attributes: number;
+    readonly DateCreated: Windows.Foundation.DateTime;
+    readonly DisplayName: string;
+    readonly DisplayType: string;
+    readonly FolderRelativeId: string;
+    readonly Name: string;
+    readonly Path: string;
+    readonly Properties: Windows.Storage.FileProperties.StorageItemContentProperties;
+    readonly Provider: Windows.Storage.StorageProvider;
+  }
+
+  class StorageLibrary implements Windows.Storage.IStorageLibrary, Windows.Storage.IStorageLibrary2, Windows.Storage.IStorageLibrary3 {
+    AreFolderSuggestionsAvailableAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    static GetLibraryAsync(libraryId: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageLibrary>;
+    static GetLibraryForUserAsync(user: Windows.System.User, libraryId: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageLibrary>;
+    RequestAddFolderAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    RequestRemoveFolderAsync(folder: Windows.Storage.StorageFolder): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly ChangeTracker: Windows.Storage.StorageLibraryChangeTracker;
+    readonly Folders: Windows.Foundation.Collections.IObservableVector<Windows.Storage.StorageFolder>;
+    readonly SaveFolder: Windows.Storage.StorageFolder;
+    DefinitionChanged: Windows.Foundation.TypedEventHandler<Windows.Storage.StorageLibrary, Object> | null;
+  }
+
+  class StorageLibraryChange implements Windows.Storage.IStorageLibraryChange {
+    GetStorageItemAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>;
+    IsOfType(type: number): boolean;
+    readonly ChangeType: number;
+    readonly Path: string;
+    readonly PreviousPath: string;
+  }
+
+  class StorageLibraryChangeReader implements Windows.Storage.IStorageLibraryChangeReader, Windows.Storage.IStorageLibraryChangeReader2 {
+    AcceptChangesAsync(): Windows.Foundation.IAsyncAction;
+    GetLastChangeId(): number | bigint;
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageLibraryChange> | Windows.Storage.StorageLibraryChange[]>;
+  }
+
+  class StorageLibraryChangeTracker implements Windows.Storage.IStorageLibraryChangeTracker, Windows.Storage.IStorageLibraryChangeTracker2 {
+    Disable(): void;
+    Enable(): void;
+    Enable(options: Windows.Storage.StorageLibraryChangeTrackerOptions): void;
+    GetChangeReader(): Windows.Storage.StorageLibraryChangeReader;
+    Reset(): void;
+  }
+
+  class StorageLibraryChangeTrackerOptions implements Windows.Storage.IStorageLibraryChangeTrackerOptions {
+    constructor();
+    TrackChangeDetails: boolean;
+  }
+
+  class StorageLibraryLastChangeId implements Windows.Storage.IStorageLibraryLastChangeId {
+    static readonly Unknown: number | bigint;
+  }
+
+  class StorageProvider implements Windows.Storage.IStorageProvider, Windows.Storage.IStorageProvider2 {
+    IsPropertySupportedForPartialFileAsync(propertyCanonicalName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly DisplayName: string;
+    readonly Id: string;
+  }
+
+  class StorageStreamTransaction implements Windows.Foundation.IClosable, Windows.Storage.IStorageStreamTransaction {
+    Close(): void;
+    CommitAsync(): Windows.Foundation.IAsyncAction;
+    readonly Stream: Windows.Storage.Streams.IRandomAccessStream;
+  }
+
+  class StreamedFileDataRequest implements Windows.Foundation.IClosable, Windows.Storage.IStreamedFileDataRequest, Windows.Storage.Streams.IOutputStream {
+    Close(): void;
+    FailAndClose(failureMode: number): void;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    WriteAsync(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+  }
+
+  class SystemAudioProperties implements Windows.Storage.ISystemAudioProperties {
+    readonly EncodingBitrate: string;
+  }
+
+  class SystemDataPaths implements Windows.Storage.ISystemDataPaths {
+    static GetDefault(): Windows.Storage.SystemDataPaths;
+    readonly Fonts: string;
+    readonly ProgramData: string;
+    readonly Public: string;
+    readonly PublicDesktop: string;
+    readonly PublicDocuments: string;
+    readonly PublicDownloads: string;
+    readonly PublicMusic: string;
+    readonly PublicPictures: string;
+    readonly PublicVideos: string;
+    readonly System: string;
+    readonly SystemArm: string;
+    readonly SystemHost: string;
+    readonly SystemX64: string;
+    readonly SystemX86: string;
+    readonly UserProfiles: string;
+    readonly Windows: string;
+  }
+
+  class SystemGPSProperties implements Windows.Storage.ISystemGPSProperties {
+    readonly LatitudeDecimal: string;
+    readonly LongitudeDecimal: string;
+  }
+
+  class SystemImageProperties implements Windows.Storage.ISystemImageProperties {
+    readonly HorizontalSize: string;
+    readonly VerticalSize: string;
+  }
+
+  class SystemMediaProperties implements Windows.Storage.ISystemMediaProperties {
+    readonly Duration: string;
+    readonly Producer: string;
+    readonly Publisher: string;
+    readonly SubTitle: string;
+    readonly Writer: string;
+    readonly Year: string;
+  }
+
+  class SystemMusicProperties implements Windows.Storage.ISystemMusicProperties {
+    readonly AlbumArtist: string;
+    readonly AlbumTitle: string;
+    readonly Artist: string;
+    readonly Composer: string;
+    readonly Conductor: string;
+    readonly DisplayArtist: string;
+    readonly Genre: string;
+    readonly TrackNumber: string;
+  }
+
+  class SystemPhotoProperties implements Windows.Storage.ISystemPhotoProperties {
+    readonly CameraManufacturer: string;
+    readonly CameraModel: string;
+    readonly DateTaken: string;
+    readonly Orientation: string;
+    readonly PeopleNames: string;
+  }
+
+  class SystemProperties {
+    static readonly Audio: Windows.Storage.SystemAudioProperties;
+    static readonly Author: string;
+    static readonly Comment: string;
+    static readonly GPS: Windows.Storage.SystemGPSProperties;
+    static readonly Image: Windows.Storage.SystemImageProperties;
+    static readonly ItemNameDisplay: string;
+    static readonly Keywords: string;
+    static readonly Media: Windows.Storage.SystemMediaProperties;
+    static readonly Music: Windows.Storage.SystemMusicProperties;
+    static readonly Photo: Windows.Storage.SystemPhotoProperties;
+    static readonly Rating: string;
+    static readonly Title: string;
+    static readonly Video: Windows.Storage.SystemVideoProperties;
+  }
+
+  class SystemVideoProperties implements Windows.Storage.ISystemVideoProperties {
+    readonly Director: string;
+    readonly FrameHeight: string;
+    readonly FrameWidth: string;
+    readonly Orientation: string;
+    readonly TotalBitrate: string;
+  }
+
+  class UserDataPaths implements Windows.Storage.IUserDataPaths {
+    static GetDefault(): Windows.Storage.UserDataPaths;
+    static GetForUser(user: Windows.System.User): Windows.Storage.UserDataPaths;
+    readonly CameraRoll: string;
+    readonly Cookies: string;
+    readonly Desktop: string;
+    readonly Documents: string;
+    readonly Downloads: string;
+    readonly Favorites: string;
+    readonly History: string;
+    readonly InternetCache: string;
+    readonly LocalAppData: string;
+    readonly LocalAppDataLow: string;
+    readonly Music: string;
+    readonly Pictures: string;
+    readonly Profile: string;
+    readonly Recent: string;
+    readonly RoamingAppData: string;
+    readonly SavedPictures: string;
+    readonly Screenshots: string;
+    readonly Templates: string;
+    readonly Videos: string;
+  }
+
+  enum ApplicationDataCreateDisposition {
+    Always = 0,
+    Existing = 1,
+  }
+
+  enum ApplicationDataLocality {
+    Local = 0,
+    Roaming = 1,
+    Temporary = 2,
+    LocalCache = 3,
+    SharedLocal = 4,
+  }
+
+  enum CreationCollisionOption {
+    GenerateUniqueName = 0,
+    ReplaceExisting = 1,
+    FailIfExists = 2,
+    OpenIfExists = 3,
+  }
+
+  enum FileAccessMode {
+    Read = 0,
+    ReadWrite = 1,
+  }
+
+  enum FileAttributes {
+    Normal = 0,
+    ReadOnly = 1,
+    Directory = 16,
+    Archive = 32,
+    Temporary = 256,
+    LocallyIncomplete = 512,
+  }
+
+  enum 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,
+    AllAppMods = 14,
+    CurrentAppMods = 15,
+    DownloadsFolder = 16,
+  }
+
+  enum KnownFoldersAccessStatus {
+    DeniedBySystem = 0,
+    NotDeclaredByApp = 1,
+    DeniedByUser = 2,
+    UserPromptRequired = 3,
+    Allowed = 4,
+    AllowedPerAppFolder = 5,
+  }
+
+  enum KnownLibraryId {
+    Music = 0,
+    Pictures = 1,
+    Videos = 2,
+    Documents = 3,
+  }
+
+  enum NameCollisionOption {
+    GenerateUniqueName = 0,
+    ReplaceExisting = 1,
+    FailIfExists = 2,
+  }
+
+  enum StorageDeleteOption {
+    Default = 0,
+    PermanentDelete = 1,
+  }
+
+  enum StorageItemTypes {
+    None = 0,
+    File = 1,
+    Folder = 2,
+  }
+
+  enum StorageLibraryChangeType {
+    Created = 0,
+    Deleted = 1,
+    MovedOrRenamed = 2,
+    ContentsChanged = 3,
+    MovedOutOfLibrary = 4,
+    MovedIntoLibrary = 5,
+    ContentsReplaced = 6,
+    IndexingStatusChanged = 7,
+    EncryptionChanged = 8,
+    ChangeTrackingLost = 9,
+  }
+
+  enum StorageOpenOptions {
+    None = 0,
+    AllowOnlyReaders = 1,
+    AllowReadersAndWriters = 2,
+  }
+
+  enum StreamedFileFailureMode {
+    Failed = 0,
+    CurrentlyUnavailable = 1,
+    Incomplete = 2,
+  }
+
+  interface ApplicationDataSetVersionHandler {
+    (setVersionRequest: Windows.Storage.SetVersionRequest): void;
+  }
+  var ApplicationDataSetVersionHandler: {
+    new(callback: (setVersionRequest: Windows.Storage.SetVersionRequest) => void): ApplicationDataSetVersionHandler;
+  };
+
+  interface IAppDataPaths {
+    readonly Cookies: string;
+    readonly Desktop: string;
+    readonly Documents: string;
+    readonly Favorites: string;
+    readonly History: string;
+    readonly InternetCache: string;
+    readonly LocalAppData: string;
+    readonly ProgramData: string;
+    readonly RoamingAppData: string;
+  }
+  var IAppDataPaths: abstract new (...args: any[]) => IAppDataPaths;
+
+  interface IAppDataPathsStatics {
+    GetDefault(): Windows.Storage.AppDataPaths;
+    GetForUser(user: Windows.System.User): Windows.Storage.AppDataPaths;
+  }
+  var IAppDataPathsStatics: abstract new (...args: any[]) => IAppDataPathsStatics;
+
+  interface IApplicationData {
+    ClearAsync(): Windows.Foundation.IAsyncAction;
+    ClearAsync(locality: number): Windows.Foundation.IAsyncAction;
+    SetVersionAsync(desiredVersion: number, handler: Windows.Storage.ApplicationDataSetVersionHandler): Windows.Foundation.IAsyncAction;
+    SignalDataChanged(): void;
+    readonly LocalFolder: Windows.Storage.StorageFolder;
+    readonly LocalSettings: Windows.Storage.ApplicationDataContainer;
+    readonly RoamingFolder: Windows.Storage.StorageFolder;
+    readonly RoamingSettings: Windows.Storage.ApplicationDataContainer;
+    readonly RoamingStorageQuota: number | bigint;
+    readonly TemporaryFolder: Windows.Storage.StorageFolder;
+    readonly Version: number;
+    DataChanged: Windows.Foundation.TypedEventHandler<Windows.Storage.ApplicationData, Object> | null;
+  }
+  var IApplicationData: abstract new (...args: any[]) => IApplicationData;
+
+  interface IApplicationData2 {
+    readonly LocalCacheFolder: Windows.Storage.StorageFolder;
+  }
+  var IApplicationData2: abstract new (...args: any[]) => IApplicationData2;
+
+  interface IApplicationData3 {
+    ClearPublisherCacheFolderAsync(folderName: string): Windows.Foundation.IAsyncAction;
+    GetPublisherCacheFolder(folderName: string): Windows.Storage.StorageFolder;
+    readonly SharedLocalFolder: Windows.Storage.StorageFolder;
+  }
+  var IApplicationData3: abstract new (...args: any[]) => IApplicationData3;
+
+  interface IApplicationDataContainer {
+    CreateContainer(name: string, disposition: number): Windows.Storage.ApplicationDataContainer;
+    DeleteContainer(name: string): void;
+    readonly Containers: Windows.Foundation.Collections.IMapView<string, Windows.Storage.ApplicationDataContainer>;
+    readonly Locality: number;
+    readonly Name: string;
+    readonly Values: Windows.Foundation.Collections.IPropertySet;
+  }
+  var IApplicationDataContainer: abstract new (...args: any[]) => IApplicationDataContainer;
+
+  interface IApplicationDataStatics {
+    readonly Current: Windows.Storage.ApplicationData;
+  }
+  var IApplicationDataStatics: abstract new (...args: any[]) => IApplicationDataStatics;
+
+  interface IApplicationDataStatics2 {
+    GetForUserAsync(user: Windows.System.User): Windows.Foundation.IAsyncOperation<Windows.Storage.ApplicationData>;
+  }
+  var IApplicationDataStatics2: abstract new (...args: any[]) => IApplicationDataStatics2;
+
+  interface ICachedFileManagerStatics {
+    CompleteUpdatesAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<number>;
+    DeferUpdates(file: Windows.Storage.IStorageFile): void;
+  }
+  var ICachedFileManagerStatics: abstract new (...args: any[]) => ICachedFileManagerStatics;
+
+  interface IDownloadsFolderStatics {
+    CreateFileAsync(desiredName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CreateFileAsync(desiredName: string, option: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CreateFolderAsync(desiredName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    CreateFolderAsync(desiredName: string, option: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+  }
+  var IDownloadsFolderStatics: abstract new (...args: any[]) => IDownloadsFolderStatics;
+
+  interface IDownloadsFolderStatics2 {
+    CreateFileForUserAsync(user: Windows.System.User, desiredName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CreateFileForUserAsync(user: Windows.System.User, desiredName: string, option: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CreateFolderForUserAsync(user: Windows.System.User, desiredName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    CreateFolderForUserAsync(user: Windows.System.User, desiredName: string, option: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+  }
+  var IDownloadsFolderStatics2: abstract new (...args: any[]) => IDownloadsFolderStatics2;
+
+  interface IFileIOStatics {
+    AppendLinesAsync(file: Windows.Storage.IStorageFile, lines: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    AppendLinesAsync(file: Windows.Storage.IStorageFile, lines: Windows.Foundation.Collections.IIterable<string> | string[], encoding: number): Windows.Foundation.IAsyncAction;
+    AppendTextAsync(file: Windows.Storage.IStorageFile, contents: string): Windows.Foundation.IAsyncAction;
+    AppendTextAsync(file: Windows.Storage.IStorageFile, contents: string, encoding: number): Windows.Foundation.IAsyncAction;
+    ReadBufferAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    ReadLinesAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<string> | string[]>;
+    ReadLinesAsync(file: Windows.Storage.IStorageFile, encoding: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<string> | string[]>;
+    ReadTextAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<string>;
+    ReadTextAsync(file: Windows.Storage.IStorageFile, encoding: number): Windows.Foundation.IAsyncOperation<string>;
+    WriteBufferAsync(file: Windows.Storage.IStorageFile, buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncAction;
+    WriteBytesAsync(file: Windows.Storage.IStorageFile, buffer: number[]): Windows.Foundation.IAsyncAction;
+    WriteLinesAsync(file: Windows.Storage.IStorageFile, lines: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    WriteLinesAsync(file: Windows.Storage.IStorageFile, lines: Windows.Foundation.Collections.IIterable<string> | string[], encoding: number): Windows.Foundation.IAsyncAction;
+    WriteTextAsync(file: Windows.Storage.IStorageFile, contents: string): Windows.Foundation.IAsyncAction;
+    WriteTextAsync(file: Windows.Storage.IStorageFile, contents: string, encoding: number): Windows.Foundation.IAsyncAction;
+  }
+  var IFileIOStatics: abstract new (...args: any[]) => IFileIOStatics;
+
+  interface IKnownFoldersCameraRollStatics {
+    readonly CameraRoll: Windows.Storage.StorageFolder;
+  }
+  var IKnownFoldersCameraRollStatics: abstract new (...args: any[]) => IKnownFoldersCameraRollStatics;
+
+  interface IKnownFoldersPlaylistsStatics {
+    readonly Playlists: Windows.Storage.StorageFolder;
+  }
+  var IKnownFoldersPlaylistsStatics: abstract new (...args: any[]) => IKnownFoldersPlaylistsStatics;
+
+  interface IKnownFoldersSavedPicturesStatics {
+    readonly SavedPictures: Windows.Storage.StorageFolder;
+  }
+  var IKnownFoldersSavedPicturesStatics: abstract new (...args: any[]) => IKnownFoldersSavedPicturesStatics;
+
+  interface IKnownFoldersStatics {
+    readonly DocumentsLibrary: Windows.Storage.StorageFolder;
+    readonly HomeGroup: Windows.Storage.StorageFolder;
+    readonly MediaServerDevices: Windows.Storage.StorageFolder;
+    readonly MusicLibrary: Windows.Storage.StorageFolder;
+    readonly PicturesLibrary: Windows.Storage.StorageFolder;
+    readonly RemovableDevices: Windows.Storage.StorageFolder;
+    readonly VideosLibrary: Windows.Storage.StorageFolder;
+  }
+  var IKnownFoldersStatics: abstract new (...args: any[]) => IKnownFoldersStatics;
+
+  interface IKnownFoldersStatics2 {
+    readonly AppCaptures: Windows.Storage.StorageFolder;
+    readonly Objects3D: Windows.Storage.StorageFolder;
+    readonly RecordedCalls: Windows.Storage.StorageFolder;
+  }
+  var IKnownFoldersStatics2: abstract new (...args: any[]) => IKnownFoldersStatics2;
+
+  interface IKnownFoldersStatics3 {
+    GetFolderForUserAsync(user: Windows.System.User, folderId: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+  }
+  var IKnownFoldersStatics3: abstract new (...args: any[]) => IKnownFoldersStatics3;
+
+  interface IKnownFoldersStatics4 {
+    GetFolderAsync(folderId: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    RequestAccessAsync(folderId: number): Windows.Foundation.IAsyncOperation<number>;
+    RequestAccessForUserAsync(user: Windows.System.User, folderId: number): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IKnownFoldersStatics4: abstract new (...args: any[]) => IKnownFoldersStatics4;
+
+  interface IPathIOStatics {
+    AppendLinesAsync(absolutePath: string, lines: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    AppendLinesAsync(absolutePath: string, lines: Windows.Foundation.Collections.IIterable<string> | string[], encoding: number): Windows.Foundation.IAsyncAction;
+    AppendTextAsync(absolutePath: string, contents: string): Windows.Foundation.IAsyncAction;
+    AppendTextAsync(absolutePath: string, contents: string, encoding: number): Windows.Foundation.IAsyncAction;
+    ReadBufferAsync(absolutePath: string): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    ReadLinesAsync(absolutePath: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<string> | string[]>;
+    ReadLinesAsync(absolutePath: string, encoding: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<string> | string[]>;
+    ReadTextAsync(absolutePath: string): Windows.Foundation.IAsyncOperation<string>;
+    ReadTextAsync(absolutePath: string, encoding: number): Windows.Foundation.IAsyncOperation<string>;
+    WriteBufferAsync(absolutePath: string, buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncAction;
+    WriteBytesAsync(absolutePath: string, buffer: number[]): Windows.Foundation.IAsyncAction;
+    WriteLinesAsync(absolutePath: string, lines: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    WriteLinesAsync(absolutePath: string, lines: Windows.Foundation.Collections.IIterable<string> | string[], encoding: number): Windows.Foundation.IAsyncAction;
+    WriteTextAsync(absolutePath: string, contents: string): Windows.Foundation.IAsyncAction;
+    WriteTextAsync(absolutePath: string, contents: string, encoding: number): Windows.Foundation.IAsyncAction;
+  }
+  var IPathIOStatics: abstract new (...args: any[]) => IPathIOStatics;
+
+  interface ISetVersionDeferral {
+    Complete(): void;
+  }
+  var ISetVersionDeferral: abstract new (...args: any[]) => ISetVersionDeferral;
+
+  interface ISetVersionRequest {
+    GetDeferral(): Windows.Storage.SetVersionDeferral;
+    readonly CurrentVersion: number;
+    readonly DesiredVersion: number;
+  }
+  var ISetVersionRequest: abstract new (...args: any[]) => ISetVersionRequest;
+
+  interface IStorageFile extends Windows.Storage.IStorageItem, Windows.Storage.Streams.IInputStreamReference, Windows.Storage.Streams.IRandomAccessStreamReference {
+    CopyAndReplaceAsync(fileToReplace: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncAction;
+    CopyAsync(destinationFolder: Windows.Storage.IStorageFolder): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CopyAsync(destinationFolder: Windows.Storage.IStorageFolder, desiredNewName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CopyAsync(destinationFolder: Windows.Storage.IStorageFolder, desiredNewName: string, option: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    DeleteAsync(option: number): Windows.Foundation.IAsyncAction;
+    GetBasicPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.BasicProperties>;
+    IsOfType(type: number): boolean;
+    MoveAndReplaceAsync(fileToReplace: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncAction;
+    MoveAsync(destinationFolder: Windows.Storage.IStorageFolder): Windows.Foundation.IAsyncAction;
+    MoveAsync(destinationFolder: Windows.Storage.IStorageFolder, desiredNewName: string): Windows.Foundation.IAsyncAction;
+    MoveAsync(destinationFolder: Windows.Storage.IStorageFolder, desiredNewName: string, option: number): Windows.Foundation.IAsyncAction;
+    OpenAsync(accessMode: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    OpenReadAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamWithContentType>;
+    OpenSequentialReadAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IInputStream>;
+    OpenTransactedWriteAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageStreamTransaction>;
+    RenameAsync(desiredName: string): Windows.Foundation.IAsyncAction;
+    RenameAsync(desiredName: string, option: number): Windows.Foundation.IAsyncAction;
+    readonly ContentType: string;
+    readonly FileType: string;
+  }
+  var IStorageFile: abstract new (...args: any[]) => IStorageFile;
+
+  interface IStorageFile2 {
+    OpenAsync(accessMode: number, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    OpenTransactedWriteAsync(options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageStreamTransaction>;
+  }
+  var IStorageFile2: abstract new (...args: any[]) => IStorageFile2;
+
+  interface IStorageFilePropertiesWithAvailability {
+    readonly IsAvailable: boolean;
+  }
+  var IStorageFilePropertiesWithAvailability: abstract new (...args: any[]) => IStorageFilePropertiesWithAvailability;
+
+  interface IStorageFileStatics {
+    CreateStreamedFileAsync(displayNameWithExtension: string, dataRequested: Windows.Storage.StreamedFileDataRequestedHandler, thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CreateStreamedFileFromUriAsync(displayNameWithExtension: string, uri: Windows.Foundation.Uri, thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    GetFileFromApplicationUriAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    GetFileFromPathAsync(path: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    ReplaceWithStreamedFileAsync(fileToReplace: Windows.Storage.IStorageFile, dataRequested: Windows.Storage.StreamedFileDataRequestedHandler, thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    ReplaceWithStreamedFileFromUriAsync(fileToReplace: Windows.Storage.IStorageFile, uri: Windows.Foundation.Uri, thumbnail: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+  }
+  var IStorageFileStatics: abstract new (...args: any[]) => IStorageFileStatics;
+
+  interface IStorageFileStatics2 {
+    GetFileFromPathForUserAsync(user: Windows.System.User, path: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+  }
+  var IStorageFileStatics2: abstract new (...args: any[]) => IStorageFileStatics2;
+
+  interface IStorageFolder extends Windows.Storage.IStorageItem {
+    CreateFileAsync(desiredName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CreateFileAsync(desiredName: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CreateFolderAsync(desiredName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    CreateFolderAsync(desiredName: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    DeleteAsync(option: number): Windows.Foundation.IAsyncAction;
+    GetBasicPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.BasicProperties>;
+    GetFileAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    GetFilesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[]>;
+    GetFolderAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetFoldersAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFolder> | Windows.Storage.StorageFolder[]>;
+    GetItemAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>;
+    GetItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[]>;
+    IsOfType(type: number): boolean;
+    RenameAsync(desiredName: string): Windows.Foundation.IAsyncAction;
+    RenameAsync(desiredName: string, option: number): Windows.Foundation.IAsyncAction;
+  }
+  var IStorageFolder: abstract new (...args: any[]) => IStorageFolder;
+
+  interface IStorageFolder2 {
+    TryGetItemAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>;
+  }
+  var IStorageFolder2: abstract new (...args: any[]) => IStorageFolder2;
+
+  interface IStorageFolder3 {
+    TryGetChangeTracker(): Windows.Storage.StorageLibraryChangeTracker;
+  }
+  var IStorageFolder3: abstract new (...args: any[]) => IStorageFolder3;
+
+  interface IStorageFolderStatics {
+    GetFolderFromPathAsync(path: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+  }
+  var IStorageFolderStatics: abstract new (...args: any[]) => IStorageFolderStatics;
+
+  interface IStorageFolderStatics2 {
+    GetFolderFromPathForUserAsync(user: Windows.System.User, path: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+  }
+  var IStorageFolderStatics2: abstract new (...args: any[]) => IStorageFolderStatics2;
+
+  interface IStorageItem {
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    DeleteAsync(option: number): Windows.Foundation.IAsyncAction;
+    GetBasicPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.BasicProperties>;
+    IsOfType(type: number): boolean;
+    RenameAsync(desiredName: string): Windows.Foundation.IAsyncAction;
+    RenameAsync(desiredName: string, option: number): Windows.Foundation.IAsyncAction;
+    readonly Attributes: number;
+    readonly DateCreated: Windows.Foundation.DateTime;
+    readonly Name: string;
+    readonly Path: string;
+  }
+  var IStorageItem: abstract new (...args: any[]) => IStorageItem;
+
+  interface IStorageItem2 extends Windows.Storage.IStorageItem {
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    DeleteAsync(option: number): Windows.Foundation.IAsyncAction;
+    GetBasicPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.BasicProperties>;
+    GetParentAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    IsEqual(item: Windows.Storage.IStorageItem): boolean;
+    IsOfType(type: number): boolean;
+    RenameAsync(desiredName: string): Windows.Foundation.IAsyncAction;
+    RenameAsync(desiredName: string, option: number): Windows.Foundation.IAsyncAction;
+  }
+  var IStorageItem2: abstract new (...args: any[]) => IStorageItem2;
+
+  interface IStorageItemProperties {
+    GetThumbnailAsync(mode: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetThumbnailAsync(mode: number, requestedSize: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetThumbnailAsync(mode: number, requestedSize: number, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    readonly DisplayName: string;
+    readonly DisplayType: string;
+    readonly FolderRelativeId: string;
+    readonly Properties: Windows.Storage.FileProperties.StorageItemContentProperties;
+  }
+  var IStorageItemProperties: abstract new (...args: any[]) => IStorageItemProperties;
+
+  interface IStorageItemProperties2 extends Windows.Storage.IStorageItemProperties {
+    GetScaledImageAsThumbnailAsync(mode: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetScaledImageAsThumbnailAsync(mode: number, requestedSize: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetScaledImageAsThumbnailAsync(mode: number, requestedSize: number, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetThumbnailAsync(mode: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetThumbnailAsync(mode: number, requestedSize: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetThumbnailAsync(mode: number, requestedSize: number, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+  }
+  var IStorageItemProperties2: abstract new (...args: any[]) => IStorageItemProperties2;
+
+  interface IStorageItemPropertiesWithProvider extends Windows.Storage.IStorageItemProperties {
+    GetThumbnailAsync(mode: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetThumbnailAsync(mode: number, requestedSize: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetThumbnailAsync(mode: number, requestedSize: number, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    readonly Provider: Windows.Storage.StorageProvider;
+  }
+  var IStorageItemPropertiesWithProvider: abstract new (...args: any[]) => IStorageItemPropertiesWithProvider;
+
+  interface IStorageLibrary {
+    RequestAddFolderAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    RequestRemoveFolderAsync(folder: Windows.Storage.StorageFolder): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Folders: Windows.Foundation.Collections.IObservableVector<Windows.Storage.StorageFolder>;
+    readonly SaveFolder: Windows.Storage.StorageFolder;
+    DefinitionChanged: Windows.Foundation.TypedEventHandler<Windows.Storage.StorageLibrary, Object> | null;
+  }
+  var IStorageLibrary: abstract new (...args: any[]) => IStorageLibrary;
+
+  interface IStorageLibrary2 {
+    readonly ChangeTracker: Windows.Storage.StorageLibraryChangeTracker;
+  }
+  var IStorageLibrary2: abstract new (...args: any[]) => IStorageLibrary2;
+
+  interface IStorageLibrary3 {
+    AreFolderSuggestionsAvailableAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IStorageLibrary3: abstract new (...args: any[]) => IStorageLibrary3;
+
+  interface IStorageLibraryChange {
+    GetStorageItemAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>;
+    IsOfType(type: number): boolean;
+    readonly ChangeType: number;
+    readonly Path: string;
+    readonly PreviousPath: string;
+  }
+  var IStorageLibraryChange: abstract new (...args: any[]) => IStorageLibraryChange;
+
+  interface IStorageLibraryChangeReader {
+    AcceptChangesAsync(): Windows.Foundation.IAsyncAction;
+    ReadBatchAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageLibraryChange> | Windows.Storage.StorageLibraryChange[]>;
+  }
+  var IStorageLibraryChangeReader: abstract new (...args: any[]) => IStorageLibraryChangeReader;
+
+  interface IStorageLibraryChangeReader2 {
+    GetLastChangeId(): number | bigint;
+  }
+  var IStorageLibraryChangeReader2: abstract new (...args: any[]) => IStorageLibraryChangeReader2;
+
+  interface IStorageLibraryChangeTracker {
+    Enable(): void;
+    GetChangeReader(): Windows.Storage.StorageLibraryChangeReader;
+    Reset(): void;
+  }
+  var IStorageLibraryChangeTracker: abstract new (...args: any[]) => IStorageLibraryChangeTracker;
+
+  interface IStorageLibraryChangeTracker2 {
+    Disable(): void;
+    Enable(options: Windows.Storage.StorageLibraryChangeTrackerOptions): void;
+  }
+  var IStorageLibraryChangeTracker2: abstract new (...args: any[]) => IStorageLibraryChangeTracker2;
+
+  interface IStorageLibraryChangeTrackerOptions {
+    TrackChangeDetails: boolean;
+  }
+  var IStorageLibraryChangeTrackerOptions: abstract new (...args: any[]) => IStorageLibraryChangeTrackerOptions;
+
+  interface IStorageLibraryLastChangeId {
+  }
+  var IStorageLibraryLastChangeId: abstract new (...args: any[]) => IStorageLibraryLastChangeId;
+
+  interface IStorageLibraryLastChangeIdStatics {
+    readonly Unknown: number | bigint;
+  }
+  var IStorageLibraryLastChangeIdStatics: abstract new (...args: any[]) => IStorageLibraryLastChangeIdStatics;
+
+  interface IStorageLibraryStatics {
+    GetLibraryAsync(libraryId: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageLibrary>;
+  }
+  var IStorageLibraryStatics: abstract new (...args: any[]) => IStorageLibraryStatics;
+
+  interface IStorageLibraryStatics2 {
+    GetLibraryForUserAsync(user: Windows.System.User, libraryId: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageLibrary>;
+  }
+  var IStorageLibraryStatics2: abstract new (...args: any[]) => IStorageLibraryStatics2;
+
+  interface IStorageProvider {
+    readonly DisplayName: string;
+    readonly Id: string;
+  }
+  var IStorageProvider: abstract new (...args: any[]) => IStorageProvider;
+
+  interface IStorageProvider2 extends Windows.Storage.IStorageProvider {
+    IsPropertySupportedForPartialFileAsync(propertyCanonicalName: string): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IStorageProvider2: abstract new (...args: any[]) => IStorageProvider2;
+
+  interface IStorageStreamTransaction extends Windows.Foundation.IClosable {
+    Close(): void;
+    CommitAsync(): Windows.Foundation.IAsyncAction;
+    readonly Stream: Windows.Storage.Streams.IRandomAccessStream;
+  }
+  var IStorageStreamTransaction: abstract new (...args: any[]) => IStorageStreamTransaction;
+
+  interface IStreamedFileDataRequest {
+    FailAndClose(failureMode: number): void;
+  }
+  var IStreamedFileDataRequest: abstract new (...args: any[]) => IStreamedFileDataRequest;
+
+  interface ISystemAudioProperties {
+    readonly EncodingBitrate: string;
+  }
+  var ISystemAudioProperties: abstract new (...args: any[]) => ISystemAudioProperties;
+
+  interface ISystemDataPaths {
+    readonly Fonts: string;
+    readonly ProgramData: string;
+    readonly Public: string;
+    readonly PublicDesktop: string;
+    readonly PublicDocuments: string;
+    readonly PublicDownloads: string;
+    readonly PublicMusic: string;
+    readonly PublicPictures: string;
+    readonly PublicVideos: string;
+    readonly System: string;
+    readonly SystemArm: string;
+    readonly SystemHost: string;
+    readonly SystemX64: string;
+    readonly SystemX86: string;
+    readonly UserProfiles: string;
+    readonly Windows: string;
+  }
+  var ISystemDataPaths: abstract new (...args: any[]) => ISystemDataPaths;
+
+  interface ISystemDataPathsStatics {
+    GetDefault(): Windows.Storage.SystemDataPaths;
+  }
+  var ISystemDataPathsStatics: abstract new (...args: any[]) => ISystemDataPathsStatics;
+
+  interface ISystemGPSProperties {
+    readonly LatitudeDecimal: string;
+    readonly LongitudeDecimal: string;
+  }
+  var ISystemGPSProperties: abstract new (...args: any[]) => ISystemGPSProperties;
+
+  interface ISystemImageProperties {
+    readonly HorizontalSize: string;
+    readonly VerticalSize: string;
+  }
+  var ISystemImageProperties: abstract new (...args: any[]) => ISystemImageProperties;
+
+  interface ISystemMediaProperties {
+    readonly Duration: string;
+    readonly Producer: string;
+    readonly Publisher: string;
+    readonly SubTitle: string;
+    readonly Writer: string;
+    readonly Year: string;
+  }
+  var ISystemMediaProperties: abstract new (...args: any[]) => ISystemMediaProperties;
+
+  interface ISystemMusicProperties {
+    readonly AlbumArtist: string;
+    readonly AlbumTitle: string;
+    readonly Artist: string;
+    readonly Composer: string;
+    readonly Conductor: string;
+    readonly DisplayArtist: string;
+    readonly Genre: string;
+    readonly TrackNumber: string;
+  }
+  var ISystemMusicProperties: abstract new (...args: any[]) => ISystemMusicProperties;
+
+  interface ISystemPhotoProperties {
+    readonly CameraManufacturer: string;
+    readonly CameraModel: string;
+    readonly DateTaken: string;
+    readonly Orientation: string;
+    readonly PeopleNames: string;
+  }
+  var ISystemPhotoProperties: abstract new (...args: any[]) => ISystemPhotoProperties;
+
+  interface ISystemProperties {
+    readonly Audio: Windows.Storage.SystemAudioProperties;
+    readonly Author: string;
+    readonly Comment: string;
+    readonly GPS: Windows.Storage.SystemGPSProperties;
+    readonly Image: Windows.Storage.SystemImageProperties;
+    readonly ItemNameDisplay: string;
+    readonly Keywords: string;
+    readonly Media: Windows.Storage.SystemMediaProperties;
+    readonly Music: Windows.Storage.SystemMusicProperties;
+    readonly Photo: Windows.Storage.SystemPhotoProperties;
+    readonly Rating: string;
+    readonly Title: string;
+    readonly Video: Windows.Storage.SystemVideoProperties;
+  }
+  var ISystemProperties: abstract new (...args: any[]) => ISystemProperties;
+
+  interface ISystemVideoProperties {
+    readonly Director: string;
+    readonly FrameHeight: string;
+    readonly FrameWidth: string;
+    readonly Orientation: string;
+    readonly TotalBitrate: string;
+  }
+  var ISystemVideoProperties: abstract new (...args: any[]) => ISystemVideoProperties;
+
+  interface IUserDataPaths {
+    readonly CameraRoll: string;
+    readonly Cookies: string;
+    readonly Desktop: string;
+    readonly Documents: string;
+    readonly Downloads: string;
+    readonly Favorites: string;
+    readonly History: string;
+    readonly InternetCache: string;
+    readonly LocalAppData: string;
+    readonly LocalAppDataLow: string;
+    readonly Music: string;
+    readonly Pictures: string;
+    readonly Profile: string;
+    readonly Recent: string;
+    readonly RoamingAppData: string;
+    readonly SavedPictures: string;
+    readonly Screenshots: string;
+    readonly Templates: string;
+    readonly Videos: string;
+  }
+  var IUserDataPaths: abstract new (...args: any[]) => IUserDataPaths;
+
+  interface IUserDataPathsStatics {
+    GetDefault(): Windows.Storage.UserDataPaths;
+    GetForUser(user: Windows.System.User): Windows.Storage.UserDataPaths;
+  }
+  var IUserDataPathsStatics: abstract new (...args: any[]) => IUserDataPathsStatics;
+
+  interface StreamedFileDataRequestedHandler {
+    (stream: Windows.Storage.StreamedFileDataRequest): void;
+  }
+  var StreamedFileDataRequestedHandler: {
+    new(callback: (stream: Windows.Storage.StreamedFileDataRequest) => void): StreamedFileDataRequestedHandler;
+  };
+
+}
+
+declare namespace Windows.Storage.AccessCache {
+  class AccessListEntryView {
+    First(): Windows.Foundation.Collections.IIterator<Windows.Storage.AccessCache.AccessListEntry>;
+    GetAt(index: number): Windows.Storage.AccessCache.AccessListEntry;
+    GetMany(startIndex: number, items: Windows.Storage.AccessCache.AccessListEntry[]): number;
+    IndexOf(value: Windows.Storage.AccessCache.AccessListEntry, index: number): boolean;
+    readonly Size: number;
+  }
+
+  class ItemRemovedEventArgs implements Windows.Storage.AccessCache.IItemRemovedEventArgs {
+    readonly RemovedEntry: Windows.Storage.AccessCache.AccessListEntry;
+  }
+
+  class StorageApplicationPermissions {
+    static GetFutureAccessListForUser(user: Windows.System.User): Windows.Storage.AccessCache.StorageItemAccessList;
+    static GetMostRecentlyUsedListForUser(user: Windows.System.User): Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList;
+    static readonly FutureAccessList: Windows.Storage.AccessCache.StorageItemAccessList;
+    static readonly MostRecentlyUsedList: Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList;
+  }
+
+  class StorageItemAccessList implements Windows.Storage.AccessCache.IStorageItemAccessList {
+    Add(file: Windows.Storage.IStorageItem): string;
+    Add(file: Windows.Storage.IStorageItem, metadata: string): string;
+    AddOrReplace(token: string, file: Windows.Storage.IStorageItem): void;
+    AddOrReplace(token: string, file: Windows.Storage.IStorageItem, metadata: string): void;
+    CheckAccess(file: Windows.Storage.IStorageItem): boolean;
+    Clear(): void;
+    ContainsItem(token: string): boolean;
+    GetFileAsync(token: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    GetFileAsync(token: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    GetFolderAsync(token: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetFolderAsync(token: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetItemAsync(token: string): Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>;
+    GetItemAsync(token: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>;
+    Remove(token: string): void;
+    readonly Entries: Windows.Storage.AccessCache.AccessListEntryView;
+    readonly MaximumItemsAllowed: number;
+  }
+
+  class StorageItemMostRecentlyUsedList implements Windows.Storage.AccessCache.IStorageItemAccessList, Windows.Storage.AccessCache.IStorageItemMostRecentlyUsedList, Windows.Storage.AccessCache.IStorageItemMostRecentlyUsedList2 {
+    Add(file: Windows.Storage.IStorageItem): string;
+    Add(file: Windows.Storage.IStorageItem, metadata: string): string;
+    Add(file: Windows.Storage.IStorageItem, metadata: string, visibility: number): string;
+    AddOrReplace(token: string, file: Windows.Storage.IStorageItem): void;
+    AddOrReplace(token: string, file: Windows.Storage.IStorageItem, metadata: string): void;
+    AddOrReplace(token: string, file: Windows.Storage.IStorageItem, metadata: string, visibility: number): void;
+    CheckAccess(file: Windows.Storage.IStorageItem): boolean;
+    Clear(): void;
+    ContainsItem(token: string): boolean;
+    GetFileAsync(token: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    GetFileAsync(token: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    GetFolderAsync(token: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetFolderAsync(token: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetItemAsync(token: string): Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>;
+    GetItemAsync(token: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>;
+    Remove(token: string): void;
+    readonly Entries: Windows.Storage.AccessCache.AccessListEntryView;
+    readonly MaximumItemsAllowed: number;
+    ItemRemoved: Windows.Foundation.TypedEventHandler<Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList, Windows.Storage.AccessCache.ItemRemovedEventArgs> | null;
+  }
+
+  enum AccessCacheOptions {
+    None = 0,
+    DisallowUserInput = 1,
+    FastLocationsOnly = 2,
+    UseReadOnlyCachedCopy = 4,
+    SuppressAccessTimeUpdate = 8,
+  }
+
+  enum RecentStorageItemVisibility {
+    AppOnly = 0,
+    AppAndSystem = 1,
+  }
+
+  interface AccessListEntry {
+    Token: string;
+    Metadata: string;
+  }
+  var AccessListEntry: {
+    new(token: string, metadata: string): AccessListEntry;
+    new(fields: { Token?: string; Metadata?: string }): AccessListEntry;
+  };
+
+  interface IItemRemovedEventArgs {
+    readonly RemovedEntry: Windows.Storage.AccessCache.AccessListEntry;
+  }
+  var IItemRemovedEventArgs: abstract new (...args: any[]) => IItemRemovedEventArgs;
+
+  interface IStorageApplicationPermissionsStatics {
+    readonly FutureAccessList: Windows.Storage.AccessCache.StorageItemAccessList;
+    readonly MostRecentlyUsedList: Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList;
+  }
+  var IStorageApplicationPermissionsStatics: abstract new (...args: any[]) => IStorageApplicationPermissionsStatics;
+
+  interface IStorageApplicationPermissionsStatics2 {
+    GetFutureAccessListForUser(user: Windows.System.User): Windows.Storage.AccessCache.StorageItemAccessList;
+    GetMostRecentlyUsedListForUser(user: Windows.System.User): Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList;
+  }
+  var IStorageApplicationPermissionsStatics2: abstract new (...args: any[]) => IStorageApplicationPermissionsStatics2;
+
+  interface IStorageItemAccessList {
+    Add(file: Windows.Storage.IStorageItem): string;
+    Add(file: Windows.Storage.IStorageItem, metadata: string): string;
+    AddOrReplace(token: string, file: Windows.Storage.IStorageItem): void;
+    AddOrReplace(token: string, file: Windows.Storage.IStorageItem, metadata: string): void;
+    CheckAccess(file: Windows.Storage.IStorageItem): boolean;
+    Clear(): void;
+    ContainsItem(token: string): boolean;
+    GetFileAsync(token: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    GetFileAsync(token: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    GetFolderAsync(token: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetFolderAsync(token: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetItemAsync(token: string): Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>;
+    GetItemAsync(token: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>;
+    Remove(token: string): void;
+    readonly Entries: Windows.Storage.AccessCache.AccessListEntryView;
+    readonly MaximumItemsAllowed: number;
+  }
+  var IStorageItemAccessList: abstract new (...args: any[]) => IStorageItemAccessList;
+
+  interface IStorageItemMostRecentlyUsedList extends Windows.Storage.AccessCache.IStorageItemAccessList {
+    Add(file: Windows.Storage.IStorageItem): string;
+    Add(file: Windows.Storage.IStorageItem, metadata: string): string;
+    AddOrReplace(token: string, file: Windows.Storage.IStorageItem): void;
+    AddOrReplace(token: string, file: Windows.Storage.IStorageItem, metadata: string): void;
+    CheckAccess(file: Windows.Storage.IStorageItem): boolean;
+    Clear(): void;
+    ContainsItem(token: string): boolean;
+    GetFileAsync(token: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    GetFileAsync(token: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    GetFolderAsync(token: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetFolderAsync(token: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetItemAsync(token: string): Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>;
+    GetItemAsync(token: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>;
+    Remove(token: string): void;
+    ItemRemoved: Windows.Foundation.TypedEventHandler<Windows.Storage.AccessCache.StorageItemMostRecentlyUsedList, Windows.Storage.AccessCache.ItemRemovedEventArgs> | null;
+  }
+  var IStorageItemMostRecentlyUsedList: abstract new (...args: any[]) => IStorageItemMostRecentlyUsedList;
+
+  interface IStorageItemMostRecentlyUsedList2 extends Windows.Storage.AccessCache.IStorageItemAccessList, Windows.Storage.AccessCache.IStorageItemMostRecentlyUsedList {
+    Add(file: Windows.Storage.IStorageItem, metadata: string, visibility: number): string;
+    Add(file: Windows.Storage.IStorageItem): string;
+    Add(file: Windows.Storage.IStorageItem, metadata: string): string;
+    AddOrReplace(token: string, file: Windows.Storage.IStorageItem, metadata: string, visibility: number): void;
+    AddOrReplace(token: string, file: Windows.Storage.IStorageItem): void;
+    AddOrReplace(token: string, file: Windows.Storage.IStorageItem, metadata: string): void;
+    CheckAccess(file: Windows.Storage.IStorageItem): boolean;
+    Clear(): void;
+    ContainsItem(token: string): boolean;
+    GetFileAsync(token: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    GetFileAsync(token: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    GetFolderAsync(token: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetFolderAsync(token: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetItemAsync(token: string): Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>;
+    GetItemAsync(token: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>;
+    Remove(token: string): void;
+  }
+  var IStorageItemMostRecentlyUsedList2: abstract new (...args: any[]) => IStorageItemMostRecentlyUsedList2;
+
+}
+
+declare namespace Windows.Storage.BulkAccess {
+  class FileInformation implements Windows.Storage.BulkAccess.IStorageItemInformation, Windows.Storage.IStorageFile, Windows.Storage.IStorageFile2, Windows.Storage.IStorageFilePropertiesWithAvailability, Windows.Storage.IStorageItem, Windows.Storage.IStorageItem2, Windows.Storage.IStorageItemProperties, Windows.Storage.IStorageItemPropertiesWithProvider, Windows.Storage.Streams.IInputStreamReference, Windows.Storage.Streams.IRandomAccessStreamReference {
+    CopyAndReplaceAsync(fileToReplace: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncAction;
+    CopyAsync(destinationFolder: Windows.Storage.IStorageFolder): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CopyAsync(destinationFolder: Windows.Storage.IStorageFolder, desiredNewName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CopyAsync(destinationFolder: Windows.Storage.IStorageFolder, desiredNewName: string, option: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    DeleteAsync(option: number): Windows.Foundation.IAsyncAction;
+    GetBasicPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.BasicProperties>;
+    GetParentAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetThumbnailAsync(mode: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetThumbnailAsync(mode: number, requestedSize: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetThumbnailAsync(mode: number, requestedSize: number, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    IsEqual(item: Windows.Storage.IStorageItem): boolean;
+    IsOfType(type: number): boolean;
+    MoveAndReplaceAsync(fileToReplace: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncAction;
+    MoveAsync(destinationFolder: Windows.Storage.IStorageFolder): Windows.Foundation.IAsyncAction;
+    MoveAsync(destinationFolder: Windows.Storage.IStorageFolder, desiredNewName: string): Windows.Foundation.IAsyncAction;
+    MoveAsync(destinationFolder: Windows.Storage.IStorageFolder, desiredNewName: string, option: number): Windows.Foundation.IAsyncAction;
+    OpenAsync(accessMode: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    OpenAsync(accessMode: number, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    OpenReadAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamWithContentType>;
+    OpenSequentialReadAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IInputStream>;
+    OpenTransactedWriteAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageStreamTransaction>;
+    OpenTransactedWriteAsync(options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageStreamTransaction>;
+    RenameAsync(desiredName: string): Windows.Foundation.IAsyncAction;
+    RenameAsync(desiredName: string, option: number): Windows.Foundation.IAsyncAction;
+    readonly Attributes: number;
+    readonly BasicProperties: Windows.Storage.FileProperties.BasicProperties;
+    readonly ContentType: string;
+    readonly DateCreated: Windows.Foundation.DateTime;
+    readonly DisplayName: string;
+    readonly DisplayType: string;
+    readonly DocumentProperties: Windows.Storage.FileProperties.DocumentProperties;
+    readonly FileType: string;
+    readonly FolderRelativeId: string;
+    readonly ImageProperties: Windows.Storage.FileProperties.ImageProperties;
+    readonly IsAvailable: boolean;
+    readonly MusicProperties: Windows.Storage.FileProperties.MusicProperties;
+    readonly Name: string;
+    readonly Path: string;
+    readonly Properties: Windows.Storage.FileProperties.StorageItemContentProperties;
+    readonly Provider: Windows.Storage.StorageProvider;
+    readonly Thumbnail: Windows.Storage.FileProperties.StorageItemThumbnail;
+    readonly VideoProperties: Windows.Storage.FileProperties.VideoProperties;
+    PropertiesUpdated: Windows.Foundation.TypedEventHandler<Windows.Storage.BulkAccess.IStorageItemInformation, Object> | null;
+    ThumbnailUpdated: Windows.Foundation.TypedEventHandler<Windows.Storage.BulkAccess.IStorageItemInformation, Object> | null;
+  }
+
+  class FileInformationFactory implements Windows.Storage.BulkAccess.IFileInformationFactory {
+    constructor(queryResult: Windows.Storage.Search.IStorageQueryResultBase, mode: number);
+    constructor(queryResult: Windows.Storage.Search.IStorageQueryResultBase, mode: number, requestedThumbnailSize: number);
+    constructor(queryResult: Windows.Storage.Search.IStorageQueryResultBase, mode: number, requestedThumbnailSize: number, thumbnailOptions: number);
+    constructor(queryResult: Windows.Storage.Search.IStorageQueryResultBase, mode: number, requestedThumbnailSize: number, thumbnailOptions: number, delayLoad: boolean);
+    GetFilesAsync(startIndex: number, maxItemsToRetrieve: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.BulkAccess.FileInformation> | Windows.Storage.BulkAccess.FileInformation[]>;
+    GetFilesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.BulkAccess.FileInformation> | Windows.Storage.BulkAccess.FileInformation[]>;
+    GetFoldersAsync(startIndex: number, maxItemsToRetrieve: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.BulkAccess.FolderInformation> | Windows.Storage.BulkAccess.FolderInformation[]>;
+    GetFoldersAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.BulkAccess.FolderInformation> | Windows.Storage.BulkAccess.FolderInformation[]>;
+    GetItemsAsync(startIndex: number, maxItemsToRetrieve: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.BulkAccess.IStorageItemInformation> | Windows.Storage.BulkAccess.IStorageItemInformation[]>;
+    GetItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.BulkAccess.IStorageItemInformation> | Windows.Storage.BulkAccess.IStorageItemInformation[]>;
+    GetVirtualizedFilesVector(): Object;
+    GetVirtualizedFoldersVector(): Object;
+    GetVirtualizedItemsVector(): Object;
+  }
+
+  class FolderInformation implements Windows.Storage.BulkAccess.IStorageItemInformation, Windows.Storage.IStorageFolder, Windows.Storage.IStorageFolder2, Windows.Storage.IStorageItem, Windows.Storage.IStorageItem2, Windows.Storage.IStorageItemProperties, Windows.Storage.IStorageItemPropertiesWithProvider, Windows.Storage.Search.IStorageFolderQueryOperations {
+    AreQueryOptionsSupported(queryOptions: Windows.Storage.Search.QueryOptions): boolean;
+    CreateFileAsync(desiredName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CreateFileAsync(desiredName: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CreateFileQuery(): Windows.Storage.Search.StorageFileQueryResult;
+    CreateFileQuery(query: number): Windows.Storage.Search.StorageFileQueryResult;
+    CreateFileQueryWithOptions(queryOptions: Windows.Storage.Search.QueryOptions): Windows.Storage.Search.StorageFileQueryResult;
+    CreateFolderAsync(desiredName: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    CreateFolderAsync(desiredName: string, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    CreateFolderQuery(): Windows.Storage.Search.StorageFolderQueryResult;
+    CreateFolderQuery(query: number): Windows.Storage.Search.StorageFolderQueryResult;
+    CreateFolderQueryWithOptions(queryOptions: Windows.Storage.Search.QueryOptions): Windows.Storage.Search.StorageFolderQueryResult;
+    CreateItemQuery(): Windows.Storage.Search.StorageItemQueryResult;
+    CreateItemQueryWithOptions(queryOptions: Windows.Storage.Search.QueryOptions): Windows.Storage.Search.StorageItemQueryResult;
+    DeleteAsync(): Windows.Foundation.IAsyncAction;
+    DeleteAsync(option: number): Windows.Foundation.IAsyncAction;
+    GetBasicPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.BasicProperties>;
+    GetFileAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    GetFilesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[]>;
+    GetFilesAsync(query: number, startIndex: number, maxItemsToRetrieve: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[]>;
+    GetFilesAsync(query: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[]>;
+    GetFolderAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetFoldersAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFolder> | Windows.Storage.StorageFolder[]>;
+    GetFoldersAsync(query: number, startIndex: number, maxItemsToRetrieve: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFolder> | Windows.Storage.StorageFolder[]>;
+    GetFoldersAsync(query: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFolder> | Windows.Storage.StorageFolder[]>;
+    GetIndexedStateAsync(): Windows.Foundation.IAsyncOperation<number>;
+    GetItemAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>;
+    GetItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[]>;
+    GetItemsAsync(startIndex: number, maxItemsToRetrieve: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[]>;
+    GetParentAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    GetThumbnailAsync(mode: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetThumbnailAsync(mode: number, requestedSize: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    GetThumbnailAsync(mode: number, requestedSize: number, options: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
+    IsCommonFileQuerySupported(query: number): boolean;
+    IsCommonFolderQuerySupported(query: number): boolean;
+    IsEqual(item: Windows.Storage.IStorageItem): boolean;
+    IsOfType(type: number): boolean;
+    RenameAsync(desiredName: string): Windows.Foundation.IAsyncAction;
+    RenameAsync(desiredName: string, option: number): Windows.Foundation.IAsyncAction;
+    TryGetItemAsync(name: string): Windows.Foundation.IAsyncOperation<Windows.Storage.IStorageItem>;
+    readonly Attributes: number;
+    readonly BasicProperties: Windows.Storage.FileProperties.BasicProperties;
+    readonly DateCreated: Windows.Foundation.DateTime;
+    readonly DisplayName: string;
+    readonly DisplayType: string;
+    readonly DocumentProperties: Windows.Storage.FileProperties.DocumentProperties;
+    readonly FolderRelativeId: string;
+    readonly ImageProperties: Windows.Storage.FileProperties.ImageProperties;
+    readonly MusicProperties: Windows.Storage.FileProperties.MusicProperties;
+    readonly Name: string;
+    readonly Path: string;
+    readonly Properties: Windows.Storage.FileProperties.StorageItemContentProperties;
+    readonly Provider: Windows.Storage.StorageProvider;
+    readonly Thumbnail: Windows.Storage.FileProperties.StorageItemThumbnail;
+    readonly VideoProperties: Windows.Storage.FileProperties.VideoProperties;
+    PropertiesUpdated: Windows.Foundation.TypedEventHandler<Windows.Storage.BulkAccess.IStorageItemInformation, Object> | null;
+    ThumbnailUpdated: Windows.Foundation.TypedEventHandler<Windows.Storage.BulkAccess.IStorageItemInformation, Object> | null;
+  }
+
+  interface IFileInformationFactory {
+    GetFilesAsync(startIndex: number, maxItemsToRetrieve: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.BulkAccess.FileInformation> | Windows.Storage.BulkAccess.FileInformation[]>;
+    GetFilesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.BulkAccess.FileInformation> | Windows.Storage.BulkAccess.FileInformation[]>;
+    GetFoldersAsync(startIndex: number, maxItemsToRetrieve: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.BulkAccess.FolderInformation> | Windows.Storage.BulkAccess.FolderInformation[]>;
+    GetFoldersAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.BulkAccess.FolderInformation> | Windows.Storage.BulkAccess.FolderInformation[]>;
+    GetItemsAsync(startIndex: number, maxItemsToRetrieve: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.BulkAccess.IStorageItemInformation> | Windows.Storage.BulkAccess.IStorageItemInformation[]>;
+    GetItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.BulkAccess.IStorageItemInformation> | Windows.Storage.BulkAccess.IStorageItemInformation[]>;
+    GetVirtualizedFilesVector(): Object;
+    GetVirtualizedFoldersVector(): Object;
+    GetVirtualizedItemsVector(): Object;
+  }
+  var IFileInformationFactory: abstract new (...args: any[]) => IFileInformationFactory;
+
+  interface IFileInformationFactoryFactory {
+    CreateWithMode(queryResult: Windows.Storage.Search.IStorageQueryResultBase, mode: number): Windows.Storage.BulkAccess.FileInformationFactory;
+    CreateWithModeAndSize(queryResult: Windows.Storage.Search.IStorageQueryResultBase, mode: number, requestedThumbnailSize: number): Windows.Storage.BulkAccess.FileInformationFactory;
+    CreateWithModeAndSizeAndOptions(queryResult: Windows.Storage.Search.IStorageQueryResultBase, mode: number, requestedThumbnailSize: number, thumbnailOptions: number): Windows.Storage.BulkAccess.FileInformationFactory;
+    CreateWithModeAndSizeAndOptionsAndFlags(queryResult: Windows.Storage.Search.IStorageQueryResultBase, mode: number, requestedThumbnailSize: number, thumbnailOptions: number, delayLoad: boolean): Windows.Storage.BulkAccess.FileInformationFactory;
+  }
+  var IFileInformationFactoryFactory: abstract new (...args: any[]) => IFileInformationFactoryFactory;
+
+  interface IStorageItemInformation {
+    readonly BasicProperties: Windows.Storage.FileProperties.BasicProperties;
+    readonly DocumentProperties: Windows.Storage.FileProperties.DocumentProperties;
+    readonly ImageProperties: Windows.Storage.FileProperties.ImageProperties;
+    readonly MusicProperties: Windows.Storage.FileProperties.MusicProperties;
+    readonly Thumbnail: Windows.Storage.FileProperties.StorageItemThumbnail;
+    readonly VideoProperties: Windows.Storage.FileProperties.VideoProperties;
+    PropertiesUpdated: Windows.Foundation.TypedEventHandler<Windows.Storage.BulkAccess.IStorageItemInformation, Object> | null;
+    ThumbnailUpdated: Windows.Foundation.TypedEventHandler<Windows.Storage.BulkAccess.IStorageItemInformation, Object> | null;
+  }
+  var IStorageItemInformation: abstract new (...args: any[]) => IStorageItemInformation;
+
+}
+
+declare namespace Windows.Storage.Compression {
+  class Compressor implements Windows.Foundation.IClosable, Windows.Storage.Compression.ICompressor, Windows.Storage.Streams.IOutputStream {
+    constructor(underlyingStream: Windows.Storage.Streams.IOutputStream);
+    constructor(underlyingStream: Windows.Storage.Streams.IOutputStream, algorithm: number, blockSize: number);
+    Close(): void;
+    DetachStream(): Windows.Storage.Streams.IOutputStream;
+    FinishAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    WriteAsync(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+  }
+
+  class Decompressor implements Windows.Foundation.IClosable, Windows.Storage.Compression.IDecompressor, Windows.Storage.Streams.IInputStream {
+    constructor(underlyingStream: Windows.Storage.Streams.IInputStream);
+    Close(): void;
+    DetachStream(): Windows.Storage.Streams.IInputStream;
+    ReadAsync(buffer: Windows.Storage.Streams.IBuffer, count: number, options: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number>;
+  }
+
+  enum CompressAlgorithm {
+    InvalidAlgorithm = 0,
+    NullAlgorithm = 1,
+    Mszip = 2,
+    Xpress = 3,
+    XpressHuff = 4,
+    Lzms = 5,
+  }
+
+  interface ICompressor extends Windows.Foundation.IClosable, Windows.Storage.Streams.IOutputStream {
+    Close(): void;
+    DetachStream(): Windows.Storage.Streams.IOutputStream;
+    FinishAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    WriteAsync(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+  }
+  var ICompressor: abstract new (...args: any[]) => ICompressor;
+
+  interface ICompressorFactory {
+    CreateCompressor(underlyingStream: Windows.Storage.Streams.IOutputStream): Windows.Storage.Compression.Compressor;
+    CreateCompressorEx(underlyingStream: Windows.Storage.Streams.IOutputStream, algorithm: number, blockSize: number): Windows.Storage.Compression.Compressor;
+  }
+  var ICompressorFactory: abstract new (...args: any[]) => ICompressorFactory;
+
+  interface IDecompressor extends Windows.Foundation.IClosable, Windows.Storage.Streams.IInputStream {
+    Close(): void;
+    DetachStream(): Windows.Storage.Streams.IInputStream;
+    ReadAsync(buffer: Windows.Storage.Streams.IBuffer, count: number, options: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number>;
+  }
+  var IDecompressor: abstract new (...args: any[]) => IDecompressor;
+
+  interface IDecompressorFactory {
+    CreateDecompressor(underlyingStream: Windows.Storage.Streams.IInputStream): Windows.Storage.Compression.Decompressor;
+  }
+  var IDecompressorFactory: abstract new (...args: any[]) => IDecompressorFactory;
+
+}
+
+declare namespace Windows.Storage.FileProperties {
+  class BasicProperties implements Windows.Storage.FileProperties.IBasicProperties, Windows.Storage.FileProperties.IStorageItemExtraProperties {
+    RetrievePropertiesAsync(propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>>;
+    SavePropertiesAsync(propertiesToSave: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Object>> | Windows.Foundation.Collections.IKeyValuePair<string, Object>[]): Windows.Foundation.IAsyncAction;
+    SavePropertiesAsync(): Windows.Foundation.IAsyncAction;
+    readonly DateModified: Windows.Foundation.DateTime;
+    readonly ItemDate: Windows.Foundation.DateTime;
+    readonly Size: number | bigint;
+  }
+
+  class DocumentProperties implements Windows.Storage.FileProperties.IDocumentProperties, Windows.Storage.FileProperties.IStorageItemExtraProperties {
+    RetrievePropertiesAsync(propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>>;
+    SavePropertiesAsync(propertiesToSave: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Object>> | Windows.Foundation.Collections.IKeyValuePair<string, Object>[]): Windows.Foundation.IAsyncAction;
+    SavePropertiesAsync(): Windows.Foundation.IAsyncAction;
+    readonly Author: Windows.Foundation.Collections.IVector<string> | string[];
+    Comment: string;
+    readonly Keywords: Windows.Foundation.Collections.IVector<string> | string[];
+    Title: string;
+  }
+
+  class GeotagHelper {
+    static GetGeotagAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Devices.Geolocation.Geopoint>;
+    static SetGeotagAsync(file: Windows.Storage.IStorageFile, geopoint: Windows.Devices.Geolocation.Geopoint): Windows.Foundation.IAsyncAction;
+    static SetGeotagFromGeolocatorAsync(file: Windows.Storage.IStorageFile, geolocator: Windows.Devices.Geolocation.Geolocator): Windows.Foundation.IAsyncAction;
+  }
+
+  class ImageProperties implements Windows.Storage.FileProperties.IImageProperties, Windows.Storage.FileProperties.IStorageItemExtraProperties {
+    RetrievePropertiesAsync(propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>>;
+    SavePropertiesAsync(propertiesToSave: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Object>> | Windows.Foundation.Collections.IKeyValuePair<string, Object>[]): Windows.Foundation.IAsyncAction;
+    SavePropertiesAsync(): Windows.Foundation.IAsyncAction;
+    CameraManufacturer: string;
+    CameraModel: string;
+    DateTaken: Windows.Foundation.DateTime;
+    readonly Height: number;
+    readonly Keywords: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Latitude: number | null;
+    readonly Longitude: number | null;
+    readonly Orientation: number;
+    readonly PeopleNames: Windows.Foundation.Collections.IVectorView<string> | string[];
+    Rating: number;
+    Title: string;
+    readonly Width: number;
+  }
+
+  class MusicProperties implements Windows.Storage.FileProperties.IMusicProperties, Windows.Storage.FileProperties.IStorageItemExtraProperties {
+    RetrievePropertiesAsync(propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>>;
+    SavePropertiesAsync(propertiesToSave: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Object>> | Windows.Foundation.Collections.IKeyValuePair<string, Object>[]): Windows.Foundation.IAsyncAction;
+    SavePropertiesAsync(): Windows.Foundation.IAsyncAction;
+    Album: string;
+    AlbumArtist: string;
+    Artist: string;
+    readonly Bitrate: number;
+    readonly Composers: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Conductors: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly Genre: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Producers: Windows.Foundation.Collections.IVector<string> | string[];
+    Publisher: string;
+    Rating: number;
+    Subtitle: string;
+    Title: string;
+    TrackNumber: number;
+    readonly Writers: Windows.Foundation.Collections.IVector<string> | string[];
+    Year: number;
+  }
+
+  class StorageItemContentProperties implements Windows.Storage.FileProperties.IStorageItemContentProperties, Windows.Storage.FileProperties.IStorageItemExtraProperties {
+    GetDocumentPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.DocumentProperties>;
+    GetImagePropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.ImageProperties>;
+    GetMusicPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.MusicProperties>;
+    GetVideoPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.VideoProperties>;
+    RetrievePropertiesAsync(propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>>;
+    SavePropertiesAsync(propertiesToSave: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Object>> | Windows.Foundation.Collections.IKeyValuePair<string, Object>[]): Windows.Foundation.IAsyncAction;
+    SavePropertiesAsync(): Windows.Foundation.IAsyncAction;
+  }
+
+  class StorageItemThumbnail implements Windows.Foundation.IClosable, Windows.Storage.FileProperties.IThumbnailProperties, Windows.Storage.Streams.IContentTypeProvider, Windows.Storage.Streams.IInputStream, Windows.Storage.Streams.IOutputStream, Windows.Storage.Streams.IRandomAccessStream, Windows.Storage.Streams.IRandomAccessStreamWithContentType {
+    CloneStream(): Windows.Storage.Streams.IRandomAccessStream;
+    Close(): void;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    GetInputStreamAt(position: number | bigint): Windows.Storage.Streams.IInputStream;
+    GetOutputStreamAt(position: number | bigint): Windows.Storage.Streams.IOutputStream;
+    ReadAsync(buffer: Windows.Storage.Streams.IBuffer, count: number, options: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number>;
+    Seek(position: number | bigint): void;
+    WriteAsync(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    readonly CanRead: boolean;
+    readonly CanWrite: boolean;
+    readonly ContentType: string;
+    readonly OriginalHeight: number;
+    readonly OriginalWidth: number;
+    readonly Position: number | bigint;
+    readonly ReturnedSmallerCachedSize: boolean;
+    Size: number | bigint;
+    readonly Type: number;
+  }
+
+  class VideoProperties implements Windows.Storage.FileProperties.IStorageItemExtraProperties, Windows.Storage.FileProperties.IVideoProperties {
+    RetrievePropertiesAsync(propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>>;
+    SavePropertiesAsync(propertiesToSave: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Object>> | Windows.Foundation.Collections.IKeyValuePair<string, Object>[]): Windows.Foundation.IAsyncAction;
+    SavePropertiesAsync(): Windows.Foundation.IAsyncAction;
+    readonly Bitrate: number;
+    readonly Directors: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly Height: number;
+    readonly Keywords: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Latitude: number | null;
+    readonly Longitude: number | null;
+    readonly Orientation: number;
+    readonly Producers: Windows.Foundation.Collections.IVector<string> | string[];
+    Publisher: string;
+    Rating: number;
+    Subtitle: string;
+    Title: string;
+    readonly Width: number;
+    readonly Writers: Windows.Foundation.Collections.IVector<string> | string[];
+    Year: number;
+  }
+
+  enum PhotoOrientation {
+    Unspecified = 0,
+    Normal = 1,
+    FlipHorizontal = 2,
+    Rotate180 = 3,
+    FlipVertical = 4,
+    Transpose = 5,
+    Rotate270 = 6,
+    Transverse = 7,
+    Rotate90 = 8,
+  }
+
+  enum PropertyPrefetchOptions {
+    None = 0,
+    MusicProperties = 1,
+    VideoProperties = 2,
+    ImageProperties = 4,
+    DocumentProperties = 8,
+    BasicProperties = 16,
+  }
+
+  enum ThumbnailMode {
+    PicturesView = 0,
+    VideosView = 1,
+    MusicView = 2,
+    DocumentsView = 3,
+    ListView = 4,
+    SingleItem = 5,
+  }
+
+  enum ThumbnailOptions {
+    None = 0,
+    ReturnOnlyIfCached = 1,
+    ResizeThumbnail = 2,
+    UseCurrentScale = 4,
+  }
+
+  enum ThumbnailType {
+    Image = 0,
+    Icon = 1,
+  }
+
+  enum VideoOrientation {
+    Normal = 0,
+    Rotate90 = 90,
+    Rotate180 = 180,
+    Rotate270 = 270,
+  }
+
+  interface IBasicProperties {
+    readonly DateModified: Windows.Foundation.DateTime;
+    readonly ItemDate: Windows.Foundation.DateTime;
+    readonly Size: number | bigint;
+  }
+  var IBasicProperties: abstract new (...args: any[]) => IBasicProperties;
+
+  interface IDocumentProperties extends Windows.Storage.FileProperties.IStorageItemExtraProperties {
+    RetrievePropertiesAsync(propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>>;
+    SavePropertiesAsync(propertiesToSave: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Object>> | Windows.Foundation.Collections.IKeyValuePair<string, Object>[]): Windows.Foundation.IAsyncAction;
+    SavePropertiesAsync(): Windows.Foundation.IAsyncAction;
+    readonly Author: Windows.Foundation.Collections.IVector<string> | string[];
+    Comment: string;
+    readonly Keywords: Windows.Foundation.Collections.IVector<string> | string[];
+    Title: string;
+  }
+  var IDocumentProperties: abstract new (...args: any[]) => IDocumentProperties;
+
+  interface IGeotagHelperStatics {
+    GetGeotagAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<Windows.Devices.Geolocation.Geopoint>;
+    SetGeotagAsync(file: Windows.Storage.IStorageFile, geopoint: Windows.Devices.Geolocation.Geopoint): Windows.Foundation.IAsyncAction;
+    SetGeotagFromGeolocatorAsync(file: Windows.Storage.IStorageFile, geolocator: Windows.Devices.Geolocation.Geolocator): Windows.Foundation.IAsyncAction;
+  }
+  var IGeotagHelperStatics: abstract new (...args: any[]) => IGeotagHelperStatics;
+
+  interface IImageProperties extends Windows.Storage.FileProperties.IStorageItemExtraProperties {
+    RetrievePropertiesAsync(propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>>;
+    SavePropertiesAsync(propertiesToSave: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Object>> | Windows.Foundation.Collections.IKeyValuePair<string, Object>[]): Windows.Foundation.IAsyncAction;
+    SavePropertiesAsync(): Windows.Foundation.IAsyncAction;
+    CameraManufacturer: string;
+    CameraModel: string;
+    DateTaken: Windows.Foundation.DateTime;
+    readonly Height: number;
+    readonly Keywords: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Latitude: number | null;
+    readonly Longitude: number | null;
+    readonly Orientation: number;
+    readonly PeopleNames: Windows.Foundation.Collections.IVectorView<string> | string[];
+    Rating: number;
+    Title: string;
+    readonly Width: number;
+  }
+  var IImageProperties: abstract new (...args: any[]) => IImageProperties;
+
+  interface IMusicProperties extends Windows.Storage.FileProperties.IStorageItemExtraProperties {
+    RetrievePropertiesAsync(propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>>;
+    SavePropertiesAsync(propertiesToSave: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Object>> | Windows.Foundation.Collections.IKeyValuePair<string, Object>[]): Windows.Foundation.IAsyncAction;
+    SavePropertiesAsync(): Windows.Foundation.IAsyncAction;
+    Album: string;
+    AlbumArtist: string;
+    Artist: string;
+    readonly Bitrate: number;
+    readonly Composers: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Conductors: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly Genre: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Producers: Windows.Foundation.Collections.IVector<string> | string[];
+    Publisher: string;
+    Rating: number;
+    Subtitle: string;
+    Title: string;
+    TrackNumber: number;
+    readonly Writers: Windows.Foundation.Collections.IVector<string> | string[];
+    Year: number;
+  }
+  var IMusicProperties: abstract new (...args: any[]) => IMusicProperties;
+
+  interface IStorageItemContentProperties extends Windows.Storage.FileProperties.IStorageItemExtraProperties {
+    GetDocumentPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.DocumentProperties>;
+    GetImagePropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.ImageProperties>;
+    GetMusicPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.MusicProperties>;
+    GetVideoPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.VideoProperties>;
+    RetrievePropertiesAsync(propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>>;
+    SavePropertiesAsync(propertiesToSave: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Object>> | Windows.Foundation.Collections.IKeyValuePair<string, Object>[]): Windows.Foundation.IAsyncAction;
+    SavePropertiesAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var IStorageItemContentProperties: abstract new (...args: any[]) => IStorageItemContentProperties;
+
+  interface IStorageItemExtraProperties {
+    RetrievePropertiesAsync(propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>>;
+    SavePropertiesAsync(propertiesToSave: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Object>> | Windows.Foundation.Collections.IKeyValuePair<string, Object>[]): Windows.Foundation.IAsyncAction;
+    SavePropertiesAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var IStorageItemExtraProperties: abstract new (...args: any[]) => IStorageItemExtraProperties;
+
+  interface IThumbnailProperties {
+    readonly OriginalHeight: number;
+    readonly OriginalWidth: number;
+    readonly ReturnedSmallerCachedSize: boolean;
+    readonly Type: number;
+  }
+  var IThumbnailProperties: abstract new (...args: any[]) => IThumbnailProperties;
+
+  interface IVideoProperties extends Windows.Storage.FileProperties.IStorageItemExtraProperties {
+    RetrievePropertiesAsync(propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>>;
+    SavePropertiesAsync(propertiesToSave: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, Object>> | Windows.Foundation.Collections.IKeyValuePair<string, Object>[]): Windows.Foundation.IAsyncAction;
+    SavePropertiesAsync(): Windows.Foundation.IAsyncAction;
+    readonly Bitrate: number;
+    readonly Directors: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly Height: number;
+    readonly Keywords: Windows.Foundation.Collections.IVector<string> | string[];
+    readonly Latitude: number | null;
+    readonly Longitude: number | null;
+    readonly Orientation: number;
+    readonly Producers: Windows.Foundation.Collections.IVector<string> | string[];
+    Publisher: string;
+    Rating: number;
+    Subtitle: string;
+    Title: string;
+    readonly Width: number;
+    readonly Writers: Windows.Foundation.Collections.IVector<string> | string[];
+    Year: number;
+  }
+  var IVideoProperties: abstract new (...args: any[]) => IVideoProperties;
+
+}
+
+declare namespace Windows.Storage.Pickers {
+  class FileExtensionVector {
+    Append(value: string): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<string>;
+    GetAt(index: number): string;
+    GetMany(startIndex: number, items: string[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<string> | string[];
+    IndexOf(value: string, index: number): boolean;
+    InsertAt(index: number, value: string): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: string[]): void;
+    SetAt(index: number, value: string): void;
+    readonly Size: number;
+  }
+
+  class FileOpenPicker implements Windows.Storage.Pickers.IFileOpenPicker, Windows.Storage.Pickers.IFileOpenPicker2, Windows.Storage.Pickers.IFileOpenPicker3, Windows.Storage.Pickers.IFileOpenPickerWithOperationId {
+    constructor();
+    static CreateForUser(user: Windows.System.User): Windows.Storage.Pickers.FileOpenPicker;
+    PickMultipleFilesAndContinue(): void;
+    PickMultipleFilesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[]>;
+    PickSingleFileAndContinue(): void;
+    PickSingleFileAsync(pickerOperationId: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    PickSingleFileAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    static ResumePickSingleFileAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CommitButtonText: string;
+    readonly ContinuationData: Windows.Foundation.Collections.ValueSet;
+    readonly FileTypeFilter: Windows.Foundation.Collections.IVector<string> | string[];
+    SettingsIdentifier: string;
+    SuggestedStartLocation: number;
+    readonly User: Windows.System.User;
+    ViewMode: number;
+  }
+
+  class FilePickerFileTypesOrderedMap {
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, Windows.Foundation.Collections.IVector<string> | string[]>>;
+    GetView(): Windows.Foundation.Collections.IMapView<string, Windows.Foundation.Collections.IVector<string> | string[]>;
+    HasKey(key: string): boolean;
+    Insert(key: string, value: Windows.Foundation.Collections.IVector<string> | string[]): boolean;
+    Lookup(key: string): Windows.Foundation.Collections.IVector<string> | string[];
+    Remove(key: string): void;
+    readonly Size: number;
+  }
+
+  class FilePickerSelectedFilesArray {
+    First(): Windows.Foundation.Collections.IIterator<Windows.Storage.StorageFile>;
+    GetAt(index: number): Windows.Storage.StorageFile;
+    GetMany(startIndex: number, items: Windows.Storage.StorageFile[]): number;
+    IndexOf(value: Windows.Storage.StorageFile, index: number): boolean;
+    readonly Size: number;
+  }
+
+  class FileSavePicker implements Windows.Storage.Pickers.IFileSavePicker, Windows.Storage.Pickers.IFileSavePicker2, Windows.Storage.Pickers.IFileSavePicker3, Windows.Storage.Pickers.IFileSavePicker4 {
+    constructor();
+    static CreateForUser(user: Windows.System.User): Windows.Storage.Pickers.FileSavePicker;
+    PickSaveFileAndContinue(): void;
+    PickSaveFileAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CommitButtonText: string;
+    readonly ContinuationData: Windows.Foundation.Collections.ValueSet;
+    DefaultFileExtension: string;
+    EnterpriseId: string;
+    readonly FileTypeChoices: Windows.Foundation.Collections.IMap<string, Windows.Foundation.Collections.IVector<string> | string[]> | Record<string, Windows.Foundation.Collections.IVector<string> | string[]>;
+    SettingsIdentifier: string;
+    SuggestedFileName: string;
+    SuggestedSaveFile: Windows.Storage.StorageFile;
+    SuggestedStartLocation: number;
+    readonly User: Windows.System.User;
+  }
+
+  class FolderPicker implements Windows.Storage.Pickers.IFolderPicker, Windows.Storage.Pickers.IFolderPicker2, Windows.Storage.Pickers.IFolderPicker3 {
+    constructor();
+    static CreateForUser(user: Windows.System.User): Windows.Storage.Pickers.FolderPicker;
+    PickFolderAndContinue(): void;
+    PickSingleFolderAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    CommitButtonText: string;
+    readonly ContinuationData: Windows.Foundation.Collections.ValueSet;
+    readonly FileTypeFilter: Windows.Foundation.Collections.IVector<string> | string[];
+    SettingsIdentifier: string;
+    SuggestedStartLocation: number;
+    readonly User: Windows.System.User;
+    ViewMode: number;
+  }
+
+  enum PickerLocationId {
+    DocumentsLibrary = 0,
+    ComputerFolder = 1,
+    Desktop = 2,
+    Downloads = 3,
+    HomeGroup = 4,
+    MusicLibrary = 5,
+    PicturesLibrary = 6,
+    VideosLibrary = 7,
+    Objects3D = 8,
+    Unspecified = 9,
+  }
+
+  enum PickerViewMode {
+    List = 0,
+    Thumbnail = 1,
+  }
+
+  interface IFileOpenPicker {
+    PickMultipleFilesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[]>;
+    PickSingleFileAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CommitButtonText: string;
+    readonly FileTypeFilter: Windows.Foundation.Collections.IVector<string> | string[];
+    SettingsIdentifier: string;
+    SuggestedStartLocation: number;
+    ViewMode: number;
+  }
+  var IFileOpenPicker: abstract new (...args: any[]) => IFileOpenPicker;
+
+  interface IFileOpenPicker2 {
+    PickMultipleFilesAndContinue(): void;
+    PickSingleFileAndContinue(): void;
+    readonly ContinuationData: Windows.Foundation.Collections.ValueSet;
+  }
+  var IFileOpenPicker2: abstract new (...args: any[]) => IFileOpenPicker2;
+
+  interface IFileOpenPicker3 {
+    readonly User: Windows.System.User;
+  }
+  var IFileOpenPicker3: abstract new (...args: any[]) => IFileOpenPicker3;
+
+  interface IFileOpenPickerStatics {
+    ResumePickSingleFileAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+  }
+  var IFileOpenPickerStatics: abstract new (...args: any[]) => IFileOpenPickerStatics;
+
+  interface IFileOpenPickerStatics2 {
+    CreateForUser(user: Windows.System.User): Windows.Storage.Pickers.FileOpenPicker;
+  }
+  var IFileOpenPickerStatics2: abstract new (...args: any[]) => IFileOpenPickerStatics2;
+
+  interface IFileOpenPickerWithOperationId {
+    PickSingleFileAsync(pickerOperationId: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+  }
+  var IFileOpenPickerWithOperationId: abstract new (...args: any[]) => IFileOpenPickerWithOperationId;
+
+  interface IFileSavePicker {
+    PickSaveFileAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFile>;
+    CommitButtonText: string;
+    DefaultFileExtension: string;
+    readonly FileTypeChoices: Windows.Foundation.Collections.IMap<string, Windows.Foundation.Collections.IVector<string> | string[]> | Record<string, Windows.Foundation.Collections.IVector<string> | string[]>;
+    SettingsIdentifier: string;
+    SuggestedFileName: string;
+    SuggestedSaveFile: Windows.Storage.StorageFile;
+    SuggestedStartLocation: number;
+  }
+  var IFileSavePicker: abstract new (...args: any[]) => IFileSavePicker;
+
+  interface IFileSavePicker2 {
+    PickSaveFileAndContinue(): void;
+    readonly ContinuationData: Windows.Foundation.Collections.ValueSet;
+  }
+  var IFileSavePicker2: abstract new (...args: any[]) => IFileSavePicker2;
+
+  interface IFileSavePicker3 {
+    EnterpriseId: string;
+  }
+  var IFileSavePicker3: abstract new (...args: any[]) => IFileSavePicker3;
+
+  interface IFileSavePicker4 {
+    readonly User: Windows.System.User;
+  }
+  var IFileSavePicker4: abstract new (...args: any[]) => IFileSavePicker4;
+
+  interface IFileSavePickerStatics {
+    CreateForUser(user: Windows.System.User): Windows.Storage.Pickers.FileSavePicker;
+  }
+  var IFileSavePickerStatics: abstract new (...args: any[]) => IFileSavePickerStatics;
+
+  interface IFolderPicker {
+    PickSingleFolderAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+    CommitButtonText: string;
+    readonly FileTypeFilter: Windows.Foundation.Collections.IVector<string> | string[];
+    SettingsIdentifier: string;
+    SuggestedStartLocation: number;
+    ViewMode: number;
+  }
+  var IFolderPicker: abstract new (...args: any[]) => IFolderPicker;
+
+  interface IFolderPicker2 {
+    PickFolderAndContinue(): void;
+    readonly ContinuationData: Windows.Foundation.Collections.ValueSet;
+  }
+  var IFolderPicker2: abstract new (...args: any[]) => IFolderPicker2;
+
+  interface IFolderPicker3 {
+    readonly User: Windows.System.User;
+  }
+  var IFolderPicker3: abstract new (...args: any[]) => IFolderPicker3;
+
+  interface IFolderPickerStatics {
+    CreateForUser(user: Windows.System.User): Windows.Storage.Pickers.FolderPicker;
+  }
+  var IFolderPickerStatics: abstract new (...args: any[]) => IFolderPickerStatics;
+
+}
+
+declare namespace Windows.Storage.Pickers.Provider {
+  class FileOpenPickerUI implements Windows.Storage.Pickers.Provider.IFileOpenPickerUI {
+    AddFile(id: string, file: Windows.Storage.IStorageFile): number;
+    CanAddFile(file: Windows.Storage.IStorageFile): boolean;
+    ContainsFile(id: string): boolean;
+    RemoveFile(id: string): void;
+    readonly AllowedFileTypes: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly SelectionMode: number;
+    readonly SettingsIdentifier: string;
+    Title: string;
+    Closing: Windows.Foundation.TypedEventHandler<Windows.Storage.Pickers.Provider.FileOpenPickerUI, Windows.Storage.Pickers.Provider.PickerClosingEventArgs> | null;
+    FileRemoved: Windows.Foundation.TypedEventHandler<Windows.Storage.Pickers.Provider.FileOpenPickerUI, Windows.Storage.Pickers.Provider.FileRemovedEventArgs> | null;
+  }
+
+  class FileRemovedEventArgs implements Windows.Storage.Pickers.Provider.IFileRemovedEventArgs {
+    readonly Id: string;
+  }
+
+  class FileSavePickerUI implements Windows.Storage.Pickers.Provider.IFileSavePickerUI {
+    TrySetFileName(value: string): number;
+    readonly AllowedFileTypes: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly FileName: string;
+    readonly SettingsIdentifier: string;
+    Title: string;
+    FileNameChanged: Windows.Foundation.TypedEventHandler<Windows.Storage.Pickers.Provider.FileSavePickerUI, Object> | null;
+    TargetFileRequested: Windows.Foundation.TypedEventHandler<Windows.Storage.Pickers.Provider.FileSavePickerUI, Windows.Storage.Pickers.Provider.TargetFileRequestedEventArgs> | null;
+  }
+
+  class PickerClosingDeferral implements Windows.Storage.Pickers.Provider.IPickerClosingDeferral {
+    Complete(): void;
+  }
+
+  class PickerClosingEventArgs implements Windows.Storage.Pickers.Provider.IPickerClosingEventArgs {
+    readonly ClosingOperation: Windows.Storage.Pickers.Provider.PickerClosingOperation;
+    readonly IsCanceled: boolean;
+  }
+
+  class PickerClosingOperation implements Windows.Storage.Pickers.Provider.IPickerClosingOperation {
+    GetDeferral(): Windows.Storage.Pickers.Provider.PickerClosingDeferral;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+
+  class TargetFileRequest implements Windows.Storage.Pickers.Provider.ITargetFileRequest {
+    GetDeferral(): Windows.Storage.Pickers.Provider.TargetFileRequestDeferral;
+    TargetFile: Windows.Storage.IStorageFile;
+  }
+
+  class TargetFileRequestDeferral implements Windows.Storage.Pickers.Provider.ITargetFileRequestDeferral {
+    Complete(): void;
+  }
+
+  class TargetFileRequestedEventArgs implements Windows.Storage.Pickers.Provider.ITargetFileRequestedEventArgs {
+    readonly Request: Windows.Storage.Pickers.Provider.TargetFileRequest;
+  }
+
+  enum AddFileResult {
+    Added = 0,
+    AlreadyAdded = 1,
+    NotAllowed = 2,
+    Unavailable = 3,
+  }
+
+  enum FileSelectionMode {
+    Single = 0,
+    Multiple = 1,
+  }
+
+  enum SetFileNameResult {
+    Succeeded = 0,
+    NotAllowed = 1,
+    Unavailable = 2,
+  }
+
+  interface IFileOpenPickerUI {
+    AddFile(id: string, file: Windows.Storage.IStorageFile): number;
+    CanAddFile(file: Windows.Storage.IStorageFile): boolean;
+    ContainsFile(id: string): boolean;
+    RemoveFile(id: string): void;
+    readonly AllowedFileTypes: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly SelectionMode: number;
+    readonly SettingsIdentifier: string;
+    Title: string;
+    Closing: Windows.Foundation.TypedEventHandler<Windows.Storage.Pickers.Provider.FileOpenPickerUI, Windows.Storage.Pickers.Provider.PickerClosingEventArgs> | null;
+    FileRemoved: Windows.Foundation.TypedEventHandler<Windows.Storage.Pickers.Provider.FileOpenPickerUI, Windows.Storage.Pickers.Provider.FileRemovedEventArgs> | null;
+  }
+  var IFileOpenPickerUI: abstract new (...args: any[]) => IFileOpenPickerUI;
+
+  interface IFileRemovedEventArgs {
+    readonly Id: string;
+  }
+  var IFileRemovedEventArgs: abstract new (...args: any[]) => IFileRemovedEventArgs;
+
+  interface IFileSavePickerUI {
+    TrySetFileName(value: string): number;
+    readonly AllowedFileTypes: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly FileName: string;
+    readonly SettingsIdentifier: string;
+    Title: string;
+    FileNameChanged: Windows.Foundation.TypedEventHandler<Windows.Storage.Pickers.Provider.FileSavePickerUI, Object> | null;
+    TargetFileRequested: Windows.Foundation.TypedEventHandler<Windows.Storage.Pickers.Provider.FileSavePickerUI, Windows.Storage.Pickers.Provider.TargetFileRequestedEventArgs> | null;
+  }
+  var IFileSavePickerUI: abstract new (...args: any[]) => IFileSavePickerUI;
+
+  interface IPickerClosingDeferral {
+    Complete(): void;
+  }
+  var IPickerClosingDeferral: abstract new (...args: any[]) => IPickerClosingDeferral;
+
+  interface IPickerClosingEventArgs {
+    readonly ClosingOperation: Windows.Storage.Pickers.Provider.PickerClosingOperation;
+    readonly IsCanceled: boolean;
+  }
+  var IPickerClosingEventArgs: abstract new (...args: any[]) => IPickerClosingEventArgs;
+
+  interface IPickerClosingOperation {
+    GetDeferral(): Windows.Storage.Pickers.Provider.PickerClosingDeferral;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+  var IPickerClosingOperation: abstract new (...args: any[]) => IPickerClosingOperation;
+
+  interface ITargetFileRequest {
+    GetDeferral(): Windows.Storage.Pickers.Provider.TargetFileRequestDeferral;
+    TargetFile: Windows.Storage.IStorageFile;
+  }
+  var ITargetFileRequest: abstract new (...args: any[]) => ITargetFileRequest;
+
+  interface ITargetFileRequestDeferral {
+    Complete(): void;
+  }
+  var ITargetFileRequestDeferral: abstract new (...args: any[]) => ITargetFileRequestDeferral;
+
+  interface ITargetFileRequestedEventArgs {
+    readonly Request: Windows.Storage.Pickers.Provider.TargetFileRequest;
+  }
+  var ITargetFileRequestedEventArgs: abstract new (...args: any[]) => ITargetFileRequestedEventArgs;
+
+}
+
+declare namespace Windows.Storage.Provider {
+  class CachedFileUpdater {
+    static SetUpdateInformation(file: Windows.Storage.IStorageFile, contentId: string, readMode: number, writeMode: number, options: number): void;
+  }
+
+  class CachedFileUpdaterUI implements Windows.Storage.Provider.ICachedFileUpdaterUI, Windows.Storage.Provider.ICachedFileUpdaterUI2 {
+    GetDeferral(): Windows.Storage.Provider.FileUpdateRequestDeferral;
+    Title: string;
+    readonly UIStatus: number;
+    readonly UpdateRequest: Windows.Storage.Provider.FileUpdateRequest;
+    readonly UpdateTarget: number;
+    FileUpdateRequested: Windows.Foundation.TypedEventHandler<Windows.Storage.Provider.CachedFileUpdaterUI, Windows.Storage.Provider.FileUpdateRequestedEventArgs> | null;
+    UIRequested: Windows.Foundation.TypedEventHandler<Windows.Storage.Provider.CachedFileUpdaterUI, Object> | null;
+  }
+
+  class FileUpdateRequest implements Windows.Storage.Provider.IFileUpdateRequest, Windows.Storage.Provider.IFileUpdateRequest2 {
+    GetDeferral(): Windows.Storage.Provider.FileUpdateRequestDeferral;
+    UpdateLocalFile(value: Windows.Storage.IStorageFile): void;
+    readonly ContentId: string;
+    readonly File: Windows.Storage.StorageFile;
+    Status: number;
+    UserInputNeededMessage: string;
+  }
+
+  class FileUpdateRequestDeferral implements Windows.Storage.Provider.IFileUpdateRequestDeferral {
+    Complete(): void;
+  }
+
+  class FileUpdateRequestedEventArgs implements Windows.Storage.Provider.IFileUpdateRequestedEventArgs {
+    readonly Request: Windows.Storage.Provider.FileUpdateRequest;
+  }
+
+  class StorageProviderFileTypeInfo implements Windows.Storage.Provider.IStorageProviderFileTypeInfo {
+    constructor(fileExtension: string, iconResource: string);
+    readonly FileExtension: string;
+    readonly IconResource: string;
+  }
+
+  class StorageProviderGetContentInfoForPathResult implements Windows.Storage.Provider.IStorageProviderGetContentInfoForPathResult {
+    constructor();
+    ContentId: string;
+    ContentUri: string;
+    Status: number;
+  }
+
+  class StorageProviderGetPathForContentUriResult implements Windows.Storage.Provider.IStorageProviderGetPathForContentUriResult {
+    constructor();
+    Path: string;
+    Status: number;
+  }
+
+  class StorageProviderItemProperties {
+    static SetAsync(item: Windows.Storage.IStorageItem, itemProperties: Windows.Foundation.Collections.IIterable<Windows.Storage.Provider.StorageProviderItemProperty> | Windows.Storage.Provider.StorageProviderItemProperty[]): Windows.Foundation.IAsyncAction;
+  }
+
+  class StorageProviderItemProperty implements Windows.Storage.Provider.IStorageProviderItemProperty {
+    constructor();
+    IconResource: string;
+    Id: number;
+    Value: string;
+  }
+
+  class StorageProviderItemPropertyDefinition implements Windows.Storage.Provider.IStorageProviderItemPropertyDefinition {
+    constructor();
+    DisplayNameResource: string;
+    Id: number;
+  }
+
+  class StorageProviderKnownFolderEntry implements Windows.Storage.Provider.IStorageProviderKnownFolderEntry {
+    constructor();
+    KnownFolderId: Guid;
+    Status: number;
+  }
+
+  class StorageProviderKnownFolderSyncInfo implements Windows.Storage.Provider.IStorageProviderKnownFolderSyncInfo {
+    constructor();
+    readonly KnownFolderEntries: Windows.Foundation.Collections.IVector<Windows.Storage.Provider.StorageProviderKnownFolderEntry> | Windows.Storage.Provider.StorageProviderKnownFolderEntry[];
+    ProviderDisplayName: string;
+    SyncRequested: Windows.Storage.Provider.StorageProviderKnownFolderSyncRequestedHandler;
+  }
+
+  class StorageProviderKnownFolderSyncRequestArgs implements Windows.Storage.Provider.IStorageProviderKnownFolderSyncRequestArgs {
+    readonly KnownFolders: Windows.Foundation.Collections.IVectorView<Guid> | Guid[];
+    readonly Source: Windows.Storage.StorageFolder;
+  }
+
+  class StorageProviderMoreInfoUI implements Windows.Storage.Provider.IStorageProviderMoreInfoUI {
+    constructor();
+    Command: Windows.Storage.Provider.IStorageProviderUICommand;
+    Message: string;
+  }
+
+  class StorageProviderQueryResultSet implements Windows.Storage.Provider.IStorageProviderQueryResultSet {
+    constructor(results: Windows.Storage.Provider.IStorageProviderQueryResult[]);
+    GetResults(): Windows.Storage.Provider.IStorageProviderQueryResult[];
+    QueryResultId: string;
+    Status: number;
+  }
+
+  class StorageProviderQuotaUI implements Windows.Storage.Provider.IStorageProviderQuotaUI {
+    constructor();
+    QuotaTotalInBytes: number | bigint;
+    QuotaUsedColor: Windows.UI.Color | null;
+    QuotaUsedInBytes: number | bigint;
+    QuotaUsedLabel: string;
+  }
+
+  class StorageProviderSearchQueryOptions implements Windows.Storage.Provider.IStorageProviderSearchQueryOptions {
+    readonly FolderScope: string;
+    readonly Language: string;
+    readonly MaxResults: number;
+    readonly ProgrammaticQuery: string;
+    readonly PropertiesToFetch: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly QueryId: string;
+    readonly SortOrder: Windows.Foundation.Collections.IVectorView<Windows.Storage.Search.SortEntry> | Windows.Storage.Search.SortEntry[];
+    readonly UserQuery: string;
+  }
+
+  class StorageProviderSearchResult implements Windows.Storage.Provider.IStorageProviderQueryResult, Windows.Storage.Provider.IStorageProviderSearchResult {
+    constructor();
+    FilePath: string;
+    Kind: number;
+    MatchKind: number;
+    MatchScore: number;
+    MatchedPropertyName: string;
+    RemoteFileId: string;
+    readonly RequestedProperties: Windows.Foundation.Collections.PropertySet;
+    ResultId: string;
+  }
+
+  class StorageProviderStatusUI implements Windows.Storage.Provider.IStorageProviderStatusUI {
+    constructor();
+    MoreInfoUI: Windows.Storage.Provider.StorageProviderMoreInfoUI;
+    ProviderPrimaryCommand: Windows.Storage.Provider.IStorageProviderUICommand;
+    ProviderSecondaryCommands: Windows.Foundation.Collections.IVector<Windows.Storage.Provider.IStorageProviderUICommand> | Windows.Storage.Provider.IStorageProviderUICommand[];
+    ProviderState: number;
+    ProviderStateIcon: Windows.Foundation.Uri;
+    ProviderStateLabel: string;
+    QuotaUI: Windows.Storage.Provider.StorageProviderQuotaUI;
+    SyncStatusCommand: Windows.Storage.Provider.IStorageProviderUICommand;
+  }
+
+  class StorageProviderSyncRootInfo implements Windows.Storage.Provider.IStorageProviderSyncRootInfo, Windows.Storage.Provider.IStorageProviderSyncRootInfo2, Windows.Storage.Provider.IStorageProviderSyncRootInfo3 {
+    constructor();
+    AllowPinning: boolean;
+    Context: Windows.Storage.Streams.IBuffer;
+    DisplayNameResource: string;
+    readonly FallbackFileTypeInfo: Windows.Foundation.Collections.IVector<Windows.Storage.Provider.StorageProviderFileTypeInfo> | Windows.Storage.Provider.StorageProviderFileTypeInfo[];
+    HardlinkPolicy: number;
+    HydrationPolicy: number;
+    HydrationPolicyModifier: number;
+    IconResource: string;
+    Id: string;
+    InSyncPolicy: number;
+    Path: Windows.Storage.IStorageFolder;
+    PopulationPolicy: number;
+    ProtectionMode: number;
+    ProviderId: Guid;
+    RecycleBinUri: Windows.Foundation.Uri;
+    ShowSiblingsAsGroup: boolean;
+    readonly StorageProviderItemPropertyDefinitions: Windows.Foundation.Collections.IVector<Windows.Storage.Provider.StorageProviderItemPropertyDefinition> | Windows.Storage.Provider.StorageProviderItemPropertyDefinition[];
+    Version: string;
+  }
+
+  class StorageProviderSyncRootManager {
+    static GetCurrentSyncRoots(): Windows.Foundation.Collections.IVectorView<Windows.Storage.Provider.StorageProviderSyncRootInfo> | Windows.Storage.Provider.StorageProviderSyncRootInfo[];
+    static GetSyncRootInformationForFolder(folder: Windows.Storage.IStorageFolder): Windows.Storage.Provider.StorageProviderSyncRootInfo;
+    static GetSyncRootInformationForId(id: string): Windows.Storage.Provider.StorageProviderSyncRootInfo;
+    static IsSupported(): boolean;
+    static Register(syncRootInformation: Windows.Storage.Provider.StorageProviderSyncRootInfo): void;
+    static Unregister(id: string): void;
+  }
+
+  enum CachedFileOptions {
+    None = 0,
+    RequireUpdateOnAccess = 1,
+    UseCachedFileWhenOffline = 2,
+    DenyAccessWhenOffline = 4,
+  }
+
+  enum CachedFileTarget {
+    Local = 0,
+    Remote = 1,
+  }
+
+  enum FileUpdateStatus {
+    Incomplete = 0,
+    Complete = 1,
+    UserInputNeeded = 2,
+    CurrentlyUnavailable = 3,
+    Failed = 4,
+    CompleteAndRenamed = 5,
+  }
+
+  enum ReadActivationMode {
+    NotNeeded = 0,
+    BeforeAccess = 1,
+  }
+
+  enum StorageProviderHardlinkPolicy {
+    None = 0,
+    Allowed = 1,
+  }
+
+  enum StorageProviderHydrationPolicy {
+    Partial = 0,
+    Progressive = 1,
+    Full = 2,
+    AlwaysFull = 3,
+  }
+
+  enum StorageProviderHydrationPolicyModifier {
+    None = 0,
+    ValidationRequired = 1,
+    StreamingAllowed = 2,
+    AutoDehydrationAllowed = 4,
+    AllowFullRestartHydration = 8,
+  }
+
+  enum StorageProviderInSyncPolicy {
+    Default = 0,
+    FileCreationTime = 1,
+    FileReadOnlyAttribute = 2,
+    FileHiddenAttribute = 4,
+    FileSystemAttribute = 8,
+    DirectoryCreationTime = 16,
+    DirectoryReadOnlyAttribute = 32,
+    DirectoryHiddenAttribute = 64,
+    DirectorySystemAttribute = 128,
+    FileLastWriteTime = 256,
+    DirectoryLastWriteTime = 512,
+    PreserveInsyncForSyncEngine = 2147483648,
+  }
+
+  enum StorageProviderKnownFolderSyncStatus {
+    Available = 0,
+    Enrolling = 1,
+    Enrolled = 2,
+  }
+
+  enum StorageProviderPopulationPolicy {
+    Full = 1,
+    AlwaysFull = 2,
+  }
+
+  enum StorageProviderProtectionMode {
+    Unknown = 0,
+    Personal = 1,
+  }
+
+  enum StorageProviderResultKind {
+    Search = 0,
+    Recommended = 1,
+    Favorites = 2,
+    Recent = 3,
+    Shared = 4,
+    RelatedFiles = 5,
+    RelatedConversations = 6,
+  }
+
+  enum StorageProviderResultUsageKind {
+    Rendered = 0,
+    Opened = 1,
+    SuggestionResponseReceived = 2,
+  }
+
+  enum StorageProviderSearchMatchKind {
+    Lexical = 0,
+    Semantic = 1,
+  }
+
+  enum StorageProviderSearchQueryStatus {
+    Success = 0,
+    Error = 1,
+    Timeout = 2,
+    NoNetwork = 3,
+    NetworkError = 4,
+    NotSignedIn = 5,
+    QueryNotSupported = 6,
+    SortOrderNotSupported = 7,
+  }
+
+  enum StorageProviderShareLinkState {
+    Enabled = 0,
+    Disabled = 1,
+  }
+
+  enum StorageProviderState {
+    InSync = 0,
+    Syncing = 1,
+    Paused = 2,
+    Error = 3,
+    Warning = 4,
+    Offline = 5,
+  }
+
+  enum StorageProviderUICommandState {
+    Enabled = 0,
+    Disabled = 1,
+    Hidden = 2,
+  }
+
+  enum StorageProviderUriSourceStatus {
+    Success = 0,
+    NoSyncRoot = 1,
+    FileNotFound = 2,
+  }
+
+  enum UIStatus {
+    Unavailable = 0,
+    Hidden = 1,
+    Visible = 2,
+    Complete = 3,
+  }
+
+  enum WriteActivationMode {
+    ReadOnly = 0,
+    NotNeeded = 1,
+    AfterWrite = 2,
+  }
+
+  interface CloudFilesContract {
+  }
+  var CloudFilesContract: {
+    new(fields: {  }): CloudFilesContract;
+  };
+
+  interface ICachedFileUpdaterStatics {
+    SetUpdateInformation(file: Windows.Storage.IStorageFile, contentId: string, readMode: number, writeMode: number, options: number): void;
+  }
+  var ICachedFileUpdaterStatics: abstract new (...args: any[]) => ICachedFileUpdaterStatics;
+
+  interface ICachedFileUpdaterUI {
+    Title: string;
+    readonly UIStatus: number;
+    readonly UpdateTarget: number;
+    FileUpdateRequested: Windows.Foundation.TypedEventHandler<Windows.Storage.Provider.CachedFileUpdaterUI, Windows.Storage.Provider.FileUpdateRequestedEventArgs> | null;
+    UIRequested: Windows.Foundation.TypedEventHandler<Windows.Storage.Provider.CachedFileUpdaterUI, Object> | null;
+  }
+  var ICachedFileUpdaterUI: abstract new (...args: any[]) => ICachedFileUpdaterUI;
+
+  interface ICachedFileUpdaterUI2 extends Windows.Storage.Provider.ICachedFileUpdaterUI {
+    GetDeferral(): Windows.Storage.Provider.FileUpdateRequestDeferral;
+    readonly UpdateRequest: Windows.Storage.Provider.FileUpdateRequest;
+  }
+  var ICachedFileUpdaterUI2: abstract new (...args: any[]) => ICachedFileUpdaterUI2;
+
+  interface IFileUpdateRequest {
+    GetDeferral(): Windows.Storage.Provider.FileUpdateRequestDeferral;
+    UpdateLocalFile(value: Windows.Storage.IStorageFile): void;
+    readonly ContentId: string;
+    readonly File: Windows.Storage.StorageFile;
+    Status: number;
+  }
+  var IFileUpdateRequest: abstract new (...args: any[]) => IFileUpdateRequest;
+
+  interface IFileUpdateRequest2 extends Windows.Storage.Provider.IFileUpdateRequest {
+    GetDeferral(): Windows.Storage.Provider.FileUpdateRequestDeferral;
+    UpdateLocalFile(value: Windows.Storage.IStorageFile): void;
+    UserInputNeededMessage: string;
+  }
+  var IFileUpdateRequest2: abstract new (...args: any[]) => IFileUpdateRequest2;
+
+  interface IFileUpdateRequestDeferral {
+    Complete(): void;
+  }
+  var IFileUpdateRequestDeferral: abstract new (...args: any[]) => IFileUpdateRequestDeferral;
+
+  interface IFileUpdateRequestedEventArgs {
+    readonly Request: Windows.Storage.Provider.FileUpdateRequest;
+  }
+  var IFileUpdateRequestedEventArgs: abstract new (...args: any[]) => IFileUpdateRequestedEventArgs;
+
+  interface IStorageProviderFileTypeInfo {
+    readonly FileExtension: string;
+    readonly IconResource: string;
+  }
+  var IStorageProviderFileTypeInfo: abstract new (...args: any[]) => IStorageProviderFileTypeInfo;
+
+  interface IStorageProviderFileTypeInfoFactory {
+    CreateInstance(fileExtension: string, iconResource: string): Windows.Storage.Provider.StorageProviderFileTypeInfo;
+  }
+  var IStorageProviderFileTypeInfoFactory: abstract new (...args: any[]) => IStorageProviderFileTypeInfoFactory;
+
+  interface IStorageProviderGetContentInfoForPathResult {
+    ContentId: string;
+    ContentUri: string;
+    Status: number;
+  }
+  var IStorageProviderGetContentInfoForPathResult: abstract new (...args: any[]) => IStorageProviderGetContentInfoForPathResult;
+
+  interface IStorageProviderGetPathForContentUriResult {
+    Path: string;
+    Status: number;
+  }
+  var IStorageProviderGetPathForContentUriResult: abstract new (...args: any[]) => IStorageProviderGetPathForContentUriResult;
+
+  interface IStorageProviderItemPropertiesStatics {
+    SetAsync(item: Windows.Storage.IStorageItem, itemProperties: Windows.Foundation.Collections.IIterable<Windows.Storage.Provider.StorageProviderItemProperty> | Windows.Storage.Provider.StorageProviderItemProperty[]): Windows.Foundation.IAsyncAction;
+  }
+  var IStorageProviderItemPropertiesStatics: abstract new (...args: any[]) => IStorageProviderItemPropertiesStatics;
+
+  interface IStorageProviderItemProperty {
+    IconResource: string;
+    Id: number;
+    Value: string;
+  }
+  var IStorageProviderItemProperty: abstract new (...args: any[]) => IStorageProviderItemProperty;
+
+  interface IStorageProviderItemPropertyDefinition {
+    DisplayNameResource: string;
+    Id: number;
+  }
+  var IStorageProviderItemPropertyDefinition: abstract new (...args: any[]) => IStorageProviderItemPropertyDefinition;
+
+  interface IStorageProviderItemPropertySource {
+    GetItemProperties(itemPath: string): Windows.Foundation.Collections.IIterable<Windows.Storage.Provider.StorageProviderItemProperty> | Windows.Storage.Provider.StorageProviderItemProperty[];
+  }
+  var IStorageProviderItemPropertySource: abstract new (...args: any[]) => IStorageProviderItemPropertySource;
+
+  interface IStorageProviderKnownFolderEntry {
+    KnownFolderId: Guid;
+    Status: number;
+  }
+  var IStorageProviderKnownFolderEntry: abstract new (...args: any[]) => IStorageProviderKnownFolderEntry;
+
+  interface IStorageProviderKnownFolderSyncInfo {
+    readonly KnownFolderEntries: Windows.Foundation.Collections.IVector<Windows.Storage.Provider.StorageProviderKnownFolderEntry> | Windows.Storage.Provider.StorageProviderKnownFolderEntry[];
+    ProviderDisplayName: string;
+    SyncRequested: Windows.Storage.Provider.StorageProviderKnownFolderSyncRequestedHandler;
+  }
+  var IStorageProviderKnownFolderSyncInfo: abstract new (...args: any[]) => IStorageProviderKnownFolderSyncInfo;
+
+  interface IStorageProviderKnownFolderSyncInfoSource {
+    GetKnownFolderSyncInfo(): Windows.Storage.Provider.StorageProviderKnownFolderSyncInfo;
+    KnownFolderSyncInfoChanged: Windows.Foundation.TypedEventHandler<Windows.Storage.Provider.IStorageProviderKnownFolderSyncInfoSource, Object> | null;
+  }
+  var IStorageProviderKnownFolderSyncInfoSource: abstract new (...args: any[]) => IStorageProviderKnownFolderSyncInfoSource;
+
+  interface IStorageProviderKnownFolderSyncInfoSourceFactory {
+    GetKnownFolderSyncInfoSource(): Windows.Storage.Provider.IStorageProviderKnownFolderSyncInfoSource;
+  }
+  var IStorageProviderKnownFolderSyncInfoSourceFactory: abstract new (...args: any[]) => IStorageProviderKnownFolderSyncInfoSourceFactory;
+
+  interface IStorageProviderKnownFolderSyncRequestArgs {
+    readonly KnownFolders: Windows.Foundation.Collections.IVectorView<Guid> | Guid[];
+    readonly Source: Windows.Storage.StorageFolder;
+  }
+  var IStorageProviderKnownFolderSyncRequestArgs: abstract new (...args: any[]) => IStorageProviderKnownFolderSyncRequestArgs;
+
+  interface IStorageProviderMoreInfoUI {
+    Command: Windows.Storage.Provider.IStorageProviderUICommand;
+    Message: string;
+  }
+  var IStorageProviderMoreInfoUI: abstract new (...args: any[]) => IStorageProviderMoreInfoUI;
+
+  interface IStorageProviderPropertyCapabilities {
+    IsPropertySupported(propertyCanonicalName: string): boolean;
+  }
+  var IStorageProviderPropertyCapabilities: abstract new (...args: any[]) => IStorageProviderPropertyCapabilities;
+
+  interface IStorageProviderQueryResult {
+    FilePath: string;
+    Kind: number;
+    RemoteFileId: string;
+    readonly RequestedProperties: Windows.Foundation.Collections.PropertySet;
+    ResultId: string;
+  }
+  var IStorageProviderQueryResult: abstract new (...args: any[]) => IStorageProviderQueryResult;
+
+  interface IStorageProviderQueryResultSet {
+    GetResults(): Windows.Storage.Provider.IStorageProviderQueryResult[];
+    QueryResultId: string;
+    Status: number;
+  }
+  var IStorageProviderQueryResultSet: abstract new (...args: any[]) => IStorageProviderQueryResultSet;
+
+  interface IStorageProviderQueryResultSetFactory {
+    CreateInstance(results: Windows.Storage.Provider.IStorageProviderQueryResult[]): Windows.Storage.Provider.StorageProviderQueryResultSet;
+  }
+  var IStorageProviderQueryResultSetFactory: abstract new (...args: any[]) => IStorageProviderQueryResultSetFactory;
+
+  interface IStorageProviderQuotaUI {
+    QuotaTotalInBytes: number | bigint;
+    QuotaUsedColor: Windows.UI.Color | null;
+    QuotaUsedInBytes: number | bigint;
+    QuotaUsedLabel: string;
+  }
+  var IStorageProviderQuotaUI: abstract new (...args: any[]) => IStorageProviderQuotaUI;
+
+  interface IStorageProviderSearchHandler {
+    Find(options: Windows.Storage.Provider.StorageProviderSearchQueryOptions): Windows.Storage.Provider.StorageProviderQueryResultSet;
+    ReportUsage(resultUsageKind: number, remoteFileId: string, resultId: string, latency: Windows.Foundation.TimeSpan): void;
+  }
+  var IStorageProviderSearchHandler: abstract new (...args: any[]) => IStorageProviderSearchHandler;
+
+  interface IStorageProviderSearchHandlerFactory {
+    CreateSearchHandler(cloudProviderId: string): Windows.Storage.Provider.IStorageProviderSearchHandler;
+  }
+  var IStorageProviderSearchHandlerFactory: abstract new (...args: any[]) => IStorageProviderSearchHandlerFactory;
+
+  interface IStorageProviderSearchQueryOptions {
+    readonly FolderScope: string;
+    readonly Language: string;
+    readonly MaxResults: number;
+    readonly ProgrammaticQuery: string;
+    readonly PropertiesToFetch: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly QueryId: string;
+    readonly SortOrder: Windows.Foundation.Collections.IVectorView<Windows.Storage.Search.SortEntry> | Windows.Storage.Search.SortEntry[];
+    readonly UserQuery: string;
+  }
+  var IStorageProviderSearchQueryOptions: abstract new (...args: any[]) => IStorageProviderSearchQueryOptions;
+
+  interface IStorageProviderSearchResult {
+    MatchKind: number;
+    MatchScore: number;
+    MatchedPropertyName: string;
+  }
+  var IStorageProviderSearchResult: abstract new (...args: any[]) => IStorageProviderSearchResult;
+
+  interface IStorageProviderShareLinkSource {
+    CreateLinkAsync(storageItemList: Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Uri>;
+    GetDefaultAccessControlStringAsync(storageItemList: Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[]): Windows.Foundation.IAsyncOperation<string>;
+    GetState(storageItemList: Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[]): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IStorageProviderShareLinkSource: abstract new (...args: any[]) => IStorageProviderShareLinkSource;
+
+  interface IStorageProviderStatusUI {
+    MoreInfoUI: Windows.Storage.Provider.StorageProviderMoreInfoUI;
+    ProviderPrimaryCommand: Windows.Storage.Provider.IStorageProviderUICommand;
+    ProviderSecondaryCommands: Windows.Foundation.Collections.IVector<Windows.Storage.Provider.IStorageProviderUICommand> | Windows.Storage.Provider.IStorageProviderUICommand[];
+    ProviderState: number;
+    ProviderStateIcon: Windows.Foundation.Uri;
+    ProviderStateLabel: string;
+    QuotaUI: Windows.Storage.Provider.StorageProviderQuotaUI;
+    SyncStatusCommand: Windows.Storage.Provider.IStorageProviderUICommand;
+  }
+  var IStorageProviderStatusUI: abstract new (...args: any[]) => IStorageProviderStatusUI;
+
+  interface IStorageProviderStatusUISource {
+    GetStatusUI(): Windows.Storage.Provider.StorageProviderStatusUI;
+    StatusUIChanged: Windows.Foundation.TypedEventHandler<Windows.Storage.Provider.IStorageProviderStatusUISource, Object> | null;
+  }
+  var IStorageProviderStatusUISource: abstract new (...args: any[]) => IStorageProviderStatusUISource;
+
+  interface IStorageProviderStatusUISourceFactory {
+    GetStatusUISource(syncRootId: string): Windows.Storage.Provider.IStorageProviderStatusUISource;
+  }
+  var IStorageProviderStatusUISourceFactory: abstract new (...args: any[]) => IStorageProviderStatusUISourceFactory;
+
+  interface IStorageProviderSyncRootInfo {
+    AllowPinning: boolean;
+    Context: Windows.Storage.Streams.IBuffer;
+    DisplayNameResource: string;
+    HardlinkPolicy: number;
+    HydrationPolicy: number;
+    HydrationPolicyModifier: number;
+    IconResource: string;
+    Id: string;
+    InSyncPolicy: number;
+    Path: Windows.Storage.IStorageFolder;
+    PopulationPolicy: number;
+    ProtectionMode: number;
+    RecycleBinUri: Windows.Foundation.Uri;
+    ShowSiblingsAsGroup: boolean;
+    readonly StorageProviderItemPropertyDefinitions: Windows.Foundation.Collections.IVector<Windows.Storage.Provider.StorageProviderItemPropertyDefinition> | Windows.Storage.Provider.StorageProviderItemPropertyDefinition[];
+    Version: string;
+  }
+  var IStorageProviderSyncRootInfo: abstract new (...args: any[]) => IStorageProviderSyncRootInfo;
+
+  interface IStorageProviderSyncRootInfo2 {
+    ProviderId: Guid;
+  }
+  var IStorageProviderSyncRootInfo2: abstract new (...args: any[]) => IStorageProviderSyncRootInfo2;
+
+  interface IStorageProviderSyncRootInfo3 {
+    readonly FallbackFileTypeInfo: Windows.Foundation.Collections.IVector<Windows.Storage.Provider.StorageProviderFileTypeInfo> | Windows.Storage.Provider.StorageProviderFileTypeInfo[];
+  }
+  var IStorageProviderSyncRootInfo3: abstract new (...args: any[]) => IStorageProviderSyncRootInfo3;
+
+  interface IStorageProviderSyncRootManagerStatics {
+    GetCurrentSyncRoots(): Windows.Foundation.Collections.IVectorView<Windows.Storage.Provider.StorageProviderSyncRootInfo> | Windows.Storage.Provider.StorageProviderSyncRootInfo[];
+    GetSyncRootInformationForFolder(folder: Windows.Storage.IStorageFolder): Windows.Storage.Provider.StorageProviderSyncRootInfo;
+    GetSyncRootInformationForId(id: string): Windows.Storage.Provider.StorageProviderSyncRootInfo;
+    Register(syncRootInformation: Windows.Storage.Provider.StorageProviderSyncRootInfo): void;
+    Unregister(id: string): void;
+  }
+  var IStorageProviderSyncRootManagerStatics: abstract new (...args: any[]) => IStorageProviderSyncRootManagerStatics;
+
+  interface IStorageProviderSyncRootManagerStatics2 {
+    IsSupported(): boolean;
+  }
+  var IStorageProviderSyncRootManagerStatics2: abstract new (...args: any[]) => IStorageProviderSyncRootManagerStatics2;
+
+  interface IStorageProviderUICommand {
+    Invoke(): void;
+    readonly Description: string;
+    readonly Icon: Windows.Foundation.Uri;
+    readonly Label: string;
+    readonly State: number;
+  }
+  var IStorageProviderUICommand: abstract new (...args: any[]) => IStorageProviderUICommand;
+
+  interface IStorageProviderUriSource {
+    GetContentInfoForPath(path: string, result: Windows.Storage.Provider.StorageProviderGetContentInfoForPathResult): void;
+    GetPathForContentUri(contentUri: string, result: Windows.Storage.Provider.StorageProviderGetPathForContentUriResult): void;
+  }
+  var IStorageProviderUriSource: abstract new (...args: any[]) => IStorageProviderUriSource;
+
+  interface StorageProviderKnownFolderSyncRequestedHandler {
+    (args: Windows.Storage.Provider.StorageProviderKnownFolderSyncRequestArgs): void;
+  }
+  var StorageProviderKnownFolderSyncRequestedHandler: {
+    new(callback: (args: Windows.Storage.Provider.StorageProviderKnownFolderSyncRequestArgs) => void): StorageProviderKnownFolderSyncRequestedHandler;
+  };
+
+}
+
+declare namespace Windows.Storage.Search {
+  class ContentIndexer implements Windows.Storage.Search.IContentIndexer, Windows.Storage.Search.IContentIndexerQueryOperations {
+    AddAsync(indexableContent: Windows.Storage.Search.IIndexableContent): Windows.Foundation.IAsyncAction;
+    CreateQuery(searchFilter: string, propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[], sortOrder: Windows.Foundation.Collections.IIterable<Windows.Storage.Search.SortEntry> | Windows.Storage.Search.SortEntry[], searchFilterLanguage: string): Windows.Storage.Search.ContentIndexerQuery;
+    CreateQuery(searchFilter: string, propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[], sortOrder: Windows.Foundation.Collections.IIterable<Windows.Storage.Search.SortEntry> | Windows.Storage.Search.SortEntry[]): Windows.Storage.Search.ContentIndexerQuery;
+    CreateQuery(searchFilter: string, propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Storage.Search.ContentIndexerQuery;
+    DeleteAllAsync(): Windows.Foundation.IAsyncAction;
+    DeleteAsync(contentId: string): Windows.Foundation.IAsyncAction;
+    DeleteMultipleAsync(contentIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    static GetIndexer(indexName: string): Windows.Storage.Search.ContentIndexer;
+    static GetIndexer(): Windows.Storage.Search.ContentIndexer;
+    RetrievePropertiesAsync(contentId: string, propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<string, Object>>;
+    UpdateAsync(indexableContent: Windows.Storage.Search.IIndexableContent): Windows.Foundation.IAsyncAction;
+    readonly Revision: number | bigint;
+  }
+
+  class ContentIndexerQuery implements Windows.Storage.Search.IContentIndexerQuery {
+    GetAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.Search.IIndexableContent> | Windows.Storage.Search.IIndexableContent[]>;
+    GetAsync(startIndex: number, maxItems: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.Search.IIndexableContent> | Windows.Storage.Search.IIndexableContent[]>;
+    GetCountAsync(): Windows.Foundation.IAsyncOperation<number>;
+    GetPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Foundation.Collections.IMapView<string, Object>> | Windows.Foundation.Collections.IMapView<string, Object>[]>;
+    GetPropertiesAsync(startIndex: number, maxItems: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Foundation.Collections.IMapView<string, Object>> | Windows.Foundation.Collections.IMapView<string, Object>[]>;
+    readonly QueryFolder: Windows.Storage.StorageFolder;
+  }
+
+  class IndexableContent implements Windows.Storage.Search.IIndexableContent {
+    constructor();
+    Id: string;
+    readonly Properties: Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>;
+    Stream: Windows.Storage.Streams.IRandomAccessStream;
+    StreamContentType: string;
+  }
+
+  class QueryOptions implements Windows.Storage.Search.IQueryOptions, Windows.Storage.Search.IQueryOptionsWithProviderFilter {
+    constructor(query: number, fileTypeFilter: Windows.Foundation.Collections.IIterable<string> | string[]);
+    constructor(query: number);
+    constructor();
+    LoadFromString(value: string): void;
+    SaveToString(): string;
+    SetPropertyPrefetch(options: number, propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): void;
+    SetThumbnailPrefetch(mode: number, requestedSize: number, options: number): void;
+    ApplicationSearchFilter: string;
+    readonly DateStackOption: number;
+    readonly FileTypeFilter: Windows.Foundation.Collections.IVector<string> | string[];
+    FolderDepth: number;
+    readonly GroupPropertyName: string;
+    IndexerOption: number;
+    Language: string;
+    readonly SortOrder: Windows.Foundation.Collections.IVector<Windows.Storage.Search.SortEntry> | Windows.Storage.Search.SortEntry[];
+    readonly StorageProviderIdFilter: Windows.Foundation.Collections.IVector<string> | string[];
+    UserSearchFilter: string;
+  }
+
+  class SortEntryVector {
+    Append(value: Windows.Storage.Search.SortEntry): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Storage.Search.SortEntry>;
+    GetAt(index: number): Windows.Storage.Search.SortEntry;
+    GetMany(startIndex: number, items: Windows.Storage.Search.SortEntry[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.Storage.Search.SortEntry> | Windows.Storage.Search.SortEntry[];
+    IndexOf(value: Windows.Storage.Search.SortEntry, index: number): boolean;
+    InsertAt(index: number, value: Windows.Storage.Search.SortEntry): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.Storage.Search.SortEntry[]): void;
+    SetAt(index: number, value: Windows.Storage.Search.SortEntry): void;
+    readonly Size: number;
+  }
+
+  class StorageFileQueryResult implements Windows.Storage.Search.IStorageFileQueryResult, Windows.Storage.Search.IStorageFileQueryResult2, Windows.Storage.Search.IStorageQueryResultBase {
+    ApplyNewQueryOptions(newQueryOptions: Windows.Storage.Search.QueryOptions): void;
+    FindStartIndexAsync(value: Object): Windows.Foundation.IAsyncOperation<number>;
+    GetCurrentQueryOptions(): Windows.Storage.Search.QueryOptions;
+    GetFilesAsync(startIndex: number, maxNumberOfItems: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[]>;
+    GetFilesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[]>;
+    GetItemCountAsync(): Windows.Foundation.IAsyncOperation<number>;
+    GetMatchingPropertiesWithRanges(file: Windows.Storage.StorageFile): Windows.Foundation.Collections.IMap<string, Windows.Foundation.Collections.IVectorView<Windows.Data.Text.TextSegment> | Windows.Data.Text.TextSegment[]> | Record<string, Windows.Foundation.Collections.IVectorView<Windows.Data.Text.TextSegment> | Windows.Data.Text.TextSegment[]>;
+    readonly Folder: Windows.Storage.StorageFolder;
+    ContentsChanged: Windows.Foundation.TypedEventHandler<Windows.Storage.Search.IStorageQueryResultBase, Object> | null;
+    OptionsChanged: Windows.Foundation.TypedEventHandler<Windows.Storage.Search.IStorageQueryResultBase, Object> | null;
+  }
+
+  class StorageFolderQueryResult implements Windows.Storage.Search.IStorageFolderQueryResult, Windows.Storage.Search.IStorageQueryResultBase {
+    ApplyNewQueryOptions(newQueryOptions: Windows.Storage.Search.QueryOptions): void;
+    FindStartIndexAsync(value: Object): Windows.Foundation.IAsyncOperation<number>;
+    GetCurrentQueryOptions(): Windows.Storage.Search.QueryOptions;
+    GetFoldersAsync(startIndex: number, maxNumberOfItems: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFolder> | Windows.Storage.StorageFolder[]>;
+    GetFoldersAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFolder> | Windows.Storage.StorageFolder[]>;
+    GetItemCountAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly Folder: Windows.Storage.StorageFolder;
+    ContentsChanged: Windows.Foundation.TypedEventHandler<Windows.Storage.Search.IStorageQueryResultBase, Object> | null;
+    OptionsChanged: Windows.Foundation.TypedEventHandler<Windows.Storage.Search.IStorageQueryResultBase, Object> | null;
+  }
+
+  class StorageItemQueryResult implements Windows.Storage.Search.IStorageItemQueryResult, Windows.Storage.Search.IStorageQueryResultBase {
+    ApplyNewQueryOptions(newQueryOptions: Windows.Storage.Search.QueryOptions): void;
+    FindStartIndexAsync(value: Object): Windows.Foundation.IAsyncOperation<number>;
+    GetCurrentQueryOptions(): Windows.Storage.Search.QueryOptions;
+    GetItemCountAsync(): Windows.Foundation.IAsyncOperation<number>;
+    GetItemsAsync(startIndex: number, maxNumberOfItems: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[]>;
+    GetItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[]>;
+    readonly Folder: Windows.Storage.StorageFolder;
+    ContentsChanged: Windows.Foundation.TypedEventHandler<Windows.Storage.Search.IStorageQueryResultBase, Object> | null;
+    OptionsChanged: Windows.Foundation.TypedEventHandler<Windows.Storage.Search.IStorageQueryResultBase, Object> | null;
+  }
+
+  class StorageLibraryChangeTrackerTriggerDetails implements Windows.Storage.Search.IStorageLibraryChangeTrackerTriggerDetails {
+    readonly ChangeTracker: Windows.Storage.StorageLibraryChangeTracker;
+    readonly Folder: Windows.Storage.StorageFolder;
+  }
+
+  class StorageLibraryContentChangedTriggerDetails implements Windows.Storage.Search.IStorageLibraryContentChangedTriggerDetails {
+    CreateModifiedSinceQuery(lastQueryTime: Windows.Foundation.DateTime): Windows.Storage.Search.StorageItemQueryResult;
+    readonly Folder: Windows.Storage.StorageFolder;
+  }
+
+  class ValueAndLanguage implements Windows.Storage.Search.IValueAndLanguage {
+    constructor();
+    Language: string;
+    Value: Object;
+  }
+
+  enum CommonFileQuery {
+    DefaultQuery = 0,
+    OrderByName = 1,
+    OrderByTitle = 2,
+    OrderByMusicProperties = 3,
+    OrderBySearchRank = 4,
+    OrderByDate = 5,
+  }
+
+  enum CommonFolderQuery {
+    DefaultQuery = 0,
+    GroupByYear = 100,
+    GroupByMonth = 101,
+    GroupByArtist = 102,
+    GroupByAlbum = 103,
+    GroupByAlbumArtist = 104,
+    GroupByComposer = 105,
+    GroupByGenre = 106,
+    GroupByPublishedYear = 107,
+    GroupByRating = 108,
+    GroupByTag = 109,
+    GroupByAuthor = 110,
+    GroupByType = 111,
+  }
+
+  enum DateStackOption {
+    None = 0,
+    Year = 1,
+    Month = 2,
+  }
+
+  enum FolderDepth {
+    Shallow = 0,
+    Deep = 1,
+  }
+
+  enum IndexedState {
+    Unknown = 0,
+    NotIndexed = 1,
+    PartiallyIndexed = 2,
+    FullyIndexed = 3,
+  }
+
+  enum IndexerOption {
+    UseIndexerWhenAvailable = 0,
+    OnlyUseIndexer = 1,
+    DoNotUseIndexer = 2,
+    OnlyUseIndexerAndOptimizeForIndexedProperties = 3,
+  }
+
+  interface IContentIndexer {
+    AddAsync(indexableContent: Windows.Storage.Search.IIndexableContent): Windows.Foundation.IAsyncAction;
+    DeleteAllAsync(): Windows.Foundation.IAsyncAction;
+    DeleteAsync(contentId: string): Windows.Foundation.IAsyncAction;
+    DeleteMultipleAsync(contentIds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncAction;
+    RetrievePropertiesAsync(contentId: string, propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<string, Object>>;
+    UpdateAsync(indexableContent: Windows.Storage.Search.IIndexableContent): Windows.Foundation.IAsyncAction;
+    readonly Revision: number | bigint;
+  }
+  var IContentIndexer: abstract new (...args: any[]) => IContentIndexer;
+
+  interface IContentIndexerQuery {
+    GetAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.Search.IIndexableContent> | Windows.Storage.Search.IIndexableContent[]>;
+    GetAsync(startIndex: number, maxItems: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.Search.IIndexableContent> | Windows.Storage.Search.IIndexableContent[]>;
+    GetCountAsync(): Windows.Foundation.IAsyncOperation<number>;
+    GetPropertiesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Foundation.Collections.IMapView<string, Object>> | Windows.Foundation.Collections.IMapView<string, Object>[]>;
+    GetPropertiesAsync(startIndex: number, maxItems: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Foundation.Collections.IMapView<string, Object>> | Windows.Foundation.Collections.IMapView<string, Object>[]>;
+    readonly QueryFolder: Windows.Storage.StorageFolder;
+  }
+  var IContentIndexerQuery: abstract new (...args: any[]) => IContentIndexerQuery;
+
+  interface IContentIndexerQueryOperations {
+    CreateQuery(searchFilter: string, propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[], sortOrder: Windows.Foundation.Collections.IIterable<Windows.Storage.Search.SortEntry> | Windows.Storage.Search.SortEntry[], searchFilterLanguage: string): Windows.Storage.Search.ContentIndexerQuery;
+    CreateQuery(searchFilter: string, propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[], sortOrder: Windows.Foundation.Collections.IIterable<Windows.Storage.Search.SortEntry> | Windows.Storage.Search.SortEntry[]): Windows.Storage.Search.ContentIndexerQuery;
+    CreateQuery(searchFilter: string, propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Storage.Search.ContentIndexerQuery;
+  }
+  var IContentIndexerQueryOperations: abstract new (...args: any[]) => IContentIndexerQueryOperations;
+
+  interface IContentIndexerStatics {
+    GetIndexer(indexName: string): Windows.Storage.Search.ContentIndexer;
+    GetIndexer(): Windows.Storage.Search.ContentIndexer;
+  }
+  var IContentIndexerStatics: abstract new (...args: any[]) => IContentIndexerStatics;
+
+  interface IIndexableContent {
+    Id: string;
+    readonly Properties: Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>;
+    Stream: Windows.Storage.Streams.IRandomAccessStream;
+    StreamContentType: string;
+  }
+  var IIndexableContent: abstract new (...args: any[]) => IIndexableContent;
+
+  interface IQueryOptions {
+    LoadFromString(value: string): void;
+    SaveToString(): string;
+    SetPropertyPrefetch(options: number, propertiesToRetrieve: Windows.Foundation.Collections.IIterable<string> | string[]): void;
+    SetThumbnailPrefetch(mode: number, requestedSize: number, options: number): void;
+    ApplicationSearchFilter: string;
+    readonly DateStackOption: number;
+    readonly FileTypeFilter: Windows.Foundation.Collections.IVector<string> | string[];
+    FolderDepth: number;
+    readonly GroupPropertyName: string;
+    IndexerOption: number;
+    Language: string;
+    readonly SortOrder: Windows.Foundation.Collections.IVector<Windows.Storage.Search.SortEntry> | Windows.Storage.Search.SortEntry[];
+    UserSearchFilter: string;
+  }
+  var IQueryOptions: abstract new (...args: any[]) => IQueryOptions;
+
+  interface IQueryOptionsFactory {
+    CreateCommonFileQuery(query: number, fileTypeFilter: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Storage.Search.QueryOptions;
+    CreateCommonFolderQuery(query: number): Windows.Storage.Search.QueryOptions;
+  }
+  var IQueryOptionsFactory: abstract new (...args: any[]) => IQueryOptionsFactory;
+
+  interface IQueryOptionsWithProviderFilter {
+    readonly StorageProviderIdFilter: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var IQueryOptionsWithProviderFilter: abstract new (...args: any[]) => IQueryOptionsWithProviderFilter;
+
+  interface IStorageFileQueryResult extends Windows.Storage.Search.IStorageQueryResultBase {
+    ApplyNewQueryOptions(newQueryOptions: Windows.Storage.Search.QueryOptions): void;
+    FindStartIndexAsync(value: Object): Windows.Foundation.IAsyncOperation<number>;
+    GetCurrentQueryOptions(): Windows.Storage.Search.QueryOptions;
+    GetFilesAsync(startIndex: number, maxNumberOfItems: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[]>;
+    GetFilesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[]>;
+    GetItemCountAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IStorageFileQueryResult: abstract new (...args: any[]) => IStorageFileQueryResult;
+
+  interface IStorageFileQueryResult2 extends Windows.Storage.Search.IStorageQueryResultBase {
+    ApplyNewQueryOptions(newQueryOptions: Windows.Storage.Search.QueryOptions): void;
+    FindStartIndexAsync(value: Object): Windows.Foundation.IAsyncOperation<number>;
+    GetCurrentQueryOptions(): Windows.Storage.Search.QueryOptions;
+    GetItemCountAsync(): Windows.Foundation.IAsyncOperation<number>;
+    GetMatchingPropertiesWithRanges(file: Windows.Storage.StorageFile): Windows.Foundation.Collections.IMap<string, Windows.Foundation.Collections.IVectorView<Windows.Data.Text.TextSegment> | Windows.Data.Text.TextSegment[]> | Record<string, Windows.Foundation.Collections.IVectorView<Windows.Data.Text.TextSegment> | Windows.Data.Text.TextSegment[]>;
+  }
+  var IStorageFileQueryResult2: abstract new (...args: any[]) => IStorageFileQueryResult2;
+
+  interface IStorageFolderQueryOperations {
+    AreQueryOptionsSupported(queryOptions: Windows.Storage.Search.QueryOptions): boolean;
+    CreateFileQuery(): Windows.Storage.Search.StorageFileQueryResult;
+    CreateFileQuery(query: number): Windows.Storage.Search.StorageFileQueryResult;
+    CreateFileQueryWithOptions(queryOptions: Windows.Storage.Search.QueryOptions): Windows.Storage.Search.StorageFileQueryResult;
+    CreateFolderQuery(): Windows.Storage.Search.StorageFolderQueryResult;
+    CreateFolderQuery(query: number): Windows.Storage.Search.StorageFolderQueryResult;
+    CreateFolderQueryWithOptions(queryOptions: Windows.Storage.Search.QueryOptions): Windows.Storage.Search.StorageFolderQueryResult;
+    CreateItemQuery(): Windows.Storage.Search.StorageItemQueryResult;
+    CreateItemQueryWithOptions(queryOptions: Windows.Storage.Search.QueryOptions): Windows.Storage.Search.StorageItemQueryResult;
+    GetFilesAsync(query: number, startIndex: number, maxItemsToRetrieve: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[]>;
+    GetFilesAsync(query: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[]>;
+    GetFoldersAsync(query: number, startIndex: number, maxItemsToRetrieve: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFolder> | Windows.Storage.StorageFolder[]>;
+    GetFoldersAsync(query: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFolder> | Windows.Storage.StorageFolder[]>;
+    GetIndexedStateAsync(): Windows.Foundation.IAsyncOperation<number>;
+    GetItemsAsync(startIndex: number, maxItemsToRetrieve: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[]>;
+    IsCommonFileQuerySupported(query: number): boolean;
+    IsCommonFolderQuerySupported(query: number): boolean;
+  }
+  var IStorageFolderQueryOperations: abstract new (...args: any[]) => IStorageFolderQueryOperations;
+
+  interface IStorageFolderQueryResult extends Windows.Storage.Search.IStorageQueryResultBase {
+    ApplyNewQueryOptions(newQueryOptions: Windows.Storage.Search.QueryOptions): void;
+    FindStartIndexAsync(value: Object): Windows.Foundation.IAsyncOperation<number>;
+    GetCurrentQueryOptions(): Windows.Storage.Search.QueryOptions;
+    GetFoldersAsync(startIndex: number, maxNumberOfItems: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFolder> | Windows.Storage.StorageFolder[]>;
+    GetFoldersAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFolder> | Windows.Storage.StorageFolder[]>;
+    GetItemCountAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IStorageFolderQueryResult: abstract new (...args: any[]) => IStorageFolderQueryResult;
+
+  interface IStorageItemQueryResult extends Windows.Storage.Search.IStorageQueryResultBase {
+    ApplyNewQueryOptions(newQueryOptions: Windows.Storage.Search.QueryOptions): void;
+    FindStartIndexAsync(value: Object): Windows.Foundation.IAsyncOperation<number>;
+    GetCurrentQueryOptions(): Windows.Storage.Search.QueryOptions;
+    GetItemCountAsync(): Windows.Foundation.IAsyncOperation<number>;
+    GetItemsAsync(startIndex: number, maxNumberOfItems: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[]>;
+    GetItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[]>;
+  }
+  var IStorageItemQueryResult: abstract new (...args: any[]) => IStorageItemQueryResult;
+
+  interface IStorageLibraryChangeTrackerTriggerDetails {
+    readonly ChangeTracker: Windows.Storage.StorageLibraryChangeTracker;
+    readonly Folder: Windows.Storage.StorageFolder;
+  }
+  var IStorageLibraryChangeTrackerTriggerDetails: abstract new (...args: any[]) => IStorageLibraryChangeTrackerTriggerDetails;
+
+  interface IStorageLibraryContentChangedTriggerDetails {
+    CreateModifiedSinceQuery(lastQueryTime: Windows.Foundation.DateTime): Windows.Storage.Search.StorageItemQueryResult;
+    readonly Folder: Windows.Storage.StorageFolder;
+  }
+  var IStorageLibraryContentChangedTriggerDetails: abstract new (...args: any[]) => IStorageLibraryContentChangedTriggerDetails;
+
+  interface IStorageQueryResultBase {
+    ApplyNewQueryOptions(newQueryOptions: Windows.Storage.Search.QueryOptions): void;
+    FindStartIndexAsync(value: Object): Windows.Foundation.IAsyncOperation<number>;
+    GetCurrentQueryOptions(): Windows.Storage.Search.QueryOptions;
+    GetItemCountAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly Folder: Windows.Storage.StorageFolder;
+    ContentsChanged: Windows.Foundation.TypedEventHandler<Windows.Storage.Search.IStorageQueryResultBase, Object> | null;
+    OptionsChanged: Windows.Foundation.TypedEventHandler<Windows.Storage.Search.IStorageQueryResultBase, Object> | null;
+  }
+  var IStorageQueryResultBase: abstract new (...args: any[]) => IStorageQueryResultBase;
+
+  interface IValueAndLanguage {
+    Language: string;
+    Value: Object;
+  }
+  var IValueAndLanguage: abstract new (...args: any[]) => IValueAndLanguage;
+
+  interface SortEntry {
+    PropertyName: string;
+    AscendingOrder: boolean;
+  }
+  var SortEntry: {
+    new(propertyName: string, ascendingOrder: boolean): SortEntry;
+    new(fields: { PropertyName?: string; AscendingOrder?: boolean }): SortEntry;
+  };
+
+}
+
+declare namespace Windows.Storage.Streams {
+  class Buffer implements Windows.Storage.Streams.IBuffer {
+    constructor(capacity: number);
+    static CreateCopyFromMemoryBuffer(input: Windows.Foundation.IMemoryBuffer): Windows.Storage.Streams.Buffer;
+    static CreateMemoryBufferOverIBuffer(input: Windows.Storage.Streams.IBuffer): Windows.Foundation.MemoryBuffer;
+    readonly Capacity: number;
+    Length: number;
+  }
+
+  class DataReader implements Windows.Foundation.IClosable, Windows.Storage.Streams.IDataReader {
+    constructor(inputStream: Windows.Storage.Streams.IInputStream);
+    Close(): void;
+    DetachBuffer(): Windows.Storage.Streams.IBuffer;
+    DetachStream(): Windows.Storage.Streams.IInputStream;
+    static FromBuffer(buffer: Windows.Storage.Streams.IBuffer): Windows.Storage.Streams.DataReader;
+    LoadAsync(count: number): Windows.Storage.Streams.DataReaderLoadOperation;
+    ReadBoolean(): boolean;
+    ReadBuffer(length: number): Windows.Storage.Streams.IBuffer;
+    ReadByte(): number;
+    ReadBytes(value: number[]): void;
+    ReadDateTime(): Windows.Foundation.DateTime;
+    ReadDouble(): number;
+    ReadGuid(): Guid;
+    ReadInt16(): number;
+    ReadInt32(): number;
+    ReadInt64(): number | bigint;
+    ReadSingle(): number;
+    ReadString(codeUnitCount: number): string;
+    ReadTimeSpan(): Windows.Foundation.TimeSpan;
+    ReadUInt16(): number;
+    ReadUInt32(): number;
+    ReadUInt64(): number | bigint;
+    ByteOrder: number;
+    InputStreamOptions: number;
+    readonly UnconsumedBufferLength: number;
+    UnicodeEncoding: number;
+  }
+
+  class DataReaderLoadOperation implements Windows.Foundation.IAsyncInfo {
+    Cancel(): void;
+    Close(): void;
+    GetResults(): number;
+    Completed: Windows.Foundation.AsyncOperationCompletedHandler<number>;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly Id: number;
+    readonly Status: number;
+  }
+
+  class DataWriter implements Windows.Foundation.IClosable, Windows.Storage.Streams.IDataWriter {
+    constructor(outputStream: Windows.Storage.Streams.IOutputStream);
+    constructor();
+    Close(): void;
+    DetachBuffer(): Windows.Storage.Streams.IBuffer;
+    DetachStream(): Windows.Storage.Streams.IOutputStream;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    MeasureString(value: string): number;
+    StoreAsync(): Windows.Storage.Streams.DataWriterStoreOperation;
+    WriteBoolean(value: boolean): void;
+    WriteBuffer(buffer: Windows.Storage.Streams.IBuffer): void;
+    WriteBuffer(buffer: Windows.Storage.Streams.IBuffer, start: number, count: number): void;
+    WriteByte(value: number): void;
+    WriteBytes(value: number[]): void;
+    WriteDateTime(value: Windows.Foundation.DateTime): void;
+    WriteDouble(value: number): void;
+    WriteGuid(value: Guid): void;
+    WriteInt16(value: number): void;
+    WriteInt32(value: number): void;
+    WriteInt64(value: number | bigint): void;
+    WriteSingle(value: number): void;
+    WriteString(value: string): number;
+    WriteTimeSpan(value: Windows.Foundation.TimeSpan): void;
+    WriteUInt16(value: number): void;
+    WriteUInt32(value: number): void;
+    WriteUInt64(value: number | bigint): void;
+    ByteOrder: number;
+    UnicodeEncoding: number;
+    readonly UnstoredBufferLength: number;
+  }
+
+  class DataWriterStoreOperation implements Windows.Foundation.IAsyncInfo {
+    Cancel(): void;
+    Close(): void;
+    GetResults(): number;
+    Completed: Windows.Foundation.AsyncOperationCompletedHandler<number>;
+    readonly ErrorCode: Windows.Foundation.HResult;
+    readonly Id: number;
+    readonly Status: number;
+  }
+
+  class FileInputStream implements Windows.Foundation.IClosable, Windows.Storage.Streams.IInputStream {
+    Close(): void;
+    ReadAsync(buffer: Windows.Storage.Streams.IBuffer, count: number, options: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number>;
+  }
+
+  class FileOutputStream implements Windows.Foundation.IClosable, Windows.Storage.Streams.IOutputStream {
+    Close(): void;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    WriteAsync(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+  }
+
+  class FileRandomAccessStream implements Windows.Foundation.IClosable, Windows.Storage.Streams.IInputStream, Windows.Storage.Streams.IOutputStream, Windows.Storage.Streams.IRandomAccessStream {
+    CloneStream(): Windows.Storage.Streams.IRandomAccessStream;
+    Close(): void;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    GetInputStreamAt(position: number | bigint): Windows.Storage.Streams.IInputStream;
+    GetOutputStreamAt(position: number | bigint): Windows.Storage.Streams.IOutputStream;
+    static OpenAsync(filePath: string, accessMode: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    static OpenAsync(filePath: string, accessMode: number, sharingOptions: number, openDisposition: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    static OpenForUserAsync(user: Windows.System.User, filePath: string, accessMode: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    static OpenForUserAsync(user: Windows.System.User, filePath: string, accessMode: number, sharingOptions: number, openDisposition: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    static OpenTransactedWriteAsync(filePath: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageStreamTransaction>;
+    static OpenTransactedWriteAsync(filePath: string, openOptions: number, openDisposition: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageStreamTransaction>;
+    static OpenTransactedWriteForUserAsync(user: Windows.System.User, filePath: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageStreamTransaction>;
+    static OpenTransactedWriteForUserAsync(user: Windows.System.User, filePath: string, openOptions: number, openDisposition: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageStreamTransaction>;
+    ReadAsync(buffer: Windows.Storage.Streams.IBuffer, count: number, options: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number>;
+    Seek(position: number | bigint): void;
+    WriteAsync(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    readonly CanRead: boolean;
+    readonly CanWrite: boolean;
+    readonly Position: number | bigint;
+    Size: number | bigint;
+  }
+
+  class InMemoryRandomAccessStream implements Windows.Foundation.IClosable, Windows.Storage.Streams.IInputStream, Windows.Storage.Streams.IOutputStream, Windows.Storage.Streams.IRandomAccessStream {
+    constructor();
+    CloneStream(): Windows.Storage.Streams.IRandomAccessStream;
+    Close(): void;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    GetInputStreamAt(position: number | bigint): Windows.Storage.Streams.IInputStream;
+    GetOutputStreamAt(position: number | bigint): Windows.Storage.Streams.IOutputStream;
+    ReadAsync(buffer: Windows.Storage.Streams.IBuffer, count: number, options: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number>;
+    Seek(position: number | bigint): void;
+    WriteAsync(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    readonly CanRead: boolean;
+    readonly CanWrite: boolean;
+    readonly Position: number | bigint;
+    Size: number | bigint;
+  }
+
+  class InputStreamOverStream implements Windows.Foundation.IClosable, Windows.Storage.Streams.IInputStream {
+    Close(): void;
+    ReadAsync(buffer: Windows.Storage.Streams.IBuffer, count: number, options: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number>;
+  }
+
+  class OutputStreamOverStream implements Windows.Foundation.IClosable, Windows.Storage.Streams.IOutputStream {
+    Close(): void;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    WriteAsync(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+  }
+
+  class RandomAccessStream {
+    static CopyAndCloseAsync(source: Windows.Storage.Streams.IInputStream, destination: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+    static CopyAsync(source: Windows.Storage.Streams.IInputStream, destination: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+    static CopyAsync(source: Windows.Storage.Streams.IInputStream, destination: Windows.Storage.Streams.IOutputStream, bytesToCopy: number | bigint): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+  }
+
+  class RandomAccessStreamOverStream implements Windows.Foundation.IClosable, Windows.Storage.Streams.IInputStream, Windows.Storage.Streams.IOutputStream, Windows.Storage.Streams.IRandomAccessStream {
+    CloneStream(): Windows.Storage.Streams.IRandomAccessStream;
+    Close(): void;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    GetInputStreamAt(position: number | bigint): Windows.Storage.Streams.IInputStream;
+    GetOutputStreamAt(position: number | bigint): Windows.Storage.Streams.IOutputStream;
+    ReadAsync(buffer: Windows.Storage.Streams.IBuffer, count: number, options: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number>;
+    Seek(position: number | bigint): void;
+    WriteAsync(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    readonly CanRead: boolean;
+    readonly CanWrite: boolean;
+    readonly Position: number | bigint;
+    Size: number | bigint;
+  }
+
+  class RandomAccessStreamReference implements Windows.Storage.Streams.IRandomAccessStreamReference {
+    static CreateFromFile(file: Windows.Storage.IStorageFile): Windows.Storage.Streams.RandomAccessStreamReference;
+    static CreateFromStream(stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Storage.Streams.RandomAccessStreamReference;
+    static CreateFromUri(uri: Windows.Foundation.Uri): Windows.Storage.Streams.RandomAccessStreamReference;
+    OpenReadAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamWithContentType>;
+  }
+
+  enum ByteOrder {
+    LittleEndian = 0,
+    BigEndian = 1,
+  }
+
+  enum FileOpenDisposition {
+    OpenExisting = 0,
+    OpenAlways = 1,
+    CreateNew = 2,
+    CreateAlways = 3,
+    TruncateExisting = 4,
+  }
+
+  enum InputStreamOptions {
+    None = 0,
+    Partial = 1,
+    ReadAhead = 2,
+  }
+
+  enum UnicodeEncoding {
+    Utf8 = 0,
+    Utf16LE = 1,
+    Utf16BE = 2,
+  }
+
+  interface IBuffer {
+    readonly Capacity: number;
+    Length: number;
+  }
+  var IBuffer: abstract new (...args: any[]) => IBuffer;
+
+  interface IBufferFactory {
+    Create(capacity: number): Windows.Storage.Streams.Buffer;
+  }
+  var IBufferFactory: abstract new (...args: any[]) => IBufferFactory;
+
+  interface IBufferStatics {
+    CreateCopyFromMemoryBuffer(input: Windows.Foundation.IMemoryBuffer): Windows.Storage.Streams.Buffer;
+    CreateMemoryBufferOverIBuffer(input: Windows.Storage.Streams.IBuffer): Windows.Foundation.MemoryBuffer;
+  }
+  var IBufferStatics: abstract new (...args: any[]) => IBufferStatics;
+
+  interface IContentTypeProvider {
+    readonly ContentType: string;
+  }
+  var IContentTypeProvider: abstract new (...args: any[]) => IContentTypeProvider;
+
+  interface IDataReader {
+    DetachBuffer(): Windows.Storage.Streams.IBuffer;
+    DetachStream(): Windows.Storage.Streams.IInputStream;
+    LoadAsync(count: number): Windows.Storage.Streams.DataReaderLoadOperation;
+    ReadBoolean(): boolean;
+    ReadBuffer(length: number): Windows.Storage.Streams.IBuffer;
+    ReadByte(): number;
+    ReadBytes(value: number[]): void;
+    ReadDateTime(): Windows.Foundation.DateTime;
+    ReadDouble(): number;
+    ReadGuid(): Guid;
+    ReadInt16(): number;
+    ReadInt32(): number;
+    ReadInt64(): number | bigint;
+    ReadSingle(): number;
+    ReadString(codeUnitCount: number): string;
+    ReadTimeSpan(): Windows.Foundation.TimeSpan;
+    ReadUInt16(): number;
+    ReadUInt32(): number;
+    ReadUInt64(): number | bigint;
+    ByteOrder: number;
+    InputStreamOptions: number;
+    readonly UnconsumedBufferLength: number;
+    UnicodeEncoding: number;
+  }
+  var IDataReader: abstract new (...args: any[]) => IDataReader;
+
+  interface IDataReaderFactory {
+    CreateDataReader(inputStream: Windows.Storage.Streams.IInputStream): Windows.Storage.Streams.DataReader;
+  }
+  var IDataReaderFactory: abstract new (...args: any[]) => IDataReaderFactory;
+
+  interface IDataReaderStatics {
+    FromBuffer(buffer: Windows.Storage.Streams.IBuffer): Windows.Storage.Streams.DataReader;
+  }
+  var IDataReaderStatics: abstract new (...args: any[]) => IDataReaderStatics;
+
+  interface IDataWriter {
+    DetachBuffer(): Windows.Storage.Streams.IBuffer;
+    DetachStream(): Windows.Storage.Streams.IOutputStream;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    MeasureString(value: string): number;
+    StoreAsync(): Windows.Storage.Streams.DataWriterStoreOperation;
+    WriteBoolean(value: boolean): void;
+    WriteBuffer(buffer: Windows.Storage.Streams.IBuffer): void;
+    WriteBuffer(buffer: Windows.Storage.Streams.IBuffer, start: number, count: number): void;
+    WriteByte(value: number): void;
+    WriteBytes(value: number[]): void;
+    WriteDateTime(value: Windows.Foundation.DateTime): void;
+    WriteDouble(value: number): void;
+    WriteGuid(value: Guid): void;
+    WriteInt16(value: number): void;
+    WriteInt32(value: number): void;
+    WriteInt64(value: number | bigint): void;
+    WriteSingle(value: number): void;
+    WriteString(value: string): number;
+    WriteTimeSpan(value: Windows.Foundation.TimeSpan): void;
+    WriteUInt16(value: number): void;
+    WriteUInt32(value: number): void;
+    WriteUInt64(value: number | bigint): void;
+    ByteOrder: number;
+    UnicodeEncoding: number;
+    readonly UnstoredBufferLength: number;
+  }
+  var IDataWriter: abstract new (...args: any[]) => IDataWriter;
+
+  interface IDataWriterFactory {
+    CreateDataWriter(outputStream: Windows.Storage.Streams.IOutputStream): Windows.Storage.Streams.DataWriter;
+  }
+  var IDataWriterFactory: abstract new (...args: any[]) => IDataWriterFactory;
+
+  interface IFileRandomAccessStreamStatics {
+    OpenAsync(filePath: string, accessMode: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    OpenAsync(filePath: string, accessMode: number, sharingOptions: number, openDisposition: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    OpenForUserAsync(user: Windows.System.User, filePath: string, accessMode: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    OpenForUserAsync(user: Windows.System.User, filePath: string, accessMode: number, sharingOptions: number, openDisposition: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream>;
+    OpenTransactedWriteAsync(filePath: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageStreamTransaction>;
+    OpenTransactedWriteAsync(filePath: string, openOptions: number, openDisposition: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageStreamTransaction>;
+    OpenTransactedWriteForUserAsync(user: Windows.System.User, filePath: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageStreamTransaction>;
+    OpenTransactedWriteForUserAsync(user: Windows.System.User, filePath: string, openOptions: number, openDisposition: number): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageStreamTransaction>;
+  }
+  var IFileRandomAccessStreamStatics: abstract new (...args: any[]) => IFileRandomAccessStreamStatics;
+
+  interface IInputStream extends Windows.Foundation.IClosable {
+    Close(): void;
+    ReadAsync(buffer: Windows.Storage.Streams.IBuffer, count: number, options: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number>;
+  }
+  var IInputStream: abstract new (...args: any[]) => IInputStream;
+
+  interface IInputStreamReference {
+    OpenSequentialReadAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IInputStream>;
+  }
+  var IInputStreamReference: abstract new (...args: any[]) => IInputStreamReference;
+
+  interface IOutputStream extends Windows.Foundation.IClosable {
+    Close(): void;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    WriteAsync(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+  }
+  var IOutputStream: abstract new (...args: any[]) => IOutputStream;
+
+  interface IPropertySetSerializer {
+    Deserialize(propertySet: Windows.Foundation.Collections.IPropertySet, buffer: Windows.Storage.Streams.IBuffer): void;
+    Serialize(propertySet: Windows.Foundation.Collections.IPropertySet): Windows.Storage.Streams.IBuffer;
+  }
+  var IPropertySetSerializer: abstract new (...args: any[]) => IPropertySetSerializer;
+
+  interface IRandomAccessStream extends Windows.Foundation.IClosable, Windows.Storage.Streams.IInputStream, Windows.Storage.Streams.IOutputStream {
+    CloneStream(): Windows.Storage.Streams.IRandomAccessStream;
+    Close(): void;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    GetInputStreamAt(position: number | bigint): Windows.Storage.Streams.IInputStream;
+    GetOutputStreamAt(position: number | bigint): Windows.Storage.Streams.IOutputStream;
+    ReadAsync(buffer: Windows.Storage.Streams.IBuffer, count: number, options: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number>;
+    Seek(position: number | bigint): void;
+    WriteAsync(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    readonly CanRead: boolean;
+    readonly CanWrite: boolean;
+    readonly Position: number | bigint;
+    Size: number | bigint;
+  }
+  var IRandomAccessStream: abstract new (...args: any[]) => IRandomAccessStream;
+
+  interface IRandomAccessStreamReference {
+    OpenReadAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamWithContentType>;
+  }
+  var IRandomAccessStreamReference: abstract new (...args: any[]) => IRandomAccessStreamReference;
+
+  interface IRandomAccessStreamReferenceStatics {
+    CreateFromFile(file: Windows.Storage.IStorageFile): Windows.Storage.Streams.RandomAccessStreamReference;
+    CreateFromStream(stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Storage.Streams.RandomAccessStreamReference;
+    CreateFromUri(uri: Windows.Foundation.Uri): Windows.Storage.Streams.RandomAccessStreamReference;
+  }
+  var IRandomAccessStreamReferenceStatics: abstract new (...args: any[]) => IRandomAccessStreamReferenceStatics;
+
+  interface IRandomAccessStreamStatics {
+    CopyAndCloseAsync(source: Windows.Storage.Streams.IInputStream, destination: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+    CopyAsync(source: Windows.Storage.Streams.IInputStream, destination: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+    CopyAsync(source: Windows.Storage.Streams.IInputStream, destination: Windows.Storage.Streams.IOutputStream, bytesToCopy: number | bigint): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+  }
+  var IRandomAccessStreamStatics: abstract new (...args: any[]) => IRandomAccessStreamStatics;
+
+  interface IRandomAccessStreamWithContentType extends Windows.Foundation.IClosable, Windows.Storage.Streams.IContentTypeProvider, Windows.Storage.Streams.IInputStream, Windows.Storage.Streams.IOutputStream, Windows.Storage.Streams.IRandomAccessStream {
+    CloneStream(): Windows.Storage.Streams.IRandomAccessStream;
+    Close(): void;
+    FlushAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    GetInputStreamAt(position: number | bigint): Windows.Storage.Streams.IInputStream;
+    GetOutputStreamAt(position: number | bigint): Windows.Storage.Streams.IOutputStream;
+    ReadAsync(buffer: Windows.Storage.Streams.IBuffer, count: number, options: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number>;
+    Seek(position: number | bigint): void;
+    WriteAsync(buffer: Windows.Storage.Streams.IBuffer): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+  }
+  var IRandomAccessStreamWithContentType: abstract new (...args: any[]) => IRandomAccessStreamWithContentType;
+
+}
+
+declare namespace Windows.System {
+  class AppActivationResult implements Windows.System.IAppActivationResult {
+    readonly AppResourceGroupInfo: Windows.System.AppResourceGroupInfo;
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+
+  class AppDiagnosticInfo implements Windows.System.IAppDiagnosticInfo, Windows.System.IAppDiagnosticInfo2, Windows.System.IAppDiagnosticInfo3 {
+    CreateResourceGroupWatcher(): Windows.System.AppResourceGroupInfoWatcher;
+    static CreateWatcher(): Windows.System.AppDiagnosticInfoWatcher;
+    GetResourceGroups(): Windows.Foundation.Collections.IVector<Windows.System.AppResourceGroupInfo> | Windows.System.AppResourceGroupInfo[];
+    LaunchAsync(): Windows.Foundation.IAsyncOperation<Windows.System.AppActivationResult>;
+    static RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    static RequestInfoAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.System.AppDiagnosticInfo> | Windows.System.AppDiagnosticInfo[]>;
+    static RequestInfoForAppAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.System.AppDiagnosticInfo> | Windows.System.AppDiagnosticInfo[]>;
+    static RequestInfoForAppAsync(appUserModelId: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.System.AppDiagnosticInfo> | Windows.System.AppDiagnosticInfo[]>;
+    static RequestInfoForPackageAsync(packageFamilyName: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.System.AppDiagnosticInfo> | Windows.System.AppDiagnosticInfo[]>;
+    readonly AppInfo: Windows.ApplicationModel.AppInfo;
+  }
+
+  class AppDiagnosticInfoWatcher implements Windows.System.IAppDiagnosticInfoWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.System.AppDiagnosticInfoWatcher, Windows.System.AppDiagnosticInfoWatcherEventArgs> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.System.AppDiagnosticInfoWatcher, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.System.AppDiagnosticInfoWatcher, Windows.System.AppDiagnosticInfoWatcherEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.System.AppDiagnosticInfoWatcher, Object> | null;
+  }
+
+  class AppDiagnosticInfoWatcherEventArgs implements Windows.System.IAppDiagnosticInfoWatcherEventArgs {
+    readonly AppDiagnosticInfo: Windows.System.AppDiagnosticInfo;
+  }
+
+  class AppExecutionStateChangeResult implements Windows.System.IAppExecutionStateChangeResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+
+  class AppMemoryReport implements Windows.System.IAppMemoryReport, Windows.System.IAppMemoryReport2 {
+    readonly ExpectedTotalCommitLimit: number | bigint;
+    readonly PeakPrivateCommitUsage: number | bigint;
+    readonly PrivateCommitUsage: number | bigint;
+    readonly TotalCommitLimit: number | bigint;
+    readonly TotalCommitUsage: number | bigint;
+  }
+
+  class AppMemoryUsageLimitChangingEventArgs implements Windows.System.IAppMemoryUsageLimitChangingEventArgs {
+    readonly NewLimit: number | bigint;
+    readonly OldLimit: number | bigint;
+  }
+
+  class AppResourceGroupBackgroundTaskReport implements Windows.System.IAppResourceGroupBackgroundTaskReport {
+    readonly EntryPoint: string;
+    readonly Name: string;
+    readonly TaskId: Guid;
+    readonly Trigger: string;
+  }
+
+  class AppResourceGroupInfo implements Windows.System.IAppResourceGroupInfo, Windows.System.IAppResourceGroupInfo2 {
+    GetBackgroundTaskReports(): Windows.Foundation.Collections.IVector<Windows.System.AppResourceGroupBackgroundTaskReport> | Windows.System.AppResourceGroupBackgroundTaskReport[];
+    GetMemoryReport(): Windows.System.AppResourceGroupMemoryReport;
+    GetProcessDiagnosticInfos(): Windows.Foundation.Collections.IVector<Windows.System.Diagnostics.ProcessDiagnosticInfo> | Windows.System.Diagnostics.ProcessDiagnosticInfo[];
+    GetStateReport(): Windows.System.AppResourceGroupStateReport;
+    StartResumeAsync(): Windows.Foundation.IAsyncOperation<Windows.System.AppExecutionStateChangeResult>;
+    StartSuspendAsync(): Windows.Foundation.IAsyncOperation<Windows.System.AppExecutionStateChangeResult>;
+    StartTerminateAsync(): Windows.Foundation.IAsyncOperation<Windows.System.AppExecutionStateChangeResult>;
+    readonly InstanceId: Guid;
+    readonly IsShared: boolean;
+  }
+
+  class AppResourceGroupInfoWatcher implements Windows.System.IAppResourceGroupInfoWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.System.AppResourceGroupInfoWatcher, Windows.System.AppResourceGroupInfoWatcherEventArgs> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.System.AppResourceGroupInfoWatcher, Object> | null;
+    ExecutionStateChanged: Windows.Foundation.TypedEventHandler<Windows.System.AppResourceGroupInfoWatcher, Windows.System.AppResourceGroupInfoWatcherExecutionStateChangedEventArgs> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.System.AppResourceGroupInfoWatcher, Windows.System.AppResourceGroupInfoWatcherEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.System.AppResourceGroupInfoWatcher, Object> | null;
+  }
+
+  class AppResourceGroupInfoWatcherEventArgs implements Windows.System.IAppResourceGroupInfoWatcherEventArgs {
+    readonly AppDiagnosticInfos: Windows.Foundation.Collections.IVectorView<Windows.System.AppDiagnosticInfo> | Windows.System.AppDiagnosticInfo[];
+    readonly AppResourceGroupInfo: Windows.System.AppResourceGroupInfo;
+  }
+
+  class AppResourceGroupInfoWatcherExecutionStateChangedEventArgs implements Windows.System.IAppResourceGroupInfoWatcherExecutionStateChangedEventArgs {
+    readonly AppDiagnosticInfos: Windows.Foundation.Collections.IVectorView<Windows.System.AppDiagnosticInfo> | Windows.System.AppDiagnosticInfo[];
+    readonly AppResourceGroupInfo: Windows.System.AppResourceGroupInfo;
+  }
+
+  class AppResourceGroupMemoryReport implements Windows.System.IAppResourceGroupMemoryReport {
+    readonly CommitUsageLevel: number;
+    readonly CommitUsageLimit: number | bigint;
+    readonly PrivateCommitUsage: number | bigint;
+    readonly TotalCommitUsage: number | bigint;
+  }
+
+  class AppResourceGroupStateReport implements Windows.System.IAppResourceGroupStateReport {
+    readonly EnergyQuotaState: number;
+    readonly ExecutionState: number;
+  }
+
+  class AppUriHandlerHost implements Windows.System.IAppUriHandlerHost, Windows.System.IAppUriHandlerHost2 {
+    constructor(name: string);
+    constructor();
+    IsEnabled: boolean;
+    Name: string;
+  }
+
+  class AppUriHandlerRegistration implements Windows.System.IAppUriHandlerRegistration, Windows.System.IAppUriHandlerRegistration2 {
+    GetAllHosts(): Windows.Foundation.Collections.IVector<Windows.System.AppUriHandlerHost> | Windows.System.AppUriHandlerHost[];
+    GetAppAddedHostsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.System.AppUriHandlerHost> | Windows.System.AppUriHandlerHost[]>;
+    SetAppAddedHostsAsync(hosts: Windows.Foundation.Collections.IIterable<Windows.System.AppUriHandlerHost> | Windows.System.AppUriHandlerHost[]): Windows.Foundation.IAsyncAction;
+    UpdateHosts(hosts: Windows.Foundation.Collections.IIterable<Windows.System.AppUriHandlerHost> | Windows.System.AppUriHandlerHost[]): void;
+    readonly Name: string;
+    readonly PackageFamilyName: string;
+    readonly User: Windows.System.User;
+  }
+
+  class AppUriHandlerRegistrationManager implements Windows.System.IAppUriHandlerRegistrationManager, Windows.System.IAppUriHandlerRegistrationManager2 {
+    static GetDefault(): Windows.System.AppUriHandlerRegistrationManager;
+    static GetForPackage(packageFamilyName: string): Windows.System.AppUriHandlerRegistrationManager;
+    static GetForPackageForUser(packageFamilyName: string, user: Windows.System.User): Windows.System.AppUriHandlerRegistrationManager;
+    static GetForUser(user: Windows.System.User): Windows.System.AppUriHandlerRegistrationManager;
+    TryGetRegistration(name: string): Windows.System.AppUriHandlerRegistration;
+    readonly PackageFamilyName: string;
+    readonly User: Windows.System.User;
+  }
+
+  class DateTimeSettings {
+    static SetSystemDateTime(utcDateTime: Windows.Foundation.DateTime): void;
+  }
+
+  class DispatcherQueue implements Windows.System.IDispatcherQueue, Windows.System.IDispatcherQueue2 {
+    CreateTimer(): Windows.System.DispatcherQueueTimer;
+    static GetForCurrentThread(): Windows.System.DispatcherQueue;
+    TryEnqueue(callback: Windows.System.DispatcherQueueHandler): boolean;
+    TryEnqueue(priority: number, callback: Windows.System.DispatcherQueueHandler): boolean;
+    readonly HasThreadAccess: boolean;
+    ShutdownCompleted: Windows.Foundation.TypedEventHandler<Windows.System.DispatcherQueue, Object> | null;
+    ShutdownStarting: Windows.Foundation.TypedEventHandler<Windows.System.DispatcherQueue, Windows.System.DispatcherQueueShutdownStartingEventArgs> | null;
+  }
+
+  class DispatcherQueueController implements Windows.System.IDispatcherQueueController {
+    static CreateOnDedicatedThread(): Windows.System.DispatcherQueueController;
+    ShutdownQueueAsync(): Windows.Foundation.IAsyncAction;
+    readonly DispatcherQueue: Windows.System.DispatcherQueue;
+  }
+
+  class DispatcherQueueShutdownStartingEventArgs implements Windows.System.IDispatcherQueueShutdownStartingEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+
+  class DispatcherQueueTimer implements Windows.System.IDispatcherQueueTimer {
+    Start(): void;
+    Stop(): void;
+    Interval: Windows.Foundation.TimeSpan;
+    IsRepeating: boolean;
+    readonly IsRunning: boolean;
+    Tick: Windows.Foundation.TypedEventHandler<Windows.System.DispatcherQueueTimer, Object> | null;
+  }
+
+  class FolderLauncherOptions implements Windows.System.IFolderLauncherOptions, Windows.System.ILauncherViewOptions {
+    constructor();
+    DesiredRemainingView: number;
+    readonly ItemsToSelect: Windows.Foundation.Collections.IVector<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[];
+  }
+
+  class KnownUserProperties {
+    static readonly AccountName: string;
+    static readonly AgeEnforcementRegion: string;
+    static readonly DisplayName: string;
+    static readonly DomainName: string;
+    static readonly FirstName: string;
+    static readonly GuestHost: string;
+    static readonly LastName: string;
+    static readonly PrincipalName: string;
+    static readonly ProviderName: string;
+    static readonly SessionInitiationProtocolUri: string;
+  }
+
+  class LaunchUriResult implements Windows.System.ILaunchUriResult {
+    readonly Result: Windows.Foundation.Collections.ValueSet;
+    readonly Status: number;
+  }
+
+  class Launcher {
+    static FindAppUriHandlersAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.AppInfo> | Windows.ApplicationModel.AppInfo[]>;
+    static FindFileHandlersAsync(extension: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.AppInfo> | Windows.ApplicationModel.AppInfo[]>;
+    static FindUriSchemeHandlersAsync(scheme: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.AppInfo> | Windows.ApplicationModel.AppInfo[]>;
+    static FindUriSchemeHandlersAsync(scheme: string, launchQuerySupportType: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.AppInfo> | Windows.ApplicationModel.AppInfo[]>;
+    static LaunchFileAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<boolean>;
+    static LaunchFileAsync(file: Windows.Storage.IStorageFile, options: Windows.System.LauncherOptions): Windows.Foundation.IAsyncOperation<boolean>;
+    static LaunchFolderAsync(folder: Windows.Storage.IStorageFolder): Windows.Foundation.IAsyncOperation<boolean>;
+    static LaunchFolderAsync(folder: Windows.Storage.IStorageFolder, options: Windows.System.FolderLauncherOptions): Windows.Foundation.IAsyncOperation<boolean>;
+    static LaunchFolderPathAsync(path: string): Windows.Foundation.IAsyncOperation<boolean>;
+    static LaunchFolderPathAsync(path: string, options: Windows.System.FolderLauncherOptions): Windows.Foundation.IAsyncOperation<boolean>;
+    static LaunchFolderPathForUserAsync(user: Windows.System.User, path: string): Windows.Foundation.IAsyncOperation<boolean>;
+    static LaunchFolderPathForUserAsync(user: Windows.System.User, path: string, options: Windows.System.FolderLauncherOptions): Windows.Foundation.IAsyncOperation<boolean>;
+    static LaunchUriAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<boolean>;
+    static LaunchUriAsync(uri: Windows.Foundation.Uri, options: Windows.System.LauncherOptions): Windows.Foundation.IAsyncOperation<boolean>;
+    static LaunchUriAsync(uri: Windows.Foundation.Uri, options: Windows.System.LauncherOptions, inputData: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<boolean>;
+    static LaunchUriForResultsAsync(uri: Windows.Foundation.Uri, options: Windows.System.LauncherOptions): Windows.Foundation.IAsyncOperation<Windows.System.LaunchUriResult>;
+    static LaunchUriForResultsAsync(uri: Windows.Foundation.Uri, options: Windows.System.LauncherOptions, inputData: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<Windows.System.LaunchUriResult>;
+    static LaunchUriForResultsForUserAsync(user: Windows.System.User, uri: Windows.Foundation.Uri, options: Windows.System.LauncherOptions): Windows.Foundation.IAsyncOperation<Windows.System.LaunchUriResult>;
+    static LaunchUriForResultsForUserAsync(user: Windows.System.User, uri: Windows.Foundation.Uri, options: Windows.System.LauncherOptions, inputData: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<Windows.System.LaunchUriResult>;
+    static LaunchUriForUserAsync(user: Windows.System.User, uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<number>;
+    static LaunchUriForUserAsync(user: Windows.System.User, uri: Windows.Foundation.Uri, options: Windows.System.LauncherOptions): Windows.Foundation.IAsyncOperation<number>;
+    static LaunchUriForUserAsync(user: Windows.System.User, uri: Windows.Foundation.Uri, options: Windows.System.LauncherOptions, inputData: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<number>;
+    static QueryAppUriSupportAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<number>;
+    static QueryAppUriSupportAsync(uri: Windows.Foundation.Uri, packageFamilyName: string): Windows.Foundation.IAsyncOperation<number>;
+    static QueryFileSupportAsync(file: Windows.Storage.StorageFile): Windows.Foundation.IAsyncOperation<number>;
+    static QueryFileSupportAsync(file: Windows.Storage.StorageFile, packageFamilyName: string): Windows.Foundation.IAsyncOperation<number>;
+    static QueryUriSupportAsync(uri: Windows.Foundation.Uri, launchQuerySupportType: number): Windows.Foundation.IAsyncOperation<number>;
+    static QueryUriSupportAsync(uri: Windows.Foundation.Uri, launchQuerySupportType: number, packageFamilyName: string): Windows.Foundation.IAsyncOperation<number>;
+  }
+
+  class LauncherOptions implements Windows.System.ILauncherOptions, Windows.System.ILauncherOptions2, Windows.System.ILauncherOptions3, Windows.System.ILauncherOptions4, Windows.System.ILauncherViewOptions {
+    constructor();
+    ContentType: string;
+    DesiredRemainingView: number;
+    DisplayApplicationPicker: boolean;
+    FallbackUri: Windows.Foundation.Uri;
+    IgnoreAppUriHandlers: boolean;
+    LimitPickerToCurrentAppAndAppUriHandlers: boolean;
+    NeighboringFilesQuery: Windows.Storage.Search.StorageFileQueryResult;
+    PreferredApplicationDisplayName: string;
+    PreferredApplicationPackageFamilyName: string;
+    TargetApplicationPackageFamilyName: string;
+    TreatAsUntrusted: boolean;
+    readonly UI: Windows.System.LauncherUIOptions;
+  }
+
+  class LauncherUIOptions implements Windows.System.ILauncherUIOptions {
+    InvocationPoint: Windows.Foundation.Point | null;
+    PreferredPlacement: number;
+    SelectionRect: Windows.Foundation.Rect | null;
+  }
+
+  class MemoryManager {
+    static GetAppMemoryReport(): Windows.System.AppMemoryReport;
+    static GetProcessMemoryReport(): Windows.System.ProcessMemoryReport;
+    static TrySetAppMemoryUsageLimit(value: number | bigint): boolean;
+    static readonly AppMemoryUsage: number | bigint;
+    static readonly AppMemoryUsageLevel: number;
+    static readonly AppMemoryUsageLimit: number | bigint;
+    static readonly ExpectedAppMemoryUsageLimit: number | bigint;
+    static AppMemoryUsageDecreased: Windows.Foundation.EventHandler<Object> | null;
+    static AppMemoryUsageIncreased: Windows.Foundation.EventHandler<Object> | null;
+    static AppMemoryUsageLimitChanging: Windows.Foundation.EventHandler<Windows.System.AppMemoryUsageLimitChangingEventArgs> | null;
+  }
+
+  class ProcessLauncher {
+    static RunToCompletionAsync(fileName: string, args: string): Windows.Foundation.IAsyncOperation<Windows.System.ProcessLauncherResult>;
+    static RunToCompletionAsync(fileName: string, args: string, options: Windows.System.ProcessLauncherOptions): Windows.Foundation.IAsyncOperation<Windows.System.ProcessLauncherResult>;
+  }
+
+  class ProcessLauncherOptions implements Windows.System.IProcessLauncherOptions {
+    constructor();
+    StandardError: Windows.Storage.Streams.IOutputStream;
+    StandardInput: Windows.Storage.Streams.IInputStream;
+    StandardOutput: Windows.Storage.Streams.IOutputStream;
+    WorkingDirectory: string;
+  }
+
+  class ProcessLauncherResult implements Windows.System.IProcessLauncherResult {
+    readonly ExitCode: number;
+  }
+
+  class ProcessMemoryReport implements Windows.System.IProcessMemoryReport {
+    readonly PrivateWorkingSetUsage: number | bigint;
+    readonly TotalWorkingSetUsage: number | bigint;
+  }
+
+  class ProtocolForResultsOperation implements Windows.System.IProtocolForResultsOperation {
+    ReportCompleted(data: Windows.Foundation.Collections.ValueSet): void;
+  }
+
+  class RemoteLauncher {
+    static LaunchUriAsync(remoteSystemConnectionRequest: Windows.System.RemoteSystems.RemoteSystemConnectionRequest, uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<number>;
+    static LaunchUriAsync(remoteSystemConnectionRequest: Windows.System.RemoteSystems.RemoteSystemConnectionRequest, uri: Windows.Foundation.Uri, options: Windows.System.RemoteLauncherOptions): Windows.Foundation.IAsyncOperation<number>;
+    static LaunchUriAsync(remoteSystemConnectionRequest: Windows.System.RemoteSystems.RemoteSystemConnectionRequest, uri: Windows.Foundation.Uri, options: Windows.System.RemoteLauncherOptions, inputData: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<number>;
+  }
+
+  class RemoteLauncherOptions implements Windows.System.IRemoteLauncherOptions {
+    constructor();
+    FallbackUri: Windows.Foundation.Uri;
+    readonly PreferredAppIds: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+
+  class ShutdownManager {
+    static BeginShutdown(shutdownKind: number, timeout: Windows.Foundation.TimeSpan): void;
+    static CancelShutdown(): void;
+    static EnterPowerState(powerState: number): void;
+    static EnterPowerState(powerState: number, wakeUpAfter: Windows.Foundation.TimeSpan): void;
+    static IsPowerStateSupported(powerState: number): boolean;
+  }
+
+  class TimeZoneSettings {
+    static AutoUpdateTimeZoneAsync(timeout: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<number>;
+    static ChangeTimeZoneByDisplayName(timeZoneDisplayName: string): void;
+    static readonly CanChangeTimeZone: boolean;
+    static readonly CurrentTimeZoneDisplayName: string;
+    static readonly SupportedTimeZoneDisplayNames: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+
+  class User implements Windows.System.IUser, Windows.System.IUser2 {
+    CheckUserAgeConsentGroupAsync(consentGroup: number): Windows.Foundation.IAsyncOperation<number>;
+    static CreateWatcher(): Windows.System.UserWatcher;
+    static FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.System.User> | Windows.System.User[]>;
+    static FindAllAsync(type: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.System.User> | Windows.System.User[]>;
+    static FindAllAsync(type: number, status: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.System.User> | Windows.System.User[]>;
+    static GetDefault(): Windows.System.User;
+    static GetFromId(nonRoamableId: string): Windows.System.User;
+    GetPictureAsync(desiredSize: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamReference>;
+    GetPropertiesAsync(values: Windows.Foundation.Collections.IVectorView<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IPropertySet>;
+    GetPropertyAsync(value: string): Windows.Foundation.IAsyncOperation<Object>;
+    readonly AuthenticationStatus: number;
+    readonly NonRoamableId: string;
+    readonly Type: number;
+  }
+
+  class UserAuthenticationStatusChangeDeferral implements Windows.System.IUserAuthenticationStatusChangeDeferral {
+    Complete(): void;
+  }
+
+  class UserAuthenticationStatusChangingEventArgs implements Windows.System.IUserAuthenticationStatusChangingEventArgs {
+    GetDeferral(): Windows.System.UserAuthenticationStatusChangeDeferral;
+    readonly CurrentStatus: number;
+    readonly NewStatus: number;
+    readonly User: Windows.System.User;
+  }
+
+  class UserChangedEventArgs implements Windows.System.IUserChangedEventArgs, Windows.System.IUserChangedEventArgs2 {
+    readonly ChangedPropertyKinds: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly User: Windows.System.User;
+  }
+
+  class UserDeviceAssociation {
+    static FindUserFromDeviceId(deviceId: string): Windows.System.User;
+    static UserDeviceAssociationChanged: Windows.Foundation.EventHandler<Windows.System.UserDeviceAssociationChangedEventArgs> | null;
+  }
+
+  class UserDeviceAssociationChangedEventArgs implements Windows.System.IUserDeviceAssociationChangedEventArgs {
+    readonly DeviceId: string;
+    readonly NewUser: Windows.System.User;
+    readonly OldUser: Windows.System.User;
+  }
+
+  class UserPicker implements Windows.System.IUserPicker {
+    constructor();
+    static IsSupported(): boolean;
+    PickSingleUserAsync(): Windows.Foundation.IAsyncOperation<Windows.System.User>;
+    AllowGuestAccounts: boolean;
+    SuggestedSelectedUser: Windows.System.User;
+  }
+
+  class UserWatcher implements Windows.System.IUserWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.System.UserWatcher, Windows.System.UserChangedEventArgs> | null;
+    AuthenticationStatusChanged: Windows.Foundation.TypedEventHandler<Windows.System.UserWatcher, Windows.System.UserChangedEventArgs> | null;
+    AuthenticationStatusChanging: Windows.Foundation.TypedEventHandler<Windows.System.UserWatcher, Windows.System.UserAuthenticationStatusChangingEventArgs> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.System.UserWatcher, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.System.UserWatcher, Windows.System.UserChangedEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.System.UserWatcher, Object> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.System.UserWatcher, Windows.System.UserChangedEventArgs> | null;
+  }
+
+  enum AppDiagnosticInfoWatcherStatus {
+    Created = 0,
+    Started = 1,
+    EnumerationCompleted = 2,
+    Stopping = 3,
+    Stopped = 4,
+    Aborted = 5,
+  }
+
+  enum AppMemoryUsageLevel {
+    Low = 0,
+    Medium = 1,
+    High = 2,
+    OverLimit = 3,
+  }
+
+  enum AppResourceGroupEnergyQuotaState {
+    Unknown = 0,
+    Over = 1,
+    Under = 2,
+  }
+
+  enum AppResourceGroupExecutionState {
+    Unknown = 0,
+    Running = 1,
+    Suspending = 2,
+    Suspended = 3,
+    NotRunning = 4,
+  }
+
+  enum AppResourceGroupInfoWatcherStatus {
+    Created = 0,
+    Started = 1,
+    EnumerationCompleted = 2,
+    Stopping = 3,
+    Stopped = 4,
+    Aborted = 5,
+  }
+
+  enum AutoUpdateTimeZoneStatus {
+    Attempted = 0,
+    TimedOut = 1,
+    Failed = 2,
+  }
+
+  enum DiagnosticAccessStatus {
+    Unspecified = 0,
+    Denied = 1,
+    Limited = 2,
+    Allowed = 3,
+  }
+
+  enum DispatcherQueuePriority {
+    Low = -10,
+    Normal = 0,
+    High = 10,
+  }
+
+  enum LaunchFileStatus {
+    Success = 0,
+    AppUnavailable = 1,
+    DeniedByPolicy = 2,
+    FileTypeNotSupported = 3,
+    Unknown = 4,
+  }
+
+  enum LaunchQuerySupportStatus {
+    Available = 0,
+    AppNotInstalled = 1,
+    AppUnavailable = 2,
+    NotSupported = 3,
+    Unknown = 4,
+  }
+
+  enum LaunchQuerySupportType {
+    Uri = 0,
+    UriForResults = 1,
+  }
+
+  enum LaunchUriStatus {
+    Success = 0,
+    AppUnavailable = 1,
+    ProtocolUnavailable = 2,
+    Unknown = 3,
+  }
+
+  enum PowerState {
+    ConnectedStandby = 0,
+    SleepS3 = 1,
+  }
+
+  enum ProcessorArchitecture {
+    X86 = 0,
+    Arm = 5,
+    X64 = 9,
+    Neutral = 11,
+    Arm64 = 12,
+    X86OnArm64 = 14,
+    Unknown = 65535,
+  }
+
+  enum RemoteLaunchUriStatus {
+    Unknown = 0,
+    Success = 1,
+    AppUnavailable = 2,
+    ProtocolUnavailable = 3,
+    RemoteSystemUnavailable = 4,
+    ValueSetTooLarge = 5,
+    DeniedByLocalSystem = 6,
+    DeniedByRemoteSystem = 7,
+  }
+
+  enum ShutdownKind {
+    Shutdown = 0,
+    Restart = 1,
+  }
+
+  enum UserAgeConsentGroup {
+    Child = 0,
+    Minor = 1,
+    Adult = 2,
+  }
+
+  enum UserAgeConsentResult {
+    NotEnforced = 0,
+    Included = 1,
+    NotIncluded = 2,
+    Unknown = 3,
+    Ambiguous = 4,
+  }
+
+  enum UserAuthenticationStatus {
+    Unauthenticated = 0,
+    LocallyAuthenticated = 1,
+    RemotelyAuthenticated = 2,
+  }
+
+  enum UserPictureSize {
+    Size64x64 = 0,
+    Size208x208 = 1,
+    Size424x424 = 2,
+    Size1080x1080 = 3,
+  }
+
+  enum UserType {
+    LocalUser = 0,
+    RemoteUser = 1,
+    LocalGuest = 2,
+    RemoteGuest = 3,
+    SystemManaged = 4,
+  }
+
+  enum UserWatcherStatus {
+    Created = 0,
+    Started = 1,
+    EnumerationCompleted = 2,
+    Stopping = 3,
+    Stopped = 4,
+    Aborted = 5,
+  }
+
+  enum UserWatcherUpdateKind {
+    Properties = 0,
+    Picture = 1,
+  }
+
+  enum VirtualKey {
+    None = 0,
+    LeftButton = 1,
+    RightButton = 2,
+    Cancel = 3,
+    MiddleButton = 4,
+    XButton1 = 5,
+    XButton2 = 6,
+    Back = 8,
+    Tab = 9,
+    Clear = 12,
+    Enter = 13,
+    Shift = 16,
+    Control = 17,
+    Menu = 18,
+    Pause = 19,
+    CapitalLock = 20,
+    Kana = 21,
+    Hangul = 21,
+    ImeOn = 22,
+    Junja = 23,
+    Final = 24,
+    Hanja = 25,
+    Kanji = 25,
+    ImeOff = 26,
+    Escape = 27,
+    Convert = 28,
+    NonConvert = 29,
+    Accept = 30,
+    ModeChange = 31,
+    Space = 32,
+    PageUp = 33,
+    PageDown = 34,
+    End = 35,
+    Home = 36,
+    Left = 37,
+    Up = 38,
+    Right = 39,
+    Down = 40,
+    Select = 41,
+    Print = 42,
+    Execute = 43,
+    Snapshot = 44,
+    Insert = 45,
+    Delete = 46,
+    Help = 47,
+    Number0 = 48,
+    Number1 = 49,
+    Number2 = 50,
+    Number3 = 51,
+    Number4 = 52,
+    Number5 = 53,
+    Number6 = 54,
+    Number7 = 55,
+    Number8 = 56,
+    Number9 = 57,
+    A = 65,
+    B = 66,
+    C = 67,
+    D = 68,
+    E = 69,
+    F = 70,
+    G = 71,
+    H = 72,
+    I = 73,
+    J = 74,
+    K = 75,
+    L = 76,
+    M = 77,
+    N = 78,
+    O = 79,
+    P = 80,
+    Q = 81,
+    R = 82,
+    S = 83,
+    T = 84,
+    U = 85,
+    V = 86,
+    W = 87,
+    X = 88,
+    Y = 89,
+    Z = 90,
+    LeftWindows = 91,
+    RightWindows = 92,
+    Application = 93,
+    Sleep = 95,
+    NumberPad0 = 96,
+    NumberPad1 = 97,
+    NumberPad2 = 98,
+    NumberPad3 = 99,
+    NumberPad4 = 100,
+    NumberPad5 = 101,
+    NumberPad6 = 102,
+    NumberPad7 = 103,
+    NumberPad8 = 104,
+    NumberPad9 = 105,
+    Multiply = 106,
+    Add = 107,
+    Separator = 108,
+    Subtract = 109,
+    Decimal = 110,
+    Divide = 111,
+    F1 = 112,
+    F2 = 113,
+    F3 = 114,
+    F4 = 115,
+    F5 = 116,
+    F6 = 117,
+    F7 = 118,
+    F8 = 119,
+    F9 = 120,
+    F10 = 121,
+    F11 = 122,
+    F12 = 123,
+    F13 = 124,
+    F14 = 125,
+    F15 = 126,
+    F16 = 127,
+    F17 = 128,
+    F18 = 129,
+    F19 = 130,
+    F20 = 131,
+    F21 = 132,
+    F22 = 133,
+    F23 = 134,
+    F24 = 135,
+    NavigationView = 136,
+    NavigationMenu = 137,
+    NavigationUp = 138,
+    NavigationDown = 139,
+    NavigationLeft = 140,
+    NavigationRight = 141,
+    NavigationAccept = 142,
+    NavigationCancel = 143,
+    NumberKeyLock = 144,
+    Scroll = 145,
+    LeftShift = 160,
+    RightShift = 161,
+    LeftControl = 162,
+    RightControl = 163,
+    LeftMenu = 164,
+    RightMenu = 165,
+    GoBack = 166,
+    GoForward = 167,
+    Refresh = 168,
+    Stop = 169,
+    Search = 170,
+    Favorites = 171,
+    GoHome = 172,
+    GamepadA = 195,
+    GamepadB = 196,
+    GamepadX = 197,
+    GamepadY = 198,
+    GamepadRightShoulder = 199,
+    GamepadLeftShoulder = 200,
+    GamepadLeftTrigger = 201,
+    GamepadRightTrigger = 202,
+    GamepadDPadUp = 203,
+    GamepadDPadDown = 204,
+    GamepadDPadLeft = 205,
+    GamepadDPadRight = 206,
+    GamepadMenu = 207,
+    GamepadView = 208,
+    GamepadLeftThumbstickButton = 209,
+    GamepadRightThumbstickButton = 210,
+    GamepadLeftThumbstickUp = 211,
+    GamepadLeftThumbstickDown = 212,
+    GamepadLeftThumbstickRight = 213,
+    GamepadLeftThumbstickLeft = 214,
+    GamepadRightThumbstickUp = 215,
+    GamepadRightThumbstickDown = 216,
+    GamepadRightThumbstickRight = 217,
+    GamepadRightThumbstickLeft = 218,
+  }
+
+  enum VirtualKeyModifiers {
+    None = 0,
+    Control = 1,
+    Menu = 2,
+    Shift = 4,
+    Windows = 8,
+  }
+
+  interface DispatcherQueueHandler {
+    (): void;
+  }
+  var DispatcherQueueHandler: {
+    new(callback: () => void): DispatcherQueueHandler;
+  };
+
+  interface IAppActivationResult {
+    readonly AppResourceGroupInfo: Windows.System.AppResourceGroupInfo;
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+  var IAppActivationResult: abstract new (...args: any[]) => IAppActivationResult;
+
+  interface IAppDiagnosticInfo {
+    readonly AppInfo: Windows.ApplicationModel.AppInfo;
+  }
+  var IAppDiagnosticInfo: abstract new (...args: any[]) => IAppDiagnosticInfo;
+
+  interface IAppDiagnosticInfo2 {
+    CreateResourceGroupWatcher(): Windows.System.AppResourceGroupInfoWatcher;
+    GetResourceGroups(): Windows.Foundation.Collections.IVector<Windows.System.AppResourceGroupInfo> | Windows.System.AppResourceGroupInfo[];
+  }
+  var IAppDiagnosticInfo2: abstract new (...args: any[]) => IAppDiagnosticInfo2;
+
+  interface IAppDiagnosticInfo3 {
+    LaunchAsync(): Windows.Foundation.IAsyncOperation<Windows.System.AppActivationResult>;
+  }
+  var IAppDiagnosticInfo3: abstract new (...args: any[]) => IAppDiagnosticInfo3;
+
+  interface IAppDiagnosticInfoStatics {
+    RequestInfoAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.System.AppDiagnosticInfo> | Windows.System.AppDiagnosticInfo[]>;
+  }
+  var IAppDiagnosticInfoStatics: abstract new (...args: any[]) => IAppDiagnosticInfoStatics;
+
+  interface IAppDiagnosticInfoStatics2 {
+    CreateWatcher(): Windows.System.AppDiagnosticInfoWatcher;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    RequestInfoForAppAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.System.AppDiagnosticInfo> | Windows.System.AppDiagnosticInfo[]>;
+    RequestInfoForAppAsync(appUserModelId: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.System.AppDiagnosticInfo> | Windows.System.AppDiagnosticInfo[]>;
+    RequestInfoForPackageAsync(packageFamilyName: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.System.AppDiagnosticInfo> | Windows.System.AppDiagnosticInfo[]>;
+  }
+  var IAppDiagnosticInfoStatics2: abstract new (...args: any[]) => IAppDiagnosticInfoStatics2;
+
+  interface IAppDiagnosticInfoWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.System.AppDiagnosticInfoWatcher, Windows.System.AppDiagnosticInfoWatcherEventArgs> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.System.AppDiagnosticInfoWatcher, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.System.AppDiagnosticInfoWatcher, Windows.System.AppDiagnosticInfoWatcherEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.System.AppDiagnosticInfoWatcher, Object> | null;
+  }
+  var IAppDiagnosticInfoWatcher: abstract new (...args: any[]) => IAppDiagnosticInfoWatcher;
+
+  interface IAppDiagnosticInfoWatcherEventArgs {
+    readonly AppDiagnosticInfo: Windows.System.AppDiagnosticInfo;
+  }
+  var IAppDiagnosticInfoWatcherEventArgs: abstract new (...args: any[]) => IAppDiagnosticInfoWatcherEventArgs;
+
+  interface IAppExecutionStateChangeResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+  var IAppExecutionStateChangeResult: abstract new (...args: any[]) => IAppExecutionStateChangeResult;
+
+  interface IAppMemoryReport {
+    readonly PeakPrivateCommitUsage: number | bigint;
+    readonly PrivateCommitUsage: number | bigint;
+    readonly TotalCommitLimit: number | bigint;
+    readonly TotalCommitUsage: number | bigint;
+  }
+  var IAppMemoryReport: abstract new (...args: any[]) => IAppMemoryReport;
+
+  interface IAppMemoryReport2 {
+    readonly ExpectedTotalCommitLimit: number | bigint;
+  }
+  var IAppMemoryReport2: abstract new (...args: any[]) => IAppMemoryReport2;
+
+  interface IAppMemoryUsageLimitChangingEventArgs {
+    readonly NewLimit: number | bigint;
+    readonly OldLimit: number | bigint;
+  }
+  var IAppMemoryUsageLimitChangingEventArgs: abstract new (...args: any[]) => IAppMemoryUsageLimitChangingEventArgs;
+
+  interface IAppResourceGroupBackgroundTaskReport {
+    readonly EntryPoint: string;
+    readonly Name: string;
+    readonly TaskId: Guid;
+    readonly Trigger: string;
+  }
+  var IAppResourceGroupBackgroundTaskReport: abstract new (...args: any[]) => IAppResourceGroupBackgroundTaskReport;
+
+  interface IAppResourceGroupInfo {
+    GetBackgroundTaskReports(): Windows.Foundation.Collections.IVector<Windows.System.AppResourceGroupBackgroundTaskReport> | Windows.System.AppResourceGroupBackgroundTaskReport[];
+    GetMemoryReport(): Windows.System.AppResourceGroupMemoryReport;
+    GetProcessDiagnosticInfos(): Windows.Foundation.Collections.IVector<Windows.System.Diagnostics.ProcessDiagnosticInfo> | Windows.System.Diagnostics.ProcessDiagnosticInfo[];
+    GetStateReport(): Windows.System.AppResourceGroupStateReport;
+    readonly InstanceId: Guid;
+    readonly IsShared: boolean;
+  }
+  var IAppResourceGroupInfo: abstract new (...args: any[]) => IAppResourceGroupInfo;
+
+  interface IAppResourceGroupInfo2 {
+    StartResumeAsync(): Windows.Foundation.IAsyncOperation<Windows.System.AppExecutionStateChangeResult>;
+    StartSuspendAsync(): Windows.Foundation.IAsyncOperation<Windows.System.AppExecutionStateChangeResult>;
+    StartTerminateAsync(): Windows.Foundation.IAsyncOperation<Windows.System.AppExecutionStateChangeResult>;
+  }
+  var IAppResourceGroupInfo2: abstract new (...args: any[]) => IAppResourceGroupInfo2;
+
+  interface IAppResourceGroupInfoWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.System.AppResourceGroupInfoWatcher, Windows.System.AppResourceGroupInfoWatcherEventArgs> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.System.AppResourceGroupInfoWatcher, Object> | null;
+    ExecutionStateChanged: Windows.Foundation.TypedEventHandler<Windows.System.AppResourceGroupInfoWatcher, Windows.System.AppResourceGroupInfoWatcherExecutionStateChangedEventArgs> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.System.AppResourceGroupInfoWatcher, Windows.System.AppResourceGroupInfoWatcherEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.System.AppResourceGroupInfoWatcher, Object> | null;
+  }
+  var IAppResourceGroupInfoWatcher: abstract new (...args: any[]) => IAppResourceGroupInfoWatcher;
+
+  interface IAppResourceGroupInfoWatcherEventArgs {
+    readonly AppDiagnosticInfos: Windows.Foundation.Collections.IVectorView<Windows.System.AppDiagnosticInfo> | Windows.System.AppDiagnosticInfo[];
+    readonly AppResourceGroupInfo: Windows.System.AppResourceGroupInfo;
+  }
+  var IAppResourceGroupInfoWatcherEventArgs: abstract new (...args: any[]) => IAppResourceGroupInfoWatcherEventArgs;
+
+  interface IAppResourceGroupInfoWatcherExecutionStateChangedEventArgs {
+    readonly AppDiagnosticInfos: Windows.Foundation.Collections.IVectorView<Windows.System.AppDiagnosticInfo> | Windows.System.AppDiagnosticInfo[];
+    readonly AppResourceGroupInfo: Windows.System.AppResourceGroupInfo;
+  }
+  var IAppResourceGroupInfoWatcherExecutionStateChangedEventArgs: abstract new (...args: any[]) => IAppResourceGroupInfoWatcherExecutionStateChangedEventArgs;
+
+  interface IAppResourceGroupMemoryReport {
+    readonly CommitUsageLevel: number;
+    readonly CommitUsageLimit: number | bigint;
+    readonly PrivateCommitUsage: number | bigint;
+    readonly TotalCommitUsage: number | bigint;
+  }
+  var IAppResourceGroupMemoryReport: abstract new (...args: any[]) => IAppResourceGroupMemoryReport;
+
+  interface IAppResourceGroupStateReport {
+    readonly EnergyQuotaState: number;
+    readonly ExecutionState: number;
+  }
+  var IAppResourceGroupStateReport: abstract new (...args: any[]) => IAppResourceGroupStateReport;
+
+  interface IAppUriHandlerHost {
+    Name: string;
+  }
+  var IAppUriHandlerHost: abstract new (...args: any[]) => IAppUriHandlerHost;
+
+  interface IAppUriHandlerHost2 {
+    IsEnabled: boolean;
+  }
+  var IAppUriHandlerHost2: abstract new (...args: any[]) => IAppUriHandlerHost2;
+
+  interface IAppUriHandlerHostFactory {
+    CreateInstance(name: string): Windows.System.AppUriHandlerHost;
+  }
+  var IAppUriHandlerHostFactory: abstract new (...args: any[]) => IAppUriHandlerHostFactory;
+
+  interface IAppUriHandlerRegistration {
+    GetAppAddedHostsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVector<Windows.System.AppUriHandlerHost> | Windows.System.AppUriHandlerHost[]>;
+    SetAppAddedHostsAsync(hosts: Windows.Foundation.Collections.IIterable<Windows.System.AppUriHandlerHost> | Windows.System.AppUriHandlerHost[]): Windows.Foundation.IAsyncAction;
+    readonly Name: string;
+    readonly User: Windows.System.User;
+  }
+  var IAppUriHandlerRegistration: abstract new (...args: any[]) => IAppUriHandlerRegistration;
+
+  interface IAppUriHandlerRegistration2 {
+    GetAllHosts(): Windows.Foundation.Collections.IVector<Windows.System.AppUriHandlerHost> | Windows.System.AppUriHandlerHost[];
+    UpdateHosts(hosts: Windows.Foundation.Collections.IIterable<Windows.System.AppUriHandlerHost> | Windows.System.AppUriHandlerHost[]): void;
+    readonly PackageFamilyName: string;
+  }
+  var IAppUriHandlerRegistration2: abstract new (...args: any[]) => IAppUriHandlerRegistration2;
+
+  interface IAppUriHandlerRegistrationManager {
+    TryGetRegistration(name: string): Windows.System.AppUriHandlerRegistration;
+    readonly User: Windows.System.User;
+  }
+  var IAppUriHandlerRegistrationManager: abstract new (...args: any[]) => IAppUriHandlerRegistrationManager;
+
+  interface IAppUriHandlerRegistrationManager2 {
+    readonly PackageFamilyName: string;
+  }
+  var IAppUriHandlerRegistrationManager2: abstract new (...args: any[]) => IAppUriHandlerRegistrationManager2;
+
+  interface IAppUriHandlerRegistrationManagerStatics {
+    GetDefault(): Windows.System.AppUriHandlerRegistrationManager;
+    GetForUser(user: Windows.System.User): Windows.System.AppUriHandlerRegistrationManager;
+  }
+  var IAppUriHandlerRegistrationManagerStatics: abstract new (...args: any[]) => IAppUriHandlerRegistrationManagerStatics;
+
+  interface IAppUriHandlerRegistrationManagerStatics2 {
+    GetForPackage(packageFamilyName: string): Windows.System.AppUriHandlerRegistrationManager;
+    GetForPackageForUser(packageFamilyName: string, user: Windows.System.User): Windows.System.AppUriHandlerRegistrationManager;
+  }
+  var IAppUriHandlerRegistrationManagerStatics2: abstract new (...args: any[]) => IAppUriHandlerRegistrationManagerStatics2;
+
+  interface IDateTimeSettingsStatics {
+    SetSystemDateTime(utcDateTime: Windows.Foundation.DateTime): void;
+  }
+  var IDateTimeSettingsStatics: abstract new (...args: any[]) => IDateTimeSettingsStatics;
+
+  interface IDispatcherQueue {
+    CreateTimer(): Windows.System.DispatcherQueueTimer;
+    TryEnqueue(callback: Windows.System.DispatcherQueueHandler): boolean;
+    TryEnqueue(priority: number, callback: Windows.System.DispatcherQueueHandler): boolean;
+    ShutdownCompleted: Windows.Foundation.TypedEventHandler<Windows.System.DispatcherQueue, Object> | null;
+    ShutdownStarting: Windows.Foundation.TypedEventHandler<Windows.System.DispatcherQueue, Windows.System.DispatcherQueueShutdownStartingEventArgs> | null;
+  }
+  var IDispatcherQueue: abstract new (...args: any[]) => IDispatcherQueue;
+
+  interface IDispatcherQueue2 {
+    readonly HasThreadAccess: boolean;
+  }
+  var IDispatcherQueue2: abstract new (...args: any[]) => IDispatcherQueue2;
+
+  interface IDispatcherQueueController {
+    ShutdownQueueAsync(): Windows.Foundation.IAsyncAction;
+    readonly DispatcherQueue: Windows.System.DispatcherQueue;
+  }
+  var IDispatcherQueueController: abstract new (...args: any[]) => IDispatcherQueueController;
+
+  interface IDispatcherQueueControllerStatics {
+    CreateOnDedicatedThread(): Windows.System.DispatcherQueueController;
+  }
+  var IDispatcherQueueControllerStatics: abstract new (...args: any[]) => IDispatcherQueueControllerStatics;
+
+  interface IDispatcherQueueShutdownStartingEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+  var IDispatcherQueueShutdownStartingEventArgs: abstract new (...args: any[]) => IDispatcherQueueShutdownStartingEventArgs;
+
+  interface IDispatcherQueueStatics {
+    GetForCurrentThread(): Windows.System.DispatcherQueue;
+  }
+  var IDispatcherQueueStatics: abstract new (...args: any[]) => IDispatcherQueueStatics;
+
+  interface IDispatcherQueueTimer {
+    Start(): void;
+    Stop(): void;
+    Interval: Windows.Foundation.TimeSpan;
+    IsRepeating: boolean;
+    readonly IsRunning: boolean;
+    Tick: Windows.Foundation.TypedEventHandler<Windows.System.DispatcherQueueTimer, Object> | null;
+  }
+  var IDispatcherQueueTimer: abstract new (...args: any[]) => IDispatcherQueueTimer;
+
+  interface IFolderLauncherOptions {
+    readonly ItemsToSelect: Windows.Foundation.Collections.IVector<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[];
+  }
+  var IFolderLauncherOptions: abstract new (...args: any[]) => IFolderLauncherOptions;
+
+  interface IKnownUserPropertiesStatics {
+    readonly AccountName: string;
+    readonly DisplayName: string;
+    readonly DomainName: string;
+    readonly FirstName: string;
+    readonly GuestHost: string;
+    readonly LastName: string;
+    readonly PrincipalName: string;
+    readonly ProviderName: string;
+    readonly SessionInitiationProtocolUri: string;
+  }
+  var IKnownUserPropertiesStatics: abstract new (...args: any[]) => IKnownUserPropertiesStatics;
+
+  interface IKnownUserPropertiesStatics2 {
+    readonly AgeEnforcementRegion: string;
+  }
+  var IKnownUserPropertiesStatics2: abstract new (...args: any[]) => IKnownUserPropertiesStatics2;
+
+  interface ILaunchUriResult {
+    readonly Result: Windows.Foundation.Collections.ValueSet;
+    readonly Status: number;
+  }
+  var ILaunchUriResult: abstract new (...args: any[]) => ILaunchUriResult;
+
+  interface ILauncherOptions {
+    ContentType: string;
+    DisplayApplicationPicker: boolean;
+    FallbackUri: Windows.Foundation.Uri;
+    PreferredApplicationDisplayName: string;
+    PreferredApplicationPackageFamilyName: string;
+    TreatAsUntrusted: boolean;
+    readonly UI: Windows.System.LauncherUIOptions;
+  }
+  var ILauncherOptions: abstract new (...args: any[]) => ILauncherOptions;
+
+  interface ILauncherOptions2 {
+    NeighboringFilesQuery: Windows.Storage.Search.StorageFileQueryResult;
+    TargetApplicationPackageFamilyName: string;
+  }
+  var ILauncherOptions2: abstract new (...args: any[]) => ILauncherOptions2;
+
+  interface ILauncherOptions3 {
+    IgnoreAppUriHandlers: boolean;
+  }
+  var ILauncherOptions3: abstract new (...args: any[]) => ILauncherOptions3;
+
+  interface ILauncherOptions4 {
+    LimitPickerToCurrentAppAndAppUriHandlers: boolean;
+  }
+  var ILauncherOptions4: abstract new (...args: any[]) => ILauncherOptions4;
+
+  interface ILauncherStatics {
+    LaunchFileAsync(file: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<boolean>;
+    LaunchFileAsync(file: Windows.Storage.IStorageFile, options: Windows.System.LauncherOptions): Windows.Foundation.IAsyncOperation<boolean>;
+    LaunchUriAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<boolean>;
+    LaunchUriAsync(uri: Windows.Foundation.Uri, options: Windows.System.LauncherOptions): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var ILauncherStatics: abstract new (...args: any[]) => ILauncherStatics;
+
+  interface ILauncherStatics2 {
+    FindFileHandlersAsync(extension: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.AppInfo> | Windows.ApplicationModel.AppInfo[]>;
+    FindUriSchemeHandlersAsync(scheme: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.AppInfo> | Windows.ApplicationModel.AppInfo[]>;
+    FindUriSchemeHandlersAsync(scheme: string, launchQuerySupportType: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.AppInfo> | Windows.ApplicationModel.AppInfo[]>;
+    LaunchUriAsync(uri: Windows.Foundation.Uri, options: Windows.System.LauncherOptions, inputData: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<boolean>;
+    LaunchUriForResultsAsync(uri: Windows.Foundation.Uri, options: Windows.System.LauncherOptions): Windows.Foundation.IAsyncOperation<Windows.System.LaunchUriResult>;
+    LaunchUriForResultsAsync(uri: Windows.Foundation.Uri, options: Windows.System.LauncherOptions, inputData: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<Windows.System.LaunchUriResult>;
+    QueryFileSupportAsync(file: Windows.Storage.StorageFile): Windows.Foundation.IAsyncOperation<number>;
+    QueryFileSupportAsync(file: Windows.Storage.StorageFile, packageFamilyName: string): Windows.Foundation.IAsyncOperation<number>;
+    QueryUriSupportAsync(uri: Windows.Foundation.Uri, launchQuerySupportType: number): Windows.Foundation.IAsyncOperation<number>;
+    QueryUriSupportAsync(uri: Windows.Foundation.Uri, launchQuerySupportType: number, packageFamilyName: string): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var ILauncherStatics2: abstract new (...args: any[]) => ILauncherStatics2;
+
+  interface ILauncherStatics3 {
+    LaunchFolderAsync(folder: Windows.Storage.IStorageFolder): Windows.Foundation.IAsyncOperation<boolean>;
+    LaunchFolderAsync(folder: Windows.Storage.IStorageFolder, options: Windows.System.FolderLauncherOptions): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var ILauncherStatics3: abstract new (...args: any[]) => ILauncherStatics3;
+
+  interface ILauncherStatics4 {
+    FindAppUriHandlersAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.ApplicationModel.AppInfo> | Windows.ApplicationModel.AppInfo[]>;
+    LaunchUriForResultsForUserAsync(user: Windows.System.User, uri: Windows.Foundation.Uri, options: Windows.System.LauncherOptions): Windows.Foundation.IAsyncOperation<Windows.System.LaunchUriResult>;
+    LaunchUriForResultsForUserAsync(user: Windows.System.User, uri: Windows.Foundation.Uri, options: Windows.System.LauncherOptions, inputData: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<Windows.System.LaunchUriResult>;
+    LaunchUriForUserAsync(user: Windows.System.User, uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<number>;
+    LaunchUriForUserAsync(user: Windows.System.User, uri: Windows.Foundation.Uri, options: Windows.System.LauncherOptions): Windows.Foundation.IAsyncOperation<number>;
+    LaunchUriForUserAsync(user: Windows.System.User, uri: Windows.Foundation.Uri, options: Windows.System.LauncherOptions, inputData: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<number>;
+    QueryAppUriSupportAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<number>;
+    QueryAppUriSupportAsync(uri: Windows.Foundation.Uri, packageFamilyName: string): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var ILauncherStatics4: abstract new (...args: any[]) => ILauncherStatics4;
+
+  interface ILauncherStatics5 {
+    LaunchFolderPathAsync(path: string): Windows.Foundation.IAsyncOperation<boolean>;
+    LaunchFolderPathAsync(path: string, options: Windows.System.FolderLauncherOptions): Windows.Foundation.IAsyncOperation<boolean>;
+    LaunchFolderPathForUserAsync(user: Windows.System.User, path: string): Windows.Foundation.IAsyncOperation<boolean>;
+    LaunchFolderPathForUserAsync(user: Windows.System.User, path: string, options: Windows.System.FolderLauncherOptions): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var ILauncherStatics5: abstract new (...args: any[]) => ILauncherStatics5;
+
+  interface ILauncherUIOptions {
+    InvocationPoint: Windows.Foundation.Point | null;
+    PreferredPlacement: number;
+    SelectionRect: Windows.Foundation.Rect | null;
+  }
+  var ILauncherUIOptions: abstract new (...args: any[]) => ILauncherUIOptions;
+
+  interface ILauncherViewOptions {
+    DesiredRemainingView: number;
+  }
+  var ILauncherViewOptions: abstract new (...args: any[]) => ILauncherViewOptions;
+
+  interface IMemoryManagerStatics {
+    readonly AppMemoryUsage: number | bigint;
+    readonly AppMemoryUsageLevel: number;
+    readonly AppMemoryUsageLimit: number | bigint;
+    AppMemoryUsageDecreased: Windows.Foundation.EventHandler<Object> | null;
+    AppMemoryUsageIncreased: Windows.Foundation.EventHandler<Object> | null;
+    AppMemoryUsageLimitChanging: Windows.Foundation.EventHandler<Windows.System.AppMemoryUsageLimitChangingEventArgs> | null;
+  }
+  var IMemoryManagerStatics: abstract new (...args: any[]) => IMemoryManagerStatics;
+
+  interface IMemoryManagerStatics2 {
+    GetAppMemoryReport(): Windows.System.AppMemoryReport;
+    GetProcessMemoryReport(): Windows.System.ProcessMemoryReport;
+  }
+  var IMemoryManagerStatics2: abstract new (...args: any[]) => IMemoryManagerStatics2;
+
+  interface IMemoryManagerStatics3 {
+    TrySetAppMemoryUsageLimit(value: number | bigint): boolean;
+  }
+  var IMemoryManagerStatics3: abstract new (...args: any[]) => IMemoryManagerStatics3;
+
+  interface IMemoryManagerStatics4 {
+    readonly ExpectedAppMemoryUsageLimit: number | bigint;
+  }
+  var IMemoryManagerStatics4: abstract new (...args: any[]) => IMemoryManagerStatics4;
+
+  interface IProcessLauncherOptions {
+    StandardError: Windows.Storage.Streams.IOutputStream;
+    StandardInput: Windows.Storage.Streams.IInputStream;
+    StandardOutput: Windows.Storage.Streams.IOutputStream;
+    WorkingDirectory: string;
+  }
+  var IProcessLauncherOptions: abstract new (...args: any[]) => IProcessLauncherOptions;
+
+  interface IProcessLauncherResult {
+    readonly ExitCode: number;
+  }
+  var IProcessLauncherResult: abstract new (...args: any[]) => IProcessLauncherResult;
+
+  interface IProcessLauncherStatics {
+    RunToCompletionAsync(fileName: string, args: string): Windows.Foundation.IAsyncOperation<Windows.System.ProcessLauncherResult>;
+    RunToCompletionAsync(fileName: string, args: string, options: Windows.System.ProcessLauncherOptions): Windows.Foundation.IAsyncOperation<Windows.System.ProcessLauncherResult>;
+  }
+  var IProcessLauncherStatics: abstract new (...args: any[]) => IProcessLauncherStatics;
+
+  interface IProcessMemoryReport {
+    readonly PrivateWorkingSetUsage: number | bigint;
+    readonly TotalWorkingSetUsage: number | bigint;
+  }
+  var IProcessMemoryReport: abstract new (...args: any[]) => IProcessMemoryReport;
+
+  interface IProtocolForResultsOperation {
+    ReportCompleted(data: Windows.Foundation.Collections.ValueSet): void;
+  }
+  var IProtocolForResultsOperation: abstract new (...args: any[]) => IProtocolForResultsOperation;
+
+  interface IRemoteLauncherOptions {
+    FallbackUri: Windows.Foundation.Uri;
+    readonly PreferredAppIds: Windows.Foundation.Collections.IVector<string> | string[];
+  }
+  var IRemoteLauncherOptions: abstract new (...args: any[]) => IRemoteLauncherOptions;
+
+  interface IRemoteLauncherStatics {
+    LaunchUriAsync(remoteSystemConnectionRequest: Windows.System.RemoteSystems.RemoteSystemConnectionRequest, uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<number>;
+    LaunchUriAsync(remoteSystemConnectionRequest: Windows.System.RemoteSystems.RemoteSystemConnectionRequest, uri: Windows.Foundation.Uri, options: Windows.System.RemoteLauncherOptions): Windows.Foundation.IAsyncOperation<number>;
+    LaunchUriAsync(remoteSystemConnectionRequest: Windows.System.RemoteSystems.RemoteSystemConnectionRequest, uri: Windows.Foundation.Uri, options: Windows.System.RemoteLauncherOptions, inputData: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IRemoteLauncherStatics: abstract new (...args: any[]) => IRemoteLauncherStatics;
+
+  interface IShutdownManagerStatics {
+    BeginShutdown(shutdownKind: number, timeout: Windows.Foundation.TimeSpan): void;
+    CancelShutdown(): void;
+  }
+  var IShutdownManagerStatics: abstract new (...args: any[]) => IShutdownManagerStatics;
+
+  interface IShutdownManagerStatics2 extends Windows.System.IShutdownManagerStatics {
+    BeginShutdown(shutdownKind: number, timeout: Windows.Foundation.TimeSpan): void;
+    CancelShutdown(): void;
+    EnterPowerState(powerState: number): void;
+    EnterPowerState(powerState: number, wakeUpAfter: Windows.Foundation.TimeSpan): void;
+    IsPowerStateSupported(powerState: number): boolean;
+  }
+  var IShutdownManagerStatics2: abstract new (...args: any[]) => IShutdownManagerStatics2;
+
+  interface ITimeZoneSettingsStatics {
+    ChangeTimeZoneByDisplayName(timeZoneDisplayName: string): void;
+    readonly CanChangeTimeZone: boolean;
+    readonly CurrentTimeZoneDisplayName: string;
+    readonly SupportedTimeZoneDisplayNames: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var ITimeZoneSettingsStatics: abstract new (...args: any[]) => ITimeZoneSettingsStatics;
+
+  interface ITimeZoneSettingsStatics2 {
+    AutoUpdateTimeZoneAsync(timeout: Windows.Foundation.TimeSpan): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var ITimeZoneSettingsStatics2: abstract new (...args: any[]) => ITimeZoneSettingsStatics2;
+
+  interface IUser {
+    GetPictureAsync(desiredSize: number): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamReference>;
+    GetPropertiesAsync(values: Windows.Foundation.Collections.IVectorView<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IPropertySet>;
+    GetPropertyAsync(value: string): Windows.Foundation.IAsyncOperation<Object>;
+    readonly AuthenticationStatus: number;
+    readonly NonRoamableId: string;
+    readonly Type: number;
+  }
+  var IUser: abstract new (...args: any[]) => IUser;
+
+  interface IUser2 {
+    CheckUserAgeConsentGroupAsync(consentGroup: number): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IUser2: abstract new (...args: any[]) => IUser2;
+
+  interface IUserAuthenticationStatusChangeDeferral {
+    Complete(): void;
+  }
+  var IUserAuthenticationStatusChangeDeferral: abstract new (...args: any[]) => IUserAuthenticationStatusChangeDeferral;
+
+  interface IUserAuthenticationStatusChangingEventArgs {
+    GetDeferral(): Windows.System.UserAuthenticationStatusChangeDeferral;
+    readonly CurrentStatus: number;
+    readonly NewStatus: number;
+    readonly User: Windows.System.User;
+  }
+  var IUserAuthenticationStatusChangingEventArgs: abstract new (...args: any[]) => IUserAuthenticationStatusChangingEventArgs;
+
+  interface IUserChangedEventArgs {
+    readonly User: Windows.System.User;
+  }
+  var IUserChangedEventArgs: abstract new (...args: any[]) => IUserChangedEventArgs;
+
+  interface IUserChangedEventArgs2 {
+    readonly ChangedPropertyKinds: Windows.Foundation.Collections.IVectorView<number> | number[];
+  }
+  var IUserChangedEventArgs2: abstract new (...args: any[]) => IUserChangedEventArgs2;
+
+  interface IUserDeviceAssociationChangedEventArgs {
+    readonly DeviceId: string;
+    readonly NewUser: Windows.System.User;
+    readonly OldUser: Windows.System.User;
+  }
+  var IUserDeviceAssociationChangedEventArgs: abstract new (...args: any[]) => IUserDeviceAssociationChangedEventArgs;
+
+  interface IUserDeviceAssociationStatics {
+    FindUserFromDeviceId(deviceId: string): Windows.System.User;
+    UserDeviceAssociationChanged: Windows.Foundation.EventHandler<Windows.System.UserDeviceAssociationChangedEventArgs> | null;
+  }
+  var IUserDeviceAssociationStatics: abstract new (...args: any[]) => IUserDeviceAssociationStatics;
+
+  interface IUserPicker {
+    PickSingleUserAsync(): Windows.Foundation.IAsyncOperation<Windows.System.User>;
+    AllowGuestAccounts: boolean;
+    SuggestedSelectedUser: Windows.System.User;
+  }
+  var IUserPicker: abstract new (...args: any[]) => IUserPicker;
+
+  interface IUserPickerStatics {
+    IsSupported(): boolean;
+  }
+  var IUserPickerStatics: abstract new (...args: any[]) => IUserPickerStatics;
+
+  interface IUserStatics {
+    CreateWatcher(): Windows.System.UserWatcher;
+    FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.System.User> | Windows.System.User[]>;
+    FindAllAsync(type: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.System.User> | Windows.System.User[]>;
+    FindAllAsync(type: number, status: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.System.User> | Windows.System.User[]>;
+    GetFromId(nonRoamableId: string): Windows.System.User;
+  }
+  var IUserStatics: abstract new (...args: any[]) => IUserStatics;
+
+  interface IUserStatics2 {
+    GetDefault(): Windows.System.User;
+  }
+  var IUserStatics2: abstract new (...args: any[]) => IUserStatics2;
+
+  interface IUserWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.System.UserWatcher, Windows.System.UserChangedEventArgs> | null;
+    AuthenticationStatusChanged: Windows.Foundation.TypedEventHandler<Windows.System.UserWatcher, Windows.System.UserChangedEventArgs> | null;
+    AuthenticationStatusChanging: Windows.Foundation.TypedEventHandler<Windows.System.UserWatcher, Windows.System.UserAuthenticationStatusChangingEventArgs> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.System.UserWatcher, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.System.UserWatcher, Windows.System.UserChangedEventArgs> | null;
+    Stopped: Windows.Foundation.TypedEventHandler<Windows.System.UserWatcher, Object> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.System.UserWatcher, Windows.System.UserChangedEventArgs> | null;
+  }
+  var IUserWatcher: abstract new (...args: any[]) => IUserWatcher;
+
+  interface SystemManagementContract {
+  }
+  var SystemManagementContract: {
+    new(fields: {  }): SystemManagementContract;
+  };
+
+}
+
+declare namespace Windows.System.Diagnostics {
+  class DiagnosticActionResult implements Windows.System.Diagnostics.IDiagnosticActionResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Results: Windows.Foundation.Collections.ValueSet;
+  }
+
+  class DiagnosticInvoker implements Windows.System.Diagnostics.IDiagnosticInvoker, Windows.System.Diagnostics.IDiagnosticInvoker2 {
+    static GetDefault(): Windows.System.Diagnostics.DiagnosticInvoker;
+    static GetForUser(user: Windows.System.User): Windows.System.Diagnostics.DiagnosticInvoker;
+    RunDiagnosticActionAsync(context: Windows.Data.Json.JsonObject): Windows.Foundation.IAsyncOperationWithProgress<Windows.System.Diagnostics.DiagnosticActionResult, number>;
+    RunDiagnosticActionFromStringAsync(context: string): Windows.Foundation.IAsyncOperationWithProgress<Windows.System.Diagnostics.DiagnosticActionResult, number>;
+    static readonly IsSupported: boolean;
+  }
+
+  class ProcessCpuUsage implements Windows.System.Diagnostics.IProcessCpuUsage {
+    GetReport(): Windows.System.Diagnostics.ProcessCpuUsageReport;
+  }
+
+  class ProcessCpuUsageReport implements Windows.System.Diagnostics.IProcessCpuUsageReport {
+    readonly KernelTime: Windows.Foundation.TimeSpan;
+    readonly UserTime: Windows.Foundation.TimeSpan;
+  }
+
+  class ProcessDiagnosticInfo implements Windows.System.Diagnostics.IProcessDiagnosticInfo, Windows.System.Diagnostics.IProcessDiagnosticInfo2 {
+    GetAppDiagnosticInfos(): Windows.Foundation.Collections.IVector<Windows.System.AppDiagnosticInfo> | Windows.System.AppDiagnosticInfo[];
+    static GetForCurrentProcess(): Windows.System.Diagnostics.ProcessDiagnosticInfo;
+    static GetForProcesses(): Windows.Foundation.Collections.IVectorView<Windows.System.Diagnostics.ProcessDiagnosticInfo> | Windows.System.Diagnostics.ProcessDiagnosticInfo[];
+    static TryGetForProcessId(processId: number): Windows.System.Diagnostics.ProcessDiagnosticInfo;
+    readonly CpuUsage: Windows.System.Diagnostics.ProcessCpuUsage;
+    readonly DiskUsage: Windows.System.Diagnostics.ProcessDiskUsage;
+    readonly ExecutableFileName: string;
+    readonly IsPackaged: boolean;
+    readonly MemoryUsage: Windows.System.Diagnostics.ProcessMemoryUsage;
+    readonly Parent: Windows.System.Diagnostics.ProcessDiagnosticInfo;
+    readonly ProcessId: number;
+    readonly ProcessStartTime: Windows.Foundation.DateTime;
+  }
+
+  class ProcessDiskUsage implements Windows.System.Diagnostics.IProcessDiskUsage {
+    GetReport(): Windows.System.Diagnostics.ProcessDiskUsageReport;
+  }
+
+  class ProcessDiskUsageReport implements Windows.System.Diagnostics.IProcessDiskUsageReport {
+    readonly BytesReadCount: number | bigint;
+    readonly BytesWrittenCount: number | bigint;
+    readonly OtherBytesCount: number | bigint;
+    readonly OtherOperationCount: number | bigint;
+    readonly ReadOperationCount: number | bigint;
+    readonly WriteOperationCount: number | bigint;
+  }
+
+  class ProcessMemoryUsage implements Windows.System.Diagnostics.IProcessMemoryUsage {
+    GetReport(): Windows.System.Diagnostics.ProcessMemoryUsageReport;
+  }
+
+  class ProcessMemoryUsageReport implements Windows.System.Diagnostics.IProcessMemoryUsageReport {
+    readonly NonPagedPoolSizeInBytes: number | bigint;
+    readonly PageFaultCount: number;
+    readonly PageFileSizeInBytes: number | bigint;
+    readonly PagedPoolSizeInBytes: number | bigint;
+    readonly PeakNonPagedPoolSizeInBytes: number | bigint;
+    readonly PeakPageFileSizeInBytes: number | bigint;
+    readonly PeakPagedPoolSizeInBytes: number | bigint;
+    readonly PeakVirtualMemorySizeInBytes: number | bigint;
+    readonly PeakWorkingSetSizeInBytes: number | bigint;
+    readonly PrivatePageCount: number | bigint;
+    readonly VirtualMemorySizeInBytes: number | bigint;
+    readonly WorkingSetSizeInBytes: number | bigint;
+  }
+
+  class SystemCpuUsage implements Windows.System.Diagnostics.ISystemCpuUsage {
+    GetReport(): Windows.System.Diagnostics.SystemCpuUsageReport;
+  }
+
+  class SystemCpuUsageReport implements Windows.System.Diagnostics.ISystemCpuUsageReport {
+    readonly IdleTime: Windows.Foundation.TimeSpan;
+    readonly KernelTime: Windows.Foundation.TimeSpan;
+    readonly UserTime: Windows.Foundation.TimeSpan;
+  }
+
+  class SystemDiagnosticInfo implements Windows.System.Diagnostics.ISystemDiagnosticInfo {
+    static GetForCurrentSystem(): Windows.System.Diagnostics.SystemDiagnosticInfo;
+    static IsArchitectureSupported(type: number): boolean;
+    readonly CpuUsage: Windows.System.Diagnostics.SystemCpuUsage;
+    readonly MemoryUsage: Windows.System.Diagnostics.SystemMemoryUsage;
+    static readonly PreferredArchitecture: number;
+  }
+
+  class SystemMemoryUsage implements Windows.System.Diagnostics.ISystemMemoryUsage {
+    GetReport(): Windows.System.Diagnostics.SystemMemoryUsageReport;
+  }
+
+  class SystemMemoryUsageReport implements Windows.System.Diagnostics.ISystemMemoryUsageReport {
+    readonly AvailableSizeInBytes: number | bigint;
+    readonly CommittedSizeInBytes: number | bigint;
+    readonly TotalPhysicalSizeInBytes: number | bigint;
+  }
+
+  enum DiagnosticActionState {
+    Initializing = 0,
+    Downloading = 1,
+    VerifyingTrust = 2,
+    Detecting = 3,
+    Resolving = 4,
+    VerifyingResolution = 5,
+    Executing = 6,
+  }
+
+  interface IDiagnosticActionResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Results: Windows.Foundation.Collections.ValueSet;
+  }
+  var IDiagnosticActionResult: abstract new (...args: any[]) => IDiagnosticActionResult;
+
+  interface IDiagnosticInvoker {
+    RunDiagnosticActionAsync(context: Windows.Data.Json.JsonObject): Windows.Foundation.IAsyncOperationWithProgress<Windows.System.Diagnostics.DiagnosticActionResult, number>;
+  }
+  var IDiagnosticInvoker: abstract new (...args: any[]) => IDiagnosticInvoker;
+
+  interface IDiagnosticInvoker2 {
+    RunDiagnosticActionFromStringAsync(context: string): Windows.Foundation.IAsyncOperationWithProgress<Windows.System.Diagnostics.DiagnosticActionResult, number>;
+  }
+  var IDiagnosticInvoker2: abstract new (...args: any[]) => IDiagnosticInvoker2;
+
+  interface IDiagnosticInvokerStatics {
+    GetDefault(): Windows.System.Diagnostics.DiagnosticInvoker;
+    GetForUser(user: Windows.System.User): Windows.System.Diagnostics.DiagnosticInvoker;
+    readonly IsSupported: boolean;
+  }
+  var IDiagnosticInvokerStatics: abstract new (...args: any[]) => IDiagnosticInvokerStatics;
+
+  interface IProcessCpuUsage {
+    GetReport(): Windows.System.Diagnostics.ProcessCpuUsageReport;
+  }
+  var IProcessCpuUsage: abstract new (...args: any[]) => IProcessCpuUsage;
+
+  interface IProcessCpuUsageReport {
+    readonly KernelTime: Windows.Foundation.TimeSpan;
+    readonly UserTime: Windows.Foundation.TimeSpan;
+  }
+  var IProcessCpuUsageReport: abstract new (...args: any[]) => IProcessCpuUsageReport;
+
+  interface IProcessDiagnosticInfo {
+    readonly CpuUsage: Windows.System.Diagnostics.ProcessCpuUsage;
+    readonly DiskUsage: Windows.System.Diagnostics.ProcessDiskUsage;
+    readonly ExecutableFileName: string;
+    readonly MemoryUsage: Windows.System.Diagnostics.ProcessMemoryUsage;
+    readonly Parent: Windows.System.Diagnostics.ProcessDiagnosticInfo;
+    readonly ProcessId: number;
+    readonly ProcessStartTime: Windows.Foundation.DateTime;
+  }
+  var IProcessDiagnosticInfo: abstract new (...args: any[]) => IProcessDiagnosticInfo;
+
+  interface IProcessDiagnosticInfo2 {
+    GetAppDiagnosticInfos(): Windows.Foundation.Collections.IVector<Windows.System.AppDiagnosticInfo> | Windows.System.AppDiagnosticInfo[];
+    readonly IsPackaged: boolean;
+  }
+  var IProcessDiagnosticInfo2: abstract new (...args: any[]) => IProcessDiagnosticInfo2;
+
+  interface IProcessDiagnosticInfoStatics {
+    GetForCurrentProcess(): Windows.System.Diagnostics.ProcessDiagnosticInfo;
+    GetForProcesses(): Windows.Foundation.Collections.IVectorView<Windows.System.Diagnostics.ProcessDiagnosticInfo> | Windows.System.Diagnostics.ProcessDiagnosticInfo[];
+  }
+  var IProcessDiagnosticInfoStatics: abstract new (...args: any[]) => IProcessDiagnosticInfoStatics;
+
+  interface IProcessDiagnosticInfoStatics2 {
+    TryGetForProcessId(processId: number): Windows.System.Diagnostics.ProcessDiagnosticInfo;
+  }
+  var IProcessDiagnosticInfoStatics2: abstract new (...args: any[]) => IProcessDiagnosticInfoStatics2;
+
+  interface IProcessDiskUsage {
+    GetReport(): Windows.System.Diagnostics.ProcessDiskUsageReport;
+  }
+  var IProcessDiskUsage: abstract new (...args: any[]) => IProcessDiskUsage;
+
+  interface IProcessDiskUsageReport {
+    readonly BytesReadCount: number | bigint;
+    readonly BytesWrittenCount: number | bigint;
+    readonly OtherBytesCount: number | bigint;
+    readonly OtherOperationCount: number | bigint;
+    readonly ReadOperationCount: number | bigint;
+    readonly WriteOperationCount: number | bigint;
+  }
+  var IProcessDiskUsageReport: abstract new (...args: any[]) => IProcessDiskUsageReport;
+
+  interface IProcessMemoryUsage {
+    GetReport(): Windows.System.Diagnostics.ProcessMemoryUsageReport;
+  }
+  var IProcessMemoryUsage: abstract new (...args: any[]) => IProcessMemoryUsage;
+
+  interface IProcessMemoryUsageReport {
+    readonly NonPagedPoolSizeInBytes: number | bigint;
+    readonly PageFaultCount: number;
+    readonly PageFileSizeInBytes: number | bigint;
+    readonly PagedPoolSizeInBytes: number | bigint;
+    readonly PeakNonPagedPoolSizeInBytes: number | bigint;
+    readonly PeakPageFileSizeInBytes: number | bigint;
+    readonly PeakPagedPoolSizeInBytes: number | bigint;
+    readonly PeakVirtualMemorySizeInBytes: number | bigint;
+    readonly PeakWorkingSetSizeInBytes: number | bigint;
+    readonly PrivatePageCount: number | bigint;
+    readonly VirtualMemorySizeInBytes: number | bigint;
+    readonly WorkingSetSizeInBytes: number | bigint;
+  }
+  var IProcessMemoryUsageReport: abstract new (...args: any[]) => IProcessMemoryUsageReport;
+
+  interface ISystemCpuUsage {
+    GetReport(): Windows.System.Diagnostics.SystemCpuUsageReport;
+  }
+  var ISystemCpuUsage: abstract new (...args: any[]) => ISystemCpuUsage;
+
+  interface ISystemCpuUsageReport {
+    readonly IdleTime: Windows.Foundation.TimeSpan;
+    readonly KernelTime: Windows.Foundation.TimeSpan;
+    readonly UserTime: Windows.Foundation.TimeSpan;
+  }
+  var ISystemCpuUsageReport: abstract new (...args: any[]) => ISystemCpuUsageReport;
+
+  interface ISystemDiagnosticInfo {
+    readonly CpuUsage: Windows.System.Diagnostics.SystemCpuUsage;
+    readonly MemoryUsage: Windows.System.Diagnostics.SystemMemoryUsage;
+  }
+  var ISystemDiagnosticInfo: abstract new (...args: any[]) => ISystemDiagnosticInfo;
+
+  interface ISystemDiagnosticInfoStatics {
+    GetForCurrentSystem(): Windows.System.Diagnostics.SystemDiagnosticInfo;
+  }
+  var ISystemDiagnosticInfoStatics: abstract new (...args: any[]) => ISystemDiagnosticInfoStatics;
+
+  interface ISystemDiagnosticInfoStatics2 {
+    IsArchitectureSupported(type: number): boolean;
+    readonly PreferredArchitecture: number;
+  }
+  var ISystemDiagnosticInfoStatics2: abstract new (...args: any[]) => ISystemDiagnosticInfoStatics2;
+
+  interface ISystemMemoryUsage {
+    GetReport(): Windows.System.Diagnostics.SystemMemoryUsageReport;
+  }
+  var ISystemMemoryUsage: abstract new (...args: any[]) => ISystemMemoryUsage;
+
+  interface ISystemMemoryUsageReport {
+    readonly AvailableSizeInBytes: number | bigint;
+    readonly CommittedSizeInBytes: number | bigint;
+    readonly TotalPhysicalSizeInBytes: number | bigint;
+  }
+  var ISystemMemoryUsageReport: abstract new (...args: any[]) => ISystemMemoryUsageReport;
+
+}
+
+declare namespace Windows.System.Diagnostics.DevicePortal {
+  class DevicePortalConnection implements Windows.System.Diagnostics.DevicePortal.IDevicePortalConnection, Windows.System.Diagnostics.DevicePortal.IDevicePortalWebSocketConnection {
+    static GetForAppServiceConnection(appServiceConnection: Windows.ApplicationModel.AppService.AppServiceConnection): Windows.System.Diagnostics.DevicePortal.DevicePortalConnection;
+    GetServerMessageWebSocketForRequest(request: Windows.Web.Http.HttpRequestMessage): Windows.Networking.Sockets.ServerMessageWebSocket;
+    GetServerMessageWebSocketForRequest(request: Windows.Web.Http.HttpRequestMessage, messageType: number, protocol: string): Windows.Networking.Sockets.ServerMessageWebSocket;
+    GetServerMessageWebSocketForRequest(request: Windows.Web.Http.HttpRequestMessage, messageType: number, protocol: string, outboundBufferSizeInBytes: number, maxMessageSize: number, receiveMode: number): Windows.Networking.Sockets.ServerMessageWebSocket;
+    GetServerStreamWebSocketForRequest(request: Windows.Web.Http.HttpRequestMessage): Windows.Networking.Sockets.ServerStreamWebSocket;
+    GetServerStreamWebSocketForRequest(request: Windows.Web.Http.HttpRequestMessage, protocol: string, outboundBufferSizeInBytes: number, noDelay: boolean): Windows.Networking.Sockets.ServerStreamWebSocket;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.System.Diagnostics.DevicePortal.DevicePortalConnection, Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionClosedEventArgs> | null;
+    RequestReceived: Windows.Foundation.TypedEventHandler<Windows.System.Diagnostics.DevicePortal.DevicePortalConnection, Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionRequestReceivedEventArgs> | null;
+  }
+
+  class DevicePortalConnectionClosedEventArgs implements Windows.System.Diagnostics.DevicePortal.IDevicePortalConnectionClosedEventArgs {
+    readonly Reason: number;
+  }
+
+  class DevicePortalConnectionRequestReceivedEventArgs implements Windows.System.Diagnostics.DevicePortal.IDevicePortalConnectionRequestReceivedEventArgs, Windows.System.Diagnostics.DevicePortal.IDevicePortalWebSocketConnectionRequestReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly IsWebSocketUpgradeRequest: boolean;
+    readonly RequestMessage: Windows.Web.Http.HttpRequestMessage;
+    readonly ResponseMessage: Windows.Web.Http.HttpResponseMessage;
+    readonly WebSocketProtocolsRequested: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+
+  enum DevicePortalConnectionClosedReason {
+    Unknown = 0,
+    ResourceLimitsExceeded = 1,
+    ProtocolError = 2,
+    NotAuthorized = 3,
+    UserNotPresent = 4,
+    ServiceTerminated = 5,
+  }
+
+  interface IDevicePortalConnection {
+    Closed: Windows.Foundation.TypedEventHandler<Windows.System.Diagnostics.DevicePortal.DevicePortalConnection, Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionClosedEventArgs> | null;
+    RequestReceived: Windows.Foundation.TypedEventHandler<Windows.System.Diagnostics.DevicePortal.DevicePortalConnection, Windows.System.Diagnostics.DevicePortal.DevicePortalConnectionRequestReceivedEventArgs> | null;
+  }
+  var IDevicePortalConnection: abstract new (...args: any[]) => IDevicePortalConnection;
+
+  interface IDevicePortalConnectionClosedEventArgs {
+    readonly Reason: number;
+  }
+  var IDevicePortalConnectionClosedEventArgs: abstract new (...args: any[]) => IDevicePortalConnectionClosedEventArgs;
+
+  interface IDevicePortalConnectionRequestReceivedEventArgs {
+    readonly RequestMessage: Windows.Web.Http.HttpRequestMessage;
+    readonly ResponseMessage: Windows.Web.Http.HttpResponseMessage;
+  }
+  var IDevicePortalConnectionRequestReceivedEventArgs: abstract new (...args: any[]) => IDevicePortalConnectionRequestReceivedEventArgs;
+
+  interface IDevicePortalConnectionStatics {
+    GetForAppServiceConnection(appServiceConnection: Windows.ApplicationModel.AppService.AppServiceConnection): Windows.System.Diagnostics.DevicePortal.DevicePortalConnection;
+  }
+  var IDevicePortalConnectionStatics: abstract new (...args: any[]) => IDevicePortalConnectionStatics;
+
+  interface IDevicePortalWebSocketConnection {
+    GetServerMessageWebSocketForRequest(request: Windows.Web.Http.HttpRequestMessage): Windows.Networking.Sockets.ServerMessageWebSocket;
+    GetServerMessageWebSocketForRequest(request: Windows.Web.Http.HttpRequestMessage, messageType: number, protocol: string): Windows.Networking.Sockets.ServerMessageWebSocket;
+    GetServerMessageWebSocketForRequest(request: Windows.Web.Http.HttpRequestMessage, messageType: number, protocol: string, outboundBufferSizeInBytes: number, maxMessageSize: number, receiveMode: number): Windows.Networking.Sockets.ServerMessageWebSocket;
+    GetServerStreamWebSocketForRequest(request: Windows.Web.Http.HttpRequestMessage): Windows.Networking.Sockets.ServerStreamWebSocket;
+    GetServerStreamWebSocketForRequest(request: Windows.Web.Http.HttpRequestMessage, protocol: string, outboundBufferSizeInBytes: number, noDelay: boolean): Windows.Networking.Sockets.ServerStreamWebSocket;
+  }
+  var IDevicePortalWebSocketConnection: abstract new (...args: any[]) => IDevicePortalWebSocketConnection;
+
+  interface IDevicePortalWebSocketConnectionRequestReceivedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly IsWebSocketUpgradeRequest: boolean;
+    readonly WebSocketProtocolsRequested: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var IDevicePortalWebSocketConnectionRequestReceivedEventArgs: abstract new (...args: any[]) => IDevicePortalWebSocketConnectionRequestReceivedEventArgs;
+
+}
+
+declare namespace Windows.System.Diagnostics.Telemetry {
+  class PlatformTelemetryClient {
+    static Register(id: string): Windows.System.Diagnostics.Telemetry.PlatformTelemetryRegistrationResult;
+    static Register(id: string, settings: Windows.System.Diagnostics.Telemetry.PlatformTelemetryRegistrationSettings): Windows.System.Diagnostics.Telemetry.PlatformTelemetryRegistrationResult;
+  }
+
+  class PlatformTelemetryRegistrationResult implements Windows.System.Diagnostics.Telemetry.IPlatformTelemetryRegistrationResult {
+    readonly Status: number;
+  }
+
+  class PlatformTelemetryRegistrationSettings implements Windows.System.Diagnostics.Telemetry.IPlatformTelemetryRegistrationSettings {
+    constructor();
+    StorageSize: number;
+    UploadQuotaSize: number;
+  }
+
+  enum PlatformTelemetryRegistrationStatus {
+    Success = 0,
+    SettingsOutOfRange = 1,
+    UnknownFailure = 2,
+  }
+
+  interface IPlatformTelemetryClientStatics {
+    Register(id: string): Windows.System.Diagnostics.Telemetry.PlatformTelemetryRegistrationResult;
+    Register(id: string, settings: Windows.System.Diagnostics.Telemetry.PlatformTelemetryRegistrationSettings): Windows.System.Diagnostics.Telemetry.PlatformTelemetryRegistrationResult;
+  }
+  var IPlatformTelemetryClientStatics: abstract new (...args: any[]) => IPlatformTelemetryClientStatics;
+
+  interface IPlatformTelemetryRegistrationResult {
+    readonly Status: number;
+  }
+  var IPlatformTelemetryRegistrationResult: abstract new (...args: any[]) => IPlatformTelemetryRegistrationResult;
+
+  interface IPlatformTelemetryRegistrationSettings {
+    StorageSize: number;
+    UploadQuotaSize: number;
+  }
+  var IPlatformTelemetryRegistrationSettings: abstract new (...args: any[]) => IPlatformTelemetryRegistrationSettings;
+
+}
+
+declare namespace Windows.System.Diagnostics.TraceReporting {
+  class PlatformDiagnosticActions {
+    static DownloadLatestSettingsForNamespace(partner: string, feature: string, isScenarioNamespace: boolean, downloadOverCostedNetwork: boolean, downloadOverBattery: boolean): number;
+    static ForceUpload(latency: number, uploadOverCostedNetwork: boolean, uploadOverBattery: boolean): number;
+    static GetActiveScenarioList(): Windows.Foundation.Collections.IVectorView<Guid> | Guid[];
+    static GetActiveTraceRuntime(slotType: number): Windows.System.Diagnostics.TraceReporting.PlatformDiagnosticTraceRuntimeInfo;
+    static GetKnownTraceList(slotType: number): Windows.Foundation.Collections.IVectorView<Windows.System.Diagnostics.TraceReporting.PlatformDiagnosticTraceInfo> | Windows.System.Diagnostics.TraceReporting.PlatformDiagnosticTraceInfo[];
+    static IsScenarioEnabled(scenarioId: Guid): boolean;
+    static IsTraceRunning(slotType: number, scenarioId: Guid, traceProfileHash: number | bigint): number;
+    static TryEscalateScenario(scenarioId: Guid, escalationType: number, outputDirectory: string, timestampOutputDirectory: boolean, forceEscalationUpload: boolean, triggers: Windows.Foundation.Collections.IMapView<string, string>): boolean;
+  }
+
+  class PlatformDiagnosticTraceInfo implements Windows.System.Diagnostics.TraceReporting.IPlatformDiagnosticTraceInfo {
+    readonly IsAutoLogger: boolean;
+    readonly IsExclusive: boolean;
+    readonly MaxTraceDurationFileTime: number | bigint;
+    readonly Priority: number;
+    readonly ProfileHash: number | bigint;
+    readonly ScenarioId: Guid;
+  }
+
+  class PlatformDiagnosticTraceRuntimeInfo implements Windows.System.Diagnostics.TraceReporting.IPlatformDiagnosticTraceRuntimeInfo {
+    readonly EtwRuntimeFileTime: number | bigint;
+    readonly RuntimeFileTime: number | bigint;
+  }
+
+  enum PlatformDiagnosticActionState {
+    Success = 0,
+    FreeNetworkNotAvailable = 1,
+    ACPowerNotAvailable = 2,
+  }
+
+  enum PlatformDiagnosticEscalationType {
+    OnCompletion = 0,
+    OnFailure = 1,
+  }
+
+  enum PlatformDiagnosticEventBufferLatencies {
+    Normal = 1,
+    CostDeferred = 2,
+    Realtime = 4,
+  }
+
+  enum PlatformDiagnosticTracePriority {
+    Normal = 0,
+    UserElevated = 1,
+  }
+
+  enum PlatformDiagnosticTraceSlotState {
+    NotRunning = 0,
+    Running = 1,
+    Throttled = 2,
+  }
+
+  enum PlatformDiagnosticTraceSlotType {
+    Alternative = 0,
+    AlwaysOn = 1,
+    Mini = 2,
+  }
+
+  interface IPlatformDiagnosticActionsStatics {
+    DownloadLatestSettingsForNamespace(partner: string, feature: string, isScenarioNamespace: boolean, downloadOverCostedNetwork: boolean, downloadOverBattery: boolean): number;
+    ForceUpload(latency: number, uploadOverCostedNetwork: boolean, uploadOverBattery: boolean): number;
+    GetActiveScenarioList(): Windows.Foundation.Collections.IVectorView<Guid> | Guid[];
+    GetActiveTraceRuntime(slotType: number): Windows.System.Diagnostics.TraceReporting.PlatformDiagnosticTraceRuntimeInfo;
+    GetKnownTraceList(slotType: number): Windows.Foundation.Collections.IVectorView<Windows.System.Diagnostics.TraceReporting.PlatformDiagnosticTraceInfo> | Windows.System.Diagnostics.TraceReporting.PlatformDiagnosticTraceInfo[];
+    IsScenarioEnabled(scenarioId: Guid): boolean;
+    IsTraceRunning(slotType: number, scenarioId: Guid, traceProfileHash: number | bigint): number;
+    TryEscalateScenario(scenarioId: Guid, escalationType: number, outputDirectory: string, timestampOutputDirectory: boolean, forceEscalationUpload: boolean, triggers: Windows.Foundation.Collections.IMapView<string, string>): boolean;
+  }
+  var IPlatformDiagnosticActionsStatics: abstract new (...args: any[]) => IPlatformDiagnosticActionsStatics;
+
+  interface IPlatformDiagnosticTraceInfo {
+    readonly IsAutoLogger: boolean;
+    readonly IsExclusive: boolean;
+    readonly MaxTraceDurationFileTime: number | bigint;
+    readonly Priority: number;
+    readonly ProfileHash: number | bigint;
+    readonly ScenarioId: Guid;
+  }
+  var IPlatformDiagnosticTraceInfo: abstract new (...args: any[]) => IPlatformDiagnosticTraceInfo;
+
+  interface IPlatformDiagnosticTraceRuntimeInfo {
+    readonly EtwRuntimeFileTime: number | bigint;
+    readonly RuntimeFileTime: number | bigint;
+  }
+  var IPlatformDiagnosticTraceRuntimeInfo: abstract new (...args: any[]) => IPlatformDiagnosticTraceRuntimeInfo;
+
+}
+
+declare namespace Windows.System.Display {
+  class DisplayRequest implements Windows.System.Display.IDisplayRequest {
+    constructor();
+    RequestActive(): void;
+    RequestRelease(): void;
+  }
+
+  interface IDisplayRequest {
+    RequestActive(): void;
+    RequestRelease(): void;
+  }
+  var IDisplayRequest: abstract new (...args: any[]) => IDisplayRequest;
+
+}
+
+declare namespace Windows.System.Implementation.FileExplorer {
+  class SysStorageProviderEventReceivedEventArgs implements Windows.System.Implementation.FileExplorer.ISysStorageProviderEventReceivedEventArgs {
+    constructor(json: string);
+    readonly Json: string;
+  }
+
+  interface ISysStorageProviderEventReceivedEventArgs {
+    readonly Json: string;
+  }
+  var ISysStorageProviderEventReceivedEventArgs: abstract new (...args: any[]) => ISysStorageProviderEventReceivedEventArgs;
+
+  interface ISysStorageProviderEventReceivedEventArgsFactory {
+    CreateInstance(json: string): Windows.System.Implementation.FileExplorer.SysStorageProviderEventReceivedEventArgs;
+  }
+  var ISysStorageProviderEventReceivedEventArgsFactory: abstract new (...args: any[]) => ISysStorageProviderEventReceivedEventArgsFactory;
+
+  interface ISysStorageProviderEventSource {
+    EventReceived: Windows.Foundation.TypedEventHandler<Windows.System.Implementation.FileExplorer.ISysStorageProviderEventSource, Windows.System.Implementation.FileExplorer.SysStorageProviderEventReceivedEventArgs> | null;
+  }
+  var ISysStorageProviderEventSource: abstract new (...args: any[]) => ISysStorageProviderEventSource;
+
+  interface ISysStorageProviderHandlerFactory {
+    GetEventSource(syncRootId: string, eventName: string): Windows.System.Implementation.FileExplorer.ISysStorageProviderEventSource;
+    GetHttpRequestProvider(syncRootId: string): Windows.System.Implementation.FileExplorer.ISysStorageProviderHttpRequestProvider;
+  }
+  var ISysStorageProviderHandlerFactory: abstract new (...args: any[]) => ISysStorageProviderHandlerFactory;
+
+  interface ISysStorageProviderHttpRequestProvider {
+    SendRequestAsync(request: Windows.Web.Http.HttpRequestMessage): Windows.Foundation.IAsyncOperation<Windows.Web.Http.HttpResponseMessage>;
+  }
+  var ISysStorageProviderHttpRequestProvider: abstract new (...args: any[]) => ISysStorageProviderHttpRequestProvider;
+
+}
+
+declare namespace Windows.System.Inventory {
+  class InstalledDesktopApp implements Windows.Foundation.IStringable, Windows.System.Inventory.IInstalledDesktopApp {
+    static GetInventoryAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.System.Inventory.InstalledDesktopApp> | Windows.System.Inventory.InstalledDesktopApp[]>;
+    ToString(): string;
+    readonly DisplayName: string;
+    readonly DisplayVersion: string;
+    readonly Id: string;
+    readonly Publisher: string;
+  }
+
+  interface IInstalledDesktopApp {
+    readonly DisplayName: string;
+    readonly DisplayVersion: string;
+    readonly Id: string;
+    readonly Publisher: string;
+  }
+  var IInstalledDesktopApp: abstract new (...args: any[]) => IInstalledDesktopApp;
+
+  interface IInstalledDesktopAppStatics {
+    GetInventoryAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.System.Inventory.InstalledDesktopApp> | Windows.System.Inventory.InstalledDesktopApp[]>;
+  }
+  var IInstalledDesktopAppStatics: abstract new (...args: any[]) => IInstalledDesktopAppStatics;
+
+}
+
+declare namespace Windows.System.Power {
+  class BackgroundEnergyManager {
+    static readonly ExcessiveUsageLevel: number;
+    static readonly LowUsageLevel: number;
+    static readonly MaxAcceptableUsageLevel: number;
+    static readonly NearMaxAcceptableUsageLevel: number;
+    static readonly NearTerminationUsageLevel: number;
+    static readonly RecentEnergyUsage: number;
+    static readonly RecentEnergyUsageLevel: number;
+    static readonly TerminationUsageLevel: number;
+    static RecentEnergyUsageIncreased: Windows.Foundation.EventHandler<Object> | null;
+    static RecentEnergyUsageReturnedToLow: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class ForegroundEnergyManager {
+    static readonly ExcessiveUsageLevel: number;
+    static readonly LowUsageLevel: number;
+    static readonly MaxAcceptableUsageLevel: number;
+    static readonly NearMaxAcceptableUsageLevel: number;
+    static readonly RecentEnergyUsage: number;
+    static readonly RecentEnergyUsageLevel: number;
+    static RecentEnergyUsageIncreased: Windows.Foundation.EventHandler<Object> | null;
+    static RecentEnergyUsageReturnedToLow: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class PowerManager {
+    static readonly BatteryStatus: number;
+    static readonly EnergySaverStatus: number;
+    static readonly PowerSupplyStatus: number;
+    static readonly RemainingChargePercent: number;
+    static readonly RemainingDischargeTime: Windows.Foundation.TimeSpan;
+    static BatteryStatusChanged: Windows.Foundation.EventHandler<Object> | null;
+    static EnergySaverStatusChanged: Windows.Foundation.EventHandler<Object> | null;
+    static PowerSupplyStatusChanged: Windows.Foundation.EventHandler<Object> | null;
+    static RemainingChargePercentChanged: Windows.Foundation.EventHandler<Object> | null;
+    static RemainingDischargeTimeChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  enum BatteryStatus {
+    NotPresent = 0,
+    Discharging = 1,
+    Idle = 2,
+    Charging = 3,
+  }
+
+  enum EnergySaverStatus {
+    Disabled = 0,
+    Off = 1,
+    On = 2,
+  }
+
+  enum PowerSupplyStatus {
+    NotPresent = 0,
+    Inadequate = 1,
+    Adequate = 2,
+  }
+
+  interface IBackgroundEnergyManagerStatics {
+    readonly ExcessiveUsageLevel: number;
+    readonly LowUsageLevel: number;
+    readonly MaxAcceptableUsageLevel: number;
+    readonly NearMaxAcceptableUsageLevel: number;
+    readonly NearTerminationUsageLevel: number;
+    readonly RecentEnergyUsage: number;
+    readonly RecentEnergyUsageLevel: number;
+    readonly TerminationUsageLevel: number;
+    RecentEnergyUsageIncreased: Windows.Foundation.EventHandler<Object> | null;
+    RecentEnergyUsageReturnedToLow: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IBackgroundEnergyManagerStatics: abstract new (...args: any[]) => IBackgroundEnergyManagerStatics;
+
+  interface IForegroundEnergyManagerStatics {
+    readonly ExcessiveUsageLevel: number;
+    readonly LowUsageLevel: number;
+    readonly MaxAcceptableUsageLevel: number;
+    readonly NearMaxAcceptableUsageLevel: number;
+    readonly RecentEnergyUsage: number;
+    readonly RecentEnergyUsageLevel: number;
+    RecentEnergyUsageIncreased: Windows.Foundation.EventHandler<Object> | null;
+    RecentEnergyUsageReturnedToLow: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IForegroundEnergyManagerStatics: abstract new (...args: any[]) => IForegroundEnergyManagerStatics;
+
+  interface IPowerManagerStatics {
+    readonly BatteryStatus: number;
+    readonly EnergySaverStatus: number;
+    readonly PowerSupplyStatus: number;
+    readonly RemainingChargePercent: number;
+    readonly RemainingDischargeTime: Windows.Foundation.TimeSpan;
+    BatteryStatusChanged: Windows.Foundation.EventHandler<Object> | null;
+    EnergySaverStatusChanged: Windows.Foundation.EventHandler<Object> | null;
+    PowerSupplyStatusChanged: Windows.Foundation.EventHandler<Object> | null;
+    RemainingChargePercentChanged: Windows.Foundation.EventHandler<Object> | null;
+    RemainingDischargeTimeChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IPowerManagerStatics: abstract new (...args: any[]) => IPowerManagerStatics;
+
+}
+
+declare namespace Windows.System.Power.Diagnostics {
+  class BackgroundEnergyDiagnostics {
+    static ComputeTotalEnergyUsage(): number | bigint;
+    static ResetTotalEnergyUsage(): void;
+    static readonly DeviceSpecificConversionFactor: number;
+  }
+
+  class ForegroundEnergyDiagnostics {
+    static ComputeTotalEnergyUsage(): number | bigint;
+    static ResetTotalEnergyUsage(): void;
+    static readonly DeviceSpecificConversionFactor: number;
+  }
+
+  interface IBackgroundEnergyDiagnosticsStatics {
+    ComputeTotalEnergyUsage(): number | bigint;
+    ResetTotalEnergyUsage(): void;
+    readonly DeviceSpecificConversionFactor: number;
+  }
+  var IBackgroundEnergyDiagnosticsStatics: abstract new (...args: any[]) => IBackgroundEnergyDiagnosticsStatics;
+
+  interface IForegroundEnergyDiagnosticsStatics {
+    ComputeTotalEnergyUsage(): number | bigint;
+    ResetTotalEnergyUsage(): void;
+    readonly DeviceSpecificConversionFactor: number;
+  }
+  var IForegroundEnergyDiagnosticsStatics: abstract new (...args: any[]) => IForegroundEnergyDiagnosticsStatics;
+
+}
+
+declare namespace Windows.System.Preview {
+  class TwoPanelHingedDevicePosturePreview implements Windows.System.Preview.ITwoPanelHingedDevicePosturePreview {
+    GetCurrentPostureAsync(): Windows.Foundation.IAsyncOperation<Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReading>;
+    static GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.System.Preview.TwoPanelHingedDevicePosturePreview>;
+    PostureChanged: Windows.Foundation.TypedEventHandler<Windows.System.Preview.TwoPanelHingedDevicePosturePreview, Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs> | null;
+  }
+
+  class TwoPanelHingedDevicePosturePreviewReading implements Windows.System.Preview.ITwoPanelHingedDevicePosturePreviewReading {
+    readonly HingeState: number;
+    readonly Panel1Id: string;
+    readonly Panel1Orientation: number;
+    readonly Panel2Id: string;
+    readonly Panel2Orientation: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs implements Windows.System.Preview.ITwoPanelHingedDevicePosturePreviewReadingChangedEventArgs {
+    readonly Reading: Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReading;
+  }
+
+  enum HingeState {
+    Unknown = 0,
+    Closed = 1,
+    Concave = 2,
+    Flat = 3,
+    Convex = 4,
+    Full = 5,
+  }
+
+  interface ITwoPanelHingedDevicePosturePreview {
+    GetCurrentPostureAsync(): Windows.Foundation.IAsyncOperation<Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReading>;
+    PostureChanged: Windows.Foundation.TypedEventHandler<Windows.System.Preview.TwoPanelHingedDevicePosturePreview, Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs> | null;
+  }
+  var ITwoPanelHingedDevicePosturePreview: abstract new (...args: any[]) => ITwoPanelHingedDevicePosturePreview;
+
+  interface ITwoPanelHingedDevicePosturePreviewReading {
+    readonly HingeState: number;
+    readonly Panel1Id: string;
+    readonly Panel1Orientation: number;
+    readonly Panel2Id: string;
+    readonly Panel2Orientation: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var ITwoPanelHingedDevicePosturePreviewReading: abstract new (...args: any[]) => ITwoPanelHingedDevicePosturePreviewReading;
+
+  interface ITwoPanelHingedDevicePosturePreviewReadingChangedEventArgs {
+    readonly Reading: Windows.System.Preview.TwoPanelHingedDevicePosturePreviewReading;
+  }
+  var ITwoPanelHingedDevicePosturePreviewReadingChangedEventArgs: abstract new (...args: any[]) => ITwoPanelHingedDevicePosturePreviewReadingChangedEventArgs;
+
+  interface ITwoPanelHingedDevicePosturePreviewStatics {
+    GetDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.System.Preview.TwoPanelHingedDevicePosturePreview>;
+  }
+  var ITwoPanelHingedDevicePosturePreviewStatics: abstract new (...args: any[]) => ITwoPanelHingedDevicePosturePreviewStatics;
+
+}
+
+declare namespace Windows.System.Profile {
+  class AnalyticsInfo {
+    static GetSystemPropertiesAsync(attributeNames: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<string, string>>;
+    static readonly DeviceForm: string;
+    static readonly VersionInfo: Windows.System.Profile.AnalyticsVersionInfo;
+  }
+
+  class AnalyticsVersionInfo implements Windows.System.Profile.IAnalyticsVersionInfo, Windows.System.Profile.IAnalyticsVersionInfo2 {
+    readonly DeviceFamily: string;
+    readonly DeviceFamilyVersion: string;
+    readonly ProductName: string;
+  }
+
+  class AppApplicability {
+    static GetUnsupportedAppRequirements(capabilities: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.Collections.IVectorView<Windows.System.Profile.UnsupportedAppRequirement> | Windows.System.Profile.UnsupportedAppRequirement[];
+  }
+
+  class EducationSettings {
+    static readonly IsEducationEnvironment: boolean;
+  }
+
+  class HardwareIdentification {
+    static GetPackageSpecificToken(nonce: Windows.Storage.Streams.IBuffer): Windows.System.Profile.HardwareToken;
+  }
+
+  class HardwareToken implements Windows.System.Profile.IHardwareToken {
+    readonly Certificate: Windows.Storage.Streams.IBuffer;
+    readonly Id: Windows.Storage.Streams.IBuffer;
+    readonly Signature: Windows.Storage.Streams.IBuffer;
+  }
+
+  class KnownRetailInfoProperties {
+    static readonly BatteryLifeDescription: string;
+    static readonly DisplayDescription: string;
+    static readonly DisplayModelName: string;
+    static readonly FormFactor: string;
+    static readonly FrontCameraDescription: string;
+    static readonly GraphicsDescription: string;
+    static readonly HasNfc: string;
+    static readonly HasOpticalDrive: string;
+    static readonly HasSdSlot: string;
+    static readonly IsFeatured: string;
+    static readonly IsOfficeInstalled: string;
+    static readonly ManufacturerName: string;
+    static readonly Memory: string;
+    static readonly ModelName: string;
+    static readonly Price: string;
+    static readonly ProcessorDescription: string;
+    static readonly RearCameraDescription: string;
+    static readonly RetailAccessCode: string;
+    static readonly ScreenSize: string;
+    static readonly StorageDescription: string;
+    static readonly Weight: string;
+    static readonly WindowsEdition: string;
+  }
+
+  class PlatformAutomaticAppSignInManager {
+    static readonly Policy: number;
+  }
+
+  class PlatformDiagnosticsAndUsageDataSettings {
+    static CanCollectDiagnostics(level: number): boolean;
+    static readonly CollectionLevel: number;
+    static CollectionLevelChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class RetailInfo {
+    static readonly IsDemoModeEnabled: boolean;
+    static readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+
+  class SharedModeSettings {
+    static readonly IsEnabled: boolean;
+    static readonly ShouldAvoidLocalStorage: boolean;
+  }
+
+  class SmartAppControlPolicy {
+    static readonly IsEnabled: boolean;
+    static Changed: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class SystemIdentification {
+    static GetSystemIdForPublisher(): Windows.System.Profile.SystemIdentificationInfo;
+    static GetSystemIdForUser(user: Windows.System.User): Windows.System.Profile.SystemIdentificationInfo;
+  }
+
+  class SystemIdentificationInfo implements Windows.System.Profile.ISystemIdentificationInfo {
+    readonly Id: Windows.Storage.Streams.IBuffer;
+    readonly Source: number;
+  }
+
+  class SystemSetupInfo {
+    static readonly OutOfBoxExperienceState: number;
+    static OutOfBoxExperienceStateChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class UnsupportedAppRequirement implements Windows.System.Profile.IUnsupportedAppRequirement {
+    readonly Reasons: number;
+    readonly Requirement: string;
+  }
+
+  class WindowsIntegrityPolicy {
+    static readonly CanDisable: boolean;
+    static readonly IsDisableSupported: boolean;
+    static readonly IsEnabled: boolean;
+    static readonly IsEnabledForTrial: boolean;
+    static PolicyChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  enum PlatformAutomaticAppSignInPolicy {
+    Unknown = 0,
+    PermissionRequired = 1,
+    AlwaysAllowed = 2,
+  }
+
+  enum PlatformDataCollectionLevel {
+    Security = 0,
+    Basic = 1,
+    Enhanced = 2,
+    Full = 3,
+  }
+
+  enum SystemIdentificationSource {
+    None = 0,
+    Tpm = 1,
+    Uefi = 2,
+    Registry = 3,
+  }
+
+  enum SystemOutOfBoxExperienceState {
+    NotStarted = 0,
+    InProgress = 1,
+    Completed = 2,
+  }
+
+  enum UnsupportedAppRequirementReasons {
+    Unknown = 0,
+    DeniedBySystem = 1,
+  }
+
+  interface IAnalyticsInfoStatics {
+    readonly DeviceForm: string;
+    readonly VersionInfo: Windows.System.Profile.AnalyticsVersionInfo;
+  }
+  var IAnalyticsInfoStatics: abstract new (...args: any[]) => IAnalyticsInfoStatics;
+
+  interface IAnalyticsInfoStatics2 {
+    GetSystemPropertiesAsync(attributeNames: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IMapView<string, string>>;
+  }
+  var IAnalyticsInfoStatics2: abstract new (...args: any[]) => IAnalyticsInfoStatics2;
+
+  interface IAnalyticsVersionInfo {
+    readonly DeviceFamily: string;
+    readonly DeviceFamilyVersion: string;
+  }
+  var IAnalyticsVersionInfo: abstract new (...args: any[]) => IAnalyticsVersionInfo;
+
+  interface IAnalyticsVersionInfo2 {
+    readonly ProductName: string;
+  }
+  var IAnalyticsVersionInfo2: abstract new (...args: any[]) => IAnalyticsVersionInfo2;
+
+  interface IAppApplicabilityStatics {
+    GetUnsupportedAppRequirements(capabilities: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.Collections.IVectorView<Windows.System.Profile.UnsupportedAppRequirement> | Windows.System.Profile.UnsupportedAppRequirement[];
+  }
+  var IAppApplicabilityStatics: abstract new (...args: any[]) => IAppApplicabilityStatics;
+
+  interface IEducationSettingsStatics {
+    readonly IsEducationEnvironment: boolean;
+  }
+  var IEducationSettingsStatics: abstract new (...args: any[]) => IEducationSettingsStatics;
+
+  interface IHardwareIdentificationStatics {
+    GetPackageSpecificToken(nonce: Windows.Storage.Streams.IBuffer): Windows.System.Profile.HardwareToken;
+  }
+  var IHardwareIdentificationStatics: abstract new (...args: any[]) => IHardwareIdentificationStatics;
+
+  interface IHardwareToken {
+    readonly Certificate: Windows.Storage.Streams.IBuffer;
+    readonly Id: Windows.Storage.Streams.IBuffer;
+    readonly Signature: Windows.Storage.Streams.IBuffer;
+  }
+  var IHardwareToken: abstract new (...args: any[]) => IHardwareToken;
+
+  interface IKnownRetailInfoPropertiesStatics {
+    readonly BatteryLifeDescription: string;
+    readonly DisplayDescription: string;
+    readonly DisplayModelName: string;
+    readonly FormFactor: string;
+    readonly FrontCameraDescription: string;
+    readonly GraphicsDescription: string;
+    readonly HasNfc: string;
+    readonly HasOpticalDrive: string;
+    readonly HasSdSlot: string;
+    readonly IsFeatured: string;
+    readonly IsOfficeInstalled: string;
+    readonly ManufacturerName: string;
+    readonly Memory: string;
+    readonly ModelName: string;
+    readonly Price: string;
+    readonly ProcessorDescription: string;
+    readonly RearCameraDescription: string;
+    readonly RetailAccessCode: string;
+    readonly ScreenSize: string;
+    readonly StorageDescription: string;
+    readonly Weight: string;
+    readonly WindowsEdition: string;
+  }
+  var IKnownRetailInfoPropertiesStatics: abstract new (...args: any[]) => IKnownRetailInfoPropertiesStatics;
+
+  interface IPlatformAutomaticAppSignInManagerStatics {
+    readonly Policy: number;
+  }
+  var IPlatformAutomaticAppSignInManagerStatics: abstract new (...args: any[]) => IPlatformAutomaticAppSignInManagerStatics;
+
+  interface IPlatformDiagnosticsAndUsageDataSettingsStatics {
+    CanCollectDiagnostics(level: number): boolean;
+    readonly CollectionLevel: number;
+    CollectionLevelChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IPlatformDiagnosticsAndUsageDataSettingsStatics: abstract new (...args: any[]) => IPlatformDiagnosticsAndUsageDataSettingsStatics;
+
+  interface IRetailInfoStatics {
+    readonly IsDemoModeEnabled: boolean;
+    readonly Properties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+  var IRetailInfoStatics: abstract new (...args: any[]) => IRetailInfoStatics;
+
+  interface ISharedModeSettingsStatics {
+    readonly IsEnabled: boolean;
+  }
+  var ISharedModeSettingsStatics: abstract new (...args: any[]) => ISharedModeSettingsStatics;
+
+  interface ISharedModeSettingsStatics2 {
+    readonly ShouldAvoidLocalStorage: boolean;
+  }
+  var ISharedModeSettingsStatics2: abstract new (...args: any[]) => ISharedModeSettingsStatics2;
+
+  interface ISmartAppControlPolicyStatics {
+    readonly IsEnabled: boolean;
+    Changed: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var ISmartAppControlPolicyStatics: abstract new (...args: any[]) => ISmartAppControlPolicyStatics;
+
+  interface ISystemIdentificationInfo {
+    readonly Id: Windows.Storage.Streams.IBuffer;
+    readonly Source: number;
+  }
+  var ISystemIdentificationInfo: abstract new (...args: any[]) => ISystemIdentificationInfo;
+
+  interface ISystemIdentificationStatics {
+    GetSystemIdForPublisher(): Windows.System.Profile.SystemIdentificationInfo;
+    GetSystemIdForUser(user: Windows.System.User): Windows.System.Profile.SystemIdentificationInfo;
+  }
+  var ISystemIdentificationStatics: abstract new (...args: any[]) => ISystemIdentificationStatics;
+
+  interface ISystemSetupInfoStatics {
+    readonly OutOfBoxExperienceState: number;
+    OutOfBoxExperienceStateChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var ISystemSetupInfoStatics: abstract new (...args: any[]) => ISystemSetupInfoStatics;
+
+  interface IUnsupportedAppRequirement {
+    readonly Reasons: number;
+    readonly Requirement: string;
+  }
+  var IUnsupportedAppRequirement: abstract new (...args: any[]) => IUnsupportedAppRequirement;
+
+  interface IWindowsIntegrityPolicyStatics {
+    readonly CanDisable: boolean;
+    readonly IsDisableSupported: boolean;
+    readonly IsEnabled: boolean;
+    readonly IsEnabledForTrial: boolean;
+    PolicyChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IWindowsIntegrityPolicyStatics: abstract new (...args: any[]) => IWindowsIntegrityPolicyStatics;
+
+  interface PlatformAutomaticAppSignInContract {
+  }
+  var PlatformAutomaticAppSignInContract: {
+    new(fields: {  }): PlatformAutomaticAppSignInContract;
+  };
+
+  interface ProfileHardwareTokenContract {
+  }
+  var ProfileHardwareTokenContract: {
+    new(fields: {  }): ProfileHardwareTokenContract;
+  };
+
+  interface ProfileRetailInfoContract {
+  }
+  var ProfileRetailInfoContract: {
+    new(fields: {  }): ProfileRetailInfoContract;
+  };
+
+  interface ProfileSharedModeContract {
+  }
+  var ProfileSharedModeContract: {
+    new(fields: {  }): ProfileSharedModeContract;
+  };
+
+}
+
+declare namespace Windows.System.Profile.SystemManufacturers {
+  class OemSupportInfo implements Windows.System.Profile.SystemManufacturers.IOemSupportInfo {
+    readonly SupportAppLink: Windows.Foundation.Uri;
+    readonly SupportLink: Windows.Foundation.Uri;
+    readonly SupportProvider: string;
+  }
+
+  class SmbiosInformation {
+    static readonly SerialNumber: string;
+  }
+
+  class SystemSupportDeviceInfo implements Windows.System.Profile.SystemManufacturers.ISystemSupportDeviceInfo {
+    readonly FriendlyName: string;
+    readonly OperatingSystem: string;
+    readonly SystemFirmwareVersion: string;
+    readonly SystemHardwareVersion: string;
+    readonly SystemManufacturer: string;
+    readonly SystemProductName: string;
+    readonly SystemSku: string;
+  }
+
+  class SystemSupportInfo {
+    static readonly LocalDeviceInfo: Windows.System.Profile.SystemManufacturers.SystemSupportDeviceInfo;
+    static readonly LocalSystemEdition: string;
+    static readonly OemSupportInfo: Windows.System.Profile.SystemManufacturers.OemSupportInfo;
+  }
+
+  interface IOemSupportInfo {
+    readonly SupportAppLink: Windows.Foundation.Uri;
+    readonly SupportLink: Windows.Foundation.Uri;
+    readonly SupportProvider: string;
+  }
+  var IOemSupportInfo: abstract new (...args: any[]) => IOemSupportInfo;
+
+  interface ISmbiosInformationStatics {
+    readonly SerialNumber: string;
+  }
+  var ISmbiosInformationStatics: abstract new (...args: any[]) => ISmbiosInformationStatics;
+
+  interface ISystemSupportDeviceInfo {
+    readonly FriendlyName: string;
+    readonly OperatingSystem: string;
+    readonly SystemFirmwareVersion: string;
+    readonly SystemHardwareVersion: string;
+    readonly SystemManufacturer: string;
+    readonly SystemProductName: string;
+    readonly SystemSku: string;
+  }
+  var ISystemSupportDeviceInfo: abstract new (...args: any[]) => ISystemSupportDeviceInfo;
+
+  interface ISystemSupportInfoStatics {
+    readonly LocalSystemEdition: string;
+    readonly OemSupportInfo: Windows.System.Profile.SystemManufacturers.OemSupportInfo;
+  }
+  var ISystemSupportInfoStatics: abstract new (...args: any[]) => ISystemSupportInfoStatics;
+
+  interface ISystemSupportInfoStatics2 {
+    readonly LocalDeviceInfo: Windows.System.Profile.SystemManufacturers.SystemSupportDeviceInfo;
+  }
+  var ISystemSupportInfoStatics2: abstract new (...args: any[]) => ISystemSupportInfoStatics2;
+
+  interface SystemManufacturersContract {
+  }
+  var SystemManufacturersContract: {
+    new(fields: {  }): SystemManufacturersContract;
+  };
+
+}
+
+declare namespace Windows.System.RemoteDesktop {
+  class InteractiveSession {
+    static readonly IsRemote: boolean;
+  }
+
+  interface IInteractiveSessionStatics {
+    readonly IsRemote: boolean;
+  }
+  var IInteractiveSessionStatics: abstract new (...args: any[]) => IInteractiveSessionStatics;
+
+}
+
+declare namespace Windows.System.RemoteDesktop.Input {
+  class RemoteTextConnection implements Windows.Foundation.IClosable, Windows.System.RemoteDesktop.Input.IRemoteTextConnection, Windows.System.RemoteDesktop.Input.IRemoteTextConnection2 {
+    constructor(connectionId: Guid, pduForwarder: Windows.System.RemoteDesktop.Input.RemoteTextConnectionDataHandler, options: number);
+    constructor(connectionId: Guid, pduForwarder: Windows.System.RemoteDesktop.Input.RemoteTextConnectionDataHandler);
+    Close(): void;
+    RegisterThread(threadId: number): void;
+    ReportDataReceived(pduData: number[]): void;
+    ReportPredictedKeyEvent(scanCode: number, attributes: number): void;
+    UnregisterThread(threadId: number): void;
+    IsEnabled: boolean;
+  }
+
+  enum RemoteKeyEventAttributes {
+    None = 0,
+    KeyUp = 1,
+    Repeat = 2,
+    Extended = 4,
+    Extended1 = 8,
+  }
+
+  enum RemoteTextConnectionOptions {
+    None = 0,
+    EnablePredictedKeyReporting = 1,
+  }
+
+  interface IRemoteTextConnection {
+    RegisterThread(threadId: number): void;
+    ReportDataReceived(pduData: number[]): void;
+    UnregisterThread(threadId: number): void;
+    IsEnabled: boolean;
+  }
+  var IRemoteTextConnection: abstract new (...args: any[]) => IRemoteTextConnection;
+
+  interface IRemoteTextConnection2 {
+    ReportPredictedKeyEvent(scanCode: number, attributes: number): void;
+  }
+  var IRemoteTextConnection2: abstract new (...args: any[]) => IRemoteTextConnection2;
+
+  interface IRemoteTextConnectionFactory {
+    CreateInstance(connectionId: Guid, pduForwarder: Windows.System.RemoteDesktop.Input.RemoteTextConnectionDataHandler): Windows.System.RemoteDesktop.Input.RemoteTextConnection;
+  }
+  var IRemoteTextConnectionFactory: abstract new (...args: any[]) => IRemoteTextConnectionFactory;
+
+  interface IRemoteTextConnectionFactory2 {
+    CreateInstance(connectionId: Guid, pduForwarder: Windows.System.RemoteDesktop.Input.RemoteTextConnectionDataHandler, options: number): Windows.System.RemoteDesktop.Input.RemoteTextConnection;
+  }
+  var IRemoteTextConnectionFactory2: abstract new (...args: any[]) => IRemoteTextConnectionFactory2;
+
+  interface RemoteTextConnectionDataHandler {
+    (pduData: number[]): boolean;
+  }
+  var RemoteTextConnectionDataHandler: {
+    new(callback: (pduData: number[]) => boolean): RemoteTextConnectionDataHandler;
+  };
+
+}
+
+declare namespace Windows.System.RemoteDesktop.Provider {
+  class PerformLocalActionRequestedEventArgs implements Windows.System.RemoteDesktop.Provider.IPerformLocalActionRequestedEventArgs {
+    readonly Action: number;
+  }
+
+  class RemoteDesktopConnectionInfo implements Windows.System.RemoteDesktop.Provider.IRemoteDesktopConnectionInfo, Windows.System.RemoteDesktop.Provider.IRemoteDesktopConnectionInfo2 {
+    static GetForLaunchUri(launchUri: Windows.Foundation.Uri, windowId: Windows.UI.WindowId): Windows.System.RemoteDesktop.Provider.RemoteDesktopConnectionInfo;
+    PerformLocalActionFromRemote(action: number): void;
+    SetConnectionStatus(value: number): void;
+    SwitchToLocalSession(): void;
+  }
+
+  class RemoteDesktopConnectionRemoteInfo implements Windows.Foundation.IClosable, Windows.System.RemoteDesktop.Provider.IRemoteDesktopConnectionRemoteInfo {
+    Close(): void;
+    static GetForLaunchUri(launchUri: Windows.Foundation.Uri): Windows.System.RemoteDesktop.Provider.RemoteDesktopConnectionRemoteInfo;
+    static IsSwitchSupported(): boolean;
+    ReportSwitched(): void;
+    PerformLocalActionRequested: Windows.Foundation.TypedEventHandler<Windows.System.RemoteDesktop.Provider.RemoteDesktopConnectionRemoteInfo, Windows.System.RemoteDesktop.Provider.PerformLocalActionRequestedEventArgs> | null;
+    SwitchToLocalSessionRequested: Windows.Foundation.TypedEventHandler<Windows.System.RemoteDesktop.Provider.RemoteDesktopConnectionRemoteInfo, Object> | null;
+  }
+
+  class RemoteDesktopInfo implements Windows.System.RemoteDesktop.Provider.IRemoteDesktopInfo {
+    constructor(id: string, displayName: string);
+    readonly DisplayName: string;
+    readonly Id: string;
+  }
+
+  class RemoteDesktopRegistrar {
+    static IsSwitchToLocalSessionEnabled(): boolean;
+    static readonly DesktopInfos: Windows.Foundation.Collections.IVector<Windows.System.RemoteDesktop.Provider.RemoteDesktopInfo> | Windows.System.RemoteDesktop.Provider.RemoteDesktopInfo[];
+  }
+
+  enum RemoteDesktopConnectionStatus {
+    Connecting = 0,
+    Connected = 1,
+    UserInputNeeded = 2,
+    Disconnected = 3,
+  }
+
+  enum RemoteDesktopLocalAction {
+    ShowBluetoothSettings = 0,
+    ShowSystemSoundSettings = 1,
+    ShowSystemDisplaySettings = 2,
+    ShowSystemAccountSettings = 3,
+    ShowLocalSettings = 4,
+  }
+
+  interface IPerformLocalActionRequestedEventArgs {
+    readonly Action: number;
+  }
+  var IPerformLocalActionRequestedEventArgs: abstract new (...args: any[]) => IPerformLocalActionRequestedEventArgs;
+
+  interface IRemoteDesktopConnectionInfo {
+    SetConnectionStatus(value: number): void;
+    SwitchToLocalSession(): void;
+  }
+  var IRemoteDesktopConnectionInfo: abstract new (...args: any[]) => IRemoteDesktopConnectionInfo;
+
+  interface IRemoteDesktopConnectionInfo2 {
+    PerformLocalActionFromRemote(action: number): void;
+  }
+  var IRemoteDesktopConnectionInfo2: abstract new (...args: any[]) => IRemoteDesktopConnectionInfo2;
+
+  interface IRemoteDesktopConnectionInfoStatics {
+    GetForLaunchUri(launchUri: Windows.Foundation.Uri, windowId: Windows.UI.WindowId): Windows.System.RemoteDesktop.Provider.RemoteDesktopConnectionInfo;
+  }
+  var IRemoteDesktopConnectionInfoStatics: abstract new (...args: any[]) => IRemoteDesktopConnectionInfoStatics;
+
+  interface IRemoteDesktopConnectionRemoteInfo {
+    ReportSwitched(): void;
+    PerformLocalActionRequested: Windows.Foundation.TypedEventHandler<Windows.System.RemoteDesktop.Provider.RemoteDesktopConnectionRemoteInfo, Windows.System.RemoteDesktop.Provider.PerformLocalActionRequestedEventArgs> | null;
+    SwitchToLocalSessionRequested: Windows.Foundation.TypedEventHandler<Windows.System.RemoteDesktop.Provider.RemoteDesktopConnectionRemoteInfo, Object> | null;
+  }
+  var IRemoteDesktopConnectionRemoteInfo: abstract new (...args: any[]) => IRemoteDesktopConnectionRemoteInfo;
+
+  interface IRemoteDesktopConnectionRemoteInfoStatics {
+    GetForLaunchUri(launchUri: Windows.Foundation.Uri): Windows.System.RemoteDesktop.Provider.RemoteDesktopConnectionRemoteInfo;
+    IsSwitchSupported(): boolean;
+  }
+  var IRemoteDesktopConnectionRemoteInfoStatics: abstract new (...args: any[]) => IRemoteDesktopConnectionRemoteInfoStatics;
+
+  interface IRemoteDesktopInfo {
+    readonly DisplayName: string;
+    readonly Id: string;
+  }
+  var IRemoteDesktopInfo: abstract new (...args: any[]) => IRemoteDesktopInfo;
+
+  interface IRemoteDesktopInfoFactory {
+    CreateInstance(id: string, displayName: string): Windows.System.RemoteDesktop.Provider.RemoteDesktopInfo;
+  }
+  var IRemoteDesktopInfoFactory: abstract new (...args: any[]) => IRemoteDesktopInfoFactory;
+
+  interface IRemoteDesktopRegistrarStatics {
+    IsSwitchToLocalSessionEnabled(): boolean;
+    readonly DesktopInfos: Windows.Foundation.Collections.IVector<Windows.System.RemoteDesktop.Provider.RemoteDesktopInfo> | Windows.System.RemoteDesktop.Provider.RemoteDesktopInfo[];
+  }
+  var IRemoteDesktopRegistrarStatics: abstract new (...args: any[]) => IRemoteDesktopRegistrarStatics;
+
+}
+
+declare namespace Windows.System.RemoteSystems {
+  class KnownRemoteSystemCapabilities {
+    static readonly AppService: string;
+    static readonly LaunchUri: string;
+    static readonly RemoteSession: string;
+    static readonly SpatialEntity: string;
+  }
+
+  class RemoteSystem implements Windows.System.RemoteSystems.IRemoteSystem, Windows.System.RemoteSystems.IRemoteSystem2, Windows.System.RemoteSystems.IRemoteSystem3, Windows.System.RemoteSystems.IRemoteSystem4, Windows.System.RemoteSystems.IRemoteSystem5, Windows.System.RemoteSystems.IRemoteSystem6 {
+    static CreateWatcher(): Windows.System.RemoteSystems.RemoteSystemWatcher;
+    static CreateWatcher(filters: Windows.Foundation.Collections.IIterable<Windows.System.RemoteSystems.IRemoteSystemFilter> | Windows.System.RemoteSystems.IRemoteSystemFilter[]): Windows.System.RemoteSystems.RemoteSystemWatcher;
+    static CreateWatcherForUser(user: Windows.System.User): Windows.System.RemoteSystems.RemoteSystemWatcher;
+    static CreateWatcherForUser(user: Windows.System.User, filters: Windows.Foundation.Collections.IIterable<Windows.System.RemoteSystems.IRemoteSystemFilter> | Windows.System.RemoteSystems.IRemoteSystemFilter[]): Windows.System.RemoteSystems.RemoteSystemWatcher;
+    static FindByHostNameAsync(hostName: Windows.Networking.HostName): Windows.Foundation.IAsyncOperation<Windows.System.RemoteSystems.RemoteSystem>;
+    GetCapabilitySupportedAsync(capabilityName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    static IsAuthorizationKindEnabled(kind: number): boolean;
+    static RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    readonly Apps: Windows.Foundation.Collections.IVectorView<Windows.System.RemoteSystems.RemoteSystemApp> | Windows.System.RemoteSystems.RemoteSystemApp[];
+    readonly DisplayName: string;
+    readonly Id: string;
+    readonly IsAvailableByProximity: boolean;
+    readonly IsAvailableBySpatialProximity: boolean;
+    readonly Kind: string;
+    readonly ManufacturerDisplayName: string;
+    readonly ModelDisplayName: string;
+    readonly Platform: number;
+    readonly Status: number;
+    readonly User: Windows.System.User;
+  }
+
+  class RemoteSystemAddedEventArgs implements Windows.System.RemoteSystems.IRemoteSystemAddedEventArgs {
+    readonly RemoteSystem: Windows.System.RemoteSystems.RemoteSystem;
+  }
+
+  class RemoteSystemApp implements Windows.System.RemoteSystems.IRemoteSystemApp, Windows.System.RemoteSystems.IRemoteSystemApp2 {
+    readonly Attributes: Windows.Foundation.Collections.IMapView<string, string>;
+    readonly ConnectionToken: string;
+    readonly DisplayName: string;
+    readonly Id: string;
+    readonly IsAvailableByProximity: boolean;
+    readonly IsAvailableBySpatialProximity: boolean;
+    readonly User: Windows.System.User;
+  }
+
+  class RemoteSystemAppRegistration implements Windows.System.RemoteSystems.IRemoteSystemAppRegistration {
+    static GetDefault(): Windows.System.RemoteSystems.RemoteSystemAppRegistration;
+    static GetForUser(user: Windows.System.User): Windows.System.RemoteSystems.RemoteSystemAppRegistration;
+    SaveAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Attributes: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    readonly User: Windows.System.User;
+  }
+
+  class RemoteSystemAuthorizationKindFilter implements Windows.System.RemoteSystems.IRemoteSystemAuthorizationKindFilter, Windows.System.RemoteSystems.IRemoteSystemFilter {
+    constructor(remoteSystemAuthorizationKind: number);
+    readonly RemoteSystemAuthorizationKind: number;
+  }
+
+  class RemoteSystemConnectionInfo implements Windows.System.RemoteSystems.IRemoteSystemConnectionInfo {
+    static TryCreateFromAppServiceConnection(connection: Windows.ApplicationModel.AppService.AppServiceConnection): Windows.System.RemoteSystems.RemoteSystemConnectionInfo;
+    readonly IsProximal: boolean;
+  }
+
+  class RemoteSystemConnectionRequest implements Windows.System.RemoteSystems.IRemoteSystemConnectionRequest, Windows.System.RemoteSystems.IRemoteSystemConnectionRequest2, Windows.System.RemoteSystems.IRemoteSystemConnectionRequest3 {
+    constructor(remoteSystem: Windows.System.RemoteSystems.RemoteSystem);
+    static CreateForApp(remoteSystemApp: Windows.System.RemoteSystems.RemoteSystemApp): Windows.System.RemoteSystems.RemoteSystemConnectionRequest;
+    static CreateFromConnectionToken(connectionToken: string): Windows.System.RemoteSystems.RemoteSystemConnectionRequest;
+    static CreateFromConnectionTokenForUser(user: Windows.System.User, connectionToken: string): Windows.System.RemoteSystems.RemoteSystemConnectionRequest;
+    readonly ConnectionToken: string;
+    readonly RemoteSystem: Windows.System.RemoteSystems.RemoteSystem;
+    readonly RemoteSystemApp: Windows.System.RemoteSystems.RemoteSystemApp;
+  }
+
+  class RemoteSystemDiscoveryTypeFilter implements Windows.System.RemoteSystems.IRemoteSystemDiscoveryTypeFilter, Windows.System.RemoteSystems.IRemoteSystemFilter {
+    constructor(discoveryType: number);
+    readonly RemoteSystemDiscoveryType: number;
+  }
+
+  class RemoteSystemEnumerationCompletedEventArgs implements Windows.System.RemoteSystems.IRemoteSystemEnumerationCompletedEventArgs {
+  }
+
+  class RemoteSystemKindFilter implements Windows.System.RemoteSystems.IRemoteSystemFilter, Windows.System.RemoteSystems.IRemoteSystemKindFilter {
+    constructor(remoteSystemKinds: Windows.Foundation.Collections.IIterable<string> | string[]);
+    readonly RemoteSystemKinds: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+
+  class RemoteSystemKinds {
+    static readonly Desktop: string;
+    static readonly Holographic: string;
+    static readonly Hub: string;
+    static readonly Iot: string;
+    static readonly Laptop: string;
+    static readonly Phone: string;
+    static readonly Tablet: string;
+    static readonly Xbox: string;
+  }
+
+  class RemoteSystemRemovedEventArgs implements Windows.System.RemoteSystems.IRemoteSystemRemovedEventArgs {
+    readonly RemoteSystemId: string;
+  }
+
+  class RemoteSystemSession implements Windows.Foundation.IClosable, Windows.System.RemoteSystems.IRemoteSystemSession {
+    Close(): void;
+    CreateParticipantWatcher(): Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher;
+    static CreateWatcher(): Windows.System.RemoteSystems.RemoteSystemSessionWatcher;
+    SendInvitationAsync(invitee: Windows.System.RemoteSystems.RemoteSystem): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly ControllerDisplayName: string;
+    readonly DisplayName: string;
+    readonly Id: string;
+    Disconnected: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSession, Windows.System.RemoteSystems.RemoteSystemSessionDisconnectedEventArgs> | null;
+  }
+
+  class RemoteSystemSessionAddedEventArgs implements Windows.System.RemoteSystems.IRemoteSystemSessionAddedEventArgs {
+    readonly SessionInfo: Windows.System.RemoteSystems.RemoteSystemSessionInfo;
+  }
+
+  class RemoteSystemSessionController implements Windows.System.RemoteSystems.IRemoteSystemSessionController {
+    constructor(displayName: string);
+    constructor(displayName: string, options: Windows.System.RemoteSystems.RemoteSystemSessionOptions);
+    CreateSessionAsync(): Windows.Foundation.IAsyncOperation<Windows.System.RemoteSystems.RemoteSystemSessionCreationResult>;
+    RemoveParticipantAsync(pParticipant: Windows.System.RemoteSystems.RemoteSystemSessionParticipant): Windows.Foundation.IAsyncOperation<boolean>;
+    JoinRequested: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSessionController, Windows.System.RemoteSystems.RemoteSystemSessionJoinRequestedEventArgs> | null;
+  }
+
+  class RemoteSystemSessionCreationResult implements Windows.System.RemoteSystems.IRemoteSystemSessionCreationResult {
+    readonly Session: Windows.System.RemoteSystems.RemoteSystemSession;
+    readonly Status: number;
+  }
+
+  class RemoteSystemSessionDisconnectedEventArgs implements Windows.System.RemoteSystems.IRemoteSystemSessionDisconnectedEventArgs {
+    readonly Reason: number;
+  }
+
+  class RemoteSystemSessionInfo implements Windows.System.RemoteSystems.IRemoteSystemSessionInfo {
+    JoinAsync(): Windows.Foundation.IAsyncOperation<Windows.System.RemoteSystems.RemoteSystemSessionJoinResult>;
+    readonly ControllerDisplayName: string;
+    readonly DisplayName: string;
+  }
+
+  class RemoteSystemSessionInvitation implements Windows.System.RemoteSystems.IRemoteSystemSessionInvitation {
+    readonly Sender: Windows.System.RemoteSystems.RemoteSystem;
+    readonly SessionInfo: Windows.System.RemoteSystems.RemoteSystemSessionInfo;
+  }
+
+  class RemoteSystemSessionInvitationListener implements Windows.System.RemoteSystems.IRemoteSystemSessionInvitationListener {
+    constructor();
+    InvitationReceived: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener, Windows.System.RemoteSystems.RemoteSystemSessionInvitationReceivedEventArgs> | null;
+  }
+
+  class RemoteSystemSessionInvitationReceivedEventArgs implements Windows.System.RemoteSystems.IRemoteSystemSessionInvitationReceivedEventArgs {
+    readonly Invitation: Windows.System.RemoteSystems.RemoteSystemSessionInvitation;
+  }
+
+  class RemoteSystemSessionJoinRequest implements Windows.System.RemoteSystems.IRemoteSystemSessionJoinRequest {
+    Accept(): void;
+    readonly Participant: Windows.System.RemoteSystems.RemoteSystemSessionParticipant;
+  }
+
+  class RemoteSystemSessionJoinRequestedEventArgs implements Windows.System.RemoteSystems.IRemoteSystemSessionJoinRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly JoinRequest: Windows.System.RemoteSystems.RemoteSystemSessionJoinRequest;
+  }
+
+  class RemoteSystemSessionJoinResult implements Windows.System.RemoteSystems.IRemoteSystemSessionJoinResult {
+    readonly Session: Windows.System.RemoteSystems.RemoteSystemSession;
+    readonly Status: number;
+  }
+
+  class RemoteSystemSessionMessageChannel implements Windows.System.RemoteSystems.IRemoteSystemSessionMessageChannel {
+    constructor(session: Windows.System.RemoteSystems.RemoteSystemSession, channelName: string);
+    constructor(session: Windows.System.RemoteSystems.RemoteSystemSession, channelName: string, reliability: number);
+    BroadcastValueSetAsync(messageData: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<boolean>;
+    SendValueSetAsync(messageData: Windows.Foundation.Collections.ValueSet, participant: Windows.System.RemoteSystems.RemoteSystemSessionParticipant): Windows.Foundation.IAsyncOperation<boolean>;
+    SendValueSetToParticipantsAsync(messageData: Windows.Foundation.Collections.ValueSet, participants: Windows.Foundation.Collections.IIterable<Windows.System.RemoteSystems.RemoteSystemSessionParticipant> | Windows.System.RemoteSystems.RemoteSystemSessionParticipant[]): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Session: Windows.System.RemoteSystems.RemoteSystemSession;
+    ValueSetReceived: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel, Windows.System.RemoteSystems.RemoteSystemSessionValueSetReceivedEventArgs> | null;
+  }
+
+  class RemoteSystemSessionOptions implements Windows.System.RemoteSystems.IRemoteSystemSessionOptions {
+    constructor();
+    IsInviteOnly: boolean;
+  }
+
+  class RemoteSystemSessionParticipant implements Windows.System.RemoteSystems.IRemoteSystemSessionParticipant {
+    GetHostNames(): Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[];
+    readonly RemoteSystem: Windows.System.RemoteSystems.RemoteSystem;
+  }
+
+  class RemoteSystemSessionParticipantAddedEventArgs implements Windows.System.RemoteSystems.IRemoteSystemSessionParticipantAddedEventArgs {
+    readonly Participant: Windows.System.RemoteSystems.RemoteSystemSessionParticipant;
+  }
+
+  class RemoteSystemSessionParticipantRemovedEventArgs implements Windows.System.RemoteSystems.IRemoteSystemSessionParticipantRemovedEventArgs {
+    readonly Participant: Windows.System.RemoteSystems.RemoteSystemSessionParticipant;
+  }
+
+  class RemoteSystemSessionParticipantWatcher implements Windows.System.RemoteSystems.IRemoteSystemSessionParticipantWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher, Windows.System.RemoteSystems.RemoteSystemSessionParticipantAddedEventArgs> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher, Windows.System.RemoteSystems.RemoteSystemSessionParticipantRemovedEventArgs> | null;
+  }
+
+  class RemoteSystemSessionRemovedEventArgs implements Windows.System.RemoteSystems.IRemoteSystemSessionRemovedEventArgs {
+    readonly SessionInfo: Windows.System.RemoteSystems.RemoteSystemSessionInfo;
+  }
+
+  class RemoteSystemSessionUpdatedEventArgs implements Windows.System.RemoteSystems.IRemoteSystemSessionUpdatedEventArgs {
+    readonly SessionInfo: Windows.System.RemoteSystems.RemoteSystemSessionInfo;
+  }
+
+  class RemoteSystemSessionValueSetReceivedEventArgs implements Windows.System.RemoteSystems.IRemoteSystemSessionValueSetReceivedEventArgs {
+    readonly Message: Windows.Foundation.Collections.ValueSet;
+    readonly Sender: Windows.System.RemoteSystems.RemoteSystemSessionParticipant;
+  }
+
+  class RemoteSystemSessionWatcher implements Windows.System.RemoteSystems.IRemoteSystemSessionWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSessionWatcher, Windows.System.RemoteSystems.RemoteSystemSessionAddedEventArgs> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSessionWatcher, Windows.System.RemoteSystems.RemoteSystemSessionRemovedEventArgs> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSessionWatcher, Windows.System.RemoteSystems.RemoteSystemSessionUpdatedEventArgs> | null;
+  }
+
+  class RemoteSystemStatusTypeFilter implements Windows.System.RemoteSystems.IRemoteSystemFilter, Windows.System.RemoteSystems.IRemoteSystemStatusTypeFilter {
+    constructor(remoteSystemStatusType: number);
+    readonly RemoteSystemStatusType: number;
+  }
+
+  class RemoteSystemUpdatedEventArgs implements Windows.System.RemoteSystems.IRemoteSystemUpdatedEventArgs {
+    readonly RemoteSystem: Windows.System.RemoteSystems.RemoteSystem;
+  }
+
+  class RemoteSystemWatcher implements Windows.System.RemoteSystems.IRemoteSystemWatcher, Windows.System.RemoteSystems.IRemoteSystemWatcher2, Windows.System.RemoteSystems.IRemoteSystemWatcher3 {
+    Start(): void;
+    Stop(): void;
+    readonly User: Windows.System.User;
+    RemoteSystemAdded: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemWatcher, Windows.System.RemoteSystems.RemoteSystemAddedEventArgs> | null;
+    RemoteSystemRemoved: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemWatcher, Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs> | null;
+    RemoteSystemUpdated: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemWatcher, Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemWatcher, Windows.System.RemoteSystems.RemoteSystemEnumerationCompletedEventArgs> | null;
+    ErrorOccurred: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemWatcher, Windows.System.RemoteSystems.RemoteSystemWatcherErrorOccurredEventArgs> | null;
+  }
+
+  class RemoteSystemWatcherErrorOccurredEventArgs implements Windows.System.RemoteSystems.IRemoteSystemWatcherErrorOccurredEventArgs {
+    readonly Error: number;
+  }
+
+  class RemoteSystemWebAccountFilter implements Windows.System.RemoteSystems.IRemoteSystemFilter, Windows.System.RemoteSystems.IRemoteSystemWebAccountFilter {
+    constructor(account: Windows.Security.Credentials.WebAccount);
+    readonly Account: Windows.Security.Credentials.WebAccount;
+  }
+
+  enum RemoteSystemAccessStatus {
+    Unspecified = 0,
+    Allowed = 1,
+    DeniedByUser = 2,
+    DeniedBySystem = 3,
+  }
+
+  enum RemoteSystemAuthorizationKind {
+    SameUser = 0,
+    Anonymous = 1,
+  }
+
+  enum RemoteSystemDiscoveryType {
+    Any = 0,
+    Proximal = 1,
+    Cloud = 2,
+    SpatiallyProximal = 3,
+  }
+
+  enum RemoteSystemPlatform {
+    Unknown = 0,
+    Windows = 1,
+    Android = 2,
+    Ios = 3,
+    Linux = 4,
+  }
+
+  enum RemoteSystemSessionCreationStatus {
+    Success = 0,
+    SessionLimitsExceeded = 1,
+    OperationAborted = 2,
+  }
+
+  enum RemoteSystemSessionDisconnectedReason {
+    SessionUnavailable = 0,
+    RemovedByController = 1,
+    SessionClosed = 2,
+  }
+
+  enum RemoteSystemSessionJoinStatus {
+    Success = 0,
+    SessionLimitsExceeded = 1,
+    OperationAborted = 2,
+    SessionUnavailable = 3,
+    RejectedByController = 4,
+  }
+
+  enum RemoteSystemSessionMessageChannelReliability {
+    Reliable = 0,
+    Unreliable = 1,
+  }
+
+  enum RemoteSystemSessionParticipantWatcherStatus {
+    Created = 0,
+    Started = 1,
+    EnumerationCompleted = 2,
+    Stopping = 3,
+    Stopped = 4,
+    Aborted = 5,
+  }
+
+  enum RemoteSystemSessionWatcherStatus {
+    Created = 0,
+    Started = 1,
+    EnumerationCompleted = 2,
+    Stopping = 3,
+    Stopped = 4,
+    Aborted = 5,
+  }
+
+  enum RemoteSystemStatus {
+    Unavailable = 0,
+    DiscoveringAvailability = 1,
+    Available = 2,
+    Unknown = 3,
+  }
+
+  enum RemoteSystemStatusType {
+    Any = 0,
+    Available = 1,
+  }
+
+  enum RemoteSystemWatcherError {
+    Unknown = 0,
+    InternetNotAvailable = 1,
+    AuthenticationError = 2,
+  }
+
+  interface IKnownRemoteSystemCapabilitiesStatics {
+    readonly AppService: string;
+    readonly LaunchUri: string;
+    readonly RemoteSession: string;
+    readonly SpatialEntity: string;
+  }
+  var IKnownRemoteSystemCapabilitiesStatics: abstract new (...args: any[]) => IKnownRemoteSystemCapabilitiesStatics;
+
+  interface IRemoteSystem {
+    readonly DisplayName: string;
+    readonly Id: string;
+    readonly IsAvailableByProximity: boolean;
+    readonly Kind: string;
+    readonly Status: number;
+  }
+  var IRemoteSystem: abstract new (...args: any[]) => IRemoteSystem;
+
+  interface IRemoteSystem2 {
+    GetCapabilitySupportedAsync(capabilityName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly IsAvailableBySpatialProximity: boolean;
+  }
+  var IRemoteSystem2: abstract new (...args: any[]) => IRemoteSystem2;
+
+  interface IRemoteSystem3 {
+    readonly ManufacturerDisplayName: string;
+    readonly ModelDisplayName: string;
+  }
+  var IRemoteSystem3: abstract new (...args: any[]) => IRemoteSystem3;
+
+  interface IRemoteSystem4 {
+    readonly Platform: number;
+  }
+  var IRemoteSystem4: abstract new (...args: any[]) => IRemoteSystem4;
+
+  interface IRemoteSystem5 {
+    readonly Apps: Windows.Foundation.Collections.IVectorView<Windows.System.RemoteSystems.RemoteSystemApp> | Windows.System.RemoteSystems.RemoteSystemApp[];
+  }
+  var IRemoteSystem5: abstract new (...args: any[]) => IRemoteSystem5;
+
+  interface IRemoteSystem6 {
+    readonly User: Windows.System.User;
+  }
+  var IRemoteSystem6: abstract new (...args: any[]) => IRemoteSystem6;
+
+  interface IRemoteSystemAddedEventArgs {
+    readonly RemoteSystem: Windows.System.RemoteSystems.RemoteSystem;
+  }
+  var IRemoteSystemAddedEventArgs: abstract new (...args: any[]) => IRemoteSystemAddedEventArgs;
+
+  interface IRemoteSystemApp {
+    readonly Attributes: Windows.Foundation.Collections.IMapView<string, string>;
+    readonly DisplayName: string;
+    readonly Id: string;
+    readonly IsAvailableByProximity: boolean;
+    readonly IsAvailableBySpatialProximity: boolean;
+  }
+  var IRemoteSystemApp: abstract new (...args: any[]) => IRemoteSystemApp;
+
+  interface IRemoteSystemApp2 {
+    readonly ConnectionToken: string;
+    readonly User: Windows.System.User;
+  }
+  var IRemoteSystemApp2: abstract new (...args: any[]) => IRemoteSystemApp2;
+
+  interface IRemoteSystemAppRegistration {
+    SaveAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Attributes: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    readonly User: Windows.System.User;
+  }
+  var IRemoteSystemAppRegistration: abstract new (...args: any[]) => IRemoteSystemAppRegistration;
+
+  interface IRemoteSystemAppRegistrationStatics {
+    GetDefault(): Windows.System.RemoteSystems.RemoteSystemAppRegistration;
+    GetForUser(user: Windows.System.User): Windows.System.RemoteSystems.RemoteSystemAppRegistration;
+  }
+  var IRemoteSystemAppRegistrationStatics: abstract new (...args: any[]) => IRemoteSystemAppRegistrationStatics;
+
+  interface IRemoteSystemAuthorizationKindFilter {
+    readonly RemoteSystemAuthorizationKind: number;
+  }
+  var IRemoteSystemAuthorizationKindFilter: abstract new (...args: any[]) => IRemoteSystemAuthorizationKindFilter;
+
+  interface IRemoteSystemAuthorizationKindFilterFactory {
+    Create(remoteSystemAuthorizationKind: number): Windows.System.RemoteSystems.RemoteSystemAuthorizationKindFilter;
+  }
+  var IRemoteSystemAuthorizationKindFilterFactory: abstract new (...args: any[]) => IRemoteSystemAuthorizationKindFilterFactory;
+
+  interface IRemoteSystemConnectionInfo {
+    readonly IsProximal: boolean;
+  }
+  var IRemoteSystemConnectionInfo: abstract new (...args: any[]) => IRemoteSystemConnectionInfo;
+
+  interface IRemoteSystemConnectionInfoStatics {
+    TryCreateFromAppServiceConnection(connection: Windows.ApplicationModel.AppService.AppServiceConnection): Windows.System.RemoteSystems.RemoteSystemConnectionInfo;
+  }
+  var IRemoteSystemConnectionInfoStatics: abstract new (...args: any[]) => IRemoteSystemConnectionInfoStatics;
+
+  interface IRemoteSystemConnectionRequest {
+    readonly RemoteSystem: Windows.System.RemoteSystems.RemoteSystem;
+  }
+  var IRemoteSystemConnectionRequest: abstract new (...args: any[]) => IRemoteSystemConnectionRequest;
+
+  interface IRemoteSystemConnectionRequest2 {
+    readonly RemoteSystemApp: Windows.System.RemoteSystems.RemoteSystemApp;
+  }
+  var IRemoteSystemConnectionRequest2: abstract new (...args: any[]) => IRemoteSystemConnectionRequest2;
+
+  interface IRemoteSystemConnectionRequest3 {
+    readonly ConnectionToken: string;
+  }
+  var IRemoteSystemConnectionRequest3: abstract new (...args: any[]) => IRemoteSystemConnectionRequest3;
+
+  interface IRemoteSystemConnectionRequestFactory {
+    Create(remoteSystem: Windows.System.RemoteSystems.RemoteSystem): Windows.System.RemoteSystems.RemoteSystemConnectionRequest;
+  }
+  var IRemoteSystemConnectionRequestFactory: abstract new (...args: any[]) => IRemoteSystemConnectionRequestFactory;
+
+  interface IRemoteSystemConnectionRequestStatics {
+    CreateForApp(remoteSystemApp: Windows.System.RemoteSystems.RemoteSystemApp): Windows.System.RemoteSystems.RemoteSystemConnectionRequest;
+  }
+  var IRemoteSystemConnectionRequestStatics: abstract new (...args: any[]) => IRemoteSystemConnectionRequestStatics;
+
+  interface IRemoteSystemConnectionRequestStatics2 {
+    CreateFromConnectionToken(connectionToken: string): Windows.System.RemoteSystems.RemoteSystemConnectionRequest;
+    CreateFromConnectionTokenForUser(user: Windows.System.User, connectionToken: string): Windows.System.RemoteSystems.RemoteSystemConnectionRequest;
+  }
+  var IRemoteSystemConnectionRequestStatics2: abstract new (...args: any[]) => IRemoteSystemConnectionRequestStatics2;
+
+  interface IRemoteSystemDiscoveryTypeFilter {
+    readonly RemoteSystemDiscoveryType: number;
+  }
+  var IRemoteSystemDiscoveryTypeFilter: abstract new (...args: any[]) => IRemoteSystemDiscoveryTypeFilter;
+
+  interface IRemoteSystemDiscoveryTypeFilterFactory {
+    Create(discoveryType: number): Windows.System.RemoteSystems.RemoteSystemDiscoveryTypeFilter;
+  }
+  var IRemoteSystemDiscoveryTypeFilterFactory: abstract new (...args: any[]) => IRemoteSystemDiscoveryTypeFilterFactory;
+
+  interface IRemoteSystemEnumerationCompletedEventArgs {
+  }
+  var IRemoteSystemEnumerationCompletedEventArgs: abstract new (...args: any[]) => IRemoteSystemEnumerationCompletedEventArgs;
+
+  interface IRemoteSystemFilter {
+  }
+  var IRemoteSystemFilter: abstract new (...args: any[]) => IRemoteSystemFilter;
+
+  interface IRemoteSystemKindFilter {
+    readonly RemoteSystemKinds: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var IRemoteSystemKindFilter: abstract new (...args: any[]) => IRemoteSystemKindFilter;
+
+  interface IRemoteSystemKindFilterFactory {
+    Create(remoteSystemKinds: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.System.RemoteSystems.RemoteSystemKindFilter;
+  }
+  var IRemoteSystemKindFilterFactory: abstract new (...args: any[]) => IRemoteSystemKindFilterFactory;
+
+  interface IRemoteSystemKindStatics {
+    readonly Desktop: string;
+    readonly Holographic: string;
+    readonly Hub: string;
+    readonly Phone: string;
+    readonly Xbox: string;
+  }
+  var IRemoteSystemKindStatics: abstract new (...args: any[]) => IRemoteSystemKindStatics;
+
+  interface IRemoteSystemKindStatics2 {
+    readonly Iot: string;
+    readonly Laptop: string;
+    readonly Tablet: string;
+  }
+  var IRemoteSystemKindStatics2: abstract new (...args: any[]) => IRemoteSystemKindStatics2;
+
+  interface IRemoteSystemRemovedEventArgs {
+    readonly RemoteSystemId: string;
+  }
+  var IRemoteSystemRemovedEventArgs: abstract new (...args: any[]) => IRemoteSystemRemovedEventArgs;
+
+  interface IRemoteSystemSession {
+    CreateParticipantWatcher(): Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher;
+    SendInvitationAsync(invitee: Windows.System.RemoteSystems.RemoteSystem): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly ControllerDisplayName: string;
+    readonly DisplayName: string;
+    readonly Id: string;
+    Disconnected: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSession, Windows.System.RemoteSystems.RemoteSystemSessionDisconnectedEventArgs> | null;
+  }
+  var IRemoteSystemSession: abstract new (...args: any[]) => IRemoteSystemSession;
+
+  interface IRemoteSystemSessionAddedEventArgs {
+    readonly SessionInfo: Windows.System.RemoteSystems.RemoteSystemSessionInfo;
+  }
+  var IRemoteSystemSessionAddedEventArgs: abstract new (...args: any[]) => IRemoteSystemSessionAddedEventArgs;
+
+  interface IRemoteSystemSessionController {
+    CreateSessionAsync(): Windows.Foundation.IAsyncOperation<Windows.System.RemoteSystems.RemoteSystemSessionCreationResult>;
+    RemoveParticipantAsync(pParticipant: Windows.System.RemoteSystems.RemoteSystemSessionParticipant): Windows.Foundation.IAsyncOperation<boolean>;
+    JoinRequested: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSessionController, Windows.System.RemoteSystems.RemoteSystemSessionJoinRequestedEventArgs> | null;
+  }
+  var IRemoteSystemSessionController: abstract new (...args: any[]) => IRemoteSystemSessionController;
+
+  interface IRemoteSystemSessionControllerFactory {
+    CreateController(displayName: string): Windows.System.RemoteSystems.RemoteSystemSessionController;
+    CreateController(displayName: string, options: Windows.System.RemoteSystems.RemoteSystemSessionOptions): Windows.System.RemoteSystems.RemoteSystemSessionController;
+  }
+  var IRemoteSystemSessionControllerFactory: abstract new (...args: any[]) => IRemoteSystemSessionControllerFactory;
+
+  interface IRemoteSystemSessionCreationResult {
+    readonly Session: Windows.System.RemoteSystems.RemoteSystemSession;
+    readonly Status: number;
+  }
+  var IRemoteSystemSessionCreationResult: abstract new (...args: any[]) => IRemoteSystemSessionCreationResult;
+
+  interface IRemoteSystemSessionDisconnectedEventArgs {
+    readonly Reason: number;
+  }
+  var IRemoteSystemSessionDisconnectedEventArgs: abstract new (...args: any[]) => IRemoteSystemSessionDisconnectedEventArgs;
+
+  interface IRemoteSystemSessionInfo {
+    JoinAsync(): Windows.Foundation.IAsyncOperation<Windows.System.RemoteSystems.RemoteSystemSessionJoinResult>;
+    readonly ControllerDisplayName: string;
+    readonly DisplayName: string;
+  }
+  var IRemoteSystemSessionInfo: abstract new (...args: any[]) => IRemoteSystemSessionInfo;
+
+  interface IRemoteSystemSessionInvitation {
+    readonly Sender: Windows.System.RemoteSystems.RemoteSystem;
+    readonly SessionInfo: Windows.System.RemoteSystems.RemoteSystemSessionInfo;
+  }
+  var IRemoteSystemSessionInvitation: abstract new (...args: any[]) => IRemoteSystemSessionInvitation;
+
+  interface IRemoteSystemSessionInvitationListener {
+    InvitationReceived: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSessionInvitationListener, Windows.System.RemoteSystems.RemoteSystemSessionInvitationReceivedEventArgs> | null;
+  }
+  var IRemoteSystemSessionInvitationListener: abstract new (...args: any[]) => IRemoteSystemSessionInvitationListener;
+
+  interface IRemoteSystemSessionInvitationReceivedEventArgs {
+    readonly Invitation: Windows.System.RemoteSystems.RemoteSystemSessionInvitation;
+  }
+  var IRemoteSystemSessionInvitationReceivedEventArgs: abstract new (...args: any[]) => IRemoteSystemSessionInvitationReceivedEventArgs;
+
+  interface IRemoteSystemSessionJoinRequest {
+    Accept(): void;
+    readonly Participant: Windows.System.RemoteSystems.RemoteSystemSessionParticipant;
+  }
+  var IRemoteSystemSessionJoinRequest: abstract new (...args: any[]) => IRemoteSystemSessionJoinRequest;
+
+  interface IRemoteSystemSessionJoinRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly JoinRequest: Windows.System.RemoteSystems.RemoteSystemSessionJoinRequest;
+  }
+  var IRemoteSystemSessionJoinRequestedEventArgs: abstract new (...args: any[]) => IRemoteSystemSessionJoinRequestedEventArgs;
+
+  interface IRemoteSystemSessionJoinResult {
+    readonly Session: Windows.System.RemoteSystems.RemoteSystemSession;
+    readonly Status: number;
+  }
+  var IRemoteSystemSessionJoinResult: abstract new (...args: any[]) => IRemoteSystemSessionJoinResult;
+
+  interface IRemoteSystemSessionMessageChannel {
+    BroadcastValueSetAsync(messageData: Windows.Foundation.Collections.ValueSet): Windows.Foundation.IAsyncOperation<boolean>;
+    SendValueSetAsync(messageData: Windows.Foundation.Collections.ValueSet, participant: Windows.System.RemoteSystems.RemoteSystemSessionParticipant): Windows.Foundation.IAsyncOperation<boolean>;
+    SendValueSetToParticipantsAsync(messageData: Windows.Foundation.Collections.ValueSet, participants: Windows.Foundation.Collections.IIterable<Windows.System.RemoteSystems.RemoteSystemSessionParticipant> | Windows.System.RemoteSystems.RemoteSystemSessionParticipant[]): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Session: Windows.System.RemoteSystems.RemoteSystemSession;
+    ValueSetReceived: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel, Windows.System.RemoteSystems.RemoteSystemSessionValueSetReceivedEventArgs> | null;
+  }
+  var IRemoteSystemSessionMessageChannel: abstract new (...args: any[]) => IRemoteSystemSessionMessageChannel;
+
+  interface IRemoteSystemSessionMessageChannelFactory {
+    Create(session: Windows.System.RemoteSystems.RemoteSystemSession, channelName: string): Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel;
+    Create(session: Windows.System.RemoteSystems.RemoteSystemSession, channelName: string, reliability: number): Windows.System.RemoteSystems.RemoteSystemSessionMessageChannel;
+  }
+  var IRemoteSystemSessionMessageChannelFactory: abstract new (...args: any[]) => IRemoteSystemSessionMessageChannelFactory;
+
+  interface IRemoteSystemSessionOptions {
+    IsInviteOnly: boolean;
+  }
+  var IRemoteSystemSessionOptions: abstract new (...args: any[]) => IRemoteSystemSessionOptions;
+
+  interface IRemoteSystemSessionParticipant {
+    GetHostNames(): Windows.Foundation.Collections.IVectorView<Windows.Networking.HostName> | Windows.Networking.HostName[];
+    readonly RemoteSystem: Windows.System.RemoteSystems.RemoteSystem;
+  }
+  var IRemoteSystemSessionParticipant: abstract new (...args: any[]) => IRemoteSystemSessionParticipant;
+
+  interface IRemoteSystemSessionParticipantAddedEventArgs {
+    readonly Participant: Windows.System.RemoteSystems.RemoteSystemSessionParticipant;
+  }
+  var IRemoteSystemSessionParticipantAddedEventArgs: abstract new (...args: any[]) => IRemoteSystemSessionParticipantAddedEventArgs;
+
+  interface IRemoteSystemSessionParticipantRemovedEventArgs {
+    readonly Participant: Windows.System.RemoteSystems.RemoteSystemSessionParticipant;
+  }
+  var IRemoteSystemSessionParticipantRemovedEventArgs: abstract new (...args: any[]) => IRemoteSystemSessionParticipantRemovedEventArgs;
+
+  interface IRemoteSystemSessionParticipantWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher, Windows.System.RemoteSystems.RemoteSystemSessionParticipantAddedEventArgs> | null;
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher, Object> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSessionParticipantWatcher, Windows.System.RemoteSystems.RemoteSystemSessionParticipantRemovedEventArgs> | null;
+  }
+  var IRemoteSystemSessionParticipantWatcher: abstract new (...args: any[]) => IRemoteSystemSessionParticipantWatcher;
+
+  interface IRemoteSystemSessionRemovedEventArgs {
+    readonly SessionInfo: Windows.System.RemoteSystems.RemoteSystemSessionInfo;
+  }
+  var IRemoteSystemSessionRemovedEventArgs: abstract new (...args: any[]) => IRemoteSystemSessionRemovedEventArgs;
+
+  interface IRemoteSystemSessionStatics {
+    CreateWatcher(): Windows.System.RemoteSystems.RemoteSystemSessionWatcher;
+  }
+  var IRemoteSystemSessionStatics: abstract new (...args: any[]) => IRemoteSystemSessionStatics;
+
+  interface IRemoteSystemSessionUpdatedEventArgs {
+    readonly SessionInfo: Windows.System.RemoteSystems.RemoteSystemSessionInfo;
+  }
+  var IRemoteSystemSessionUpdatedEventArgs: abstract new (...args: any[]) => IRemoteSystemSessionUpdatedEventArgs;
+
+  interface IRemoteSystemSessionValueSetReceivedEventArgs {
+    readonly Message: Windows.Foundation.Collections.ValueSet;
+    readonly Sender: Windows.System.RemoteSystems.RemoteSystemSessionParticipant;
+  }
+  var IRemoteSystemSessionValueSetReceivedEventArgs: abstract new (...args: any[]) => IRemoteSystemSessionValueSetReceivedEventArgs;
+
+  interface IRemoteSystemSessionWatcher {
+    Start(): void;
+    Stop(): void;
+    readonly Status: number;
+    Added: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSessionWatcher, Windows.System.RemoteSystems.RemoteSystemSessionAddedEventArgs> | null;
+    Removed: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSessionWatcher, Windows.System.RemoteSystems.RemoteSystemSessionRemovedEventArgs> | null;
+    Updated: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemSessionWatcher, Windows.System.RemoteSystems.RemoteSystemSessionUpdatedEventArgs> | null;
+  }
+  var IRemoteSystemSessionWatcher: abstract new (...args: any[]) => IRemoteSystemSessionWatcher;
+
+  interface IRemoteSystemStatics {
+    CreateWatcher(): Windows.System.RemoteSystems.RemoteSystemWatcher;
+    CreateWatcher(filters: Windows.Foundation.Collections.IIterable<Windows.System.RemoteSystems.IRemoteSystemFilter> | Windows.System.RemoteSystems.IRemoteSystemFilter[]): Windows.System.RemoteSystems.RemoteSystemWatcher;
+    FindByHostNameAsync(hostName: Windows.Networking.HostName): Windows.Foundation.IAsyncOperation<Windows.System.RemoteSystems.RemoteSystem>;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IRemoteSystemStatics: abstract new (...args: any[]) => IRemoteSystemStatics;
+
+  interface IRemoteSystemStatics2 {
+    IsAuthorizationKindEnabled(kind: number): boolean;
+  }
+  var IRemoteSystemStatics2: abstract new (...args: any[]) => IRemoteSystemStatics2;
+
+  interface IRemoteSystemStatics3 {
+    CreateWatcherForUser(user: Windows.System.User): Windows.System.RemoteSystems.RemoteSystemWatcher;
+    CreateWatcherForUser(user: Windows.System.User, filters: Windows.Foundation.Collections.IIterable<Windows.System.RemoteSystems.IRemoteSystemFilter> | Windows.System.RemoteSystems.IRemoteSystemFilter[]): Windows.System.RemoteSystems.RemoteSystemWatcher;
+  }
+  var IRemoteSystemStatics3: abstract new (...args: any[]) => IRemoteSystemStatics3;
+
+  interface IRemoteSystemStatusTypeFilter {
+    readonly RemoteSystemStatusType: number;
+  }
+  var IRemoteSystemStatusTypeFilter: abstract new (...args: any[]) => IRemoteSystemStatusTypeFilter;
+
+  interface IRemoteSystemStatusTypeFilterFactory {
+    Create(remoteSystemStatusType: number): Windows.System.RemoteSystems.RemoteSystemStatusTypeFilter;
+  }
+  var IRemoteSystemStatusTypeFilterFactory: abstract new (...args: any[]) => IRemoteSystemStatusTypeFilterFactory;
+
+  interface IRemoteSystemUpdatedEventArgs {
+    readonly RemoteSystem: Windows.System.RemoteSystems.RemoteSystem;
+  }
+  var IRemoteSystemUpdatedEventArgs: abstract new (...args: any[]) => IRemoteSystemUpdatedEventArgs;
+
+  interface IRemoteSystemWatcher {
+    Start(): void;
+    Stop(): void;
+    RemoteSystemAdded: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemWatcher, Windows.System.RemoteSystems.RemoteSystemAddedEventArgs> | null;
+    RemoteSystemRemoved: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemWatcher, Windows.System.RemoteSystems.RemoteSystemRemovedEventArgs> | null;
+    RemoteSystemUpdated: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemWatcher, Windows.System.RemoteSystems.RemoteSystemUpdatedEventArgs> | null;
+  }
+  var IRemoteSystemWatcher: abstract new (...args: any[]) => IRemoteSystemWatcher;
+
+  interface IRemoteSystemWatcher2 {
+    EnumerationCompleted: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemWatcher, Windows.System.RemoteSystems.RemoteSystemEnumerationCompletedEventArgs> | null;
+    ErrorOccurred: Windows.Foundation.TypedEventHandler<Windows.System.RemoteSystems.RemoteSystemWatcher, Windows.System.RemoteSystems.RemoteSystemWatcherErrorOccurredEventArgs> | null;
+  }
+  var IRemoteSystemWatcher2: abstract new (...args: any[]) => IRemoteSystemWatcher2;
+
+  interface IRemoteSystemWatcher3 {
+    readonly User: Windows.System.User;
+  }
+  var IRemoteSystemWatcher3: abstract new (...args: any[]) => IRemoteSystemWatcher3;
+
+  interface IRemoteSystemWatcherErrorOccurredEventArgs {
+    readonly Error: number;
+  }
+  var IRemoteSystemWatcherErrorOccurredEventArgs: abstract new (...args: any[]) => IRemoteSystemWatcherErrorOccurredEventArgs;
+
+  interface IRemoteSystemWebAccountFilter {
+    readonly Account: Windows.Security.Credentials.WebAccount;
+  }
+  var IRemoteSystemWebAccountFilter: abstract new (...args: any[]) => IRemoteSystemWebAccountFilter;
+
+  interface IRemoteSystemWebAccountFilterFactory {
+    Create(account: Windows.Security.Credentials.WebAccount): Windows.System.RemoteSystems.RemoteSystemWebAccountFilter;
+  }
+  var IRemoteSystemWebAccountFilterFactory: abstract new (...args: any[]) => IRemoteSystemWebAccountFilterFactory;
+
+}
+
+declare namespace Windows.System.Threading {
+  class ThreadPool {
+    static RunAsync(handler: Windows.System.Threading.WorkItemHandler): Windows.Foundation.IAsyncAction;
+    static RunAsync(handler: Windows.System.Threading.WorkItemHandler, priority: number): Windows.Foundation.IAsyncAction;
+    static RunAsync(handler: Windows.System.Threading.WorkItemHandler, priority: number, options: number): Windows.Foundation.IAsyncAction;
+  }
+
+  class ThreadPoolTimer implements Windows.System.Threading.IThreadPoolTimer {
+    Cancel(): void;
+    static CreatePeriodicTimer(handler: Windows.System.Threading.TimerElapsedHandler, period: Windows.Foundation.TimeSpan): Windows.System.Threading.ThreadPoolTimer;
+    static CreatePeriodicTimer(handler: Windows.System.Threading.TimerElapsedHandler, period: Windows.Foundation.TimeSpan, destroyed: Windows.System.Threading.TimerDestroyedHandler): Windows.System.Threading.ThreadPoolTimer;
+    static CreateTimer(handler: Windows.System.Threading.TimerElapsedHandler, delay: Windows.Foundation.TimeSpan): Windows.System.Threading.ThreadPoolTimer;
+    static CreateTimer(handler: Windows.System.Threading.TimerElapsedHandler, delay: Windows.Foundation.TimeSpan, destroyed: Windows.System.Threading.TimerDestroyedHandler): Windows.System.Threading.ThreadPoolTimer;
+    readonly Delay: Windows.Foundation.TimeSpan;
+    readonly Period: Windows.Foundation.TimeSpan;
+  }
+
+  enum WorkItemOptions {
+    None = 0,
+    TimeSliced = 1,
+  }
+
+  enum WorkItemPriority {
+    Low = -1,
+    Normal = 0,
+    High = 1,
+  }
+
+  interface IThreadPoolStatics {
+    RunAsync(handler: Windows.System.Threading.WorkItemHandler): Windows.Foundation.IAsyncAction;
+    RunAsync(handler: Windows.System.Threading.WorkItemHandler, priority: number): Windows.Foundation.IAsyncAction;
+    RunAsync(handler: Windows.System.Threading.WorkItemHandler, priority: number, options: number): Windows.Foundation.IAsyncAction;
+  }
+  var IThreadPoolStatics: abstract new (...args: any[]) => IThreadPoolStatics;
+
+  interface IThreadPoolTimer {
+    Cancel(): void;
+    readonly Delay: Windows.Foundation.TimeSpan;
+    readonly Period: Windows.Foundation.TimeSpan;
+  }
+  var IThreadPoolTimer: abstract new (...args: any[]) => IThreadPoolTimer;
+
+  interface IThreadPoolTimerStatics {
+    CreatePeriodicTimer(handler: Windows.System.Threading.TimerElapsedHandler, period: Windows.Foundation.TimeSpan): Windows.System.Threading.ThreadPoolTimer;
+    CreatePeriodicTimer(handler: Windows.System.Threading.TimerElapsedHandler, period: Windows.Foundation.TimeSpan, destroyed: Windows.System.Threading.TimerDestroyedHandler): Windows.System.Threading.ThreadPoolTimer;
+    CreateTimer(handler: Windows.System.Threading.TimerElapsedHandler, delay: Windows.Foundation.TimeSpan): Windows.System.Threading.ThreadPoolTimer;
+    CreateTimer(handler: Windows.System.Threading.TimerElapsedHandler, delay: Windows.Foundation.TimeSpan, destroyed: Windows.System.Threading.TimerDestroyedHandler): Windows.System.Threading.ThreadPoolTimer;
+  }
+  var IThreadPoolTimerStatics: abstract new (...args: any[]) => IThreadPoolTimerStatics;
+
+  interface TimerDestroyedHandler {
+    (timer: Windows.System.Threading.ThreadPoolTimer): void;
+  }
+  var TimerDestroyedHandler: {
+    new(callback: (timer: Windows.System.Threading.ThreadPoolTimer) => void): TimerDestroyedHandler;
+  };
+
+  interface TimerElapsedHandler {
+    (timer: Windows.System.Threading.ThreadPoolTimer): void;
+  }
+  var TimerElapsedHandler: {
+    new(callback: (timer: Windows.System.Threading.ThreadPoolTimer) => void): TimerElapsedHandler;
+  };
+
+  interface WorkItemHandler {
+    (operation: Windows.Foundation.IAsyncAction): void;
+  }
+  var WorkItemHandler: {
+    new(callback: (operation: Windows.Foundation.IAsyncAction) => void): WorkItemHandler;
+  };
+
+}
+
+declare namespace Windows.System.Threading.Core {
+  class PreallocatedWorkItem implements Windows.System.Threading.Core.IPreallocatedWorkItem {
+    constructor(handler: Windows.System.Threading.WorkItemHandler);
+    constructor(handler: Windows.System.Threading.WorkItemHandler, priority: number);
+    constructor(handler: Windows.System.Threading.WorkItemHandler, priority: number, options: number);
+    RunAsync(): Windows.Foundation.IAsyncAction;
+  }
+
+  class SignalNotifier implements Windows.System.Threading.Core.ISignalNotifier {
+    static AttachToEvent(name: string, handler: Windows.System.Threading.Core.SignalHandler): Windows.System.Threading.Core.SignalNotifier;
+    static AttachToEvent(name: string, handler: Windows.System.Threading.Core.SignalHandler, timeout: Windows.Foundation.TimeSpan): Windows.System.Threading.Core.SignalNotifier;
+    static AttachToSemaphore(name: string, handler: Windows.System.Threading.Core.SignalHandler): Windows.System.Threading.Core.SignalNotifier;
+    static AttachToSemaphore(name: string, handler: Windows.System.Threading.Core.SignalHandler, timeout: Windows.Foundation.TimeSpan): Windows.System.Threading.Core.SignalNotifier;
+    Enable(): void;
+    Terminate(): void;
+  }
+
+  interface IPreallocatedWorkItem {
+    RunAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var IPreallocatedWorkItem: abstract new (...args: any[]) => IPreallocatedWorkItem;
+
+  interface IPreallocatedWorkItemFactory {
+    CreateWorkItem(handler: Windows.System.Threading.WorkItemHandler): Windows.System.Threading.Core.PreallocatedWorkItem;
+    CreateWorkItemWithPriority(handler: Windows.System.Threading.WorkItemHandler, priority: number): Windows.System.Threading.Core.PreallocatedWorkItem;
+    CreateWorkItemWithPriorityAndOptions(handler: Windows.System.Threading.WorkItemHandler, priority: number, options: number): Windows.System.Threading.Core.PreallocatedWorkItem;
+  }
+  var IPreallocatedWorkItemFactory: abstract new (...args: any[]) => IPreallocatedWorkItemFactory;
+
+  interface ISignalNotifier {
+    Enable(): void;
+    Terminate(): void;
+  }
+  var ISignalNotifier: abstract new (...args: any[]) => ISignalNotifier;
+
+  interface ISignalNotifierStatics {
+    AttachToEvent(name: string, handler: Windows.System.Threading.Core.SignalHandler): Windows.System.Threading.Core.SignalNotifier;
+    AttachToEvent(name: string, handler: Windows.System.Threading.Core.SignalHandler, timeout: Windows.Foundation.TimeSpan): Windows.System.Threading.Core.SignalNotifier;
+    AttachToSemaphore(name: string, handler: Windows.System.Threading.Core.SignalHandler): Windows.System.Threading.Core.SignalNotifier;
+    AttachToSemaphore(name: string, handler: Windows.System.Threading.Core.SignalHandler, timeout: Windows.Foundation.TimeSpan): Windows.System.Threading.Core.SignalNotifier;
+  }
+  var ISignalNotifierStatics: abstract new (...args: any[]) => ISignalNotifierStatics;
+
+  interface SignalHandler {
+    (signalNotifier: Windows.System.Threading.Core.SignalNotifier, timedOut: boolean): void;
+  }
+  var SignalHandler: {
+    new(callback: (signalNotifier: Windows.System.Threading.Core.SignalNotifier, timedOut: boolean) => void): SignalHandler;
+  };
+
+}
+
+declare namespace Windows.System.Update {
+  class SystemUpdateItem implements Windows.System.Update.ISystemUpdateItem {
+    readonly Description: string;
+    readonly DownloadProgress: number;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Id: string;
+    readonly InstallProgress: number;
+    readonly Revision: number;
+    readonly State: number;
+    readonly Title: string;
+  }
+
+  class SystemUpdateLastErrorInfo implements Windows.System.Update.ISystemUpdateLastErrorInfo {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly IsInteractive: boolean;
+    readonly State: number;
+  }
+
+  class SystemUpdateManager {
+    static BlockAutomaticRebootAsync(lockId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    static GetAutomaticRebootBlockIds(): Windows.Foundation.Collections.IVectorView<string> | string[];
+    static GetFlightRing(): string;
+    static GetUpdateItems(): Windows.Foundation.Collections.IVectorView<Windows.System.Update.SystemUpdateItem> | Windows.System.Update.SystemUpdateItem[];
+    static IsSupported(): boolean;
+    static RebootToCompleteInstall(): void;
+    static SetFlightRing(flightRing: string): boolean;
+    static StartCancelUpdates(): void;
+    static StartInstall(action: number): void;
+    static TrySetUserActiveHours(start: Windows.Foundation.TimeSpan, end: Windows.Foundation.TimeSpan): boolean;
+    static UnblockAutomaticRebootAsync(lockId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    static readonly AttentionRequiredReason: number;
+    static readonly DownloadProgress: number;
+    static readonly ExtendedError: Windows.Foundation.HResult;
+    static readonly InstallProgress: number;
+    static readonly LastErrorInfo: Windows.System.Update.SystemUpdateLastErrorInfo;
+    static readonly LastUpdateCheckTime: Windows.Foundation.DateTime;
+    static readonly LastUpdateInstallTime: Windows.Foundation.DateTime;
+    static readonly State: number;
+    static readonly UserActiveHoursEnd: Windows.Foundation.TimeSpan;
+    static readonly UserActiveHoursMax: number;
+    static readonly UserActiveHoursStart: Windows.Foundation.TimeSpan;
+    static StateChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  enum SystemUpdateAttentionRequiredReason {
+    None = 0,
+    NetworkRequired = 1,
+    InsufficientDiskSpace = 2,
+    InsufficientBattery = 3,
+    UpdateBlocked = 4,
+  }
+
+  enum SystemUpdateItemState {
+    NotStarted = 0,
+    Initializing = 1,
+    Preparing = 2,
+    Calculating = 3,
+    Downloading = 4,
+    Installing = 5,
+    Completed = 6,
+    RebootRequired = 7,
+    Error = 8,
+  }
+
+  enum SystemUpdateManagerState {
+    Idle = 0,
+    Detecting = 1,
+    ReadyToDownload = 2,
+    Downloading = 3,
+    ReadyToInstall = 4,
+    Installing = 5,
+    RebootRequired = 6,
+    ReadyToFinalize = 7,
+    Finalizing = 8,
+    Completed = 9,
+    AttentionRequired = 10,
+    Error = 11,
+  }
+
+  enum SystemUpdateStartInstallAction {
+    UpToReboot = 0,
+    AllowReboot = 1,
+  }
+
+  interface ISystemUpdateItem {
+    readonly Description: string;
+    readonly DownloadProgress: number;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Id: string;
+    readonly InstallProgress: number;
+    readonly Revision: number;
+    readonly State: number;
+    readonly Title: string;
+  }
+  var ISystemUpdateItem: abstract new (...args: any[]) => ISystemUpdateItem;
+
+  interface ISystemUpdateLastErrorInfo {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly IsInteractive: boolean;
+    readonly State: number;
+  }
+  var ISystemUpdateLastErrorInfo: abstract new (...args: any[]) => ISystemUpdateLastErrorInfo;
+
+  interface ISystemUpdateManagerStatics {
+    BlockAutomaticRebootAsync(lockId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    GetAutomaticRebootBlockIds(): Windows.Foundation.Collections.IVectorView<string> | string[];
+    GetFlightRing(): string;
+    GetUpdateItems(): Windows.Foundation.Collections.IVectorView<Windows.System.Update.SystemUpdateItem> | Windows.System.Update.SystemUpdateItem[];
+    IsSupported(): boolean;
+    RebootToCompleteInstall(): void;
+    SetFlightRing(flightRing: string): boolean;
+    StartCancelUpdates(): void;
+    StartInstall(action: number): void;
+    TrySetUserActiveHours(start: Windows.Foundation.TimeSpan, end: Windows.Foundation.TimeSpan): boolean;
+    UnblockAutomaticRebootAsync(lockId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly AttentionRequiredReason: number;
+    readonly DownloadProgress: number;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly InstallProgress: number;
+    readonly LastErrorInfo: Windows.System.Update.SystemUpdateLastErrorInfo;
+    readonly LastUpdateCheckTime: Windows.Foundation.DateTime;
+    readonly LastUpdateInstallTime: Windows.Foundation.DateTime;
+    readonly State: number;
+    readonly UserActiveHoursEnd: Windows.Foundation.TimeSpan;
+    readonly UserActiveHoursMax: number;
+    readonly UserActiveHoursStart: Windows.Foundation.TimeSpan;
+    StateChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var ISystemUpdateManagerStatics: abstract new (...args: any[]) => ISystemUpdateManagerStatics;
+
+}
+
+declare namespace Windows.System.UserProfile {
+  class AdvertisingManager {
+    static GetForUser(user: Windows.System.User): Windows.System.UserProfile.AdvertisingManagerForUser;
+    static readonly AdvertisingId: string;
+  }
+
+  class AdvertisingManagerForUser implements Windows.System.UserProfile.IAdvertisingManagerForUser {
+    readonly AdvertisingId: string;
+    readonly User: Windows.System.User;
+  }
+
+  class AssignedAccessSettings implements Windows.System.UserProfile.IAssignedAccessSettings {
+    static GetDefault(): Windows.System.UserProfile.AssignedAccessSettings;
+    static GetForUser(user: Windows.System.User): Windows.System.UserProfile.AssignedAccessSettings;
+    readonly IsEnabled: boolean;
+    readonly IsSingleAppKioskMode: boolean;
+    readonly User: Windows.System.User;
+  }
+
+  class DiagnosticsSettings implements Windows.System.UserProfile.IDiagnosticsSettings {
+    static GetDefault(): Windows.System.UserProfile.DiagnosticsSettings;
+    static GetForUser(user: Windows.System.User): Windows.System.UserProfile.DiagnosticsSettings;
+    readonly CanUseDiagnosticsToTailorExperiences: boolean;
+    readonly User: Windows.System.User;
+  }
+
+  class FirstSignInSettings implements Windows.System.UserProfile.IFirstSignInSettings {
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, Object>>;
+    static GetDefault(): Windows.System.UserProfile.FirstSignInSettings;
+    HasKey(key: string): boolean;
+    Lookup(key: string): Object;
+    Split(first: Windows.Foundation.Collections.IMapView<string, Object>, second: Windows.Foundation.Collections.IMapView<string, Object>): void;
+    readonly Size: number;
+  }
+
+  class GlobalizationPreferences {
+    static GetForUser(user: Windows.System.User): Windows.System.UserProfile.GlobalizationPreferencesForUser;
+    static TrySetHomeGeographicRegion(region: string): boolean;
+    static TrySetLanguages(languageTags: Windows.Foundation.Collections.IIterable<string> | string[]): boolean;
+    static readonly Calendars: Windows.Foundation.Collections.IVectorView<string> | string[];
+    static readonly Clocks: Windows.Foundation.Collections.IVectorView<string> | string[];
+    static readonly Currencies: Windows.Foundation.Collections.IVectorView<string> | string[];
+    static readonly HomeGeographicRegion: string;
+    static readonly Languages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    static readonly WeekStartsOn: number;
+  }
+
+  class GlobalizationPreferencesForUser implements Windows.System.UserProfile.IGlobalizationPreferencesForUser {
+    readonly Calendars: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Clocks: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Currencies: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly HomeGeographicRegion: string;
+    readonly Languages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly User: Windows.System.User;
+    readonly WeekStartsOn: number;
+  }
+
+  class LockScreen {
+    static GetImageStream(): Windows.Storage.Streams.IRandomAccessStream;
+    static RequestSetImageFeedAsync(syndicationFeedUri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<number>;
+    static SetImageFileAsync(value: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncAction;
+    static SetImageStreamAsync(value: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    static TryRemoveImageFeed(): boolean;
+    static readonly OriginalImageFile: Windows.Foundation.Uri;
+  }
+
+  class UserInformation {
+    static GetAccountPicture(kind: number): Windows.Storage.IStorageFile;
+    static GetDisplayNameAsync(): Windows.Foundation.IAsyncOperation<string>;
+    static GetDomainNameAsync(): Windows.Foundation.IAsyncOperation<string>;
+    static GetFirstNameAsync(): Windows.Foundation.IAsyncOperation<string>;
+    static GetLastNameAsync(): Windows.Foundation.IAsyncOperation<string>;
+    static GetPrincipalNameAsync(): Windows.Foundation.IAsyncOperation<string>;
+    static GetSessionInitiationProtocolUriAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Uri>;
+    static SetAccountPictureAsync(image: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<number>;
+    static SetAccountPictureFromStreamAsync(image: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<number>;
+    static SetAccountPicturesAsync(smallImage: Windows.Storage.IStorageFile, largeImage: Windows.Storage.IStorageFile, video: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<number>;
+    static SetAccountPicturesFromStreamsAsync(smallImage: Windows.Storage.Streams.IRandomAccessStream, largeImage: Windows.Storage.Streams.IRandomAccessStream, video: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<number>;
+    static readonly AccountPictureChangeEnabled: boolean;
+    static readonly NameAccessAllowed: boolean;
+    static AccountPictureChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class UserProfilePersonalizationSettings implements Windows.System.UserProfile.IUserProfilePersonalizationSettings {
+    static IsSupported(): boolean;
+    TrySetLockScreenImageAsync(imageFile: Windows.Storage.StorageFile): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySetWallpaperImageAsync(imageFile: Windows.Storage.StorageFile): Windows.Foundation.IAsyncOperation<boolean>;
+    static readonly Current: Windows.System.UserProfile.UserProfilePersonalizationSettings;
+  }
+
+  enum AccountPictureKind {
+    SmallImage = 0,
+    LargeImage = 1,
+    Video = 2,
+  }
+
+  enum SetAccountPictureResult {
+    Success = 0,
+    ChangeDisabled = 1,
+    LargeOrDynamicError = 2,
+    VideoFrameSizeError = 3,
+    FileSizeError = 4,
+    Failure = 5,
+  }
+
+  enum SetImageFeedResult {
+    Success = 0,
+    ChangeDisabled = 1,
+    UserCanceled = 2,
+  }
+
+  interface IAdvertisingManagerForUser {
+    readonly AdvertisingId: string;
+    readonly User: Windows.System.User;
+  }
+  var IAdvertisingManagerForUser: abstract new (...args: any[]) => IAdvertisingManagerForUser;
+
+  interface IAdvertisingManagerStatics {
+    readonly AdvertisingId: string;
+  }
+  var IAdvertisingManagerStatics: abstract new (...args: any[]) => IAdvertisingManagerStatics;
+
+  interface IAdvertisingManagerStatics2 {
+    GetForUser(user: Windows.System.User): Windows.System.UserProfile.AdvertisingManagerForUser;
+  }
+  var IAdvertisingManagerStatics2: abstract new (...args: any[]) => IAdvertisingManagerStatics2;
+
+  interface IAssignedAccessSettings {
+    readonly IsEnabled: boolean;
+    readonly IsSingleAppKioskMode: boolean;
+    readonly User: Windows.System.User;
+  }
+  var IAssignedAccessSettings: abstract new (...args: any[]) => IAssignedAccessSettings;
+
+  interface IAssignedAccessSettingsStatics {
+    GetDefault(): Windows.System.UserProfile.AssignedAccessSettings;
+    GetForUser(user: Windows.System.User): Windows.System.UserProfile.AssignedAccessSettings;
+  }
+  var IAssignedAccessSettingsStatics: abstract new (...args: any[]) => IAssignedAccessSettingsStatics;
+
+  interface IDiagnosticsSettings {
+    readonly CanUseDiagnosticsToTailorExperiences: boolean;
+    readonly User: Windows.System.User;
+  }
+  var IDiagnosticsSettings: abstract new (...args: any[]) => IDiagnosticsSettings;
+
+  interface IDiagnosticsSettingsStatics {
+    GetDefault(): Windows.System.UserProfile.DiagnosticsSettings;
+    GetForUser(user: Windows.System.User): Windows.System.UserProfile.DiagnosticsSettings;
+  }
+  var IDiagnosticsSettingsStatics: abstract new (...args: any[]) => IDiagnosticsSettingsStatics;
+
+  interface IFirstSignInSettings {
+  }
+  var IFirstSignInSettings: abstract new (...args: any[]) => IFirstSignInSettings;
+
+  interface IFirstSignInSettingsStatics {
+    GetDefault(): Windows.System.UserProfile.FirstSignInSettings;
+  }
+  var IFirstSignInSettingsStatics: abstract new (...args: any[]) => IFirstSignInSettingsStatics;
+
+  interface IGlobalizationPreferencesForUser {
+    readonly Calendars: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Clocks: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Currencies: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly HomeGeographicRegion: string;
+    readonly Languages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly User: Windows.System.User;
+    readonly WeekStartsOn: number;
+  }
+  var IGlobalizationPreferencesForUser: abstract new (...args: any[]) => IGlobalizationPreferencesForUser;
+
+  interface IGlobalizationPreferencesStatics {
+    readonly Calendars: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Clocks: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Currencies: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly HomeGeographicRegion: string;
+    readonly Languages: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly WeekStartsOn: number;
+  }
+  var IGlobalizationPreferencesStatics: abstract new (...args: any[]) => IGlobalizationPreferencesStatics;
+
+  interface IGlobalizationPreferencesStatics2 {
+    TrySetHomeGeographicRegion(region: string): boolean;
+    TrySetLanguages(languageTags: Windows.Foundation.Collections.IIterable<string> | string[]): boolean;
+  }
+  var IGlobalizationPreferencesStatics2: abstract new (...args: any[]) => IGlobalizationPreferencesStatics2;
+
+  interface IGlobalizationPreferencesStatics3 {
+    GetForUser(user: Windows.System.User): Windows.System.UserProfile.GlobalizationPreferencesForUser;
+  }
+  var IGlobalizationPreferencesStatics3: abstract new (...args: any[]) => IGlobalizationPreferencesStatics3;
+
+  interface ILockScreenImageFeedStatics {
+    RequestSetImageFeedAsync(syndicationFeedUri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<number>;
+    TryRemoveImageFeed(): boolean;
+  }
+  var ILockScreenImageFeedStatics: abstract new (...args: any[]) => ILockScreenImageFeedStatics;
+
+  interface ILockScreenStatics {
+    GetImageStream(): Windows.Storage.Streams.IRandomAccessStream;
+    SetImageFileAsync(value: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncAction;
+    SetImageStreamAsync(value: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    readonly OriginalImageFile: Windows.Foundation.Uri;
+  }
+  var ILockScreenStatics: abstract new (...args: any[]) => ILockScreenStatics;
+
+  interface IUserInformationStatics {
+    GetAccountPicture(kind: number): Windows.Storage.IStorageFile;
+    GetDisplayNameAsync(): Windows.Foundation.IAsyncOperation<string>;
+    GetDomainNameAsync(): Windows.Foundation.IAsyncOperation<string>;
+    GetFirstNameAsync(): Windows.Foundation.IAsyncOperation<string>;
+    GetLastNameAsync(): Windows.Foundation.IAsyncOperation<string>;
+    GetPrincipalNameAsync(): Windows.Foundation.IAsyncOperation<string>;
+    GetSessionInitiationProtocolUriAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Uri>;
+    SetAccountPictureAsync(image: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<number>;
+    SetAccountPictureFromStreamAsync(image: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<number>;
+    SetAccountPicturesAsync(smallImage: Windows.Storage.IStorageFile, largeImage: Windows.Storage.IStorageFile, video: Windows.Storage.IStorageFile): Windows.Foundation.IAsyncOperation<number>;
+    SetAccountPicturesFromStreamsAsync(smallImage: Windows.Storage.Streams.IRandomAccessStream, largeImage: Windows.Storage.Streams.IRandomAccessStream, video: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<number>;
+    readonly AccountPictureChangeEnabled: boolean;
+    readonly NameAccessAllowed: boolean;
+    AccountPictureChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IUserInformationStatics: abstract new (...args: any[]) => IUserInformationStatics;
+
+  interface IUserProfilePersonalizationSettings {
+    TrySetLockScreenImageAsync(imageFile: Windows.Storage.StorageFile): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySetWallpaperImageAsync(imageFile: Windows.Storage.StorageFile): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IUserProfilePersonalizationSettings: abstract new (...args: any[]) => IUserProfilePersonalizationSettings;
+
+  interface IUserProfilePersonalizationSettingsStatics {
+    IsSupported(): boolean;
+    readonly Current: Windows.System.UserProfile.UserProfilePersonalizationSettings;
+  }
+  var IUserProfilePersonalizationSettingsStatics: abstract new (...args: any[]) => IUserProfilePersonalizationSettingsStatics;
+
+  interface UserProfileContract {
+  }
+  var UserProfileContract: {
+    new(fields: {  }): UserProfileContract;
+  };
+
+  interface UserProfileLockScreenContract {
+  }
+  var UserProfileLockScreenContract: {
+    new(fields: {  }): UserProfileLockScreenContract;
+  };
+
+}
+
+declare namespace Windows.UI {
+  class ColorHelper implements Windows.UI.IColorHelper {
+    static FromArgb(a: number, r: number, g: number, b: number): Windows.UI.Color;
+    static ToDisplayName(color: Windows.UI.Color): string;
+  }
+
+  class Colors implements Windows.UI.IColors {
+    static readonly AliceBlue: Windows.UI.Color;
+    static readonly AntiqueWhite: Windows.UI.Color;
+    static readonly Aqua: Windows.UI.Color;
+    static readonly Aquamarine: Windows.UI.Color;
+    static readonly Azure: Windows.UI.Color;
+    static readonly Beige: Windows.UI.Color;
+    static readonly Bisque: Windows.UI.Color;
+    static readonly Black: Windows.UI.Color;
+    static readonly BlanchedAlmond: Windows.UI.Color;
+    static readonly Blue: Windows.UI.Color;
+    static readonly BlueViolet: Windows.UI.Color;
+    static readonly Brown: Windows.UI.Color;
+    static readonly BurlyWood: Windows.UI.Color;
+    static readonly CadetBlue: Windows.UI.Color;
+    static readonly Chartreuse: Windows.UI.Color;
+    static readonly Chocolate: Windows.UI.Color;
+    static readonly Coral: Windows.UI.Color;
+    static readonly CornflowerBlue: Windows.UI.Color;
+    static readonly Cornsilk: Windows.UI.Color;
+    static readonly Crimson: Windows.UI.Color;
+    static readonly Cyan: Windows.UI.Color;
+    static readonly DarkBlue: Windows.UI.Color;
+    static readonly DarkCyan: Windows.UI.Color;
+    static readonly DarkGoldenrod: Windows.UI.Color;
+    static readonly DarkGray: Windows.UI.Color;
+    static readonly DarkGreen: Windows.UI.Color;
+    static readonly DarkKhaki: Windows.UI.Color;
+    static readonly DarkMagenta: Windows.UI.Color;
+    static readonly DarkOliveGreen: Windows.UI.Color;
+    static readonly DarkOrange: Windows.UI.Color;
+    static readonly DarkOrchid: Windows.UI.Color;
+    static readonly DarkRed: Windows.UI.Color;
+    static readonly DarkSalmon: Windows.UI.Color;
+    static readonly DarkSeaGreen: Windows.UI.Color;
+    static readonly DarkSlateBlue: Windows.UI.Color;
+    static readonly DarkSlateGray: Windows.UI.Color;
+    static readonly DarkTurquoise: Windows.UI.Color;
+    static readonly DarkViolet: Windows.UI.Color;
+    static readonly DeepPink: Windows.UI.Color;
+    static readonly DeepSkyBlue: Windows.UI.Color;
+    static readonly DimGray: Windows.UI.Color;
+    static readonly DodgerBlue: Windows.UI.Color;
+    static readonly Firebrick: Windows.UI.Color;
+    static readonly FloralWhite: Windows.UI.Color;
+    static readonly ForestGreen: Windows.UI.Color;
+    static readonly Fuchsia: Windows.UI.Color;
+    static readonly Gainsboro: Windows.UI.Color;
+    static readonly GhostWhite: Windows.UI.Color;
+    static readonly Gold: Windows.UI.Color;
+    static readonly Goldenrod: Windows.UI.Color;
+    static readonly Gray: Windows.UI.Color;
+    static readonly Green: Windows.UI.Color;
+    static readonly GreenYellow: Windows.UI.Color;
+    static readonly Honeydew: Windows.UI.Color;
+    static readonly HotPink: Windows.UI.Color;
+    static readonly IndianRed: Windows.UI.Color;
+    static readonly Indigo: Windows.UI.Color;
+    static readonly Ivory: Windows.UI.Color;
+    static readonly Khaki: Windows.UI.Color;
+    static readonly Lavender: Windows.UI.Color;
+    static readonly LavenderBlush: Windows.UI.Color;
+    static readonly LawnGreen: Windows.UI.Color;
+    static readonly LemonChiffon: Windows.UI.Color;
+    static readonly LightBlue: Windows.UI.Color;
+    static readonly LightCoral: Windows.UI.Color;
+    static readonly LightCyan: Windows.UI.Color;
+    static readonly LightGoldenrodYellow: Windows.UI.Color;
+    static readonly LightGray: Windows.UI.Color;
+    static readonly LightGreen: Windows.UI.Color;
+    static readonly LightPink: Windows.UI.Color;
+    static readonly LightSalmon: Windows.UI.Color;
+    static readonly LightSeaGreen: Windows.UI.Color;
+    static readonly LightSkyBlue: Windows.UI.Color;
+    static readonly LightSlateGray: Windows.UI.Color;
+    static readonly LightSteelBlue: Windows.UI.Color;
+    static readonly LightYellow: Windows.UI.Color;
+    static readonly Lime: Windows.UI.Color;
+    static readonly LimeGreen: Windows.UI.Color;
+    static readonly Linen: Windows.UI.Color;
+    static readonly Magenta: Windows.UI.Color;
+    static readonly Maroon: Windows.UI.Color;
+    static readonly MediumAquamarine: Windows.UI.Color;
+    static readonly MediumBlue: Windows.UI.Color;
+    static readonly MediumOrchid: Windows.UI.Color;
+    static readonly MediumPurple: Windows.UI.Color;
+    static readonly MediumSeaGreen: Windows.UI.Color;
+    static readonly MediumSlateBlue: Windows.UI.Color;
+    static readonly MediumSpringGreen: Windows.UI.Color;
+    static readonly MediumTurquoise: Windows.UI.Color;
+    static readonly MediumVioletRed: Windows.UI.Color;
+    static readonly MidnightBlue: Windows.UI.Color;
+    static readonly MintCream: Windows.UI.Color;
+    static readonly MistyRose: Windows.UI.Color;
+    static readonly Moccasin: Windows.UI.Color;
+    static readonly NavajoWhite: Windows.UI.Color;
+    static readonly Navy: Windows.UI.Color;
+    static readonly OldLace: Windows.UI.Color;
+    static readonly Olive: Windows.UI.Color;
+    static readonly OliveDrab: Windows.UI.Color;
+    static readonly Orange: Windows.UI.Color;
+    static readonly OrangeRed: Windows.UI.Color;
+    static readonly Orchid: Windows.UI.Color;
+    static readonly PaleGoldenrod: Windows.UI.Color;
+    static readonly PaleGreen: Windows.UI.Color;
+    static readonly PaleTurquoise: Windows.UI.Color;
+    static readonly PaleVioletRed: Windows.UI.Color;
+    static readonly PapayaWhip: Windows.UI.Color;
+    static readonly PeachPuff: Windows.UI.Color;
+    static readonly Peru: Windows.UI.Color;
+    static readonly Pink: Windows.UI.Color;
+    static readonly Plum: Windows.UI.Color;
+    static readonly PowderBlue: Windows.UI.Color;
+    static readonly Purple: Windows.UI.Color;
+    static readonly Red: Windows.UI.Color;
+    static readonly RosyBrown: Windows.UI.Color;
+    static readonly RoyalBlue: Windows.UI.Color;
+    static readonly SaddleBrown: Windows.UI.Color;
+    static readonly Salmon: Windows.UI.Color;
+    static readonly SandyBrown: Windows.UI.Color;
+    static readonly SeaGreen: Windows.UI.Color;
+    static readonly SeaShell: Windows.UI.Color;
+    static readonly Sienna: Windows.UI.Color;
+    static readonly Silver: Windows.UI.Color;
+    static readonly SkyBlue: Windows.UI.Color;
+    static readonly SlateBlue: Windows.UI.Color;
+    static readonly SlateGray: Windows.UI.Color;
+    static readonly Snow: Windows.UI.Color;
+    static readonly SpringGreen: Windows.UI.Color;
+    static readonly SteelBlue: Windows.UI.Color;
+    static readonly Tan: Windows.UI.Color;
+    static readonly Teal: Windows.UI.Color;
+    static readonly Thistle: Windows.UI.Color;
+    static readonly Tomato: Windows.UI.Color;
+    static readonly Transparent: Windows.UI.Color;
+    static readonly Turquoise: Windows.UI.Color;
+    static readonly Violet: Windows.UI.Color;
+    static readonly Wheat: Windows.UI.Color;
+    static readonly White: Windows.UI.Color;
+    static readonly WhiteSmoke: Windows.UI.Color;
+    static readonly Yellow: Windows.UI.Color;
+    static readonly YellowGreen: Windows.UI.Color;
+  }
+
+  class UIContentRoot implements Windows.UI.IUIContentRoot {
+    readonly UIContext: Windows.UI.UIContext;
+  }
+
+  class UIContext implements Windows.UI.IUIContext {
+  }
+
+  interface Color {
+    A: number;
+    R: number;
+    G: number;
+    B: number;
+  }
+  var Color: {
+    new(a: number, r: number, g: number, b: number): Color;
+    new(fields: { A?: number; R?: number; G?: number; B?: number }): Color;
+  };
+
+  interface IColorHelper {
+  }
+  var IColorHelper: abstract new (...args: any[]) => IColorHelper;
+
+  interface IColorHelperStatics {
+    FromArgb(a: number, r: number, g: number, b: number): Windows.UI.Color;
+  }
+  var IColorHelperStatics: abstract new (...args: any[]) => IColorHelperStatics;
+
+  interface IColorHelperStatics2 {
+    ToDisplayName(color: Windows.UI.Color): string;
+  }
+  var IColorHelperStatics2: abstract new (...args: any[]) => IColorHelperStatics2;
+
+  interface IColors {
+  }
+  var IColors: abstract new (...args: any[]) => IColors;
+
+  interface IColorsStatics {
+    readonly AliceBlue: Windows.UI.Color;
+    readonly AntiqueWhite: Windows.UI.Color;
+    readonly Aqua: Windows.UI.Color;
+    readonly Aquamarine: Windows.UI.Color;
+    readonly Azure: Windows.UI.Color;
+    readonly Beige: Windows.UI.Color;
+    readonly Bisque: Windows.UI.Color;
+    readonly Black: Windows.UI.Color;
+    readonly BlanchedAlmond: Windows.UI.Color;
+    readonly Blue: Windows.UI.Color;
+    readonly BlueViolet: Windows.UI.Color;
+    readonly Brown: Windows.UI.Color;
+    readonly BurlyWood: Windows.UI.Color;
+    readonly CadetBlue: Windows.UI.Color;
+    readonly Chartreuse: Windows.UI.Color;
+    readonly Chocolate: Windows.UI.Color;
+    readonly Coral: Windows.UI.Color;
+    readonly CornflowerBlue: Windows.UI.Color;
+    readonly Cornsilk: Windows.UI.Color;
+    readonly Crimson: Windows.UI.Color;
+    readonly Cyan: Windows.UI.Color;
+    readonly DarkBlue: Windows.UI.Color;
+    readonly DarkCyan: Windows.UI.Color;
+    readonly DarkGoldenrod: Windows.UI.Color;
+    readonly DarkGray: Windows.UI.Color;
+    readonly DarkGreen: Windows.UI.Color;
+    readonly DarkKhaki: Windows.UI.Color;
+    readonly DarkMagenta: Windows.UI.Color;
+    readonly DarkOliveGreen: Windows.UI.Color;
+    readonly DarkOrange: Windows.UI.Color;
+    readonly DarkOrchid: Windows.UI.Color;
+    readonly DarkRed: Windows.UI.Color;
+    readonly DarkSalmon: Windows.UI.Color;
+    readonly DarkSeaGreen: Windows.UI.Color;
+    readonly DarkSlateBlue: Windows.UI.Color;
+    readonly DarkSlateGray: Windows.UI.Color;
+    readonly DarkTurquoise: Windows.UI.Color;
+    readonly DarkViolet: Windows.UI.Color;
+    readonly DeepPink: Windows.UI.Color;
+    readonly DeepSkyBlue: Windows.UI.Color;
+    readonly DimGray: Windows.UI.Color;
+    readonly DodgerBlue: Windows.UI.Color;
+    readonly Firebrick: Windows.UI.Color;
+    readonly FloralWhite: Windows.UI.Color;
+    readonly ForestGreen: Windows.UI.Color;
+    readonly Fuchsia: Windows.UI.Color;
+    readonly Gainsboro: Windows.UI.Color;
+    readonly GhostWhite: Windows.UI.Color;
+    readonly Gold: Windows.UI.Color;
+    readonly Goldenrod: Windows.UI.Color;
+    readonly Gray: Windows.UI.Color;
+    readonly Green: Windows.UI.Color;
+    readonly GreenYellow: Windows.UI.Color;
+    readonly Honeydew: Windows.UI.Color;
+    readonly HotPink: Windows.UI.Color;
+    readonly IndianRed: Windows.UI.Color;
+    readonly Indigo: Windows.UI.Color;
+    readonly Ivory: Windows.UI.Color;
+    readonly Khaki: Windows.UI.Color;
+    readonly Lavender: Windows.UI.Color;
+    readonly LavenderBlush: Windows.UI.Color;
+    readonly LawnGreen: Windows.UI.Color;
+    readonly LemonChiffon: Windows.UI.Color;
+    readonly LightBlue: Windows.UI.Color;
+    readonly LightCoral: Windows.UI.Color;
+    readonly LightCyan: Windows.UI.Color;
+    readonly LightGoldenrodYellow: Windows.UI.Color;
+    readonly LightGray: Windows.UI.Color;
+    readonly LightGreen: Windows.UI.Color;
+    readonly LightPink: Windows.UI.Color;
+    readonly LightSalmon: Windows.UI.Color;
+    readonly LightSeaGreen: Windows.UI.Color;
+    readonly LightSkyBlue: Windows.UI.Color;
+    readonly LightSlateGray: Windows.UI.Color;
+    readonly LightSteelBlue: Windows.UI.Color;
+    readonly LightYellow: Windows.UI.Color;
+    readonly Lime: Windows.UI.Color;
+    readonly LimeGreen: Windows.UI.Color;
+    readonly Linen: Windows.UI.Color;
+    readonly Magenta: Windows.UI.Color;
+    readonly Maroon: Windows.UI.Color;
+    readonly MediumAquamarine: Windows.UI.Color;
+    readonly MediumBlue: Windows.UI.Color;
+    readonly MediumOrchid: Windows.UI.Color;
+    readonly MediumPurple: Windows.UI.Color;
+    readonly MediumSeaGreen: Windows.UI.Color;
+    readonly MediumSlateBlue: Windows.UI.Color;
+    readonly MediumSpringGreen: Windows.UI.Color;
+    readonly MediumTurquoise: Windows.UI.Color;
+    readonly MediumVioletRed: Windows.UI.Color;
+    readonly MidnightBlue: Windows.UI.Color;
+    readonly MintCream: Windows.UI.Color;
+    readonly MistyRose: Windows.UI.Color;
+    readonly Moccasin: Windows.UI.Color;
+    readonly NavajoWhite: Windows.UI.Color;
+    readonly Navy: Windows.UI.Color;
+    readonly OldLace: Windows.UI.Color;
+    readonly Olive: Windows.UI.Color;
+    readonly OliveDrab: Windows.UI.Color;
+    readonly Orange: Windows.UI.Color;
+    readonly OrangeRed: Windows.UI.Color;
+    readonly Orchid: Windows.UI.Color;
+    readonly PaleGoldenrod: Windows.UI.Color;
+    readonly PaleGreen: Windows.UI.Color;
+    readonly PaleTurquoise: Windows.UI.Color;
+    readonly PaleVioletRed: Windows.UI.Color;
+    readonly PapayaWhip: Windows.UI.Color;
+    readonly PeachPuff: Windows.UI.Color;
+    readonly Peru: Windows.UI.Color;
+    readonly Pink: Windows.UI.Color;
+    readonly Plum: Windows.UI.Color;
+    readonly PowderBlue: Windows.UI.Color;
+    readonly Purple: Windows.UI.Color;
+    readonly Red: Windows.UI.Color;
+    readonly RosyBrown: Windows.UI.Color;
+    readonly RoyalBlue: Windows.UI.Color;
+    readonly SaddleBrown: Windows.UI.Color;
+    readonly Salmon: Windows.UI.Color;
+    readonly SandyBrown: Windows.UI.Color;
+    readonly SeaGreen: Windows.UI.Color;
+    readonly SeaShell: Windows.UI.Color;
+    readonly Sienna: Windows.UI.Color;
+    readonly Silver: Windows.UI.Color;
+    readonly SkyBlue: Windows.UI.Color;
+    readonly SlateBlue: Windows.UI.Color;
+    readonly SlateGray: Windows.UI.Color;
+    readonly Snow: Windows.UI.Color;
+    readonly SpringGreen: Windows.UI.Color;
+    readonly SteelBlue: Windows.UI.Color;
+    readonly Tan: Windows.UI.Color;
+    readonly Teal: Windows.UI.Color;
+    readonly Thistle: Windows.UI.Color;
+    readonly Tomato: Windows.UI.Color;
+    readonly Transparent: Windows.UI.Color;
+    readonly Turquoise: Windows.UI.Color;
+    readonly Violet: Windows.UI.Color;
+    readonly Wheat: Windows.UI.Color;
+    readonly White: Windows.UI.Color;
+    readonly WhiteSmoke: Windows.UI.Color;
+    readonly Yellow: Windows.UI.Color;
+    readonly YellowGreen: Windows.UI.Color;
+  }
+  var IColorsStatics: abstract new (...args: any[]) => IColorsStatics;
+
+  interface IUIContentRoot {
+    readonly UIContext: Windows.UI.UIContext;
+  }
+  var IUIContentRoot: abstract new (...args: any[]) => IUIContentRoot;
+
+  interface IUIContext {
+  }
+  var IUIContext: abstract new (...args: any[]) => IUIContext;
+
+  interface WindowId {
+    Value: number | bigint;
+  }
+  var WindowId: {
+    new(value: number | bigint): WindowId;
+    new(fields: { Value?: number | bigint }): WindowId;
+  };
+
+}
+
+declare namespace Windows.UI.Accessibility {
+  class ScreenReaderPositionChangedEventArgs implements Windows.UI.Accessibility.IScreenReaderPositionChangedEventArgs {
+    readonly IsReadingText: boolean;
+    readonly ScreenPositionInRawPixels: Windows.Foundation.Rect;
+  }
+
+  class ScreenReaderService implements Windows.UI.Accessibility.IScreenReaderService {
+    constructor();
+    readonly CurrentScreenReaderPosition: Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs;
+    ScreenReaderPositionChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Accessibility.ScreenReaderService, Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs> | null;
+  }
+
+  interface IScreenReaderPositionChangedEventArgs {
+    readonly IsReadingText: boolean;
+    readonly ScreenPositionInRawPixels: Windows.Foundation.Rect;
+  }
+  var IScreenReaderPositionChangedEventArgs: abstract new (...args: any[]) => IScreenReaderPositionChangedEventArgs;
+
+  interface IScreenReaderService {
+    readonly CurrentScreenReaderPosition: Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs;
+    ScreenReaderPositionChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Accessibility.ScreenReaderService, Windows.UI.Accessibility.ScreenReaderPositionChangedEventArgs> | null;
+  }
+  var IScreenReaderService: abstract new (...args: any[]) => IScreenReaderService;
+
+}
+
+declare namespace Windows.UI.ApplicationSettings {
+  class AccountsSettingsPane implements Windows.UI.ApplicationSettings.IAccountsSettingsPane {
+    static GetForCurrentView(): Windows.UI.ApplicationSettings.AccountsSettingsPane;
+    static Show(): void;
+    static ShowAddAccountAsync(): Windows.Foundation.IAsyncAction;
+    static ShowAddAccountForUserAsync(user: Windows.System.User): Windows.Foundation.IAsyncAction;
+    static ShowManageAccountsAsync(): Windows.Foundation.IAsyncAction;
+    static ShowManageAccountsForUserAsync(user: Windows.System.User): Windows.Foundation.IAsyncAction;
+    AccountCommandsRequested: Windows.Foundation.TypedEventHandler<Windows.UI.ApplicationSettings.AccountsSettingsPane, Windows.UI.ApplicationSettings.AccountsSettingsPaneCommandsRequestedEventArgs> | null;
+  }
+
+  class AccountsSettingsPaneCommandsRequestedEventArgs implements Windows.UI.ApplicationSettings.IAccountsSettingsPaneCommandsRequestedEventArgs, Windows.UI.ApplicationSettings.IAccountsSettingsPaneCommandsRequestedEventArgs2 {
+    GetDeferral(): Windows.UI.ApplicationSettings.AccountsSettingsPaneEventDeferral;
+    readonly Commands: Windows.Foundation.Collections.IVector<Windows.UI.ApplicationSettings.SettingsCommand> | Windows.UI.ApplicationSettings.SettingsCommand[];
+    readonly CredentialCommands: Windows.Foundation.Collections.IVector<Windows.UI.ApplicationSettings.CredentialCommand> | Windows.UI.ApplicationSettings.CredentialCommand[];
+    HeaderText: string;
+    readonly User: Windows.System.User;
+    readonly WebAccountCommands: Windows.Foundation.Collections.IVector<Windows.UI.ApplicationSettings.WebAccountCommand> | Windows.UI.ApplicationSettings.WebAccountCommand[];
+    readonly WebAccountProviderCommands: Windows.Foundation.Collections.IVector<Windows.UI.ApplicationSettings.WebAccountProviderCommand> | Windows.UI.ApplicationSettings.WebAccountProviderCommand[];
+  }
+
+  class AccountsSettingsPaneEventDeferral implements Windows.UI.ApplicationSettings.IAccountsSettingsPaneEventDeferral {
+    Complete(): void;
+  }
+
+  class CredentialCommand implements Windows.UI.ApplicationSettings.ICredentialCommand {
+    constructor(passwordCredential: Windows.Security.Credentials.PasswordCredential);
+    constructor(passwordCredential: Windows.Security.Credentials.PasswordCredential, deleted: Windows.UI.ApplicationSettings.CredentialCommandCredentialDeletedHandler);
+    readonly CredentialDeleted: Windows.UI.ApplicationSettings.CredentialCommandCredentialDeletedHandler;
+    readonly PasswordCredential: Windows.Security.Credentials.PasswordCredential;
+  }
+
+  class SettingsCommand implements Windows.UI.Popups.IUICommand {
+    constructor(settingsCommandId: Object, label: string, handler: Windows.UI.Popups.UICommandInvokedHandler);
+    static readonly AccountsCommand: Windows.UI.ApplicationSettings.SettingsCommand;
+    Id: Object;
+    Invoked: Windows.UI.Popups.UICommandInvokedHandler;
+    Label: string;
+  }
+
+  class SettingsPane implements Windows.UI.ApplicationSettings.ISettingsPane {
+    static GetForCurrentView(): Windows.UI.ApplicationSettings.SettingsPane;
+    static Show(): void;
+    static readonly Edge: number;
+    CommandsRequested: Windows.Foundation.TypedEventHandler<Windows.UI.ApplicationSettings.SettingsPane, Windows.UI.ApplicationSettings.SettingsPaneCommandsRequestedEventArgs> | null;
+  }
+
+  class SettingsPaneCommandsRequest implements Windows.UI.ApplicationSettings.ISettingsPaneCommandsRequest {
+    readonly ApplicationCommands: Windows.Foundation.Collections.IVector<Windows.UI.ApplicationSettings.SettingsCommand> | Windows.UI.ApplicationSettings.SettingsCommand[];
+  }
+
+  class SettingsPaneCommandsRequestedEventArgs implements Windows.UI.ApplicationSettings.ISettingsPaneCommandsRequestedEventArgs {
+    readonly Request: Windows.UI.ApplicationSettings.SettingsPaneCommandsRequest;
+  }
+
+  class WebAccountCommand implements Windows.UI.ApplicationSettings.IWebAccountCommand {
+    constructor(webAccount: Windows.Security.Credentials.WebAccount, invoked: Windows.UI.ApplicationSettings.WebAccountCommandInvokedHandler, actions: number);
+    readonly Actions: number;
+    readonly Invoked: Windows.UI.ApplicationSettings.WebAccountCommandInvokedHandler;
+    readonly WebAccount: Windows.Security.Credentials.WebAccount;
+  }
+
+  class WebAccountInvokedArgs implements Windows.UI.ApplicationSettings.IWebAccountInvokedArgs {
+    readonly Action: number;
+  }
+
+  class WebAccountProviderCommand implements Windows.UI.ApplicationSettings.IWebAccountProviderCommand {
+    constructor(webAccountProvider: Windows.Security.Credentials.WebAccountProvider, invoked: Windows.UI.ApplicationSettings.WebAccountProviderCommandInvokedHandler);
+    readonly Invoked: Windows.UI.ApplicationSettings.WebAccountProviderCommandInvokedHandler;
+    readonly WebAccountProvider: Windows.Security.Credentials.WebAccountProvider;
+  }
+
+  enum SettingsEdgeLocation {
+    Right = 0,
+    Left = 1,
+  }
+
+  enum SupportedWebAccountActions {
+    None = 0,
+    Reconnect = 1,
+    Remove = 2,
+    ViewDetails = 4,
+    Manage = 8,
+    More = 16,
+  }
+
+  enum WebAccountAction {
+    Reconnect = 0,
+    Remove = 1,
+    ViewDetails = 2,
+    Manage = 3,
+    More = 4,
+  }
+
+  interface ApplicationsSettingsContract {
+  }
+  var ApplicationsSettingsContract: {
+    new(fields: {  }): ApplicationsSettingsContract;
+  };
+
+  interface CredentialCommandCredentialDeletedHandler {
+    (command: Windows.UI.ApplicationSettings.CredentialCommand): void;
+  }
+  var CredentialCommandCredentialDeletedHandler: {
+    new(callback: (command: Windows.UI.ApplicationSettings.CredentialCommand) => void): CredentialCommandCredentialDeletedHandler;
+  };
+
+  interface IAccountsSettingsPane {
+    AccountCommandsRequested: Windows.Foundation.TypedEventHandler<Windows.UI.ApplicationSettings.AccountsSettingsPane, Windows.UI.ApplicationSettings.AccountsSettingsPaneCommandsRequestedEventArgs> | null;
+  }
+  var IAccountsSettingsPane: abstract new (...args: any[]) => IAccountsSettingsPane;
+
+  interface IAccountsSettingsPaneCommandsRequestedEventArgs {
+    GetDeferral(): Windows.UI.ApplicationSettings.AccountsSettingsPaneEventDeferral;
+    readonly Commands: Windows.Foundation.Collections.IVector<Windows.UI.ApplicationSettings.SettingsCommand> | Windows.UI.ApplicationSettings.SettingsCommand[];
+    readonly CredentialCommands: Windows.Foundation.Collections.IVector<Windows.UI.ApplicationSettings.CredentialCommand> | Windows.UI.ApplicationSettings.CredentialCommand[];
+    HeaderText: string;
+    readonly WebAccountCommands: Windows.Foundation.Collections.IVector<Windows.UI.ApplicationSettings.WebAccountCommand> | Windows.UI.ApplicationSettings.WebAccountCommand[];
+    readonly WebAccountProviderCommands: Windows.Foundation.Collections.IVector<Windows.UI.ApplicationSettings.WebAccountProviderCommand> | Windows.UI.ApplicationSettings.WebAccountProviderCommand[];
+  }
+  var IAccountsSettingsPaneCommandsRequestedEventArgs: abstract new (...args: any[]) => IAccountsSettingsPaneCommandsRequestedEventArgs;
+
+  interface IAccountsSettingsPaneCommandsRequestedEventArgs2 {
+    readonly User: Windows.System.User;
+  }
+  var IAccountsSettingsPaneCommandsRequestedEventArgs2: abstract new (...args: any[]) => IAccountsSettingsPaneCommandsRequestedEventArgs2;
+
+  interface IAccountsSettingsPaneEventDeferral {
+    Complete(): void;
+  }
+  var IAccountsSettingsPaneEventDeferral: abstract new (...args: any[]) => IAccountsSettingsPaneEventDeferral;
+
+  interface IAccountsSettingsPaneStatics {
+    GetForCurrentView(): Windows.UI.ApplicationSettings.AccountsSettingsPane;
+    Show(): void;
+  }
+  var IAccountsSettingsPaneStatics: abstract new (...args: any[]) => IAccountsSettingsPaneStatics;
+
+  interface IAccountsSettingsPaneStatics2 extends Windows.UI.ApplicationSettings.IAccountsSettingsPaneStatics {
+    GetForCurrentView(): Windows.UI.ApplicationSettings.AccountsSettingsPane;
+    Show(): void;
+    ShowAddAccountAsync(): Windows.Foundation.IAsyncAction;
+    ShowManageAccountsAsync(): Windows.Foundation.IAsyncAction;
+  }
+  var IAccountsSettingsPaneStatics2: abstract new (...args: any[]) => IAccountsSettingsPaneStatics2;
+
+  interface IAccountsSettingsPaneStatics3 {
+    ShowAddAccountForUserAsync(user: Windows.System.User): Windows.Foundation.IAsyncAction;
+    ShowManageAccountsForUserAsync(user: Windows.System.User): Windows.Foundation.IAsyncAction;
+  }
+  var IAccountsSettingsPaneStatics3: abstract new (...args: any[]) => IAccountsSettingsPaneStatics3;
+
+  interface ICredentialCommand {
+    readonly CredentialDeleted: Windows.UI.ApplicationSettings.CredentialCommandCredentialDeletedHandler;
+    readonly PasswordCredential: Windows.Security.Credentials.PasswordCredential;
+  }
+  var ICredentialCommand: abstract new (...args: any[]) => ICredentialCommand;
+
+  interface ICredentialCommandFactory {
+    CreateCredentialCommand(passwordCredential: Windows.Security.Credentials.PasswordCredential): Windows.UI.ApplicationSettings.CredentialCommand;
+    CreateCredentialCommandWithHandler(passwordCredential: Windows.Security.Credentials.PasswordCredential, deleted: Windows.UI.ApplicationSettings.CredentialCommandCredentialDeletedHandler): Windows.UI.ApplicationSettings.CredentialCommand;
+  }
+  var ICredentialCommandFactory: abstract new (...args: any[]) => ICredentialCommandFactory;
+
+  interface ISettingsCommandFactory {
+    CreateSettingsCommand(settingsCommandId: Object, label: string, handler: Windows.UI.Popups.UICommandInvokedHandler): Windows.UI.ApplicationSettings.SettingsCommand;
+  }
+  var ISettingsCommandFactory: abstract new (...args: any[]) => ISettingsCommandFactory;
+
+  interface ISettingsCommandStatics {
+    readonly AccountsCommand: Windows.UI.ApplicationSettings.SettingsCommand;
+  }
+  var ISettingsCommandStatics: abstract new (...args: any[]) => ISettingsCommandStatics;
+
+  interface ISettingsPane {
+    CommandsRequested: Windows.Foundation.TypedEventHandler<Windows.UI.ApplicationSettings.SettingsPane, Windows.UI.ApplicationSettings.SettingsPaneCommandsRequestedEventArgs> | null;
+  }
+  var ISettingsPane: abstract new (...args: any[]) => ISettingsPane;
+
+  interface ISettingsPaneCommandsRequest {
+    readonly ApplicationCommands: Windows.Foundation.Collections.IVector<Windows.UI.ApplicationSettings.SettingsCommand> | Windows.UI.ApplicationSettings.SettingsCommand[];
+  }
+  var ISettingsPaneCommandsRequest: abstract new (...args: any[]) => ISettingsPaneCommandsRequest;
+
+  interface ISettingsPaneCommandsRequestedEventArgs {
+    readonly Request: Windows.UI.ApplicationSettings.SettingsPaneCommandsRequest;
+  }
+  var ISettingsPaneCommandsRequestedEventArgs: abstract new (...args: any[]) => ISettingsPaneCommandsRequestedEventArgs;
+
+  interface ISettingsPaneStatics {
+    GetForCurrentView(): Windows.UI.ApplicationSettings.SettingsPane;
+    Show(): void;
+    readonly Edge: number;
+  }
+  var ISettingsPaneStatics: abstract new (...args: any[]) => ISettingsPaneStatics;
+
+  interface IWebAccountCommand {
+    readonly Actions: number;
+    readonly Invoked: Windows.UI.ApplicationSettings.WebAccountCommandInvokedHandler;
+    readonly WebAccount: Windows.Security.Credentials.WebAccount;
+  }
+  var IWebAccountCommand: abstract new (...args: any[]) => IWebAccountCommand;
+
+  interface IWebAccountCommandFactory {
+    CreateWebAccountCommand(webAccount: Windows.Security.Credentials.WebAccount, invoked: Windows.UI.ApplicationSettings.WebAccountCommandInvokedHandler, actions: number): Windows.UI.ApplicationSettings.WebAccountCommand;
+  }
+  var IWebAccountCommandFactory: abstract new (...args: any[]) => IWebAccountCommandFactory;
+
+  interface IWebAccountInvokedArgs {
+    readonly Action: number;
+  }
+  var IWebAccountInvokedArgs: abstract new (...args: any[]) => IWebAccountInvokedArgs;
+
+  interface IWebAccountProviderCommand {
+    readonly Invoked: Windows.UI.ApplicationSettings.WebAccountProviderCommandInvokedHandler;
+    readonly WebAccountProvider: Windows.Security.Credentials.WebAccountProvider;
+  }
+  var IWebAccountProviderCommand: abstract new (...args: any[]) => IWebAccountProviderCommand;
+
+  interface IWebAccountProviderCommandFactory {
+    CreateWebAccountProviderCommand(webAccountProvider: Windows.Security.Credentials.WebAccountProvider, invoked: Windows.UI.ApplicationSettings.WebAccountProviderCommandInvokedHandler): Windows.UI.ApplicationSettings.WebAccountProviderCommand;
+  }
+  var IWebAccountProviderCommandFactory: abstract new (...args: any[]) => IWebAccountProviderCommandFactory;
+
+  interface WebAccountCommandInvokedHandler {
+    (command: Windows.UI.ApplicationSettings.WebAccountCommand, args: Windows.UI.ApplicationSettings.WebAccountInvokedArgs): void;
+  }
+  var WebAccountCommandInvokedHandler: {
+    new(callback: (command: Windows.UI.ApplicationSettings.WebAccountCommand, args: Windows.UI.ApplicationSettings.WebAccountInvokedArgs) => void): WebAccountCommandInvokedHandler;
+  };
+
+  interface WebAccountProviderCommandInvokedHandler {
+    (command: Windows.UI.ApplicationSettings.WebAccountProviderCommand): void;
+  }
+  var WebAccountProviderCommandInvokedHandler: {
+    new(callback: (command: Windows.UI.ApplicationSettings.WebAccountProviderCommand) => void): WebAccountProviderCommandInvokedHandler;
+  };
+
+}
+
+declare namespace Windows.UI.Composition {
+  class AmbientLight extends Windows.UI.Composition.CompositionLight implements Windows.UI.Composition.IAmbientLight, Windows.UI.Composition.IAmbientLight2 {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Color: Windows.UI.Color;
+    Intensity: number;
+  }
+
+  class AnimationController extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.IAnimationController {
+    Close(): void;
+    Pause(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    Resume(): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    static readonly MaxPlaybackRate: number;
+    static readonly MinPlaybackRate: number;
+    PlaybackRate: number;
+    Progress: number;
+    ProgressBehavior: number;
+  }
+
+  class AnimationPropertyInfo extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.IAnimationPropertyInfo, Windows.UI.Composition.IAnimationPropertyInfo2 {
+    Close(): void;
+    GetResolvedCompositionObject(): Windows.UI.Composition.CompositionObject;
+    GetResolvedCompositionObjectProperty(): string;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    AccessMode: number;
+  }
+
+  class BackEasingFunction extends Windows.UI.Composition.CompositionEasingFunction implements Windows.UI.Composition.IBackEasingFunction {
+    Close(): void;
+    static CreateBackEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, amplitude: number): Windows.UI.Composition.BackEasingFunction;
+    static CreateBounceEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, bounces: number, bounciness: number): Windows.UI.Composition.BounceEasingFunction;
+    static CreateCircleEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.CircleEasingFunction;
+    static CreateCubicBezierEasingFunction(owner: Windows.UI.Composition.Compositor, controlPoint1: Windows.Foundation.Numerics.Vector2, controlPoint2: Windows.Foundation.Numerics.Vector2): Windows.UI.Composition.CubicBezierEasingFunction;
+    static CreateElasticEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, oscillations: number, springiness: number): Windows.UI.Composition.ElasticEasingFunction;
+    static CreateExponentialEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, exponent: number): Windows.UI.Composition.ExponentialEasingFunction;
+    static CreateLinearEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.LinearEasingFunction;
+    static CreatePowerEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, power: number): Windows.UI.Composition.PowerEasingFunction;
+    static CreateSineEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.SineEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.StepEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor, stepCount: number): Windows.UI.Composition.StepEasingFunction;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Amplitude: number;
+    readonly Mode: number;
+  }
+
+  class BooleanKeyFrameAnimation extends Windows.UI.Composition.KeyFrameAnimation implements Windows.UI.Composition.IBooleanKeyFrameAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string): void;
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+    InsertKeyFrame(normalizedProgressKey: number, value: boolean): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class BounceEasingFunction extends Windows.UI.Composition.CompositionEasingFunction implements Windows.UI.Composition.IBounceEasingFunction {
+    Close(): void;
+    static CreateBackEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, amplitude: number): Windows.UI.Composition.BackEasingFunction;
+    static CreateBounceEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, bounces: number, bounciness: number): Windows.UI.Composition.BounceEasingFunction;
+    static CreateCircleEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.CircleEasingFunction;
+    static CreateCubicBezierEasingFunction(owner: Windows.UI.Composition.Compositor, controlPoint1: Windows.Foundation.Numerics.Vector2, controlPoint2: Windows.Foundation.Numerics.Vector2): Windows.UI.Composition.CubicBezierEasingFunction;
+    static CreateElasticEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, oscillations: number, springiness: number): Windows.UI.Composition.ElasticEasingFunction;
+    static CreateExponentialEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, exponent: number): Windows.UI.Composition.ExponentialEasingFunction;
+    static CreateLinearEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.LinearEasingFunction;
+    static CreatePowerEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, power: number): Windows.UI.Composition.PowerEasingFunction;
+    static CreateSineEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.SineEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.StepEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor, stepCount: number): Windows.UI.Composition.StepEasingFunction;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Bounces: number;
+    readonly Bounciness: number;
+    readonly Mode: number;
+  }
+
+  class BounceScalarNaturalMotionAnimation extends Windows.UI.Composition.ScalarNaturalMotionAnimation implements Windows.UI.Composition.IBounceScalarNaturalMotionAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Acceleration: number;
+    Restitution: number;
+  }
+
+  class BounceVector2NaturalMotionAnimation extends Windows.UI.Composition.Vector2NaturalMotionAnimation implements Windows.UI.Composition.IBounceVector2NaturalMotionAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Acceleration: number;
+    Restitution: number;
+  }
+
+  class BounceVector3NaturalMotionAnimation extends Windows.UI.Composition.Vector3NaturalMotionAnimation implements Windows.UI.Composition.IBounceVector3NaturalMotionAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Acceleration: number;
+    Restitution: number;
+  }
+
+  class CircleEasingFunction extends Windows.UI.Composition.CompositionEasingFunction implements Windows.UI.Composition.ICircleEasingFunction {
+    Close(): void;
+    static CreateBackEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, amplitude: number): Windows.UI.Composition.BackEasingFunction;
+    static CreateBounceEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, bounces: number, bounciness: number): Windows.UI.Composition.BounceEasingFunction;
+    static CreateCircleEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.CircleEasingFunction;
+    static CreateCubicBezierEasingFunction(owner: Windows.UI.Composition.Compositor, controlPoint1: Windows.Foundation.Numerics.Vector2, controlPoint2: Windows.Foundation.Numerics.Vector2): Windows.UI.Composition.CubicBezierEasingFunction;
+    static CreateElasticEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, oscillations: number, springiness: number): Windows.UI.Composition.ElasticEasingFunction;
+    static CreateExponentialEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, exponent: number): Windows.UI.Composition.ExponentialEasingFunction;
+    static CreateLinearEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.LinearEasingFunction;
+    static CreatePowerEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, power: number): Windows.UI.Composition.PowerEasingFunction;
+    static CreateSineEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.SineEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.StepEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor, stepCount: number): Windows.UI.Composition.StepEasingFunction;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Mode: number;
+  }
+
+  class ColorKeyFrameAnimation extends Windows.UI.Composition.KeyFrameAnimation implements Windows.UI.Composition.IColorKeyFrameAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string): void;
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.UI.Color): void;
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.UI.Color, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    InterpolationColorSpace: number;
+  }
+
+  class CompositionAnimation extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionAnimation, Windows.UI.Composition.ICompositionAnimation2, Windows.UI.Composition.ICompositionAnimation3, Windows.UI.Composition.ICompositionAnimation4, Windows.UI.Composition.ICompositionAnimationBase {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly InitialValueExpressions: Windows.UI.Composition.InitialValueExpressionCollection;
+    Target: string;
+  }
+
+  class CompositionAnimationGroup extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionAnimationBase, Windows.UI.Composition.ICompositionAnimationGroup {
+    Add(value: Windows.UI.Composition.CompositionAnimation): void;
+    Close(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Composition.CompositionAnimation>;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    Remove(value: Windows.UI.Composition.CompositionAnimation): void;
+    RemoveAll(): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Count: number;
+  }
+
+  class CompositionBackdropBrush extends Windows.UI.Composition.CompositionBrush implements Windows.UI.Composition.ICompositionBackdropBrush {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class CompositionBatchCompletedEventArgs extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionBatchCompletedEventArgs {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class CompositionBrush extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionBrush {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class CompositionCapabilities implements Windows.UI.Composition.ICompositionCapabilities {
+    AreEffectsFast(): boolean;
+    AreEffectsSupported(): boolean;
+    static GetForCurrentView(): Windows.UI.Composition.CompositionCapabilities;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.UI.Composition.CompositionCapabilities, Object> | null;
+  }
+
+  class CompositionClip extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionClip, Windows.UI.Composition.ICompositionClip2 {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    AnchorPoint: Windows.Foundation.Numerics.Vector2;
+    CenterPoint: Windows.Foundation.Numerics.Vector2;
+    Offset: Windows.Foundation.Numerics.Vector2;
+    RotationAngle: number;
+    RotationAngleInDegrees: number;
+    Scale: Windows.Foundation.Numerics.Vector2;
+    TransformMatrix: Windows.Foundation.Numerics.Matrix3x2;
+  }
+
+  class CompositionColorBrush extends Windows.UI.Composition.CompositionBrush implements Windows.UI.Composition.ICompositionColorBrush {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Color: Windows.UI.Color;
+  }
+
+  class CompositionColorGradientStop extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionColorGradientStop {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Color: Windows.UI.Color;
+    Offset: number;
+  }
+
+  class CompositionColorGradientStopCollection implements Windows.UI.Composition.ICompositionColorGradientStopCollection {
+    Append(value: Windows.UI.Composition.CompositionColorGradientStop): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Composition.CompositionColorGradientStop>;
+    GetAt(index: number): Windows.UI.Composition.CompositionColorGradientStop;
+    GetMany(startIndex: number, items: Windows.UI.Composition.CompositionColorGradientStop[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Composition.CompositionColorGradientStop> | Windows.UI.Composition.CompositionColorGradientStop[];
+    IndexOf(value: Windows.UI.Composition.CompositionColorGradientStop, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Composition.CompositionColorGradientStop): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Composition.CompositionColorGradientStop[]): void;
+    SetAt(index: number, value: Windows.UI.Composition.CompositionColorGradientStop): void;
+    readonly Size: number;
+  }
+
+  class CompositionCommitBatch extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionCommitBatch {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly IsActive: boolean;
+    readonly IsEnded: boolean;
+    Completed: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Composition.CompositionBatchCompletedEventArgs> | null;
+  }
+
+  class CompositionContainerShape extends Windows.UI.Composition.CompositionShape implements Windows.UI.Composition.ICompositionContainerShape {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Shapes: Windows.UI.Composition.CompositionShapeCollection;
+  }
+
+  class CompositionDrawingSurface extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionDrawingSurface, Windows.UI.Composition.ICompositionDrawingSurface2, Windows.UI.Composition.ICompositionSurface {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    Resize(sizePixels: Windows.Graphics.SizeInt32): void;
+    Scroll(offset: Windows.Graphics.PointInt32): void;
+    Scroll(offset: Windows.Graphics.PointInt32, scrollRect: Windows.Graphics.RectInt32): void;
+    ScrollWithClip(offset: Windows.Graphics.PointInt32, clipRect: Windows.Graphics.RectInt32): void;
+    ScrollWithClip(offset: Windows.Graphics.PointInt32, clipRect: Windows.Graphics.RectInt32, scrollRect: Windows.Graphics.RectInt32): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly AlphaMode: number;
+    readonly PixelFormat: number;
+    readonly Size: Windows.Foundation.Size;
+    readonly SizeInt32: Windows.Graphics.SizeInt32;
+  }
+
+  class CompositionEasingFunction extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionEasingFunction {
+    Close(): void;
+    static CreateBackEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, amplitude: number): Windows.UI.Composition.BackEasingFunction;
+    static CreateBounceEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, bounces: number, bounciness: number): Windows.UI.Composition.BounceEasingFunction;
+    static CreateCircleEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.CircleEasingFunction;
+    static CreateCubicBezierEasingFunction(owner: Windows.UI.Composition.Compositor, controlPoint1: Windows.Foundation.Numerics.Vector2, controlPoint2: Windows.Foundation.Numerics.Vector2): Windows.UI.Composition.CubicBezierEasingFunction;
+    static CreateElasticEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, oscillations: number, springiness: number): Windows.UI.Composition.ElasticEasingFunction;
+    static CreateExponentialEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, exponent: number): Windows.UI.Composition.ExponentialEasingFunction;
+    static CreateLinearEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.LinearEasingFunction;
+    static CreatePowerEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, power: number): Windows.UI.Composition.PowerEasingFunction;
+    static CreateSineEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.SineEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.StepEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor, stepCount: number): Windows.UI.Composition.StepEasingFunction;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class CompositionEffectBrush extends Windows.UI.Composition.CompositionBrush implements Windows.UI.Composition.ICompositionEffectBrush {
+    Close(): void;
+    GetSourceParameter(name: string): Windows.UI.Composition.CompositionBrush;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetSourceParameter(name: string, source: Windows.UI.Composition.CompositionBrush): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class CompositionEffectFactory extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionEffectFactory {
+    Close(): void;
+    CreateBrush(): Windows.UI.Composition.CompositionEffectBrush;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly LoadStatus: number;
+  }
+
+  class CompositionEffectSourceParameter implements Windows.Graphics.Effects.IGraphicsEffectSource, Windows.UI.Composition.ICompositionEffectSourceParameter {
+    constructor(name: string);
+    readonly Name: string;
+  }
+
+  class CompositionEllipseGeometry extends Windows.UI.Composition.CompositionGeometry implements Windows.UI.Composition.ICompositionEllipseGeometry {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Center: Windows.Foundation.Numerics.Vector2;
+    Radius: Windows.Foundation.Numerics.Vector2;
+  }
+
+  class CompositionGeometricClip extends Windows.UI.Composition.CompositionClip implements Windows.UI.Composition.ICompositionGeometricClip {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Geometry: Windows.UI.Composition.CompositionGeometry;
+    ViewBox: Windows.UI.Composition.CompositionViewBox;
+  }
+
+  class CompositionGeometry extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionGeometry {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    TrimEnd: number;
+    TrimOffset: number;
+    TrimStart: number;
+  }
+
+  class CompositionGradientBrush extends Windows.UI.Composition.CompositionBrush implements Windows.UI.Composition.ICompositionGradientBrush, Windows.UI.Composition.ICompositionGradientBrush2 {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    AnchorPoint: Windows.Foundation.Numerics.Vector2;
+    CenterPoint: Windows.Foundation.Numerics.Vector2;
+    readonly ColorStops: Windows.UI.Composition.CompositionColorGradientStopCollection;
+    ExtendMode: number;
+    InterpolationSpace: number;
+    MappingMode: number;
+    Offset: Windows.Foundation.Numerics.Vector2;
+    RotationAngle: number;
+    RotationAngleInDegrees: number;
+    Scale: Windows.Foundation.Numerics.Vector2;
+    TransformMatrix: Windows.Foundation.Numerics.Matrix3x2;
+  }
+
+  class CompositionGraphicsDevice extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionGraphicsDevice, Windows.UI.Composition.ICompositionGraphicsDevice2, Windows.UI.Composition.ICompositionGraphicsDevice3, Windows.UI.Composition.ICompositionGraphicsDevice4 {
+    CaptureAsync(captureVisual: Windows.UI.Composition.Visual, size: Windows.Graphics.SizeInt32, pixelFormat: number, alphaMode: number, sdrBoost: number): Windows.Foundation.IAsyncOperation<Windows.UI.Composition.ICompositionSurface>;
+    Close(): void;
+    CreateDrawingSurface(sizePixels: Windows.Foundation.Size, pixelFormat: number, alphaMode: number): Windows.UI.Composition.CompositionDrawingSurface;
+    CreateDrawingSurface2(sizePixels: Windows.Graphics.SizeInt32, pixelFormat: number, alphaMode: number): Windows.UI.Composition.CompositionDrawingSurface;
+    CreateMipmapSurface(sizePixels: Windows.Graphics.SizeInt32, pixelFormat: number, alphaMode: number): Windows.UI.Composition.CompositionMipmapSurface;
+    CreateVirtualDrawingSurface(sizePixels: Windows.Graphics.SizeInt32, pixelFormat: number, alphaMode: number): Windows.UI.Composition.CompositionVirtualDrawingSurface;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    Trim(): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    RenderingDeviceReplaced: Windows.Foundation.TypedEventHandler<Windows.UI.Composition.CompositionGraphicsDevice, Windows.UI.Composition.RenderingDeviceReplacedEventArgs> | null;
+  }
+
+  class CompositionLight extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionLight, Windows.UI.Composition.ICompositionLight2, Windows.UI.Composition.ICompositionLight3 {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly ExclusionsFromTargets: Windows.UI.Composition.VisualUnorderedCollection;
+    IsEnabled: boolean;
+    readonly Targets: Windows.UI.Composition.VisualUnorderedCollection;
+  }
+
+  class CompositionLineGeometry extends Windows.UI.Composition.CompositionGeometry implements Windows.UI.Composition.ICompositionLineGeometry {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    End: Windows.Foundation.Numerics.Vector2;
+    Start: Windows.Foundation.Numerics.Vector2;
+  }
+
+  class CompositionLinearGradientBrush extends Windows.UI.Composition.CompositionGradientBrush implements Windows.UI.Composition.ICompositionLinearGradientBrush {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    EndPoint: Windows.Foundation.Numerics.Vector2;
+    StartPoint: Windows.Foundation.Numerics.Vector2;
+  }
+
+  class CompositionMaskBrush extends Windows.UI.Composition.CompositionBrush implements Windows.UI.Composition.ICompositionMaskBrush {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Mask: Windows.UI.Composition.CompositionBrush;
+    Source: Windows.UI.Composition.CompositionBrush;
+  }
+
+  class CompositionMipmapSurface extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionMipmapSurface, Windows.UI.Composition.ICompositionSurface {
+    Close(): void;
+    GetDrawingSurfaceForLevel(level: number): Windows.UI.Composition.CompositionDrawingSurface;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly AlphaMode: number;
+    readonly LevelCount: number;
+    readonly PixelFormat: number;
+    readonly SizeInt32: Windows.Graphics.SizeInt32;
+  }
+
+  class CompositionNineGridBrush extends Windows.UI.Composition.CompositionBrush implements Windows.UI.Composition.ICompositionNineGridBrush {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetInsetScales(scale: number): void;
+    SetInsetScales(left: number, top: number, right: number, bottom: number): void;
+    SetInsets(inset: number): void;
+    SetInsets(left: number, top: number, right: number, bottom: number): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    BottomInset: number;
+    BottomInsetScale: number;
+    IsCenterHollow: boolean;
+    LeftInset: number;
+    LeftInsetScale: number;
+    RightInset: number;
+    RightInsetScale: number;
+    Source: Windows.UI.Composition.CompositionBrush;
+    TopInset: number;
+    TopInsetScale: number;
+  }
+
+  class CompositionObject implements Windows.Foundation.IClosable, Windows.UI.Composition.IAnimationObject, Windows.UI.Composition.ICompositionObject, Windows.UI.Composition.ICompositionObject2, Windows.UI.Composition.ICompositionObject3, Windows.UI.Composition.ICompositionObject4, Windows.UI.Composition.ICompositionObject5 {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Comment: string;
+    readonly Compositor: Windows.UI.Composition.Compositor;
+    readonly Dispatcher: Windows.UI.Core.CoreDispatcher;
+    readonly DispatcherQueue: Windows.System.DispatcherQueue;
+    ImplicitAnimations: Windows.UI.Composition.ImplicitAnimationCollection;
+    readonly Properties: Windows.UI.Composition.CompositionPropertySet;
+  }
+
+  class CompositionPath implements Windows.Graphics.IGeometrySource2D, Windows.UI.Composition.ICompositionPath {
+    constructor(source: Windows.Graphics.IGeometrySource2D);
+  }
+
+  class CompositionPathGeometry extends Windows.UI.Composition.CompositionGeometry implements Windows.UI.Composition.ICompositionPathGeometry {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Path: Windows.UI.Composition.CompositionPath;
+  }
+
+  class CompositionProjectedShadow extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionProjectedShadow {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    BlurRadiusMultiplier: number;
+    readonly Casters: Windows.UI.Composition.CompositionProjectedShadowCasterCollection;
+    LightSource: Windows.UI.Composition.CompositionLight;
+    MaxBlurRadius: number;
+    MinBlurRadius: number;
+    readonly Receivers: Windows.UI.Composition.CompositionProjectedShadowReceiverUnorderedCollection;
+  }
+
+  class CompositionProjectedShadowCaster extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionProjectedShadowCaster {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Brush: Windows.UI.Composition.CompositionBrush;
+    CastingVisual: Windows.UI.Composition.Visual;
+  }
+
+  class CompositionProjectedShadowCasterCollection extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionProjectedShadowCasterCollection {
+    Close(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Composition.CompositionProjectedShadowCaster>;
+    InsertAbove(newCaster: Windows.UI.Composition.CompositionProjectedShadowCaster, reference: Windows.UI.Composition.CompositionProjectedShadowCaster): void;
+    InsertAtBottom(newCaster: Windows.UI.Composition.CompositionProjectedShadowCaster): void;
+    InsertAtTop(newCaster: Windows.UI.Composition.CompositionProjectedShadowCaster): void;
+    InsertBelow(newCaster: Windows.UI.Composition.CompositionProjectedShadowCaster, reference: Windows.UI.Composition.CompositionProjectedShadowCaster): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    Remove(caster: Windows.UI.Composition.CompositionProjectedShadowCaster): void;
+    RemoveAll(): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Count: number;
+    static readonly MaxRespectedCasters: number;
+  }
+
+  class CompositionProjectedShadowReceiver extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionProjectedShadowReceiver {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    ReceivingVisual: Windows.UI.Composition.Visual;
+  }
+
+  class CompositionProjectedShadowReceiverUnorderedCollection extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionProjectedShadowReceiverUnorderedCollection {
+    Add(value: Windows.UI.Composition.CompositionProjectedShadowReceiver): void;
+    Close(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Composition.CompositionProjectedShadowReceiver>;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    Remove(value: Windows.UI.Composition.CompositionProjectedShadowReceiver): void;
+    RemoveAll(): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Count: number;
+  }
+
+  class CompositionPropertySet extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionPropertySet, Windows.UI.Composition.ICompositionPropertySet2 {
+    Close(): void;
+    InsertBoolean(propertyName: string, value: boolean): void;
+    InsertColor(propertyName: string, value: Windows.UI.Color): void;
+    InsertMatrix3x2(propertyName: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    InsertMatrix4x4(propertyName: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    InsertQuaternion(propertyName: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    InsertScalar(propertyName: string, value: number): void;
+    InsertVector2(propertyName: string, value: Windows.Foundation.Numerics.Vector2): void;
+    InsertVector3(propertyName: string, value: Windows.Foundation.Numerics.Vector3): void;
+    InsertVector4(propertyName: string, value: Windows.Foundation.Numerics.Vector4): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    TryGetBoolean(propertyName: string, value: boolean): number;
+    TryGetColor(propertyName: string, value: Windows.UI.Color): number;
+    TryGetMatrix3x2(propertyName: string, value: Windows.Foundation.Numerics.Matrix3x2): number;
+    TryGetMatrix4x4(propertyName: string, value: Windows.Foundation.Numerics.Matrix4x4): number;
+    TryGetQuaternion(propertyName: string, value: Windows.Foundation.Numerics.Quaternion): number;
+    TryGetScalar(propertyName: string, value: number): number;
+    TryGetVector2(propertyName: string, value: Windows.Foundation.Numerics.Vector2): number;
+    TryGetVector3(propertyName: string, value: Windows.Foundation.Numerics.Vector3): number;
+    TryGetVector4(propertyName: string, value: Windows.Foundation.Numerics.Vector4): number;
+  }
+
+  class CompositionRadialGradientBrush extends Windows.UI.Composition.CompositionGradientBrush implements Windows.UI.Composition.ICompositionRadialGradientBrush {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    EllipseCenter: Windows.Foundation.Numerics.Vector2;
+    EllipseRadius: Windows.Foundation.Numerics.Vector2;
+    GradientOriginOffset: Windows.Foundation.Numerics.Vector2;
+  }
+
+  class CompositionRectangleGeometry extends Windows.UI.Composition.CompositionGeometry implements Windows.UI.Composition.ICompositionRectangleGeometry {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Offset: Windows.Foundation.Numerics.Vector2;
+    Size: Windows.Foundation.Numerics.Vector2;
+  }
+
+  class CompositionRoundedRectangleGeometry extends Windows.UI.Composition.CompositionGeometry implements Windows.UI.Composition.ICompositionRoundedRectangleGeometry {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    CornerRadius: Windows.Foundation.Numerics.Vector2;
+    Offset: Windows.Foundation.Numerics.Vector2;
+    Size: Windows.Foundation.Numerics.Vector2;
+  }
+
+  class CompositionScopedBatch extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionScopedBatch {
+    Close(): void;
+    End(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    Resume(): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    Suspend(): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly IsActive: boolean;
+    readonly IsEnded: boolean;
+    Completed: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Composition.CompositionBatchCompletedEventArgs> | null;
+  }
+
+  class CompositionShadow extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionShadow {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class CompositionShape extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionShape {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    CenterPoint: Windows.Foundation.Numerics.Vector2;
+    Offset: Windows.Foundation.Numerics.Vector2;
+    RotationAngle: number;
+    RotationAngleInDegrees: number;
+    Scale: Windows.Foundation.Numerics.Vector2;
+    TransformMatrix: Windows.Foundation.Numerics.Matrix3x2;
+  }
+
+  class CompositionShapeCollection extends Windows.UI.Composition.CompositionObject {
+    Append(value: Windows.UI.Composition.CompositionShape): void;
+    Clear(): void;
+    Close(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Composition.CompositionShape>;
+    GetAt(index: number): Windows.UI.Composition.CompositionShape;
+    GetMany(startIndex: number, items: Windows.UI.Composition.CompositionShape[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Composition.CompositionShape> | Windows.UI.Composition.CompositionShape[];
+    IndexOf(value: Windows.UI.Composition.CompositionShape, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Composition.CompositionShape): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Composition.CompositionShape[]): void;
+    SetAt(index: number, value: Windows.UI.Composition.CompositionShape): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Size: number;
+  }
+
+  class CompositionSpriteShape extends Windows.UI.Composition.CompositionShape implements Windows.UI.Composition.ICompositionSpriteShape {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    FillBrush: Windows.UI.Composition.CompositionBrush;
+    Geometry: Windows.UI.Composition.CompositionGeometry;
+    IsStrokeNonScaling: boolean;
+    StrokeBrush: Windows.UI.Composition.CompositionBrush;
+    readonly StrokeDashArray: Windows.UI.Composition.CompositionStrokeDashArray;
+    StrokeDashCap: number;
+    StrokeDashOffset: number;
+    StrokeEndCap: number;
+    StrokeLineJoin: number;
+    StrokeMiterLimit: number;
+    StrokeStartCap: number;
+    StrokeThickness: number;
+  }
+
+  class CompositionStrokeDashArray extends Windows.UI.Composition.CompositionObject {
+    Append(value: number): void;
+    Clear(): void;
+    Close(): void;
+    First(): Windows.Foundation.Collections.IIterator<number>;
+    GetAt(index: number): number;
+    GetMany(startIndex: number, items: number[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    IndexOf(value: number, index: number): boolean;
+    InsertAt(index: number, value: number): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: number[]): void;
+    SetAt(index: number, value: number): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Size: number;
+  }
+
+  class CompositionSurfaceBrush extends Windows.UI.Composition.CompositionBrush implements Windows.UI.Composition.ICompositionSurfaceBrush, Windows.UI.Composition.ICompositionSurfaceBrush2, Windows.UI.Composition.ICompositionSurfaceBrush3 {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    AnchorPoint: Windows.Foundation.Numerics.Vector2;
+    BitmapInterpolationMode: number;
+    CenterPoint: Windows.Foundation.Numerics.Vector2;
+    HorizontalAlignmentRatio: number;
+    Offset: Windows.Foundation.Numerics.Vector2;
+    RotationAngle: number;
+    RotationAngleInDegrees: number;
+    Scale: Windows.Foundation.Numerics.Vector2;
+    SnapToPixels: boolean;
+    Stretch: number;
+    Surface: Windows.UI.Composition.ICompositionSurface;
+    TransformMatrix: Windows.Foundation.Numerics.Matrix3x2;
+    VerticalAlignmentRatio: number;
+  }
+
+  class CompositionTarget extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionTarget {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Root: Windows.UI.Composition.Visual;
+  }
+
+  class CompositionTexture extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionSurface, Windows.UI.Composition.ICompositionTexture {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    AlphaMode: number;
+    ColorSpace: number;
+    SourceRect: Windows.Graphics.RectInt32;
+  }
+
+  class CompositionTransform extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionTransform {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class CompositionViewBox extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionViewBox {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    HorizontalAlignmentRatio: number;
+    Offset: Windows.Foundation.Numerics.Vector2;
+    Size: Windows.Foundation.Numerics.Vector2;
+    Stretch: number;
+    VerticalAlignmentRatio: number;
+  }
+
+  class CompositionVirtualDrawingSurface extends Windows.UI.Composition.CompositionDrawingSurface implements Windows.UI.Composition.ICompositionVirtualDrawingSurface {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    Resize(sizePixels: Windows.Graphics.SizeInt32): void;
+    Scroll(offset: Windows.Graphics.PointInt32): void;
+    Scroll(offset: Windows.Graphics.PointInt32, scrollRect: Windows.Graphics.RectInt32): void;
+    ScrollWithClip(offset: Windows.Graphics.PointInt32, clipRect: Windows.Graphics.RectInt32): void;
+    ScrollWithClip(offset: Windows.Graphics.PointInt32, clipRect: Windows.Graphics.RectInt32, scrollRect: Windows.Graphics.RectInt32): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    Trim(rects: Windows.Graphics.RectInt32[]): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class CompositionVisualSurface extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.ICompositionSurface, Windows.UI.Composition.ICompositionVisualSurface {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    SourceOffset: Windows.Foundation.Numerics.Vector2;
+    SourceSize: Windows.Foundation.Numerics.Vector2;
+    SourceVisual: Windows.UI.Composition.Visual;
+  }
+
+  class Compositor implements Windows.Foundation.IClosable, Windows.UI.Composition.ICompositor, Windows.UI.Composition.ICompositor2, Windows.UI.Composition.ICompositor3, Windows.UI.Composition.ICompositor4, Windows.UI.Composition.ICompositor5, Windows.UI.Composition.ICompositor6, Windows.UI.Composition.ICompositor7, Windows.UI.Composition.ICompositor8, Windows.UI.Composition.ICompositorWithBlurredWallpaperBackdropBrush, Windows.UI.Composition.ICompositorWithProjectedShadow, Windows.UI.Composition.ICompositorWithRadialGradient, Windows.UI.Composition.ICompositorWithVisualSurface {
+    constructor();
+    Close(): void;
+    CreateAmbientLight(): Windows.UI.Composition.AmbientLight;
+    CreateAnimationController(): Windows.UI.Composition.AnimationController;
+    CreateAnimationGroup(): Windows.UI.Composition.CompositionAnimationGroup;
+    CreateAnimationPropertyInfo(): Windows.UI.Composition.AnimationPropertyInfo;
+    CreateBackdropBrush(): Windows.UI.Composition.CompositionBackdropBrush;
+    CreateBooleanKeyFrameAnimation(): Windows.UI.Composition.BooleanKeyFrameAnimation;
+    CreateBounceScalarAnimation(): Windows.UI.Composition.BounceScalarNaturalMotionAnimation;
+    CreateBounceVector2Animation(): Windows.UI.Composition.BounceVector2NaturalMotionAnimation;
+    CreateBounceVector3Animation(): Windows.UI.Composition.BounceVector3NaturalMotionAnimation;
+    CreateColorBrush(): Windows.UI.Composition.CompositionColorBrush;
+    CreateColorBrush(color: Windows.UI.Color): Windows.UI.Composition.CompositionColorBrush;
+    CreateColorGradientStop(): Windows.UI.Composition.CompositionColorGradientStop;
+    CreateColorGradientStop(offset: number, color: Windows.UI.Color): Windows.UI.Composition.CompositionColorGradientStop;
+    CreateColorKeyFrameAnimation(): Windows.UI.Composition.ColorKeyFrameAnimation;
+    CreateContainerShape(): Windows.UI.Composition.CompositionContainerShape;
+    CreateContainerVisual(): Windows.UI.Composition.ContainerVisual;
+    CreateCubicBezierEasingFunction(controlPoint1: Windows.Foundation.Numerics.Vector2, controlPoint2: Windows.Foundation.Numerics.Vector2): Windows.UI.Composition.CubicBezierEasingFunction;
+    CreateDistantLight(): Windows.UI.Composition.DistantLight;
+    CreateDropShadow(): Windows.UI.Composition.DropShadow;
+    CreateEffectFactory(graphicsEffect: Windows.Graphics.Effects.IGraphicsEffect): Windows.UI.Composition.CompositionEffectFactory;
+    CreateEffectFactory(graphicsEffect: Windows.Graphics.Effects.IGraphicsEffect, animatableProperties: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.UI.Composition.CompositionEffectFactory;
+    CreateEllipseGeometry(): Windows.UI.Composition.CompositionEllipseGeometry;
+    CreateExpressionAnimation(): Windows.UI.Composition.ExpressionAnimation;
+    CreateExpressionAnimation(expression: string): Windows.UI.Composition.ExpressionAnimation;
+    CreateGeometricClip(): Windows.UI.Composition.CompositionGeometricClip;
+    CreateGeometricClip(geometry: Windows.UI.Composition.CompositionGeometry): Windows.UI.Composition.CompositionGeometricClip;
+    CreateHostBackdropBrush(): Windows.UI.Composition.CompositionBackdropBrush;
+    CreateImplicitAnimationCollection(): Windows.UI.Composition.ImplicitAnimationCollection;
+    CreateInsetClip(): Windows.UI.Composition.InsetClip;
+    CreateInsetClip(leftInset: number, topInset: number, rightInset: number, bottomInset: number): Windows.UI.Composition.InsetClip;
+    CreateLayerVisual(): Windows.UI.Composition.LayerVisual;
+    CreateLineGeometry(): Windows.UI.Composition.CompositionLineGeometry;
+    CreateLinearEasingFunction(): Windows.UI.Composition.LinearEasingFunction;
+    CreateLinearGradientBrush(): Windows.UI.Composition.CompositionLinearGradientBrush;
+    CreateMaskBrush(): Windows.UI.Composition.CompositionMaskBrush;
+    CreateNineGridBrush(): Windows.UI.Composition.CompositionNineGridBrush;
+    CreatePathGeometry(): Windows.UI.Composition.CompositionPathGeometry;
+    CreatePathGeometry(path: Windows.UI.Composition.CompositionPath): Windows.UI.Composition.CompositionPathGeometry;
+    CreatePathKeyFrameAnimation(): Windows.UI.Composition.PathKeyFrameAnimation;
+    CreatePointLight(): Windows.UI.Composition.PointLight;
+    CreateProjectedShadow(): Windows.UI.Composition.CompositionProjectedShadow;
+    CreateProjectedShadowCaster(): Windows.UI.Composition.CompositionProjectedShadowCaster;
+    CreateProjectedShadowReceiver(): Windows.UI.Composition.CompositionProjectedShadowReceiver;
+    CreatePropertySet(): Windows.UI.Composition.CompositionPropertySet;
+    CreateQuaternionKeyFrameAnimation(): Windows.UI.Composition.QuaternionKeyFrameAnimation;
+    CreateRadialGradientBrush(): Windows.UI.Composition.CompositionRadialGradientBrush;
+    CreateRectangleClip(): Windows.UI.Composition.RectangleClip;
+    CreateRectangleClip(left: number, top: number, right: number, bottom: number): Windows.UI.Composition.RectangleClip;
+    CreateRectangleClip(left: number, top: number, right: number, bottom: number, topLeftRadius: Windows.Foundation.Numerics.Vector2, topRightRadius: Windows.Foundation.Numerics.Vector2, bottomRightRadius: Windows.Foundation.Numerics.Vector2, bottomLeftRadius: Windows.Foundation.Numerics.Vector2): Windows.UI.Composition.RectangleClip;
+    CreateRectangleGeometry(): Windows.UI.Composition.CompositionRectangleGeometry;
+    CreateRedirectVisual(): Windows.UI.Composition.RedirectVisual;
+    CreateRedirectVisual(source: Windows.UI.Composition.Visual): Windows.UI.Composition.RedirectVisual;
+    CreateRoundedRectangleGeometry(): Windows.UI.Composition.CompositionRoundedRectangleGeometry;
+    CreateScalarKeyFrameAnimation(): Windows.UI.Composition.ScalarKeyFrameAnimation;
+    CreateScopedBatch(batchType: number): Windows.UI.Composition.CompositionScopedBatch;
+    CreateShapeVisual(): Windows.UI.Composition.ShapeVisual;
+    CreateSpotLight(): Windows.UI.Composition.SpotLight;
+    CreateSpringScalarAnimation(): Windows.UI.Composition.SpringScalarNaturalMotionAnimation;
+    CreateSpringVector2Animation(): Windows.UI.Composition.SpringVector2NaturalMotionAnimation;
+    CreateSpringVector3Animation(): Windows.UI.Composition.SpringVector3NaturalMotionAnimation;
+    CreateSpriteShape(): Windows.UI.Composition.CompositionSpriteShape;
+    CreateSpriteShape(geometry: Windows.UI.Composition.CompositionGeometry): Windows.UI.Composition.CompositionSpriteShape;
+    CreateSpriteVisual(): Windows.UI.Composition.SpriteVisual;
+    CreateStepEasingFunction(): Windows.UI.Composition.StepEasingFunction;
+    CreateStepEasingFunction(stepCount: number): Windows.UI.Composition.StepEasingFunction;
+    CreateSurfaceBrush(): Windows.UI.Composition.CompositionSurfaceBrush;
+    CreateSurfaceBrush(surface: Windows.UI.Composition.ICompositionSurface): Windows.UI.Composition.CompositionSurfaceBrush;
+    CreateTargetForCurrentView(): Windows.UI.Composition.CompositionTarget;
+    CreateVector2KeyFrameAnimation(): Windows.UI.Composition.Vector2KeyFrameAnimation;
+    CreateVector3KeyFrameAnimation(): Windows.UI.Composition.Vector3KeyFrameAnimation;
+    CreateVector4KeyFrameAnimation(): Windows.UI.Composition.Vector4KeyFrameAnimation;
+    CreateViewBox(): Windows.UI.Composition.CompositionViewBox;
+    CreateVisualSurface(): Windows.UI.Composition.CompositionVisualSurface;
+    GetCommitBatch(batchType: number): Windows.UI.Composition.CompositionCommitBatch;
+    RequestCommitAsync(): Windows.Foundation.IAsyncAction;
+    TryCreateBlurredWallpaperBackdropBrush(): Windows.UI.Composition.CompositionBackdropBrush;
+    Comment: string;
+    readonly DispatcherQueue: Windows.System.DispatcherQueue;
+    GlobalPlaybackRate: number;
+    static readonly MaxGlobalPlaybackRate: number;
+    static readonly MinGlobalPlaybackRate: number;
+  }
+
+  class ContainerVisual extends Windows.UI.Composition.Visual implements Windows.UI.Composition.IContainerVisual {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Children: Windows.UI.Composition.VisualCollection;
+  }
+
+  class CubicBezierEasingFunction extends Windows.UI.Composition.CompositionEasingFunction implements Windows.UI.Composition.ICubicBezierEasingFunction {
+    Close(): void;
+    static CreateBackEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, amplitude: number): Windows.UI.Composition.BackEasingFunction;
+    static CreateBounceEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, bounces: number, bounciness: number): Windows.UI.Composition.BounceEasingFunction;
+    static CreateCircleEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.CircleEasingFunction;
+    static CreateCubicBezierEasingFunction(owner: Windows.UI.Composition.Compositor, controlPoint1: Windows.Foundation.Numerics.Vector2, controlPoint2: Windows.Foundation.Numerics.Vector2): Windows.UI.Composition.CubicBezierEasingFunction;
+    static CreateElasticEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, oscillations: number, springiness: number): Windows.UI.Composition.ElasticEasingFunction;
+    static CreateExponentialEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, exponent: number): Windows.UI.Composition.ExponentialEasingFunction;
+    static CreateLinearEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.LinearEasingFunction;
+    static CreatePowerEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, power: number): Windows.UI.Composition.PowerEasingFunction;
+    static CreateSineEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.SineEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.StepEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor, stepCount: number): Windows.UI.Composition.StepEasingFunction;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly ControlPoint1: Windows.Foundation.Numerics.Vector2;
+    readonly ControlPoint2: Windows.Foundation.Numerics.Vector2;
+  }
+
+  class DelegatedInkTrailVisual extends Windows.UI.Composition.Visual implements Windows.UI.Composition.IDelegatedInkTrailVisual {
+    AddTrailPoints(inkPoints: Windows.UI.Composition.InkTrailPoint[]): number;
+    AddTrailPointsWithPrediction(inkPoints: Windows.UI.Composition.InkTrailPoint[], predictedInkPoints: Windows.UI.Composition.InkTrailPoint[]): number;
+    Close(): void;
+    static Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.DelegatedInkTrailVisual;
+    static CreateForSwapChain(compositor: Windows.UI.Composition.Compositor, swapChain: Windows.UI.Composition.ICompositionSurface): Windows.UI.Composition.DelegatedInkTrailVisual;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    RemoveTrailPoints(generationId: number): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartNewTrail(color: Windows.UI.Color): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class DistantLight extends Windows.UI.Composition.CompositionLight implements Windows.UI.Composition.IDistantLight, Windows.UI.Composition.IDistantLight2 {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Color: Windows.UI.Color;
+    CoordinateSpace: Windows.UI.Composition.Visual;
+    Direction: Windows.Foundation.Numerics.Vector3;
+    Intensity: number;
+  }
+
+  class DropShadow extends Windows.UI.Composition.CompositionShadow implements Windows.UI.Composition.IDropShadow, Windows.UI.Composition.IDropShadow2 {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    BlurRadius: number;
+    Color: Windows.UI.Color;
+    Mask: Windows.UI.Composition.CompositionBrush;
+    Offset: Windows.Foundation.Numerics.Vector3;
+    Opacity: number;
+    SourcePolicy: number;
+  }
+
+  class ElasticEasingFunction extends Windows.UI.Composition.CompositionEasingFunction implements Windows.UI.Composition.IElasticEasingFunction {
+    Close(): void;
+    static CreateBackEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, amplitude: number): Windows.UI.Composition.BackEasingFunction;
+    static CreateBounceEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, bounces: number, bounciness: number): Windows.UI.Composition.BounceEasingFunction;
+    static CreateCircleEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.CircleEasingFunction;
+    static CreateCubicBezierEasingFunction(owner: Windows.UI.Composition.Compositor, controlPoint1: Windows.Foundation.Numerics.Vector2, controlPoint2: Windows.Foundation.Numerics.Vector2): Windows.UI.Composition.CubicBezierEasingFunction;
+    static CreateElasticEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, oscillations: number, springiness: number): Windows.UI.Composition.ElasticEasingFunction;
+    static CreateExponentialEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, exponent: number): Windows.UI.Composition.ExponentialEasingFunction;
+    static CreateLinearEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.LinearEasingFunction;
+    static CreatePowerEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, power: number): Windows.UI.Composition.PowerEasingFunction;
+    static CreateSineEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.SineEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.StepEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor, stepCount: number): Windows.UI.Composition.StepEasingFunction;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Mode: number;
+    readonly Oscillations: number;
+    readonly Springiness: number;
+  }
+
+  class ExponentialEasingFunction extends Windows.UI.Composition.CompositionEasingFunction implements Windows.UI.Composition.IExponentialEasingFunction {
+    Close(): void;
+    static CreateBackEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, amplitude: number): Windows.UI.Composition.BackEasingFunction;
+    static CreateBounceEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, bounces: number, bounciness: number): Windows.UI.Composition.BounceEasingFunction;
+    static CreateCircleEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.CircleEasingFunction;
+    static CreateCubicBezierEasingFunction(owner: Windows.UI.Composition.Compositor, controlPoint1: Windows.Foundation.Numerics.Vector2, controlPoint2: Windows.Foundation.Numerics.Vector2): Windows.UI.Composition.CubicBezierEasingFunction;
+    static CreateElasticEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, oscillations: number, springiness: number): Windows.UI.Composition.ElasticEasingFunction;
+    static CreateExponentialEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, exponent: number): Windows.UI.Composition.ExponentialEasingFunction;
+    static CreateLinearEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.LinearEasingFunction;
+    static CreatePowerEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, power: number): Windows.UI.Composition.PowerEasingFunction;
+    static CreateSineEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.SineEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.StepEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor, stepCount: number): Windows.UI.Composition.StepEasingFunction;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Exponent: number;
+    readonly Mode: number;
+  }
+
+  class ExpressionAnimation extends Windows.UI.Composition.CompositionAnimation implements Windows.UI.Composition.IExpressionAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Expression: string;
+  }
+
+  class ImplicitAnimationCollection extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.IImplicitAnimationCollection {
+    Clear(): void;
+    Close(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, Windows.UI.Composition.ICompositionAnimationBase>>;
+    GetView(): Windows.Foundation.Collections.IMapView<string, Windows.UI.Composition.ICompositionAnimationBase>;
+    HasKey(key: string): boolean;
+    Insert(key: string, value: Windows.UI.Composition.ICompositionAnimationBase): boolean;
+    Lookup(key: string): Windows.UI.Composition.ICompositionAnimationBase;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    Remove(key: string): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Size: number;
+  }
+
+  class InitialValueExpressionCollection extends Windows.UI.Composition.CompositionObject {
+    Clear(): void;
+    Close(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, string>>;
+    GetView(): Windows.Foundation.Collections.IMapView<string, string>;
+    HasKey(key: string): boolean;
+    Insert(key: string, value: string): boolean;
+    Lookup(key: string): string;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    Remove(key: string): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Size: number;
+  }
+
+  class InsetClip extends Windows.UI.Composition.CompositionClip implements Windows.UI.Composition.IInsetClip {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    BottomInset: number;
+    LeftInset: number;
+    RightInset: number;
+    TopInset: number;
+  }
+
+  class KeyFrameAnimation extends Windows.UI.Composition.CompositionAnimation implements Windows.UI.Composition.IKeyFrameAnimation, Windows.UI.Composition.IKeyFrameAnimation2, Windows.UI.Composition.IKeyFrameAnimation3 {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string): void;
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    DelayBehavior: number;
+    DelayTime: Windows.Foundation.TimeSpan;
+    Direction: number;
+    Duration: Windows.Foundation.TimeSpan;
+    IterationBehavior: number;
+    IterationCount: number;
+    readonly KeyFrameCount: number;
+    StopBehavior: number;
+  }
+
+  class LayerVisual extends Windows.UI.Composition.ContainerVisual implements Windows.UI.Composition.ILayerVisual, Windows.UI.Composition.ILayerVisual2 {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Effect: Windows.UI.Composition.CompositionEffectBrush;
+    Shadow: Windows.UI.Composition.CompositionShadow;
+  }
+
+  class LinearEasingFunction extends Windows.UI.Composition.CompositionEasingFunction implements Windows.UI.Composition.ILinearEasingFunction {
+    Close(): void;
+    static CreateBackEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, amplitude: number): Windows.UI.Composition.BackEasingFunction;
+    static CreateBounceEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, bounces: number, bounciness: number): Windows.UI.Composition.BounceEasingFunction;
+    static CreateCircleEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.CircleEasingFunction;
+    static CreateCubicBezierEasingFunction(owner: Windows.UI.Composition.Compositor, controlPoint1: Windows.Foundation.Numerics.Vector2, controlPoint2: Windows.Foundation.Numerics.Vector2): Windows.UI.Composition.CubicBezierEasingFunction;
+    static CreateElasticEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, oscillations: number, springiness: number): Windows.UI.Composition.ElasticEasingFunction;
+    static CreateExponentialEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, exponent: number): Windows.UI.Composition.ExponentialEasingFunction;
+    static CreateLinearEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.LinearEasingFunction;
+    static CreatePowerEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, power: number): Windows.UI.Composition.PowerEasingFunction;
+    static CreateSineEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.SineEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.StepEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor, stepCount: number): Windows.UI.Composition.StepEasingFunction;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class NaturalMotionAnimation extends Windows.UI.Composition.CompositionAnimation implements Windows.UI.Composition.INaturalMotionAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    DelayBehavior: number;
+    DelayTime: Windows.Foundation.TimeSpan;
+    StopBehavior: number;
+  }
+
+  class PathKeyFrameAnimation extends Windows.UI.Composition.KeyFrameAnimation implements Windows.UI.Composition.IPathKeyFrameAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string): void;
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+    InsertKeyFrame(normalizedProgressKey: number, path: Windows.UI.Composition.CompositionPath): void;
+    InsertKeyFrame(normalizedProgressKey: number, path: Windows.UI.Composition.CompositionPath, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class PointLight extends Windows.UI.Composition.CompositionLight implements Windows.UI.Composition.IPointLight, Windows.UI.Composition.IPointLight2, Windows.UI.Composition.IPointLight3 {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Color: Windows.UI.Color;
+    ConstantAttenuation: number;
+    CoordinateSpace: Windows.UI.Composition.Visual;
+    Intensity: number;
+    LinearAttenuation: number;
+    MaxAttenuationCutoff: number;
+    MinAttenuationCutoff: number;
+    Offset: Windows.Foundation.Numerics.Vector3;
+    QuadraticAttenuation: number;
+  }
+
+  class PowerEasingFunction extends Windows.UI.Composition.CompositionEasingFunction implements Windows.UI.Composition.IPowerEasingFunction {
+    Close(): void;
+    static CreateBackEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, amplitude: number): Windows.UI.Composition.BackEasingFunction;
+    static CreateBounceEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, bounces: number, bounciness: number): Windows.UI.Composition.BounceEasingFunction;
+    static CreateCircleEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.CircleEasingFunction;
+    static CreateCubicBezierEasingFunction(owner: Windows.UI.Composition.Compositor, controlPoint1: Windows.Foundation.Numerics.Vector2, controlPoint2: Windows.Foundation.Numerics.Vector2): Windows.UI.Composition.CubicBezierEasingFunction;
+    static CreateElasticEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, oscillations: number, springiness: number): Windows.UI.Composition.ElasticEasingFunction;
+    static CreateExponentialEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, exponent: number): Windows.UI.Composition.ExponentialEasingFunction;
+    static CreateLinearEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.LinearEasingFunction;
+    static CreatePowerEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, power: number): Windows.UI.Composition.PowerEasingFunction;
+    static CreateSineEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.SineEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.StepEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor, stepCount: number): Windows.UI.Composition.StepEasingFunction;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Mode: number;
+    readonly Power: number;
+  }
+
+  class QuaternionKeyFrameAnimation extends Windows.UI.Composition.KeyFrameAnimation implements Windows.UI.Composition.IQuaternionKeyFrameAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string): void;
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.Foundation.Numerics.Quaternion): void;
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.Foundation.Numerics.Quaternion, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class RectangleClip extends Windows.UI.Composition.CompositionClip implements Windows.UI.Composition.IRectangleClip {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Bottom: number;
+    BottomLeftRadius: Windows.Foundation.Numerics.Vector2;
+    BottomRightRadius: Windows.Foundation.Numerics.Vector2;
+    Left: number;
+    Right: number;
+    Top: number;
+    TopLeftRadius: Windows.Foundation.Numerics.Vector2;
+    TopRightRadius: Windows.Foundation.Numerics.Vector2;
+  }
+
+  class RedirectVisual extends Windows.UI.Composition.ContainerVisual implements Windows.UI.Composition.IRedirectVisual {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Source: Windows.UI.Composition.Visual;
+  }
+
+  class RenderingDeviceReplacedEventArgs extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.IRenderingDeviceReplacedEventArgs {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly GraphicsDevice: Windows.UI.Composition.CompositionGraphicsDevice;
+  }
+
+  class ScalarKeyFrameAnimation extends Windows.UI.Composition.KeyFrameAnimation implements Windows.UI.Composition.IScalarKeyFrameAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string): void;
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+    InsertKeyFrame(normalizedProgressKey: number, value: number): void;
+    InsertKeyFrame(normalizedProgressKey: number, value: number, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class ScalarNaturalMotionAnimation extends Windows.UI.Composition.NaturalMotionAnimation implements Windows.UI.Composition.IScalarNaturalMotionAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    FinalValue: number | null;
+    InitialValue: number | null;
+    InitialVelocity: number;
+  }
+
+  class ShapeVisual extends Windows.UI.Composition.ContainerVisual implements Windows.UI.Composition.IShapeVisual {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Shapes: Windows.UI.Composition.CompositionShapeCollection;
+    ViewBox: Windows.UI.Composition.CompositionViewBox;
+  }
+
+  class SineEasingFunction extends Windows.UI.Composition.CompositionEasingFunction implements Windows.UI.Composition.ISineEasingFunction {
+    Close(): void;
+    static CreateBackEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, amplitude: number): Windows.UI.Composition.BackEasingFunction;
+    static CreateBounceEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, bounces: number, bounciness: number): Windows.UI.Composition.BounceEasingFunction;
+    static CreateCircleEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.CircleEasingFunction;
+    static CreateCubicBezierEasingFunction(owner: Windows.UI.Composition.Compositor, controlPoint1: Windows.Foundation.Numerics.Vector2, controlPoint2: Windows.Foundation.Numerics.Vector2): Windows.UI.Composition.CubicBezierEasingFunction;
+    static CreateElasticEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, oscillations: number, springiness: number): Windows.UI.Composition.ElasticEasingFunction;
+    static CreateExponentialEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, exponent: number): Windows.UI.Composition.ExponentialEasingFunction;
+    static CreateLinearEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.LinearEasingFunction;
+    static CreatePowerEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, power: number): Windows.UI.Composition.PowerEasingFunction;
+    static CreateSineEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.SineEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.StepEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor, stepCount: number): Windows.UI.Composition.StepEasingFunction;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Mode: number;
+  }
+
+  class SpotLight extends Windows.UI.Composition.CompositionLight implements Windows.UI.Composition.ISpotLight, Windows.UI.Composition.ISpotLight2, Windows.UI.Composition.ISpotLight3 {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    ConstantAttenuation: number;
+    CoordinateSpace: Windows.UI.Composition.Visual;
+    Direction: Windows.Foundation.Numerics.Vector3;
+    InnerConeAngle: number;
+    InnerConeAngleInDegrees: number;
+    InnerConeColor: Windows.UI.Color;
+    InnerConeIntensity: number;
+    LinearAttenuation: number;
+    MaxAttenuationCutoff: number;
+    MinAttenuationCutoff: number;
+    Offset: Windows.Foundation.Numerics.Vector3;
+    OuterConeAngle: number;
+    OuterConeAngleInDegrees: number;
+    OuterConeColor: Windows.UI.Color;
+    OuterConeIntensity: number;
+    QuadraticAttenuation: number;
+  }
+
+  class SpringScalarNaturalMotionAnimation extends Windows.UI.Composition.ScalarNaturalMotionAnimation implements Windows.UI.Composition.ISpringScalarNaturalMotionAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    DampingRatio: number;
+    Period: Windows.Foundation.TimeSpan;
+  }
+
+  class SpringVector2NaturalMotionAnimation extends Windows.UI.Composition.Vector2NaturalMotionAnimation implements Windows.UI.Composition.ISpringVector2NaturalMotionAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    DampingRatio: number;
+    Period: Windows.Foundation.TimeSpan;
+  }
+
+  class SpringVector3NaturalMotionAnimation extends Windows.UI.Composition.Vector3NaturalMotionAnimation implements Windows.UI.Composition.ISpringVector3NaturalMotionAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    DampingRatio: number;
+    Period: Windows.Foundation.TimeSpan;
+  }
+
+  class SpriteVisual extends Windows.UI.Composition.ContainerVisual implements Windows.UI.Composition.ISpriteVisual, Windows.UI.Composition.ISpriteVisual2 {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Brush: Windows.UI.Composition.CompositionBrush;
+    Shadow: Windows.UI.Composition.CompositionShadow;
+  }
+
+  class StepEasingFunction extends Windows.UI.Composition.CompositionEasingFunction implements Windows.UI.Composition.IStepEasingFunction {
+    Close(): void;
+    static CreateBackEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, amplitude: number): Windows.UI.Composition.BackEasingFunction;
+    static CreateBounceEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, bounces: number, bounciness: number): Windows.UI.Composition.BounceEasingFunction;
+    static CreateCircleEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.CircleEasingFunction;
+    static CreateCubicBezierEasingFunction(owner: Windows.UI.Composition.Compositor, controlPoint1: Windows.Foundation.Numerics.Vector2, controlPoint2: Windows.Foundation.Numerics.Vector2): Windows.UI.Composition.CubicBezierEasingFunction;
+    static CreateElasticEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, oscillations: number, springiness: number): Windows.UI.Composition.ElasticEasingFunction;
+    static CreateExponentialEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, exponent: number): Windows.UI.Composition.ExponentialEasingFunction;
+    static CreateLinearEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.LinearEasingFunction;
+    static CreatePowerEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, power: number): Windows.UI.Composition.PowerEasingFunction;
+    static CreateSineEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.SineEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.StepEasingFunction;
+    static CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor, stepCount: number): Windows.UI.Composition.StepEasingFunction;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    FinalStep: number;
+    InitialStep: number;
+    IsFinalStepSingleFrame: boolean;
+    IsInitialStepSingleFrame: boolean;
+    StepCount: number;
+  }
+
+  class Vector2KeyFrameAnimation extends Windows.UI.Composition.KeyFrameAnimation implements Windows.UI.Composition.IVector2KeyFrameAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string): void;
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.Foundation.Numerics.Vector2): void;
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.Foundation.Numerics.Vector2, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class Vector2NaturalMotionAnimation extends Windows.UI.Composition.NaturalMotionAnimation implements Windows.UI.Composition.IVector2NaturalMotionAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    FinalValue: Windows.Foundation.Numerics.Vector2 | null;
+    InitialValue: Windows.Foundation.Numerics.Vector2 | null;
+    InitialVelocity: Windows.Foundation.Numerics.Vector2;
+  }
+
+  class Vector3KeyFrameAnimation extends Windows.UI.Composition.KeyFrameAnimation implements Windows.UI.Composition.IVector3KeyFrameAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string): void;
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.Foundation.Numerics.Vector3): void;
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.Foundation.Numerics.Vector3, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class Vector3NaturalMotionAnimation extends Windows.UI.Composition.NaturalMotionAnimation implements Windows.UI.Composition.IVector3NaturalMotionAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    FinalValue: Windows.Foundation.Numerics.Vector3 | null;
+    InitialValue: Windows.Foundation.Numerics.Vector3 | null;
+    InitialVelocity: Windows.Foundation.Numerics.Vector3;
+  }
+
+  class Vector4KeyFrameAnimation extends Windows.UI.Composition.KeyFrameAnimation implements Windows.UI.Composition.IVector4KeyFrameAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    Close(): void;
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string): void;
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.Foundation.Numerics.Vector4): void;
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.Foundation.Numerics.Vector4, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    SetBooleanParameter(key: string, value: boolean): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class Visual extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.IVisual, Windows.UI.Composition.IVisual2, Windows.UI.Composition.IVisual3, Windows.UI.Composition.IVisual4 {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    AnchorPoint: Windows.Foundation.Numerics.Vector2;
+    BackfaceVisibility: number;
+    BorderMode: number;
+    CenterPoint: Windows.Foundation.Numerics.Vector3;
+    Clip: Windows.UI.Composition.CompositionClip;
+    CompositeMode: number;
+    IsHitTestVisible: boolean;
+    IsPixelSnappingEnabled: boolean;
+    IsVisible: boolean;
+    Offset: Windows.Foundation.Numerics.Vector3;
+    Opacity: number;
+    Orientation: Windows.Foundation.Numerics.Quaternion;
+    readonly Parent: Windows.UI.Composition.ContainerVisual;
+    ParentForTransform: Windows.UI.Composition.Visual;
+    RelativeOffsetAdjustment: Windows.Foundation.Numerics.Vector3;
+    RelativeSizeAdjustment: Windows.Foundation.Numerics.Vector2;
+    RotationAngle: number;
+    RotationAngleInDegrees: number;
+    RotationAxis: Windows.Foundation.Numerics.Vector3;
+    Scale: Windows.Foundation.Numerics.Vector3;
+    Size: Windows.Foundation.Numerics.Vector2;
+    TransformMatrix: Windows.Foundation.Numerics.Matrix4x4;
+  }
+
+  class VisualCollection extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.IVisualCollection {
+    Close(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Composition.Visual>;
+    InsertAbove(newChild: Windows.UI.Composition.Visual, sibling: Windows.UI.Composition.Visual): void;
+    InsertAtBottom(newChild: Windows.UI.Composition.Visual): void;
+    InsertAtTop(newChild: Windows.UI.Composition.Visual): void;
+    InsertBelow(newChild: Windows.UI.Composition.Visual, sibling: Windows.UI.Composition.Visual): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    Remove(child: Windows.UI.Composition.Visual): void;
+    RemoveAll(): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Count: number;
+  }
+
+  class VisualUnorderedCollection extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.IVisualUnorderedCollection {
+    Add(newVisual: Windows.UI.Composition.Visual): void;
+    Close(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Composition.Visual>;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    Remove(visual: Windows.UI.Composition.Visual): void;
+    RemoveAll(): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Count: number;
+  }
+
+  enum AnimationControllerProgressBehavior {
+    Default = 0,
+    IncludesDelayTime = 1,
+  }
+
+  enum AnimationDelayBehavior {
+    SetInitialValueAfterDelay = 0,
+    SetInitialValueBeforeDelay = 1,
+  }
+
+  enum AnimationDirection {
+    Normal = 0,
+    Reverse = 1,
+    Alternate = 2,
+    AlternateReverse = 3,
+  }
+
+  enum AnimationIterationBehavior {
+    Count = 0,
+    Forever = 1,
+  }
+
+  enum AnimationPropertyAccessMode {
+    None = 0,
+    ReadOnly = 1,
+    WriteOnly = 2,
+    ReadWrite = 3,
+  }
+
+  enum AnimationStopBehavior {
+    LeaveCurrentValue = 0,
+    SetToInitialValue = 1,
+    SetToFinalValue = 2,
+  }
+
+  enum CompositionBackfaceVisibility {
+    Inherit = 0,
+    Visible = 1,
+    Hidden = 2,
+  }
+
+  enum CompositionBatchTypes {
+    None = 0,
+    Animation = 1,
+    Effect = 2,
+    InfiniteAnimation = 4,
+    AllAnimations = 5,
+  }
+
+  enum CompositionBitmapInterpolationMode {
+    NearestNeighbor = 0,
+    Linear = 1,
+    MagLinearMinLinearMipLinear = 2,
+    MagLinearMinLinearMipNearest = 3,
+    MagLinearMinNearestMipLinear = 4,
+    MagLinearMinNearestMipNearest = 5,
+    MagNearestMinLinearMipLinear = 6,
+    MagNearestMinLinearMipNearest = 7,
+    MagNearestMinNearestMipLinear = 8,
+    MagNearestMinNearestMipNearest = 9,
+  }
+
+  enum CompositionBorderMode {
+    Inherit = 0,
+    Soft = 1,
+    Hard = 2,
+  }
+
+  enum CompositionColorSpace {
+    Auto = 0,
+    Hsl = 1,
+    Rgb = 2,
+    HslLinear = 3,
+    RgbLinear = 4,
+  }
+
+  enum CompositionCompositeMode {
+    Inherit = 0,
+    SourceOver = 1,
+    DestinationInvert = 2,
+    MinBlend = 3,
+  }
+
+  enum CompositionDropShadowSourcePolicy {
+    Default = 0,
+    InheritFromVisualContent = 1,
+  }
+
+  enum CompositionEasingFunctionMode {
+    In = 0,
+    Out = 1,
+    InOut = 2,
+  }
+
+  enum CompositionEffectFactoryLoadStatus {
+    Success = 0,
+    EffectTooComplex = 1,
+    Pending = 2,
+    Other = -1,
+  }
+
+  enum CompositionGetValueStatus {
+    Succeeded = 0,
+    TypeMismatch = 1,
+    NotFound = 2,
+  }
+
+  enum CompositionGradientExtendMode {
+    Clamp = 0,
+    Wrap = 1,
+    Mirror = 2,
+  }
+
+  enum CompositionMappingMode {
+    Absolute = 0,
+    Relative = 1,
+  }
+
+  enum CompositionStretch {
+    None = 0,
+    Fill = 1,
+    Uniform = 2,
+    UniformToFill = 3,
+  }
+
+  enum CompositionStrokeCap {
+    Flat = 0,
+    Square = 1,
+    Round = 2,
+    Triangle = 3,
+  }
+
+  enum CompositionStrokeLineJoin {
+    Miter = 0,
+    Bevel = 1,
+    Round = 2,
+    MiterOrBevel = 3,
+  }
+
+  interface IAmbientLight {
+    Color: Windows.UI.Color;
+  }
+  var IAmbientLight: abstract new (...args: any[]) => IAmbientLight;
+
+  interface IAmbientLight2 {
+    Intensity: number;
+  }
+  var IAmbientLight2: abstract new (...args: any[]) => IAmbientLight2;
+
+  interface IAnimationController {
+    Pause(): void;
+    Resume(): void;
+    PlaybackRate: number;
+    Progress: number;
+    ProgressBehavior: number;
+  }
+  var IAnimationController: abstract new (...args: any[]) => IAnimationController;
+
+  interface IAnimationControllerStatics {
+    readonly MaxPlaybackRate: number;
+    readonly MinPlaybackRate: number;
+  }
+  var IAnimationControllerStatics: abstract new (...args: any[]) => IAnimationControllerStatics;
+
+  interface IAnimationObject {
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+  }
+  var IAnimationObject: abstract new (...args: any[]) => IAnimationObject;
+
+  interface IAnimationPropertyInfo {
+    AccessMode: number;
+  }
+  var IAnimationPropertyInfo: abstract new (...args: any[]) => IAnimationPropertyInfo;
+
+  interface IAnimationPropertyInfo2 {
+    GetResolvedCompositionObject(): Windows.UI.Composition.CompositionObject;
+    GetResolvedCompositionObjectProperty(): string;
+  }
+  var IAnimationPropertyInfo2: abstract new (...args: any[]) => IAnimationPropertyInfo2;
+
+  interface IBackEasingFunction {
+    readonly Amplitude: number;
+    readonly Mode: number;
+  }
+  var IBackEasingFunction: abstract new (...args: any[]) => IBackEasingFunction;
+
+  interface IBooleanKeyFrameAnimation {
+    InsertKeyFrame(normalizedProgressKey: number, value: boolean): void;
+  }
+  var IBooleanKeyFrameAnimation: abstract new (...args: any[]) => IBooleanKeyFrameAnimation;
+
+  interface IBounceEasingFunction {
+    readonly Bounces: number;
+    readonly Bounciness: number;
+    readonly Mode: number;
+  }
+  var IBounceEasingFunction: abstract new (...args: any[]) => IBounceEasingFunction;
+
+  interface IBounceScalarNaturalMotionAnimation {
+    Acceleration: number;
+    Restitution: number;
+  }
+  var IBounceScalarNaturalMotionAnimation: abstract new (...args: any[]) => IBounceScalarNaturalMotionAnimation;
+
+  interface IBounceVector2NaturalMotionAnimation {
+    Acceleration: number;
+    Restitution: number;
+  }
+  var IBounceVector2NaturalMotionAnimation: abstract new (...args: any[]) => IBounceVector2NaturalMotionAnimation;
+
+  interface IBounceVector3NaturalMotionAnimation {
+    Acceleration: number;
+    Restitution: number;
+  }
+  var IBounceVector3NaturalMotionAnimation: abstract new (...args: any[]) => IBounceVector3NaturalMotionAnimation;
+
+  interface ICircleEasingFunction {
+    readonly Mode: number;
+  }
+  var ICircleEasingFunction: abstract new (...args: any[]) => ICircleEasingFunction;
+
+  interface IColorKeyFrameAnimation {
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.UI.Color): void;
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.UI.Color, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+    InterpolationColorSpace: number;
+  }
+  var IColorKeyFrameAnimation: abstract new (...args: any[]) => IColorKeyFrameAnimation;
+
+  interface ICompositionAnimation {
+    ClearAllParameters(): void;
+    ClearParameter(key: string): void;
+    SetColorParameter(key: string, value: Windows.UI.Color): void;
+    SetMatrix3x2Parameter(key: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    SetMatrix4x4Parameter(key: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    SetQuaternionParameter(key: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    SetReferenceParameter(key: string, compositionObject: Windows.UI.Composition.CompositionObject): void;
+    SetScalarParameter(key: string, value: number): void;
+    SetVector2Parameter(key: string, value: Windows.Foundation.Numerics.Vector2): void;
+    SetVector3Parameter(key: string, value: Windows.Foundation.Numerics.Vector3): void;
+    SetVector4Parameter(key: string, value: Windows.Foundation.Numerics.Vector4): void;
+  }
+  var ICompositionAnimation: abstract new (...args: any[]) => ICompositionAnimation;
+
+  interface ICompositionAnimation2 {
+    SetBooleanParameter(key: string, value: boolean): void;
+    Target: string;
+  }
+  var ICompositionAnimation2: abstract new (...args: any[]) => ICompositionAnimation2;
+
+  interface ICompositionAnimation3 {
+    readonly InitialValueExpressions: Windows.UI.Composition.InitialValueExpressionCollection;
+  }
+  var ICompositionAnimation3: abstract new (...args: any[]) => ICompositionAnimation3;
+
+  interface ICompositionAnimation4 {
+    SetExpressionReferenceParameter(parameterName: string, source: Windows.UI.Composition.IAnimationObject): void;
+  }
+  var ICompositionAnimation4: abstract new (...args: any[]) => ICompositionAnimation4;
+
+  interface ICompositionAnimationBase {
+  }
+  var ICompositionAnimationBase: abstract new (...args: any[]) => ICompositionAnimationBase;
+
+  interface ICompositionAnimationFactory {
+  }
+  var ICompositionAnimationFactory: abstract new (...args: any[]) => ICompositionAnimationFactory;
+
+  interface ICompositionAnimationGroup {
+    Add(value: Windows.UI.Composition.CompositionAnimation): void;
+    Remove(value: Windows.UI.Composition.CompositionAnimation): void;
+    RemoveAll(): void;
+    readonly Count: number;
+  }
+  var ICompositionAnimationGroup: abstract new (...args: any[]) => ICompositionAnimationGroup;
+
+  interface ICompositionBackdropBrush {
+  }
+  var ICompositionBackdropBrush: abstract new (...args: any[]) => ICompositionBackdropBrush;
+
+  interface ICompositionBatchCompletedEventArgs {
+  }
+  var ICompositionBatchCompletedEventArgs: abstract new (...args: any[]) => ICompositionBatchCompletedEventArgs;
+
+  interface ICompositionBrush {
+  }
+  var ICompositionBrush: abstract new (...args: any[]) => ICompositionBrush;
+
+  interface ICompositionBrushFactory {
+  }
+  var ICompositionBrushFactory: abstract new (...args: any[]) => ICompositionBrushFactory;
+
+  interface ICompositionCapabilities {
+    AreEffectsFast(): boolean;
+    AreEffectsSupported(): boolean;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.UI.Composition.CompositionCapabilities, Object> | null;
+  }
+  var ICompositionCapabilities: abstract new (...args: any[]) => ICompositionCapabilities;
+
+  interface ICompositionCapabilitiesStatics {
+    GetForCurrentView(): Windows.UI.Composition.CompositionCapabilities;
+  }
+  var ICompositionCapabilitiesStatics: abstract new (...args: any[]) => ICompositionCapabilitiesStatics;
+
+  interface ICompositionClip {
+  }
+  var ICompositionClip: abstract new (...args: any[]) => ICompositionClip;
+
+  interface ICompositionClip2 {
+    AnchorPoint: Windows.Foundation.Numerics.Vector2;
+    CenterPoint: Windows.Foundation.Numerics.Vector2;
+    Offset: Windows.Foundation.Numerics.Vector2;
+    RotationAngle: number;
+    RotationAngleInDegrees: number;
+    Scale: Windows.Foundation.Numerics.Vector2;
+    TransformMatrix: Windows.Foundation.Numerics.Matrix3x2;
+  }
+  var ICompositionClip2: abstract new (...args: any[]) => ICompositionClip2;
+
+  interface ICompositionClipFactory {
+  }
+  var ICompositionClipFactory: abstract new (...args: any[]) => ICompositionClipFactory;
+
+  interface ICompositionColorBrush {
+    Color: Windows.UI.Color;
+  }
+  var ICompositionColorBrush: abstract new (...args: any[]) => ICompositionColorBrush;
+
+  interface ICompositionColorGradientStop {
+    Color: Windows.UI.Color;
+    Offset: number;
+  }
+  var ICompositionColorGradientStop: abstract new (...args: any[]) => ICompositionColorGradientStop;
+
+  interface ICompositionColorGradientStopCollection {
+  }
+  var ICompositionColorGradientStopCollection: abstract new (...args: any[]) => ICompositionColorGradientStopCollection;
+
+  interface ICompositionCommitBatch {
+    readonly IsActive: boolean;
+    readonly IsEnded: boolean;
+    Completed: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Composition.CompositionBatchCompletedEventArgs> | null;
+  }
+  var ICompositionCommitBatch: abstract new (...args: any[]) => ICompositionCommitBatch;
+
+  interface ICompositionContainerShape {
+    readonly Shapes: Windows.UI.Composition.CompositionShapeCollection;
+  }
+  var ICompositionContainerShape: abstract new (...args: any[]) => ICompositionContainerShape;
+
+  interface ICompositionDrawingSurface {
+    readonly AlphaMode: number;
+    readonly PixelFormat: number;
+    readonly Size: Windows.Foundation.Size;
+  }
+  var ICompositionDrawingSurface: abstract new (...args: any[]) => ICompositionDrawingSurface;
+
+  interface ICompositionDrawingSurface2 {
+    Resize(sizePixels: Windows.Graphics.SizeInt32): void;
+    Scroll(offset: Windows.Graphics.PointInt32): void;
+    Scroll(offset: Windows.Graphics.PointInt32, scrollRect: Windows.Graphics.RectInt32): void;
+    ScrollWithClip(offset: Windows.Graphics.PointInt32, clipRect: Windows.Graphics.RectInt32): void;
+    ScrollWithClip(offset: Windows.Graphics.PointInt32, clipRect: Windows.Graphics.RectInt32, scrollRect: Windows.Graphics.RectInt32): void;
+    readonly SizeInt32: Windows.Graphics.SizeInt32;
+  }
+  var ICompositionDrawingSurface2: abstract new (...args: any[]) => ICompositionDrawingSurface2;
+
+  interface ICompositionDrawingSurfaceFactory {
+  }
+  var ICompositionDrawingSurfaceFactory: abstract new (...args: any[]) => ICompositionDrawingSurfaceFactory;
+
+  interface ICompositionEasingFunction {
+  }
+  var ICompositionEasingFunction: abstract new (...args: any[]) => ICompositionEasingFunction;
+
+  interface ICompositionEasingFunctionFactory {
+  }
+  var ICompositionEasingFunctionFactory: abstract new (...args: any[]) => ICompositionEasingFunctionFactory;
+
+  interface ICompositionEasingFunctionStatics {
+    CreateBackEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, amplitude: number): Windows.UI.Composition.BackEasingFunction;
+    CreateBounceEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, bounces: number, bounciness: number): Windows.UI.Composition.BounceEasingFunction;
+    CreateCircleEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.CircleEasingFunction;
+    CreateCubicBezierEasingFunction(owner: Windows.UI.Composition.Compositor, controlPoint1: Windows.Foundation.Numerics.Vector2, controlPoint2: Windows.Foundation.Numerics.Vector2): Windows.UI.Composition.CubicBezierEasingFunction;
+    CreateElasticEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, oscillations: number, springiness: number): Windows.UI.Composition.ElasticEasingFunction;
+    CreateExponentialEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, exponent: number): Windows.UI.Composition.ExponentialEasingFunction;
+    CreateLinearEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.LinearEasingFunction;
+    CreatePowerEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number, power: number): Windows.UI.Composition.PowerEasingFunction;
+    CreateSineEasingFunction(owner: Windows.UI.Composition.Compositor, mode: number): Windows.UI.Composition.SineEasingFunction;
+    CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor): Windows.UI.Composition.StepEasingFunction;
+    CreateStepEasingFunction(owner: Windows.UI.Composition.Compositor, stepCount: number): Windows.UI.Composition.StepEasingFunction;
+  }
+  var ICompositionEasingFunctionStatics: abstract new (...args: any[]) => ICompositionEasingFunctionStatics;
+
+  interface ICompositionEffectBrush {
+    GetSourceParameter(name: string): Windows.UI.Composition.CompositionBrush;
+    SetSourceParameter(name: string, source: Windows.UI.Composition.CompositionBrush): void;
+  }
+  var ICompositionEffectBrush: abstract new (...args: any[]) => ICompositionEffectBrush;
+
+  interface ICompositionEffectFactory {
+    CreateBrush(): Windows.UI.Composition.CompositionEffectBrush;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly LoadStatus: number;
+  }
+  var ICompositionEffectFactory: abstract new (...args: any[]) => ICompositionEffectFactory;
+
+  interface ICompositionEffectSourceParameter {
+    readonly Name: string;
+  }
+  var ICompositionEffectSourceParameter: abstract new (...args: any[]) => ICompositionEffectSourceParameter;
+
+  interface ICompositionEffectSourceParameterFactory {
+    Create(name: string): Windows.UI.Composition.CompositionEffectSourceParameter;
+  }
+  var ICompositionEffectSourceParameterFactory: abstract new (...args: any[]) => ICompositionEffectSourceParameterFactory;
+
+  interface ICompositionEllipseGeometry {
+    Center: Windows.Foundation.Numerics.Vector2;
+    Radius: Windows.Foundation.Numerics.Vector2;
+  }
+  var ICompositionEllipseGeometry: abstract new (...args: any[]) => ICompositionEllipseGeometry;
+
+  interface ICompositionGeometricClip {
+    Geometry: Windows.UI.Composition.CompositionGeometry;
+    ViewBox: Windows.UI.Composition.CompositionViewBox;
+  }
+  var ICompositionGeometricClip: abstract new (...args: any[]) => ICompositionGeometricClip;
+
+  interface ICompositionGeometry {
+    TrimEnd: number;
+    TrimOffset: number;
+    TrimStart: number;
+  }
+  var ICompositionGeometry: abstract new (...args: any[]) => ICompositionGeometry;
+
+  interface ICompositionGeometryFactory {
+  }
+  var ICompositionGeometryFactory: abstract new (...args: any[]) => ICompositionGeometryFactory;
+
+  interface ICompositionGradientBrush {
+    AnchorPoint: Windows.Foundation.Numerics.Vector2;
+    CenterPoint: Windows.Foundation.Numerics.Vector2;
+    readonly ColorStops: Windows.UI.Composition.CompositionColorGradientStopCollection;
+    ExtendMode: number;
+    InterpolationSpace: number;
+    Offset: Windows.Foundation.Numerics.Vector2;
+    RotationAngle: number;
+    RotationAngleInDegrees: number;
+    Scale: Windows.Foundation.Numerics.Vector2;
+    TransformMatrix: Windows.Foundation.Numerics.Matrix3x2;
+  }
+  var ICompositionGradientBrush: abstract new (...args: any[]) => ICompositionGradientBrush;
+
+  interface ICompositionGradientBrush2 {
+    MappingMode: number;
+  }
+  var ICompositionGradientBrush2: abstract new (...args: any[]) => ICompositionGradientBrush2;
+
+  interface ICompositionGradientBrushFactory {
+  }
+  var ICompositionGradientBrushFactory: abstract new (...args: any[]) => ICompositionGradientBrushFactory;
+
+  interface ICompositionGraphicsDevice {
+    CreateDrawingSurface(sizePixels: Windows.Foundation.Size, pixelFormat: number, alphaMode: number): Windows.UI.Composition.CompositionDrawingSurface;
+    RenderingDeviceReplaced: Windows.Foundation.TypedEventHandler<Windows.UI.Composition.CompositionGraphicsDevice, Windows.UI.Composition.RenderingDeviceReplacedEventArgs> | null;
+  }
+  var ICompositionGraphicsDevice: abstract new (...args: any[]) => ICompositionGraphicsDevice;
+
+  interface ICompositionGraphicsDevice2 {
+    CreateDrawingSurface2(sizePixels: Windows.Graphics.SizeInt32, pixelFormat: number, alphaMode: number): Windows.UI.Composition.CompositionDrawingSurface;
+    CreateVirtualDrawingSurface(sizePixels: Windows.Graphics.SizeInt32, pixelFormat: number, alphaMode: number): Windows.UI.Composition.CompositionVirtualDrawingSurface;
+  }
+  var ICompositionGraphicsDevice2: abstract new (...args: any[]) => ICompositionGraphicsDevice2;
+
+  interface ICompositionGraphicsDevice3 {
+    CreateMipmapSurface(sizePixels: Windows.Graphics.SizeInt32, pixelFormat: number, alphaMode: number): Windows.UI.Composition.CompositionMipmapSurface;
+    Trim(): void;
+  }
+  var ICompositionGraphicsDevice3: abstract new (...args: any[]) => ICompositionGraphicsDevice3;
+
+  interface ICompositionGraphicsDevice4 {
+    CaptureAsync(captureVisual: Windows.UI.Composition.Visual, size: Windows.Graphics.SizeInt32, pixelFormat: number, alphaMode: number, sdrBoost: number): Windows.Foundation.IAsyncOperation<Windows.UI.Composition.ICompositionSurface>;
+  }
+  var ICompositionGraphicsDevice4: abstract new (...args: any[]) => ICompositionGraphicsDevice4;
+
+  interface ICompositionLight {
+    readonly Targets: Windows.UI.Composition.VisualUnorderedCollection;
+  }
+  var ICompositionLight: abstract new (...args: any[]) => ICompositionLight;
+
+  interface ICompositionLight2 {
+    readonly ExclusionsFromTargets: Windows.UI.Composition.VisualUnorderedCollection;
+  }
+  var ICompositionLight2: abstract new (...args: any[]) => ICompositionLight2;
+
+  interface ICompositionLight3 {
+    IsEnabled: boolean;
+  }
+  var ICompositionLight3: abstract new (...args: any[]) => ICompositionLight3;
+
+  interface ICompositionLightFactory {
+  }
+  var ICompositionLightFactory: abstract new (...args: any[]) => ICompositionLightFactory;
+
+  interface ICompositionLineGeometry {
+    End: Windows.Foundation.Numerics.Vector2;
+    Start: Windows.Foundation.Numerics.Vector2;
+  }
+  var ICompositionLineGeometry: abstract new (...args: any[]) => ICompositionLineGeometry;
+
+  interface ICompositionLinearGradientBrush {
+    EndPoint: Windows.Foundation.Numerics.Vector2;
+    StartPoint: Windows.Foundation.Numerics.Vector2;
+  }
+  var ICompositionLinearGradientBrush: abstract new (...args: any[]) => ICompositionLinearGradientBrush;
+
+  interface ICompositionMaskBrush {
+    Mask: Windows.UI.Composition.CompositionBrush;
+    Source: Windows.UI.Composition.CompositionBrush;
+  }
+  var ICompositionMaskBrush: abstract new (...args: any[]) => ICompositionMaskBrush;
+
+  interface ICompositionMipmapSurface {
+    GetDrawingSurfaceForLevel(level: number): Windows.UI.Composition.CompositionDrawingSurface;
+    readonly AlphaMode: number;
+    readonly LevelCount: number;
+    readonly PixelFormat: number;
+    readonly SizeInt32: Windows.Graphics.SizeInt32;
+  }
+  var ICompositionMipmapSurface: abstract new (...args: any[]) => ICompositionMipmapSurface;
+
+  interface ICompositionNineGridBrush {
+    SetInsetScales(scale: number): void;
+    SetInsetScales(left: number, top: number, right: number, bottom: number): void;
+    SetInsets(inset: number): void;
+    SetInsets(left: number, top: number, right: number, bottom: number): void;
+    BottomInset: number;
+    BottomInsetScale: number;
+    IsCenterHollow: boolean;
+    LeftInset: number;
+    LeftInsetScale: number;
+    RightInset: number;
+    RightInsetScale: number;
+    Source: Windows.UI.Composition.CompositionBrush;
+    TopInset: number;
+    TopInsetScale: number;
+  }
+  var ICompositionNineGridBrush: abstract new (...args: any[]) => ICompositionNineGridBrush;
+
+  interface ICompositionObject {
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    readonly Compositor: Windows.UI.Composition.Compositor;
+    readonly Dispatcher: Windows.UI.Core.CoreDispatcher;
+    readonly Properties: Windows.UI.Composition.CompositionPropertySet;
+  }
+  var ICompositionObject: abstract new (...args: any[]) => ICompositionObject;
+
+  interface ICompositionObject2 {
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    Comment: string;
+    ImplicitAnimations: Windows.UI.Composition.ImplicitAnimationCollection;
+  }
+  var ICompositionObject2: abstract new (...args: any[]) => ICompositionObject2;
+
+  interface ICompositionObject3 {
+    readonly DispatcherQueue: Windows.System.DispatcherQueue;
+  }
+  var ICompositionObject3: abstract new (...args: any[]) => ICompositionObject3;
+
+  interface ICompositionObject4 {
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+  var ICompositionObject4: abstract new (...args: any[]) => ICompositionObject4;
+
+  interface ICompositionObject5 {
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+  }
+  var ICompositionObject5: abstract new (...args: any[]) => ICompositionObject5;
+
+  interface ICompositionObjectFactory {
+  }
+  var ICompositionObjectFactory: abstract new (...args: any[]) => ICompositionObjectFactory;
+
+  interface ICompositionObjectStatics {
+    StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+  }
+  var ICompositionObjectStatics: abstract new (...args: any[]) => ICompositionObjectStatics;
+
+  interface ICompositionPath {
+  }
+  var ICompositionPath: abstract new (...args: any[]) => ICompositionPath;
+
+  interface ICompositionPathFactory {
+    Create(source: Windows.Graphics.IGeometrySource2D): Windows.UI.Composition.CompositionPath;
+  }
+  var ICompositionPathFactory: abstract new (...args: any[]) => ICompositionPathFactory;
+
+  interface ICompositionPathGeometry {
+    Path: Windows.UI.Composition.CompositionPath;
+  }
+  var ICompositionPathGeometry: abstract new (...args: any[]) => ICompositionPathGeometry;
+
+  interface ICompositionProjectedShadow {
+    BlurRadiusMultiplier: number;
+    readonly Casters: Windows.UI.Composition.CompositionProjectedShadowCasterCollection;
+    LightSource: Windows.UI.Composition.CompositionLight;
+    MaxBlurRadius: number;
+    MinBlurRadius: number;
+    readonly Receivers: Windows.UI.Composition.CompositionProjectedShadowReceiverUnorderedCollection;
+  }
+  var ICompositionProjectedShadow: abstract new (...args: any[]) => ICompositionProjectedShadow;
+
+  interface ICompositionProjectedShadowCaster {
+    Brush: Windows.UI.Composition.CompositionBrush;
+    CastingVisual: Windows.UI.Composition.Visual;
+  }
+  var ICompositionProjectedShadowCaster: abstract new (...args: any[]) => ICompositionProjectedShadowCaster;
+
+  interface ICompositionProjectedShadowCasterCollection {
+    InsertAbove(newCaster: Windows.UI.Composition.CompositionProjectedShadowCaster, reference: Windows.UI.Composition.CompositionProjectedShadowCaster): void;
+    InsertAtBottom(newCaster: Windows.UI.Composition.CompositionProjectedShadowCaster): void;
+    InsertAtTop(newCaster: Windows.UI.Composition.CompositionProjectedShadowCaster): void;
+    InsertBelow(newCaster: Windows.UI.Composition.CompositionProjectedShadowCaster, reference: Windows.UI.Composition.CompositionProjectedShadowCaster): void;
+    Remove(caster: Windows.UI.Composition.CompositionProjectedShadowCaster): void;
+    RemoveAll(): void;
+    readonly Count: number;
+  }
+  var ICompositionProjectedShadowCasterCollection: abstract new (...args: any[]) => ICompositionProjectedShadowCasterCollection;
+
+  interface ICompositionProjectedShadowCasterCollectionStatics {
+    readonly MaxRespectedCasters: number;
+  }
+  var ICompositionProjectedShadowCasterCollectionStatics: abstract new (...args: any[]) => ICompositionProjectedShadowCasterCollectionStatics;
+
+  interface ICompositionProjectedShadowReceiver {
+    ReceivingVisual: Windows.UI.Composition.Visual;
+  }
+  var ICompositionProjectedShadowReceiver: abstract new (...args: any[]) => ICompositionProjectedShadowReceiver;
+
+  interface ICompositionProjectedShadowReceiverUnorderedCollection {
+    Add(value: Windows.UI.Composition.CompositionProjectedShadowReceiver): void;
+    Remove(value: Windows.UI.Composition.CompositionProjectedShadowReceiver): void;
+    RemoveAll(): void;
+    readonly Count: number;
+  }
+  var ICompositionProjectedShadowReceiverUnorderedCollection: abstract new (...args: any[]) => ICompositionProjectedShadowReceiverUnorderedCollection;
+
+  interface ICompositionPropertySet {
+    InsertColor(propertyName: string, value: Windows.UI.Color): void;
+    InsertMatrix3x2(propertyName: string, value: Windows.Foundation.Numerics.Matrix3x2): void;
+    InsertMatrix4x4(propertyName: string, value: Windows.Foundation.Numerics.Matrix4x4): void;
+    InsertQuaternion(propertyName: string, value: Windows.Foundation.Numerics.Quaternion): void;
+    InsertScalar(propertyName: string, value: number): void;
+    InsertVector2(propertyName: string, value: Windows.Foundation.Numerics.Vector2): void;
+    InsertVector3(propertyName: string, value: Windows.Foundation.Numerics.Vector3): void;
+    InsertVector4(propertyName: string, value: Windows.Foundation.Numerics.Vector4): void;
+    TryGetColor(propertyName: string, value: Windows.UI.Color): number;
+    TryGetMatrix3x2(propertyName: string, value: Windows.Foundation.Numerics.Matrix3x2): number;
+    TryGetMatrix4x4(propertyName: string, value: Windows.Foundation.Numerics.Matrix4x4): number;
+    TryGetQuaternion(propertyName: string, value: Windows.Foundation.Numerics.Quaternion): number;
+    TryGetScalar(propertyName: string, value: number): number;
+    TryGetVector2(propertyName: string, value: Windows.Foundation.Numerics.Vector2): number;
+    TryGetVector3(propertyName: string, value: Windows.Foundation.Numerics.Vector3): number;
+    TryGetVector4(propertyName: string, value: Windows.Foundation.Numerics.Vector4): number;
+  }
+  var ICompositionPropertySet: abstract new (...args: any[]) => ICompositionPropertySet;
+
+  interface ICompositionPropertySet2 {
+    InsertBoolean(propertyName: string, value: boolean): void;
+    TryGetBoolean(propertyName: string, value: boolean): number;
+  }
+  var ICompositionPropertySet2: abstract new (...args: any[]) => ICompositionPropertySet2;
+
+  interface ICompositionRadialGradientBrush {
+    EllipseCenter: Windows.Foundation.Numerics.Vector2;
+    EllipseRadius: Windows.Foundation.Numerics.Vector2;
+    GradientOriginOffset: Windows.Foundation.Numerics.Vector2;
+  }
+  var ICompositionRadialGradientBrush: abstract new (...args: any[]) => ICompositionRadialGradientBrush;
+
+  interface ICompositionRectangleGeometry {
+    Offset: Windows.Foundation.Numerics.Vector2;
+    Size: Windows.Foundation.Numerics.Vector2;
+  }
+  var ICompositionRectangleGeometry: abstract new (...args: any[]) => ICompositionRectangleGeometry;
+
+  interface ICompositionRoundedRectangleGeometry {
+    CornerRadius: Windows.Foundation.Numerics.Vector2;
+    Offset: Windows.Foundation.Numerics.Vector2;
+    Size: Windows.Foundation.Numerics.Vector2;
+  }
+  var ICompositionRoundedRectangleGeometry: abstract new (...args: any[]) => ICompositionRoundedRectangleGeometry;
+
+  interface ICompositionScopedBatch {
+    End(): void;
+    Resume(): void;
+    Suspend(): void;
+    readonly IsActive: boolean;
+    readonly IsEnded: boolean;
+    Completed: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Composition.CompositionBatchCompletedEventArgs> | null;
+  }
+  var ICompositionScopedBatch: abstract new (...args: any[]) => ICompositionScopedBatch;
+
+  interface ICompositionShadow {
+  }
+  var ICompositionShadow: abstract new (...args: any[]) => ICompositionShadow;
+
+  interface ICompositionShadowFactory {
+  }
+  var ICompositionShadowFactory: abstract new (...args: any[]) => ICompositionShadowFactory;
+
+  interface ICompositionShape {
+    CenterPoint: Windows.Foundation.Numerics.Vector2;
+    Offset: Windows.Foundation.Numerics.Vector2;
+    RotationAngle: number;
+    RotationAngleInDegrees: number;
+    Scale: Windows.Foundation.Numerics.Vector2;
+    TransformMatrix: Windows.Foundation.Numerics.Matrix3x2;
+  }
+  var ICompositionShape: abstract new (...args: any[]) => ICompositionShape;
+
+  interface ICompositionShapeFactory {
+  }
+  var ICompositionShapeFactory: abstract new (...args: any[]) => ICompositionShapeFactory;
+
+  interface ICompositionSpriteShape {
+    FillBrush: Windows.UI.Composition.CompositionBrush;
+    Geometry: Windows.UI.Composition.CompositionGeometry;
+    IsStrokeNonScaling: boolean;
+    StrokeBrush: Windows.UI.Composition.CompositionBrush;
+    readonly StrokeDashArray: Windows.UI.Composition.CompositionStrokeDashArray;
+    StrokeDashCap: number;
+    StrokeDashOffset: number;
+    StrokeEndCap: number;
+    StrokeLineJoin: number;
+    StrokeMiterLimit: number;
+    StrokeStartCap: number;
+    StrokeThickness: number;
+  }
+  var ICompositionSpriteShape: abstract new (...args: any[]) => ICompositionSpriteShape;
+
+  interface ICompositionSupportsSystemBackdrop {
+    SystemBackdrop: Windows.UI.Composition.CompositionBrush;
+  }
+  var ICompositionSupportsSystemBackdrop: abstract new (...args: any[]) => ICompositionSupportsSystemBackdrop;
+
+  interface ICompositionSurface {
+  }
+  var ICompositionSurface: abstract new (...args: any[]) => ICompositionSurface;
+
+  interface ICompositionSurfaceBrush {
+    BitmapInterpolationMode: number;
+    HorizontalAlignmentRatio: number;
+    Stretch: number;
+    Surface: Windows.UI.Composition.ICompositionSurface;
+    VerticalAlignmentRatio: number;
+  }
+  var ICompositionSurfaceBrush: abstract new (...args: any[]) => ICompositionSurfaceBrush;
+
+  interface ICompositionSurfaceBrush2 {
+    AnchorPoint: Windows.Foundation.Numerics.Vector2;
+    CenterPoint: Windows.Foundation.Numerics.Vector2;
+    Offset: Windows.Foundation.Numerics.Vector2;
+    RotationAngle: number;
+    RotationAngleInDegrees: number;
+    Scale: Windows.Foundation.Numerics.Vector2;
+    TransformMatrix: Windows.Foundation.Numerics.Matrix3x2;
+  }
+  var ICompositionSurfaceBrush2: abstract new (...args: any[]) => ICompositionSurfaceBrush2;
+
+  interface ICompositionSurfaceBrush3 {
+    SnapToPixels: boolean;
+  }
+  var ICompositionSurfaceBrush3: abstract new (...args: any[]) => ICompositionSurfaceBrush3;
+
+  interface ICompositionSurfaceFacade {
+    GetRealSurface(): Windows.UI.Composition.ICompositionSurface;
+  }
+  var ICompositionSurfaceFacade: abstract new (...args: any[]) => ICompositionSurfaceFacade;
+
+  interface ICompositionTarget {
+    Root: Windows.UI.Composition.Visual;
+  }
+  var ICompositionTarget: abstract new (...args: any[]) => ICompositionTarget;
+
+  interface ICompositionTargetFactory {
+  }
+  var ICompositionTargetFactory: abstract new (...args: any[]) => ICompositionTargetFactory;
+
+  interface ICompositionTexture {
+    AlphaMode: number;
+    ColorSpace: number;
+    SourceRect: Windows.Graphics.RectInt32;
+  }
+  var ICompositionTexture: abstract new (...args: any[]) => ICompositionTexture;
+
+  interface ICompositionTextureFactory {
+  }
+  var ICompositionTextureFactory: abstract new (...args: any[]) => ICompositionTextureFactory;
+
+  interface ICompositionTransform {
+  }
+  var ICompositionTransform: abstract new (...args: any[]) => ICompositionTransform;
+
+  interface ICompositionTransformFactory {
+  }
+  var ICompositionTransformFactory: abstract new (...args: any[]) => ICompositionTransformFactory;
+
+  interface ICompositionViewBox {
+    HorizontalAlignmentRatio: number;
+    Offset: Windows.Foundation.Numerics.Vector2;
+    Size: Windows.Foundation.Numerics.Vector2;
+    Stretch: number;
+    VerticalAlignmentRatio: number;
+  }
+  var ICompositionViewBox: abstract new (...args: any[]) => ICompositionViewBox;
+
+  interface ICompositionVirtualDrawingSurface {
+    Trim(rects: Windows.Graphics.RectInt32[]): void;
+  }
+  var ICompositionVirtualDrawingSurface: abstract new (...args: any[]) => ICompositionVirtualDrawingSurface;
+
+  interface ICompositionVirtualDrawingSurfaceFactory {
+  }
+  var ICompositionVirtualDrawingSurfaceFactory: abstract new (...args: any[]) => ICompositionVirtualDrawingSurfaceFactory;
+
+  interface ICompositionVisualSurface {
+    SourceOffset: Windows.Foundation.Numerics.Vector2;
+    SourceSize: Windows.Foundation.Numerics.Vector2;
+    SourceVisual: Windows.UI.Composition.Visual;
+  }
+  var ICompositionVisualSurface: abstract new (...args: any[]) => ICompositionVisualSurface;
+
+  interface ICompositor {
+    CreateColorBrush(): Windows.UI.Composition.CompositionColorBrush;
+    CreateColorBrush(color: Windows.UI.Color): Windows.UI.Composition.CompositionColorBrush;
+    CreateColorKeyFrameAnimation(): Windows.UI.Composition.ColorKeyFrameAnimation;
+    CreateContainerVisual(): Windows.UI.Composition.ContainerVisual;
+    CreateCubicBezierEasingFunction(controlPoint1: Windows.Foundation.Numerics.Vector2, controlPoint2: Windows.Foundation.Numerics.Vector2): Windows.UI.Composition.CubicBezierEasingFunction;
+    CreateEffectFactory(graphicsEffect: Windows.Graphics.Effects.IGraphicsEffect): Windows.UI.Composition.CompositionEffectFactory;
+    CreateEffectFactory(graphicsEffect: Windows.Graphics.Effects.IGraphicsEffect, animatableProperties: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.UI.Composition.CompositionEffectFactory;
+    CreateExpressionAnimation(): Windows.UI.Composition.ExpressionAnimation;
+    CreateExpressionAnimation(expression: string): Windows.UI.Composition.ExpressionAnimation;
+    CreateInsetClip(): Windows.UI.Composition.InsetClip;
+    CreateInsetClip(leftInset: number, topInset: number, rightInset: number, bottomInset: number): Windows.UI.Composition.InsetClip;
+    CreateLinearEasingFunction(): Windows.UI.Composition.LinearEasingFunction;
+    CreatePropertySet(): Windows.UI.Composition.CompositionPropertySet;
+    CreateQuaternionKeyFrameAnimation(): Windows.UI.Composition.QuaternionKeyFrameAnimation;
+    CreateScalarKeyFrameAnimation(): Windows.UI.Composition.ScalarKeyFrameAnimation;
+    CreateScopedBatch(batchType: number): Windows.UI.Composition.CompositionScopedBatch;
+    CreateSpriteVisual(): Windows.UI.Composition.SpriteVisual;
+    CreateSurfaceBrush(): Windows.UI.Composition.CompositionSurfaceBrush;
+    CreateSurfaceBrush(surface: Windows.UI.Composition.ICompositionSurface): Windows.UI.Composition.CompositionSurfaceBrush;
+    CreateTargetForCurrentView(): Windows.UI.Composition.CompositionTarget;
+    CreateVector2KeyFrameAnimation(): Windows.UI.Composition.Vector2KeyFrameAnimation;
+    CreateVector3KeyFrameAnimation(): Windows.UI.Composition.Vector3KeyFrameAnimation;
+    CreateVector4KeyFrameAnimation(): Windows.UI.Composition.Vector4KeyFrameAnimation;
+    GetCommitBatch(batchType: number): Windows.UI.Composition.CompositionCommitBatch;
+  }
+  var ICompositor: abstract new (...args: any[]) => ICompositor;
+
+  interface ICompositor2 {
+    CreateAmbientLight(): Windows.UI.Composition.AmbientLight;
+    CreateAnimationGroup(): Windows.UI.Composition.CompositionAnimationGroup;
+    CreateBackdropBrush(): Windows.UI.Composition.CompositionBackdropBrush;
+    CreateDistantLight(): Windows.UI.Composition.DistantLight;
+    CreateDropShadow(): Windows.UI.Composition.DropShadow;
+    CreateImplicitAnimationCollection(): Windows.UI.Composition.ImplicitAnimationCollection;
+    CreateLayerVisual(): Windows.UI.Composition.LayerVisual;
+    CreateMaskBrush(): Windows.UI.Composition.CompositionMaskBrush;
+    CreateNineGridBrush(): Windows.UI.Composition.CompositionNineGridBrush;
+    CreatePointLight(): Windows.UI.Composition.PointLight;
+    CreateSpotLight(): Windows.UI.Composition.SpotLight;
+    CreateStepEasingFunction(): Windows.UI.Composition.StepEasingFunction;
+    CreateStepEasingFunction(stepCount: number): Windows.UI.Composition.StepEasingFunction;
+  }
+  var ICompositor2: abstract new (...args: any[]) => ICompositor2;
+
+  interface ICompositor3 {
+    CreateHostBackdropBrush(): Windows.UI.Composition.CompositionBackdropBrush;
+  }
+  var ICompositor3: abstract new (...args: any[]) => ICompositor3;
+
+  interface ICompositor4 {
+    CreateColorGradientStop(): Windows.UI.Composition.CompositionColorGradientStop;
+    CreateColorGradientStop(offset: number, color: Windows.UI.Color): Windows.UI.Composition.CompositionColorGradientStop;
+    CreateLinearGradientBrush(): Windows.UI.Composition.CompositionLinearGradientBrush;
+    CreateSpringScalarAnimation(): Windows.UI.Composition.SpringScalarNaturalMotionAnimation;
+    CreateSpringVector2Animation(): Windows.UI.Composition.SpringVector2NaturalMotionAnimation;
+    CreateSpringVector3Animation(): Windows.UI.Composition.SpringVector3NaturalMotionAnimation;
+  }
+  var ICompositor4: abstract new (...args: any[]) => ICompositor4;
+
+  interface ICompositor5 {
+    CreateBounceScalarAnimation(): Windows.UI.Composition.BounceScalarNaturalMotionAnimation;
+    CreateBounceVector2Animation(): Windows.UI.Composition.BounceVector2NaturalMotionAnimation;
+    CreateBounceVector3Animation(): Windows.UI.Composition.BounceVector3NaturalMotionAnimation;
+    CreateContainerShape(): Windows.UI.Composition.CompositionContainerShape;
+    CreateEllipseGeometry(): Windows.UI.Composition.CompositionEllipseGeometry;
+    CreateLineGeometry(): Windows.UI.Composition.CompositionLineGeometry;
+    CreatePathGeometry(): Windows.UI.Composition.CompositionPathGeometry;
+    CreatePathGeometry(path: Windows.UI.Composition.CompositionPath): Windows.UI.Composition.CompositionPathGeometry;
+    CreatePathKeyFrameAnimation(): Windows.UI.Composition.PathKeyFrameAnimation;
+    CreateRectangleGeometry(): Windows.UI.Composition.CompositionRectangleGeometry;
+    CreateRoundedRectangleGeometry(): Windows.UI.Composition.CompositionRoundedRectangleGeometry;
+    CreateShapeVisual(): Windows.UI.Composition.ShapeVisual;
+    CreateSpriteShape(): Windows.UI.Composition.CompositionSpriteShape;
+    CreateSpriteShape(geometry: Windows.UI.Composition.CompositionGeometry): Windows.UI.Composition.CompositionSpriteShape;
+    CreateViewBox(): Windows.UI.Composition.CompositionViewBox;
+    RequestCommitAsync(): Windows.Foundation.IAsyncAction;
+    Comment: string;
+    GlobalPlaybackRate: number;
+  }
+  var ICompositor5: abstract new (...args: any[]) => ICompositor5;
+
+  interface ICompositor6 {
+    CreateBooleanKeyFrameAnimation(): Windows.UI.Composition.BooleanKeyFrameAnimation;
+    CreateGeometricClip(): Windows.UI.Composition.CompositionGeometricClip;
+    CreateGeometricClip(geometry: Windows.UI.Composition.CompositionGeometry): Windows.UI.Composition.CompositionGeometricClip;
+    CreateRedirectVisual(): Windows.UI.Composition.RedirectVisual;
+    CreateRedirectVisual(source: Windows.UI.Composition.Visual): Windows.UI.Composition.RedirectVisual;
+  }
+  var ICompositor6: abstract new (...args: any[]) => ICompositor6;
+
+  interface ICompositor7 {
+    CreateAnimationPropertyInfo(): Windows.UI.Composition.AnimationPropertyInfo;
+    CreateRectangleClip(): Windows.UI.Composition.RectangleClip;
+    CreateRectangleClip(left: number, top: number, right: number, bottom: number): Windows.UI.Composition.RectangleClip;
+    CreateRectangleClip(left: number, top: number, right: number, bottom: number, topLeftRadius: Windows.Foundation.Numerics.Vector2, topRightRadius: Windows.Foundation.Numerics.Vector2, bottomRightRadius: Windows.Foundation.Numerics.Vector2, bottomLeftRadius: Windows.Foundation.Numerics.Vector2): Windows.UI.Composition.RectangleClip;
+    readonly DispatcherQueue: Windows.System.DispatcherQueue;
+  }
+  var ICompositor7: abstract new (...args: any[]) => ICompositor7;
+
+  interface ICompositor8 {
+    CreateAnimationController(): Windows.UI.Composition.AnimationController;
+  }
+  var ICompositor8: abstract new (...args: any[]) => ICompositor8;
+
+  interface ICompositorStatics {
+    readonly MaxGlobalPlaybackRate: number;
+    readonly MinGlobalPlaybackRate: number;
+  }
+  var ICompositorStatics: abstract new (...args: any[]) => ICompositorStatics;
+
+  interface ICompositorWithBlurredWallpaperBackdropBrush {
+    TryCreateBlurredWallpaperBackdropBrush(): Windows.UI.Composition.CompositionBackdropBrush;
+  }
+  var ICompositorWithBlurredWallpaperBackdropBrush: abstract new (...args: any[]) => ICompositorWithBlurredWallpaperBackdropBrush;
+
+  interface ICompositorWithProjectedShadow {
+    CreateProjectedShadow(): Windows.UI.Composition.CompositionProjectedShadow;
+    CreateProjectedShadowCaster(): Windows.UI.Composition.CompositionProjectedShadowCaster;
+    CreateProjectedShadowReceiver(): Windows.UI.Composition.CompositionProjectedShadowReceiver;
+  }
+  var ICompositorWithProjectedShadow: abstract new (...args: any[]) => ICompositorWithProjectedShadow;
+
+  interface ICompositorWithRadialGradient {
+    CreateRadialGradientBrush(): Windows.UI.Composition.CompositionRadialGradientBrush;
+  }
+  var ICompositorWithRadialGradient: abstract new (...args: any[]) => ICompositorWithRadialGradient;
+
+  interface ICompositorWithVisualSurface {
+    CreateVisualSurface(): Windows.UI.Composition.CompositionVisualSurface;
+  }
+  var ICompositorWithVisualSurface: abstract new (...args: any[]) => ICompositorWithVisualSurface;
+
+  interface IContainerVisual {
+    readonly Children: Windows.UI.Composition.VisualCollection;
+  }
+  var IContainerVisual: abstract new (...args: any[]) => IContainerVisual;
+
+  interface IContainerVisualFactory {
+  }
+  var IContainerVisualFactory: abstract new (...args: any[]) => IContainerVisualFactory;
+
+  interface ICubicBezierEasingFunction {
+    readonly ControlPoint1: Windows.Foundation.Numerics.Vector2;
+    readonly ControlPoint2: Windows.Foundation.Numerics.Vector2;
+  }
+  var ICubicBezierEasingFunction: abstract new (...args: any[]) => ICubicBezierEasingFunction;
+
+  interface IDelegatedInkTrailVisual {
+    AddTrailPoints(inkPoints: Windows.UI.Composition.InkTrailPoint[]): number;
+    AddTrailPointsWithPrediction(inkPoints: Windows.UI.Composition.InkTrailPoint[], predictedInkPoints: Windows.UI.Composition.InkTrailPoint[]): number;
+    RemoveTrailPoints(generationId: number): void;
+    StartNewTrail(color: Windows.UI.Color): void;
+  }
+  var IDelegatedInkTrailVisual: abstract new (...args: any[]) => IDelegatedInkTrailVisual;
+
+  interface IDelegatedInkTrailVisualStatics {
+    Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.DelegatedInkTrailVisual;
+    CreateForSwapChain(compositor: Windows.UI.Composition.Compositor, swapChain: Windows.UI.Composition.ICompositionSurface): Windows.UI.Composition.DelegatedInkTrailVisual;
+  }
+  var IDelegatedInkTrailVisualStatics: abstract new (...args: any[]) => IDelegatedInkTrailVisualStatics;
+
+  interface IDistantLight {
+    Color: Windows.UI.Color;
+    CoordinateSpace: Windows.UI.Composition.Visual;
+    Direction: Windows.Foundation.Numerics.Vector3;
+  }
+  var IDistantLight: abstract new (...args: any[]) => IDistantLight;
+
+  interface IDistantLight2 {
+    Intensity: number;
+  }
+  var IDistantLight2: abstract new (...args: any[]) => IDistantLight2;
+
+  interface IDropShadow {
+    BlurRadius: number;
+    Color: Windows.UI.Color;
+    Mask: Windows.UI.Composition.CompositionBrush;
+    Offset: Windows.Foundation.Numerics.Vector3;
+    Opacity: number;
+  }
+  var IDropShadow: abstract new (...args: any[]) => IDropShadow;
+
+  interface IDropShadow2 {
+    SourcePolicy: number;
+  }
+  var IDropShadow2: abstract new (...args: any[]) => IDropShadow2;
+
+  interface IElasticEasingFunction {
+    readonly Mode: number;
+    readonly Oscillations: number;
+    readonly Springiness: number;
+  }
+  var IElasticEasingFunction: abstract new (...args: any[]) => IElasticEasingFunction;
+
+  interface IExponentialEasingFunction {
+    readonly Exponent: number;
+    readonly Mode: number;
+  }
+  var IExponentialEasingFunction: abstract new (...args: any[]) => IExponentialEasingFunction;
+
+  interface IExpressionAnimation {
+    Expression: string;
+  }
+  var IExpressionAnimation: abstract new (...args: any[]) => IExpressionAnimation;
+
+  interface IImplicitAnimationCollection {
+  }
+  var IImplicitAnimationCollection: abstract new (...args: any[]) => IImplicitAnimationCollection;
+
+  interface IInsetClip {
+    BottomInset: number;
+    LeftInset: number;
+    RightInset: number;
+    TopInset: number;
+  }
+  var IInsetClip: abstract new (...args: any[]) => IInsetClip;
+
+  interface IKeyFrameAnimation {
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string): void;
+    InsertExpressionKeyFrame(normalizedProgressKey: number, value: string, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+    DelayTime: Windows.Foundation.TimeSpan;
+    Duration: Windows.Foundation.TimeSpan;
+    IterationBehavior: number;
+    IterationCount: number;
+    readonly KeyFrameCount: number;
+    StopBehavior: number;
+  }
+  var IKeyFrameAnimation: abstract new (...args: any[]) => IKeyFrameAnimation;
+
+  interface IKeyFrameAnimation2 {
+    Direction: number;
+  }
+  var IKeyFrameAnimation2: abstract new (...args: any[]) => IKeyFrameAnimation2;
+
+  interface IKeyFrameAnimation3 {
+    DelayBehavior: number;
+  }
+  var IKeyFrameAnimation3: abstract new (...args: any[]) => IKeyFrameAnimation3;
+
+  interface IKeyFrameAnimationFactory {
+  }
+  var IKeyFrameAnimationFactory: abstract new (...args: any[]) => IKeyFrameAnimationFactory;
+
+  interface ILayerVisual {
+    Effect: Windows.UI.Composition.CompositionEffectBrush;
+  }
+  var ILayerVisual: abstract new (...args: any[]) => ILayerVisual;
+
+  interface ILayerVisual2 {
+    Shadow: Windows.UI.Composition.CompositionShadow;
+  }
+  var ILayerVisual2: abstract new (...args: any[]) => ILayerVisual2;
+
+  interface ILinearEasingFunction {
+  }
+  var ILinearEasingFunction: abstract new (...args: any[]) => ILinearEasingFunction;
+
+  interface INaturalMotionAnimation {
+    DelayBehavior: number;
+    DelayTime: Windows.Foundation.TimeSpan;
+    StopBehavior: number;
+  }
+  var INaturalMotionAnimation: abstract new (...args: any[]) => INaturalMotionAnimation;
+
+  interface INaturalMotionAnimationFactory {
+  }
+  var INaturalMotionAnimationFactory: abstract new (...args: any[]) => INaturalMotionAnimationFactory;
+
+  interface IPathKeyFrameAnimation {
+    InsertKeyFrame(normalizedProgressKey: number, path: Windows.UI.Composition.CompositionPath): void;
+    InsertKeyFrame(normalizedProgressKey: number, path: Windows.UI.Composition.CompositionPath, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+  }
+  var IPathKeyFrameAnimation: abstract new (...args: any[]) => IPathKeyFrameAnimation;
+
+  interface IPointLight {
+    Color: Windows.UI.Color;
+    ConstantAttenuation: number;
+    CoordinateSpace: Windows.UI.Composition.Visual;
+    LinearAttenuation: number;
+    Offset: Windows.Foundation.Numerics.Vector3;
+    QuadraticAttenuation: number;
+  }
+  var IPointLight: abstract new (...args: any[]) => IPointLight;
+
+  interface IPointLight2 {
+    Intensity: number;
+  }
+  var IPointLight2: abstract new (...args: any[]) => IPointLight2;
+
+  interface IPointLight3 {
+    MaxAttenuationCutoff: number;
+    MinAttenuationCutoff: number;
+  }
+  var IPointLight3: abstract new (...args: any[]) => IPointLight3;
+
+  interface IPowerEasingFunction {
+    readonly Mode: number;
+    readonly Power: number;
+  }
+  var IPowerEasingFunction: abstract new (...args: any[]) => IPowerEasingFunction;
+
+  interface IQuaternionKeyFrameAnimation {
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.Foundation.Numerics.Quaternion): void;
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.Foundation.Numerics.Quaternion, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+  }
+  var IQuaternionKeyFrameAnimation: abstract new (...args: any[]) => IQuaternionKeyFrameAnimation;
+
+  interface IRectangleClip {
+    Bottom: number;
+    BottomLeftRadius: Windows.Foundation.Numerics.Vector2;
+    BottomRightRadius: Windows.Foundation.Numerics.Vector2;
+    Left: number;
+    Right: number;
+    Top: number;
+    TopLeftRadius: Windows.Foundation.Numerics.Vector2;
+    TopRightRadius: Windows.Foundation.Numerics.Vector2;
+  }
+  var IRectangleClip: abstract new (...args: any[]) => IRectangleClip;
+
+  interface IRedirectVisual {
+    Source: Windows.UI.Composition.Visual;
+  }
+  var IRedirectVisual: abstract new (...args: any[]) => IRedirectVisual;
+
+  interface IRenderingDeviceReplacedEventArgs {
+    readonly GraphicsDevice: Windows.UI.Composition.CompositionGraphicsDevice;
+  }
+  var IRenderingDeviceReplacedEventArgs: abstract new (...args: any[]) => IRenderingDeviceReplacedEventArgs;
+
+  interface IScalarKeyFrameAnimation {
+    InsertKeyFrame(normalizedProgressKey: number, value: number): void;
+    InsertKeyFrame(normalizedProgressKey: number, value: number, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+  }
+  var IScalarKeyFrameAnimation: abstract new (...args: any[]) => IScalarKeyFrameAnimation;
+
+  interface IScalarNaturalMotionAnimation {
+    FinalValue: number | null;
+    InitialValue: number | null;
+    InitialVelocity: number;
+  }
+  var IScalarNaturalMotionAnimation: abstract new (...args: any[]) => IScalarNaturalMotionAnimation;
+
+  interface IScalarNaturalMotionAnimationFactory {
+  }
+  var IScalarNaturalMotionAnimationFactory: abstract new (...args: any[]) => IScalarNaturalMotionAnimationFactory;
+
+  interface IShapeVisual {
+    readonly Shapes: Windows.UI.Composition.CompositionShapeCollection;
+    ViewBox: Windows.UI.Composition.CompositionViewBox;
+  }
+  var IShapeVisual: abstract new (...args: any[]) => IShapeVisual;
+
+  interface ISineEasingFunction {
+    readonly Mode: number;
+  }
+  var ISineEasingFunction: abstract new (...args: any[]) => ISineEasingFunction;
+
+  interface ISpotLight {
+    ConstantAttenuation: number;
+    CoordinateSpace: Windows.UI.Composition.Visual;
+    Direction: Windows.Foundation.Numerics.Vector3;
+    InnerConeAngle: number;
+    InnerConeAngleInDegrees: number;
+    InnerConeColor: Windows.UI.Color;
+    LinearAttenuation: number;
+    Offset: Windows.Foundation.Numerics.Vector3;
+    OuterConeAngle: number;
+    OuterConeAngleInDegrees: number;
+    OuterConeColor: Windows.UI.Color;
+    QuadraticAttenuation: number;
+  }
+  var ISpotLight: abstract new (...args: any[]) => ISpotLight;
+
+  interface ISpotLight2 {
+    InnerConeIntensity: number;
+    OuterConeIntensity: number;
+  }
+  var ISpotLight2: abstract new (...args: any[]) => ISpotLight2;
+
+  interface ISpotLight3 {
+    MaxAttenuationCutoff: number;
+    MinAttenuationCutoff: number;
+  }
+  var ISpotLight3: abstract new (...args: any[]) => ISpotLight3;
+
+  interface ISpringScalarNaturalMotionAnimation {
+    DampingRatio: number;
+    Period: Windows.Foundation.TimeSpan;
+  }
+  var ISpringScalarNaturalMotionAnimation: abstract new (...args: any[]) => ISpringScalarNaturalMotionAnimation;
+
+  interface ISpringVector2NaturalMotionAnimation {
+    DampingRatio: number;
+    Period: Windows.Foundation.TimeSpan;
+  }
+  var ISpringVector2NaturalMotionAnimation: abstract new (...args: any[]) => ISpringVector2NaturalMotionAnimation;
+
+  interface ISpringVector3NaturalMotionAnimation {
+    DampingRatio: number;
+    Period: Windows.Foundation.TimeSpan;
+  }
+  var ISpringVector3NaturalMotionAnimation: abstract new (...args: any[]) => ISpringVector3NaturalMotionAnimation;
+
+  interface ISpriteVisual {
+    Brush: Windows.UI.Composition.CompositionBrush;
+  }
+  var ISpriteVisual: abstract new (...args: any[]) => ISpriteVisual;
+
+  interface ISpriteVisual2 {
+    Shadow: Windows.UI.Composition.CompositionShadow;
+  }
+  var ISpriteVisual2: abstract new (...args: any[]) => ISpriteVisual2;
+
+  interface IStepEasingFunction {
+    FinalStep: number;
+    InitialStep: number;
+    IsFinalStepSingleFrame: boolean;
+    IsInitialStepSingleFrame: boolean;
+    StepCount: number;
+  }
+  var IStepEasingFunction: abstract new (...args: any[]) => IStepEasingFunction;
+
+  interface IVector2KeyFrameAnimation {
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.Foundation.Numerics.Vector2): void;
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.Foundation.Numerics.Vector2, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+  }
+  var IVector2KeyFrameAnimation: abstract new (...args: any[]) => IVector2KeyFrameAnimation;
+
+  interface IVector2NaturalMotionAnimation {
+    FinalValue: Windows.Foundation.Numerics.Vector2 | null;
+    InitialValue: Windows.Foundation.Numerics.Vector2 | null;
+    InitialVelocity: Windows.Foundation.Numerics.Vector2;
+  }
+  var IVector2NaturalMotionAnimation: abstract new (...args: any[]) => IVector2NaturalMotionAnimation;
+
+  interface IVector2NaturalMotionAnimationFactory {
+  }
+  var IVector2NaturalMotionAnimationFactory: abstract new (...args: any[]) => IVector2NaturalMotionAnimationFactory;
+
+  interface IVector3KeyFrameAnimation {
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.Foundation.Numerics.Vector3): void;
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.Foundation.Numerics.Vector3, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+  }
+  var IVector3KeyFrameAnimation: abstract new (...args: any[]) => IVector3KeyFrameAnimation;
+
+  interface IVector3NaturalMotionAnimation {
+    FinalValue: Windows.Foundation.Numerics.Vector3 | null;
+    InitialValue: Windows.Foundation.Numerics.Vector3 | null;
+    InitialVelocity: Windows.Foundation.Numerics.Vector3;
+  }
+  var IVector3NaturalMotionAnimation: abstract new (...args: any[]) => IVector3NaturalMotionAnimation;
+
+  interface IVector3NaturalMotionAnimationFactory {
+  }
+  var IVector3NaturalMotionAnimationFactory: abstract new (...args: any[]) => IVector3NaturalMotionAnimationFactory;
+
+  interface IVector4KeyFrameAnimation {
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.Foundation.Numerics.Vector4): void;
+    InsertKeyFrame(normalizedProgressKey: number, value: Windows.Foundation.Numerics.Vector4, easingFunction: Windows.UI.Composition.CompositionEasingFunction): void;
+  }
+  var IVector4KeyFrameAnimation: abstract new (...args: any[]) => IVector4KeyFrameAnimation;
+
+  interface IVisual {
+    AnchorPoint: Windows.Foundation.Numerics.Vector2;
+    BackfaceVisibility: number;
+    BorderMode: number;
+    CenterPoint: Windows.Foundation.Numerics.Vector3;
+    Clip: Windows.UI.Composition.CompositionClip;
+    CompositeMode: number;
+    IsVisible: boolean;
+    Offset: Windows.Foundation.Numerics.Vector3;
+    Opacity: number;
+    Orientation: Windows.Foundation.Numerics.Quaternion;
+    readonly Parent: Windows.UI.Composition.ContainerVisual;
+    RotationAngle: number;
+    RotationAngleInDegrees: number;
+    RotationAxis: Windows.Foundation.Numerics.Vector3;
+    Scale: Windows.Foundation.Numerics.Vector3;
+    Size: Windows.Foundation.Numerics.Vector2;
+    TransformMatrix: Windows.Foundation.Numerics.Matrix4x4;
+  }
+  var IVisual: abstract new (...args: any[]) => IVisual;
+
+  interface IVisual2 {
+    ParentForTransform: Windows.UI.Composition.Visual;
+    RelativeOffsetAdjustment: Windows.Foundation.Numerics.Vector3;
+    RelativeSizeAdjustment: Windows.Foundation.Numerics.Vector2;
+  }
+  var IVisual2: abstract new (...args: any[]) => IVisual2;
+
+  interface IVisual3 {
+    IsHitTestVisible: boolean;
+  }
+  var IVisual3: abstract new (...args: any[]) => IVisual3;
+
+  interface IVisual4 {
+    IsPixelSnappingEnabled: boolean;
+  }
+  var IVisual4: abstract new (...args: any[]) => IVisual4;
+
+  interface IVisualCollection {
+    InsertAbove(newChild: Windows.UI.Composition.Visual, sibling: Windows.UI.Composition.Visual): void;
+    InsertAtBottom(newChild: Windows.UI.Composition.Visual): void;
+    InsertAtTop(newChild: Windows.UI.Composition.Visual): void;
+    InsertBelow(newChild: Windows.UI.Composition.Visual, sibling: Windows.UI.Composition.Visual): void;
+    Remove(child: Windows.UI.Composition.Visual): void;
+    RemoveAll(): void;
+    readonly Count: number;
+  }
+  var IVisualCollection: abstract new (...args: any[]) => IVisualCollection;
+
+  interface IVisualElement {
+  }
+  var IVisualElement: abstract new (...args: any[]) => IVisualElement;
+
+  interface IVisualElement2 {
+    GetVisualInternal(): Windows.UI.Composition.Visual;
+  }
+  var IVisualElement2: abstract new (...args: any[]) => IVisualElement2;
+
+  interface IVisualFactory {
+  }
+  var IVisualFactory: abstract new (...args: any[]) => IVisualFactory;
+
+  interface IVisualUnorderedCollection {
+    Add(newVisual: Windows.UI.Composition.Visual): void;
+    Remove(visual: Windows.UI.Composition.Visual): void;
+    RemoveAll(): void;
+    readonly Count: number;
+  }
+  var IVisualUnorderedCollection: abstract new (...args: any[]) => IVisualUnorderedCollection;
+
+  interface InkTrailPoint {
+    Point: Windows.Foundation.Point;
+    Radius: number;
+  }
+  var InkTrailPoint: {
+    new(point: Windows.Foundation.Point, radius: number): InkTrailPoint;
+    new(fields: { Point?: Windows.Foundation.Point; Radius?: number }): InkTrailPoint;
+  };
+
+}
+
+declare namespace Windows.UI.Composition.Core {
+  class CompositorController implements Windows.Foundation.IClosable, Windows.UI.Composition.Core.ICompositorController {
+    constructor();
+    Close(): void;
+    Commit(): void;
+    EnsurePreviousCommitCompletedAsync(): Windows.Foundation.IAsyncAction;
+    readonly Compositor: Windows.UI.Composition.Compositor;
+    CommitNeeded: Windows.Foundation.TypedEventHandler<Windows.UI.Composition.Core.CompositorController, Object> | null;
+  }
+
+  interface ICompositorController {
+    Commit(): void;
+    EnsurePreviousCommitCompletedAsync(): Windows.Foundation.IAsyncAction;
+    readonly Compositor: Windows.UI.Composition.Compositor;
+    CommitNeeded: Windows.Foundation.TypedEventHandler<Windows.UI.Composition.Core.CompositorController, Object> | null;
+  }
+  var ICompositorController: abstract new (...args: any[]) => ICompositorController;
+
+}
+
+declare namespace Windows.UI.Composition.Desktop {
+  class DesktopWindowTarget extends Windows.UI.Composition.CompositionTarget implements Windows.UI.Composition.Desktop.IDesktopWindowTarget {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly IsTopmost: boolean;
+  }
+
+  interface IDesktopWindowTarget {
+    readonly IsTopmost: boolean;
+  }
+  var IDesktopWindowTarget: abstract new (...args: any[]) => IDesktopWindowTarget;
+
+}
+
+declare namespace Windows.UI.Composition.Diagnostics {
+  class CompositionDebugHeatMaps implements Windows.UI.Composition.Diagnostics.ICompositionDebugHeatMaps {
+    Hide(subtree: Windows.UI.Composition.Visual): void;
+    ShowMemoryUsage(subtree: Windows.UI.Composition.Visual): void;
+    ShowOverdraw(subtree: Windows.UI.Composition.Visual, contentKinds: number): void;
+    ShowRedraw(subtree: Windows.UI.Composition.Visual): void;
+  }
+
+  class CompositionDebugSettings implements Windows.UI.Composition.Diagnostics.ICompositionDebugSettings {
+    static TryGetSettings(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Diagnostics.CompositionDebugSettings;
+    readonly HeatMaps: Windows.UI.Composition.Diagnostics.CompositionDebugHeatMaps;
+  }
+
+  enum CompositionDebugOverdrawContentKinds {
+    None = 0,
+    OffscreenRendered = 1,
+    Colors = 2,
+    Effects = 4,
+    Shadows = 8,
+    Lights = 16,
+    Surfaces = 32,
+    SwapChains = 64,
+    All = 4294967295,
+  }
+
+  interface ICompositionDebugHeatMaps {
+    Hide(subtree: Windows.UI.Composition.Visual): void;
+    ShowMemoryUsage(subtree: Windows.UI.Composition.Visual): void;
+    ShowOverdraw(subtree: Windows.UI.Composition.Visual, contentKinds: number): void;
+    ShowRedraw(subtree: Windows.UI.Composition.Visual): void;
+  }
+  var ICompositionDebugHeatMaps: abstract new (...args: any[]) => ICompositionDebugHeatMaps;
+
+  interface ICompositionDebugSettings {
+    readonly HeatMaps: Windows.UI.Composition.Diagnostics.CompositionDebugHeatMaps;
+  }
+  var ICompositionDebugSettings: abstract new (...args: any[]) => ICompositionDebugSettings;
+
+  interface ICompositionDebugSettingsStatics {
+    TryGetSettings(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Diagnostics.CompositionDebugSettings;
+  }
+  var ICompositionDebugSettingsStatics: abstract new (...args: any[]) => ICompositionDebugSettingsStatics;
+
+}
+
+declare namespace Windows.UI.Composition.Effects {
+  class SceneLightingEffect implements Windows.Graphics.Effects.IGraphicsEffect, Windows.Graphics.Effects.IGraphicsEffectSource, Windows.UI.Composition.Effects.ISceneLightingEffect, Windows.UI.Composition.Effects.ISceneLightingEffect2 {
+    constructor();
+    AmbientAmount: number;
+    DiffuseAmount: number;
+    Name: string;
+    NormalMapSource: Windows.Graphics.Effects.IGraphicsEffectSource;
+    ReflectanceModel: number;
+    SpecularAmount: number;
+    SpecularShine: number;
+  }
+
+  enum SceneLightingEffectReflectanceModel {
+    BlinnPhong = 0,
+    PhysicallyBasedBlinnPhong = 1,
+  }
+
+  interface ISceneLightingEffect {
+    AmbientAmount: number;
+    DiffuseAmount: number;
+    NormalMapSource: Windows.Graphics.Effects.IGraphicsEffectSource;
+    SpecularAmount: number;
+    SpecularShine: number;
+  }
+  var ISceneLightingEffect: abstract new (...args: any[]) => ISceneLightingEffect;
+
+  interface ISceneLightingEffect2 {
+    ReflectanceModel: number;
+  }
+  var ISceneLightingEffect2: abstract new (...args: any[]) => ISceneLightingEffect2;
+
+}
+
+declare namespace Windows.UI.Composition.Interactions {
+  class CompositionConditionalValue extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.Interactions.ICompositionConditionalValue {
+    Close(): void;
+    static Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Interactions.CompositionConditionalValue;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Condition: Windows.UI.Composition.ExpressionAnimation;
+    Value: Windows.UI.Composition.ExpressionAnimation;
+  }
+
+  class CompositionInteractionSourceCollection extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.Interactions.ICompositionInteractionSourceCollection {
+    Add(value: Windows.UI.Composition.Interactions.ICompositionInteractionSource): void;
+    Close(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Composition.Interactions.ICompositionInteractionSource>;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    Remove(value: Windows.UI.Composition.Interactions.ICompositionInteractionSource): void;
+    RemoveAll(): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Count: number;
+  }
+
+  class InteractionSourceConfiguration extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.Interactions.IInteractionSourceConfiguration {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    PositionXSourceMode: number;
+    PositionYSourceMode: number;
+    ScaleSourceMode: number;
+  }
+
+  class InteractionTracker extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.Interactions.IInteractionTracker, Windows.UI.Composition.Interactions.IInteractionTracker2, Windows.UI.Composition.Interactions.IInteractionTracker3, Windows.UI.Composition.Interactions.IInteractionTracker4, Windows.UI.Composition.Interactions.IInteractionTracker5 {
+    AdjustPositionXIfGreaterThanThreshold(adjustment: number, positionThreshold: number): void;
+    AdjustPositionYIfGreaterThanThreshold(adjustment: number, positionThreshold: number): void;
+    Close(): void;
+    ConfigureCenterPointXInertiaModifiers(conditionalValues: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.CompositionConditionalValue> | Windows.UI.Composition.Interactions.CompositionConditionalValue[]): void;
+    ConfigureCenterPointYInertiaModifiers(conditionalValues: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.CompositionConditionalValue> | Windows.UI.Composition.Interactions.CompositionConditionalValue[]): void;
+    ConfigurePositionXInertiaModifiers(modifiers: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.InteractionTrackerInertiaModifier> | Windows.UI.Composition.Interactions.InteractionTrackerInertiaModifier[]): void;
+    ConfigurePositionYInertiaModifiers(modifiers: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.InteractionTrackerInertiaModifier> | Windows.UI.Composition.Interactions.InteractionTrackerInertiaModifier[]): void;
+    ConfigureScaleInertiaModifiers(modifiers: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.InteractionTrackerInertiaModifier> | Windows.UI.Composition.Interactions.InteractionTrackerInertiaModifier[]): void;
+    ConfigureVector2PositionInertiaModifiers(modifiers: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.InteractionTrackerVector2InertiaModifier> | Windows.UI.Composition.Interactions.InteractionTrackerVector2InertiaModifier[]): void;
+    static Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Interactions.InteractionTracker;
+    static CreateWithOwner(compositor: Windows.UI.Composition.Compositor, owner: Windows.UI.Composition.Interactions.IInteractionTrackerOwner): Windows.UI.Composition.Interactions.InteractionTracker;
+    static GetBindingMode(boundTracker1: Windows.UI.Composition.Interactions.InteractionTracker, boundTracker2: Windows.UI.Composition.Interactions.InteractionTracker): number;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    static SetBindingMode(boundTracker1: Windows.UI.Composition.Interactions.InteractionTracker, boundTracker2: Windows.UI.Composition.Interactions.InteractionTracker, axisMode: number): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    TryUpdatePosition(value: Windows.Foundation.Numerics.Vector3): number;
+    TryUpdatePosition(value: Windows.Foundation.Numerics.Vector3, option: number): number;
+    TryUpdatePosition(value: Windows.Foundation.Numerics.Vector3, option: number, posUpdateOption: number): number;
+    TryUpdatePositionBy(amount: Windows.Foundation.Numerics.Vector3): number;
+    TryUpdatePositionBy(amount: Windows.Foundation.Numerics.Vector3, option: number): number;
+    TryUpdatePositionWithAdditionalVelocity(velocityInPixelsPerSecond: Windows.Foundation.Numerics.Vector3): number;
+    TryUpdatePositionWithAnimation(animation: Windows.UI.Composition.CompositionAnimation): number;
+    TryUpdateScale(value: number, centerPoint: Windows.Foundation.Numerics.Vector3): number;
+    TryUpdateScaleWithAdditionalVelocity(velocityInPercentPerSecond: number, centerPoint: Windows.Foundation.Numerics.Vector3): number;
+    TryUpdateScaleWithAnimation(animation: Windows.UI.Composition.CompositionAnimation, centerPoint: Windows.Foundation.Numerics.Vector3): number;
+    readonly InteractionSources: Windows.UI.Composition.Interactions.CompositionInteractionSourceCollection;
+    readonly IsInertiaFromImpulse: boolean;
+    readonly IsPositionRoundingSuggested: boolean;
+    MaxPosition: Windows.Foundation.Numerics.Vector3;
+    MaxScale: number;
+    MinPosition: Windows.Foundation.Numerics.Vector3;
+    MinScale: number;
+    readonly NaturalRestingPosition: Windows.Foundation.Numerics.Vector3;
+    readonly NaturalRestingScale: number;
+    readonly Owner: Windows.UI.Composition.Interactions.IInteractionTrackerOwner;
+    readonly Position: Windows.Foundation.Numerics.Vector3;
+    PositionInertiaDecayRate: Windows.Foundation.Numerics.Vector3 | null;
+    readonly PositionVelocityInPixelsPerSecond: Windows.Foundation.Numerics.Vector3;
+    readonly Scale: number;
+    ScaleInertiaDecayRate: number | null;
+    readonly ScaleVelocityInPercentPerSecond: number;
+  }
+
+  class InteractionTrackerCustomAnimationStateEnteredArgs implements Windows.UI.Composition.Interactions.IInteractionTrackerCustomAnimationStateEnteredArgs, Windows.UI.Composition.Interactions.IInteractionTrackerCustomAnimationStateEnteredArgs2 {
+    readonly IsFromBinding: boolean;
+    readonly RequestId: number;
+  }
+
+  class InteractionTrackerIdleStateEnteredArgs implements Windows.UI.Composition.Interactions.IInteractionTrackerIdleStateEnteredArgs, Windows.UI.Composition.Interactions.IInteractionTrackerIdleStateEnteredArgs2 {
+    readonly IsFromBinding: boolean;
+    readonly RequestId: number;
+  }
+
+  class InteractionTrackerInertiaModifier extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.Interactions.IInteractionTrackerInertiaModifier {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class InteractionTrackerInertiaMotion extends Windows.UI.Composition.Interactions.InteractionTrackerInertiaModifier implements Windows.UI.Composition.Interactions.IInteractionTrackerInertiaMotion {
+    Close(): void;
+    static Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Interactions.InteractionTrackerInertiaMotion;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Condition: Windows.UI.Composition.ExpressionAnimation;
+    Motion: Windows.UI.Composition.ExpressionAnimation;
+  }
+
+  class InteractionTrackerInertiaNaturalMotion extends Windows.UI.Composition.Interactions.InteractionTrackerInertiaModifier implements Windows.UI.Composition.Interactions.IInteractionTrackerInertiaNaturalMotion {
+    Close(): void;
+    static Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Interactions.InteractionTrackerInertiaNaturalMotion;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Condition: Windows.UI.Composition.ExpressionAnimation;
+    NaturalMotion: Windows.UI.Composition.ScalarNaturalMotionAnimation;
+  }
+
+  class InteractionTrackerInertiaRestingValue extends Windows.UI.Composition.Interactions.InteractionTrackerInertiaModifier implements Windows.UI.Composition.Interactions.IInteractionTrackerInertiaRestingValue {
+    Close(): void;
+    static Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Interactions.InteractionTrackerInertiaRestingValue;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Condition: Windows.UI.Composition.ExpressionAnimation;
+    RestingValue: Windows.UI.Composition.ExpressionAnimation;
+  }
+
+  class InteractionTrackerInertiaStateEnteredArgs implements Windows.UI.Composition.Interactions.IInteractionTrackerInertiaStateEnteredArgs, Windows.UI.Composition.Interactions.IInteractionTrackerInertiaStateEnteredArgs2, Windows.UI.Composition.Interactions.IInteractionTrackerInertiaStateEnteredArgs3 {
+    readonly IsFromBinding: boolean;
+    readonly IsInertiaFromImpulse: boolean;
+    readonly ModifiedRestingPosition: Windows.Foundation.Numerics.Vector3 | null;
+    readonly ModifiedRestingScale: number | null;
+    readonly NaturalRestingPosition: Windows.Foundation.Numerics.Vector3;
+    readonly NaturalRestingScale: number;
+    readonly PositionVelocityInPixelsPerSecond: Windows.Foundation.Numerics.Vector3;
+    readonly RequestId: number;
+    readonly ScaleVelocityInPercentPerSecond: number;
+  }
+
+  class InteractionTrackerInteractingStateEnteredArgs implements Windows.UI.Composition.Interactions.IInteractionTrackerInteractingStateEnteredArgs, Windows.UI.Composition.Interactions.IInteractionTrackerInteractingStateEnteredArgs2 {
+    readonly IsFromBinding: boolean;
+    readonly RequestId: number;
+  }
+
+  class InteractionTrackerRequestIgnoredArgs implements Windows.UI.Composition.Interactions.IInteractionTrackerRequestIgnoredArgs {
+    readonly RequestId: number;
+  }
+
+  class InteractionTrackerValuesChangedArgs implements Windows.UI.Composition.Interactions.IInteractionTrackerValuesChangedArgs {
+    readonly Position: Windows.Foundation.Numerics.Vector3;
+    readonly RequestId: number;
+    readonly Scale: number;
+  }
+
+  class InteractionTrackerVector2InertiaModifier extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.Interactions.IInteractionTrackerVector2InertiaModifier {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class InteractionTrackerVector2InertiaNaturalMotion extends Windows.UI.Composition.Interactions.InteractionTrackerVector2InertiaModifier implements Windows.UI.Composition.Interactions.IInteractionTrackerVector2InertiaNaturalMotion {
+    Close(): void;
+    static Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Interactions.InteractionTrackerVector2InertiaNaturalMotion;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Condition: Windows.UI.Composition.ExpressionAnimation;
+    NaturalMotion: Windows.UI.Composition.Vector2NaturalMotionAnimation;
+  }
+
+  class VisualInteractionSource extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.Interactions.ICompositionInteractionSource, Windows.UI.Composition.Interactions.IVisualInteractionSource, Windows.UI.Composition.Interactions.IVisualInteractionSource2, Windows.UI.Composition.Interactions.IVisualInteractionSource3 {
+    Close(): void;
+    ConfigureCenterPointXModifiers(conditionalValues: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.CompositionConditionalValue> | Windows.UI.Composition.Interactions.CompositionConditionalValue[]): void;
+    ConfigureCenterPointYModifiers(conditionalValues: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.CompositionConditionalValue> | Windows.UI.Composition.Interactions.CompositionConditionalValue[]): void;
+    ConfigureDeltaPositionXModifiers(conditionalValues: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.CompositionConditionalValue> | Windows.UI.Composition.Interactions.CompositionConditionalValue[]): void;
+    ConfigureDeltaPositionYModifiers(conditionalValues: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.CompositionConditionalValue> | Windows.UI.Composition.Interactions.CompositionConditionalValue[]): void;
+    ConfigureDeltaScaleModifiers(conditionalValues: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.CompositionConditionalValue> | Windows.UI.Composition.Interactions.CompositionConditionalValue[]): void;
+    static Create(source: Windows.UI.Composition.Visual): Windows.UI.Composition.Interactions.VisualInteractionSource;
+    static CreateFromIVisualElement(source: Windows.UI.Composition.IVisualElement): Windows.UI.Composition.Interactions.VisualInteractionSource;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    TryRedirectForManipulation(pointerPoint: Windows.UI.Input.PointerPoint): void;
+    readonly DeltaPosition: Windows.Foundation.Numerics.Vector3;
+    readonly DeltaScale: number;
+    IsPositionXRailsEnabled: boolean;
+    IsPositionYRailsEnabled: boolean;
+    ManipulationRedirectionMode: number;
+    readonly PointerWheelConfig: Windows.UI.Composition.Interactions.InteractionSourceConfiguration;
+    readonly Position: Windows.Foundation.Numerics.Vector3;
+    readonly PositionVelocity: Windows.Foundation.Numerics.Vector3;
+    PositionXChainingMode: number;
+    PositionXSourceMode: number;
+    PositionYChainingMode: number;
+    PositionYSourceMode: number;
+    readonly Scale: number;
+    ScaleChainingMode: number;
+    ScaleSourceMode: number;
+    readonly ScaleVelocity: number;
+    readonly Source: Windows.UI.Composition.Visual;
+  }
+
+  enum InteractionBindingAxisModes {
+    None = 0,
+    PositionX = 1,
+    PositionY = 2,
+    Scale = 4,
+  }
+
+  enum InteractionChainingMode {
+    Auto = 0,
+    Always = 1,
+    Never = 2,
+  }
+
+  enum InteractionSourceMode {
+    Disabled = 0,
+    EnabledWithInertia = 1,
+    EnabledWithoutInertia = 2,
+  }
+
+  enum InteractionSourceRedirectionMode {
+    Disabled = 0,
+    Enabled = 1,
+  }
+
+  enum InteractionTrackerClampingOption {
+    Auto = 0,
+    Disabled = 1,
+  }
+
+  enum InteractionTrackerPositionUpdateOption {
+    Default = 0,
+    AllowActiveCustomScaleAnimation = 1,
+  }
+
+  enum VisualInteractionSourceRedirectionMode {
+    Off = 0,
+    CapableTouchpadOnly = 1,
+    PointerWheelOnly = 2,
+    CapableTouchpadAndPointerWheel = 3,
+  }
+
+  interface ICompositionConditionalValue {
+    Condition: Windows.UI.Composition.ExpressionAnimation;
+    Value: Windows.UI.Composition.ExpressionAnimation;
+  }
+  var ICompositionConditionalValue: abstract new (...args: any[]) => ICompositionConditionalValue;
+
+  interface ICompositionConditionalValueStatics {
+    Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Interactions.CompositionConditionalValue;
+  }
+  var ICompositionConditionalValueStatics: abstract new (...args: any[]) => ICompositionConditionalValueStatics;
+
+  interface ICompositionInteractionSource {
+  }
+  var ICompositionInteractionSource: abstract new (...args: any[]) => ICompositionInteractionSource;
+
+  interface ICompositionInteractionSourceCollection {
+    Add(value: Windows.UI.Composition.Interactions.ICompositionInteractionSource): void;
+    Remove(value: Windows.UI.Composition.Interactions.ICompositionInteractionSource): void;
+    RemoveAll(): void;
+    readonly Count: number;
+  }
+  var ICompositionInteractionSourceCollection: abstract new (...args: any[]) => ICompositionInteractionSourceCollection;
+
+  interface IInteractionSourceConfiguration {
+    PositionXSourceMode: number;
+    PositionYSourceMode: number;
+    ScaleSourceMode: number;
+  }
+  var IInteractionSourceConfiguration: abstract new (...args: any[]) => IInteractionSourceConfiguration;
+
+  interface IInteractionTracker {
+    AdjustPositionXIfGreaterThanThreshold(adjustment: number, positionThreshold: number): void;
+    AdjustPositionYIfGreaterThanThreshold(adjustment: number, positionThreshold: number): void;
+    ConfigurePositionXInertiaModifiers(modifiers: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.InteractionTrackerInertiaModifier> | Windows.UI.Composition.Interactions.InteractionTrackerInertiaModifier[]): void;
+    ConfigurePositionYInertiaModifiers(modifiers: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.InteractionTrackerInertiaModifier> | Windows.UI.Composition.Interactions.InteractionTrackerInertiaModifier[]): void;
+    ConfigureScaleInertiaModifiers(modifiers: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.InteractionTrackerInertiaModifier> | Windows.UI.Composition.Interactions.InteractionTrackerInertiaModifier[]): void;
+    TryUpdatePosition(value: Windows.Foundation.Numerics.Vector3): number;
+    TryUpdatePositionBy(amount: Windows.Foundation.Numerics.Vector3): number;
+    TryUpdatePositionWithAdditionalVelocity(velocityInPixelsPerSecond: Windows.Foundation.Numerics.Vector3): number;
+    TryUpdatePositionWithAnimation(animation: Windows.UI.Composition.CompositionAnimation): number;
+    TryUpdateScale(value: number, centerPoint: Windows.Foundation.Numerics.Vector3): number;
+    TryUpdateScaleWithAdditionalVelocity(velocityInPercentPerSecond: number, centerPoint: Windows.Foundation.Numerics.Vector3): number;
+    TryUpdateScaleWithAnimation(animation: Windows.UI.Composition.CompositionAnimation, centerPoint: Windows.Foundation.Numerics.Vector3): number;
+    readonly InteractionSources: Windows.UI.Composition.Interactions.CompositionInteractionSourceCollection;
+    readonly IsPositionRoundingSuggested: boolean;
+    MaxPosition: Windows.Foundation.Numerics.Vector3;
+    MaxScale: number;
+    MinPosition: Windows.Foundation.Numerics.Vector3;
+    MinScale: number;
+    readonly NaturalRestingPosition: Windows.Foundation.Numerics.Vector3;
+    readonly NaturalRestingScale: number;
+    readonly Owner: Windows.UI.Composition.Interactions.IInteractionTrackerOwner;
+    readonly Position: Windows.Foundation.Numerics.Vector3;
+    PositionInertiaDecayRate: Windows.Foundation.Numerics.Vector3 | null;
+    readonly PositionVelocityInPixelsPerSecond: Windows.Foundation.Numerics.Vector3;
+    readonly Scale: number;
+    ScaleInertiaDecayRate: number | null;
+    readonly ScaleVelocityInPercentPerSecond: number;
+  }
+  var IInteractionTracker: abstract new (...args: any[]) => IInteractionTracker;
+
+  interface IInteractionTracker2 {
+    ConfigureCenterPointXInertiaModifiers(conditionalValues: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.CompositionConditionalValue> | Windows.UI.Composition.Interactions.CompositionConditionalValue[]): void;
+    ConfigureCenterPointYInertiaModifiers(conditionalValues: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.CompositionConditionalValue> | Windows.UI.Composition.Interactions.CompositionConditionalValue[]): void;
+  }
+  var IInteractionTracker2: abstract new (...args: any[]) => IInteractionTracker2;
+
+  interface IInteractionTracker3 {
+    ConfigureVector2PositionInertiaModifiers(modifiers: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.InteractionTrackerVector2InertiaModifier> | Windows.UI.Composition.Interactions.InteractionTrackerVector2InertiaModifier[]): void;
+  }
+  var IInteractionTracker3: abstract new (...args: any[]) => IInteractionTracker3;
+
+  interface IInteractionTracker4 {
+    TryUpdatePosition(value: Windows.Foundation.Numerics.Vector3, option: number): number;
+    TryUpdatePositionBy(amount: Windows.Foundation.Numerics.Vector3, option: number): number;
+    readonly IsInertiaFromImpulse: boolean;
+  }
+  var IInteractionTracker4: abstract new (...args: any[]) => IInteractionTracker4;
+
+  interface IInteractionTracker5 {
+    TryUpdatePosition(value: Windows.Foundation.Numerics.Vector3, option: number, posUpdateOption: number): number;
+  }
+  var IInteractionTracker5: abstract new (...args: any[]) => IInteractionTracker5;
+
+  interface IInteractionTrackerCustomAnimationStateEnteredArgs {
+    readonly RequestId: number;
+  }
+  var IInteractionTrackerCustomAnimationStateEnteredArgs: abstract new (...args: any[]) => IInteractionTrackerCustomAnimationStateEnteredArgs;
+
+  interface IInteractionTrackerCustomAnimationStateEnteredArgs2 {
+    readonly IsFromBinding: boolean;
+  }
+  var IInteractionTrackerCustomAnimationStateEnteredArgs2: abstract new (...args: any[]) => IInteractionTrackerCustomAnimationStateEnteredArgs2;
+
+  interface IInteractionTrackerIdleStateEnteredArgs {
+    readonly RequestId: number;
+  }
+  var IInteractionTrackerIdleStateEnteredArgs: abstract new (...args: any[]) => IInteractionTrackerIdleStateEnteredArgs;
+
+  interface IInteractionTrackerIdleStateEnteredArgs2 {
+    readonly IsFromBinding: boolean;
+  }
+  var IInteractionTrackerIdleStateEnteredArgs2: abstract new (...args: any[]) => IInteractionTrackerIdleStateEnteredArgs2;
+
+  interface IInteractionTrackerInertiaModifier {
+  }
+  var IInteractionTrackerInertiaModifier: abstract new (...args: any[]) => IInteractionTrackerInertiaModifier;
+
+  interface IInteractionTrackerInertiaModifierFactory {
+  }
+  var IInteractionTrackerInertiaModifierFactory: abstract new (...args: any[]) => IInteractionTrackerInertiaModifierFactory;
+
+  interface IInteractionTrackerInertiaMotion {
+    Condition: Windows.UI.Composition.ExpressionAnimation;
+    Motion: Windows.UI.Composition.ExpressionAnimation;
+  }
+  var IInteractionTrackerInertiaMotion: abstract new (...args: any[]) => IInteractionTrackerInertiaMotion;
+
+  interface IInteractionTrackerInertiaMotionStatics {
+    Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Interactions.InteractionTrackerInertiaMotion;
+  }
+  var IInteractionTrackerInertiaMotionStatics: abstract new (...args: any[]) => IInteractionTrackerInertiaMotionStatics;
+
+  interface IInteractionTrackerInertiaNaturalMotion {
+    Condition: Windows.UI.Composition.ExpressionAnimation;
+    NaturalMotion: Windows.UI.Composition.ScalarNaturalMotionAnimation;
+  }
+  var IInteractionTrackerInertiaNaturalMotion: abstract new (...args: any[]) => IInteractionTrackerInertiaNaturalMotion;
+
+  interface IInteractionTrackerInertiaNaturalMotionStatics {
+    Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Interactions.InteractionTrackerInertiaNaturalMotion;
+  }
+  var IInteractionTrackerInertiaNaturalMotionStatics: abstract new (...args: any[]) => IInteractionTrackerInertiaNaturalMotionStatics;
+
+  interface IInteractionTrackerInertiaRestingValue {
+    Condition: Windows.UI.Composition.ExpressionAnimation;
+    RestingValue: Windows.UI.Composition.ExpressionAnimation;
+  }
+  var IInteractionTrackerInertiaRestingValue: abstract new (...args: any[]) => IInteractionTrackerInertiaRestingValue;
+
+  interface IInteractionTrackerInertiaRestingValueStatics {
+    Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Interactions.InteractionTrackerInertiaRestingValue;
+  }
+  var IInteractionTrackerInertiaRestingValueStatics: abstract new (...args: any[]) => IInteractionTrackerInertiaRestingValueStatics;
+
+  interface IInteractionTrackerInertiaStateEnteredArgs {
+    readonly ModifiedRestingPosition: Windows.Foundation.Numerics.Vector3 | null;
+    readonly ModifiedRestingScale: number | null;
+    readonly NaturalRestingPosition: Windows.Foundation.Numerics.Vector3;
+    readonly NaturalRestingScale: number;
+    readonly PositionVelocityInPixelsPerSecond: Windows.Foundation.Numerics.Vector3;
+    readonly RequestId: number;
+    readonly ScaleVelocityInPercentPerSecond: number;
+  }
+  var IInteractionTrackerInertiaStateEnteredArgs: abstract new (...args: any[]) => IInteractionTrackerInertiaStateEnteredArgs;
+
+  interface IInteractionTrackerInertiaStateEnteredArgs2 {
+    readonly IsInertiaFromImpulse: boolean;
+  }
+  var IInteractionTrackerInertiaStateEnteredArgs2: abstract new (...args: any[]) => IInteractionTrackerInertiaStateEnteredArgs2;
+
+  interface IInteractionTrackerInertiaStateEnteredArgs3 {
+    readonly IsFromBinding: boolean;
+  }
+  var IInteractionTrackerInertiaStateEnteredArgs3: abstract new (...args: any[]) => IInteractionTrackerInertiaStateEnteredArgs3;
+
+  interface IInteractionTrackerInteractingStateEnteredArgs {
+    readonly RequestId: number;
+  }
+  var IInteractionTrackerInteractingStateEnteredArgs: abstract new (...args: any[]) => IInteractionTrackerInteractingStateEnteredArgs;
+
+  interface IInteractionTrackerInteractingStateEnteredArgs2 {
+    readonly IsFromBinding: boolean;
+  }
+  var IInteractionTrackerInteractingStateEnteredArgs2: abstract new (...args: any[]) => IInteractionTrackerInteractingStateEnteredArgs2;
+
+  interface IInteractionTrackerOwner {
+    CustomAnimationStateEntered(sender: Windows.UI.Composition.Interactions.InteractionTracker, args: Windows.UI.Composition.Interactions.InteractionTrackerCustomAnimationStateEnteredArgs): void;
+    IdleStateEntered(sender: Windows.UI.Composition.Interactions.InteractionTracker, args: Windows.UI.Composition.Interactions.InteractionTrackerIdleStateEnteredArgs): void;
+    InertiaStateEntered(sender: Windows.UI.Composition.Interactions.InteractionTracker, args: Windows.UI.Composition.Interactions.InteractionTrackerInertiaStateEnteredArgs): void;
+    InteractingStateEntered(sender: Windows.UI.Composition.Interactions.InteractionTracker, args: Windows.UI.Composition.Interactions.InteractionTrackerInteractingStateEnteredArgs): void;
+    RequestIgnored(sender: Windows.UI.Composition.Interactions.InteractionTracker, args: Windows.UI.Composition.Interactions.InteractionTrackerRequestIgnoredArgs): void;
+    ValuesChanged(sender: Windows.UI.Composition.Interactions.InteractionTracker, args: Windows.UI.Composition.Interactions.InteractionTrackerValuesChangedArgs): void;
+  }
+  var IInteractionTrackerOwner: abstract new (...args: any[]) => IInteractionTrackerOwner;
+
+  interface IInteractionTrackerRequestIgnoredArgs {
+    readonly RequestId: number;
+  }
+  var IInteractionTrackerRequestIgnoredArgs: abstract new (...args: any[]) => IInteractionTrackerRequestIgnoredArgs;
+
+  interface IInteractionTrackerStatics {
+    Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Interactions.InteractionTracker;
+    CreateWithOwner(compositor: Windows.UI.Composition.Compositor, owner: Windows.UI.Composition.Interactions.IInteractionTrackerOwner): Windows.UI.Composition.Interactions.InteractionTracker;
+  }
+  var IInteractionTrackerStatics: abstract new (...args: any[]) => IInteractionTrackerStatics;
+
+  interface IInteractionTrackerStatics2 {
+    GetBindingMode(boundTracker1: Windows.UI.Composition.Interactions.InteractionTracker, boundTracker2: Windows.UI.Composition.Interactions.InteractionTracker): number;
+    SetBindingMode(boundTracker1: Windows.UI.Composition.Interactions.InteractionTracker, boundTracker2: Windows.UI.Composition.Interactions.InteractionTracker, axisMode: number): void;
+  }
+  var IInteractionTrackerStatics2: abstract new (...args: any[]) => IInteractionTrackerStatics2;
+
+  interface IInteractionTrackerValuesChangedArgs {
+    readonly Position: Windows.Foundation.Numerics.Vector3;
+    readonly RequestId: number;
+    readonly Scale: number;
+  }
+  var IInteractionTrackerValuesChangedArgs: abstract new (...args: any[]) => IInteractionTrackerValuesChangedArgs;
+
+  interface IInteractionTrackerVector2InertiaModifier {
+  }
+  var IInteractionTrackerVector2InertiaModifier: abstract new (...args: any[]) => IInteractionTrackerVector2InertiaModifier;
+
+  interface IInteractionTrackerVector2InertiaModifierFactory {
+  }
+  var IInteractionTrackerVector2InertiaModifierFactory: abstract new (...args: any[]) => IInteractionTrackerVector2InertiaModifierFactory;
+
+  interface IInteractionTrackerVector2InertiaNaturalMotion {
+    Condition: Windows.UI.Composition.ExpressionAnimation;
+    NaturalMotion: Windows.UI.Composition.Vector2NaturalMotionAnimation;
+  }
+  var IInteractionTrackerVector2InertiaNaturalMotion: abstract new (...args: any[]) => IInteractionTrackerVector2InertiaNaturalMotion;
+
+  interface IInteractionTrackerVector2InertiaNaturalMotionStatics {
+    Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Interactions.InteractionTrackerVector2InertiaNaturalMotion;
+  }
+  var IInteractionTrackerVector2InertiaNaturalMotionStatics: abstract new (...args: any[]) => IInteractionTrackerVector2InertiaNaturalMotionStatics;
+
+  interface IVisualInteractionSource {
+    TryRedirectForManipulation(pointerPoint: Windows.UI.Input.PointerPoint): void;
+    IsPositionXRailsEnabled: boolean;
+    IsPositionYRailsEnabled: boolean;
+    ManipulationRedirectionMode: number;
+    PositionXChainingMode: number;
+    PositionXSourceMode: number;
+    PositionYChainingMode: number;
+    PositionYSourceMode: number;
+    ScaleChainingMode: number;
+    ScaleSourceMode: number;
+    readonly Source: Windows.UI.Composition.Visual;
+  }
+  var IVisualInteractionSource: abstract new (...args: any[]) => IVisualInteractionSource;
+
+  interface IVisualInteractionSource2 {
+    ConfigureCenterPointXModifiers(conditionalValues: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.CompositionConditionalValue> | Windows.UI.Composition.Interactions.CompositionConditionalValue[]): void;
+    ConfigureCenterPointYModifiers(conditionalValues: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.CompositionConditionalValue> | Windows.UI.Composition.Interactions.CompositionConditionalValue[]): void;
+    ConfigureDeltaPositionXModifiers(conditionalValues: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.CompositionConditionalValue> | Windows.UI.Composition.Interactions.CompositionConditionalValue[]): void;
+    ConfigureDeltaPositionYModifiers(conditionalValues: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.CompositionConditionalValue> | Windows.UI.Composition.Interactions.CompositionConditionalValue[]): void;
+    ConfigureDeltaScaleModifiers(conditionalValues: Windows.Foundation.Collections.IIterable<Windows.UI.Composition.Interactions.CompositionConditionalValue> | Windows.UI.Composition.Interactions.CompositionConditionalValue[]): void;
+    readonly DeltaPosition: Windows.Foundation.Numerics.Vector3;
+    readonly DeltaScale: number;
+    readonly Position: Windows.Foundation.Numerics.Vector3;
+    readonly PositionVelocity: Windows.Foundation.Numerics.Vector3;
+    readonly Scale: number;
+    readonly ScaleVelocity: number;
+  }
+  var IVisualInteractionSource2: abstract new (...args: any[]) => IVisualInteractionSource2;
+
+  interface IVisualInteractionSource3 {
+    readonly PointerWheelConfig: Windows.UI.Composition.Interactions.InteractionSourceConfiguration;
+  }
+  var IVisualInteractionSource3: abstract new (...args: any[]) => IVisualInteractionSource3;
+
+  interface IVisualInteractionSourceObjectFactory {
+  }
+  var IVisualInteractionSourceObjectFactory: abstract new (...args: any[]) => IVisualInteractionSourceObjectFactory;
+
+  interface IVisualInteractionSourceStatics {
+    Create(source: Windows.UI.Composition.Visual): Windows.UI.Composition.Interactions.VisualInteractionSource;
+  }
+  var IVisualInteractionSourceStatics: abstract new (...args: any[]) => IVisualInteractionSourceStatics;
+
+  interface IVisualInteractionSourceStatics2 {
+    CreateFromIVisualElement(source: Windows.UI.Composition.IVisualElement): Windows.UI.Composition.Interactions.VisualInteractionSource;
+  }
+  var IVisualInteractionSourceStatics2: abstract new (...args: any[]) => IVisualInteractionSourceStatics2;
+
+}
+
+declare namespace Windows.UI.Composition.Scenes {
+  class SceneBoundingBox extends Windows.UI.Composition.Scenes.SceneObject implements Windows.UI.Composition.Scenes.ISceneBoundingBox {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Center: Windows.Foundation.Numerics.Vector3;
+    readonly Extents: Windows.Foundation.Numerics.Vector3;
+    readonly Max: Windows.Foundation.Numerics.Vector3;
+    readonly Min: Windows.Foundation.Numerics.Vector3;
+    readonly Size: Windows.Foundation.Numerics.Vector3;
+  }
+
+  class SceneComponent extends Windows.UI.Composition.Scenes.SceneObject implements Windows.UI.Composition.Scenes.ISceneComponent {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly ComponentType: number;
+  }
+
+  class SceneComponentCollection extends Windows.UI.Composition.Scenes.SceneObject implements Windows.UI.Composition.Scenes.ISceneComponentCollection {
+    Append(value: Windows.UI.Composition.Scenes.SceneComponent): void;
+    Clear(): void;
+    Close(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Composition.Scenes.SceneComponent>;
+    GetAt(index: number): Windows.UI.Composition.Scenes.SceneComponent;
+    GetMany(startIndex: number, items: Windows.UI.Composition.Scenes.SceneComponent[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Composition.Scenes.SceneComponent> | Windows.UI.Composition.Scenes.SceneComponent[];
+    IndexOf(value: Windows.UI.Composition.Scenes.SceneComponent, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Composition.Scenes.SceneComponent): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Composition.Scenes.SceneComponent[]): void;
+    SetAt(index: number, value: Windows.UI.Composition.Scenes.SceneComponent): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Size: number;
+  }
+
+  class SceneMaterial extends Windows.UI.Composition.Scenes.SceneObject implements Windows.UI.Composition.Scenes.ISceneMaterial {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class SceneMaterialInput extends Windows.UI.Composition.Scenes.SceneObject implements Windows.UI.Composition.Scenes.ISceneMaterialInput {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class SceneMesh extends Windows.UI.Composition.Scenes.SceneObject implements Windows.UI.Composition.Scenes.ISceneMesh {
+    Close(): void;
+    static Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Scenes.SceneMesh;
+    FillMeshAttribute(semantic: number, format: number, memory: Windows.Foundation.MemoryBuffer): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Bounds: Windows.UI.Composition.Scenes.SceneBoundingBox;
+    PrimitiveTopology: number;
+  }
+
+  class SceneMeshMaterialAttributeMap extends Windows.UI.Composition.Scenes.SceneObject implements Windows.UI.Composition.Scenes.ISceneMeshMaterialAttributeMap {
+    Clear(): void;
+    Close(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, number>>;
+    GetView(): Windows.Foundation.Collections.IMapView<string, number>;
+    HasKey(key: string): boolean;
+    Insert(key: string, value: number): boolean;
+    Lookup(key: string): number;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    Remove(key: string): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Size: number;
+  }
+
+  class SceneMeshRendererComponent extends Windows.UI.Composition.Scenes.SceneRendererComponent implements Windows.UI.Composition.Scenes.ISceneMeshRendererComponent {
+    Close(): void;
+    static Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Scenes.SceneMeshRendererComponent;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Material: Windows.UI.Composition.Scenes.SceneMaterial;
+    Mesh: Windows.UI.Composition.Scenes.SceneMesh;
+    readonly UVMappings: Windows.UI.Composition.Scenes.SceneMeshMaterialAttributeMap;
+  }
+
+  class SceneMetallicRoughnessMaterial extends Windows.UI.Composition.Scenes.ScenePbrMaterial implements Windows.UI.Composition.Scenes.ISceneMetallicRoughnessMaterial {
+    Close(): void;
+    static Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Scenes.SceneMetallicRoughnessMaterial;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    BaseColorFactor: Windows.Foundation.Numerics.Vector4;
+    BaseColorInput: Windows.UI.Composition.Scenes.SceneMaterialInput;
+    MetallicFactor: number;
+    MetallicRoughnessInput: Windows.UI.Composition.Scenes.SceneMaterialInput;
+    RoughnessFactor: number;
+  }
+
+  class SceneModelTransform extends Windows.UI.Composition.CompositionTransform implements Windows.UI.Composition.Scenes.ISceneModelTransform {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Orientation: Windows.Foundation.Numerics.Quaternion;
+    RotationAngle: number;
+    RotationAngleInDegrees: number;
+    RotationAxis: Windows.Foundation.Numerics.Vector3;
+    Scale: Windows.Foundation.Numerics.Vector3;
+    Translation: Windows.Foundation.Numerics.Vector3;
+  }
+
+  class SceneNode extends Windows.UI.Composition.Scenes.SceneObject implements Windows.UI.Composition.Scenes.ISceneNode {
+    Close(): void;
+    static Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Scenes.SceneNode;
+    FindFirstComponentOfType(value: number): Windows.UI.Composition.Scenes.SceneComponent;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Children: Windows.UI.Composition.Scenes.SceneNodeCollection;
+    readonly Components: Windows.UI.Composition.Scenes.SceneComponentCollection;
+    readonly Parent: Windows.UI.Composition.Scenes.SceneNode;
+    readonly Transform: Windows.UI.Composition.Scenes.SceneModelTransform;
+  }
+
+  class SceneNodeCollection extends Windows.UI.Composition.Scenes.SceneObject implements Windows.UI.Composition.Scenes.ISceneNodeCollection {
+    Append(value: Windows.UI.Composition.Scenes.SceneNode): void;
+    Clear(): void;
+    Close(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Composition.Scenes.SceneNode>;
+    GetAt(index: number): Windows.UI.Composition.Scenes.SceneNode;
+    GetMany(startIndex: number, items: Windows.UI.Composition.Scenes.SceneNode[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Composition.Scenes.SceneNode> | Windows.UI.Composition.Scenes.SceneNode[];
+    IndexOf(value: Windows.UI.Composition.Scenes.SceneNode, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Composition.Scenes.SceneNode): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Composition.Scenes.SceneNode[]): void;
+    SetAt(index: number, value: Windows.UI.Composition.Scenes.SceneNode): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    readonly Size: number;
+  }
+
+  class SceneObject extends Windows.UI.Composition.CompositionObject implements Windows.UI.Composition.Scenes.ISceneObject {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class ScenePbrMaterial extends Windows.UI.Composition.Scenes.SceneMaterial implements Windows.UI.Composition.Scenes.IScenePbrMaterial {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    AlphaCutoff: number;
+    AlphaMode: number;
+    EmissiveFactor: Windows.Foundation.Numerics.Vector3;
+    EmissiveInput: Windows.UI.Composition.Scenes.SceneMaterialInput;
+    IsDoubleSided: boolean;
+    NormalInput: Windows.UI.Composition.Scenes.SceneMaterialInput;
+    NormalScale: number;
+    OcclusionInput: Windows.UI.Composition.Scenes.SceneMaterialInput;
+    OcclusionStrength: number;
+  }
+
+  class SceneRendererComponent extends Windows.UI.Composition.Scenes.SceneComponent implements Windows.UI.Composition.Scenes.ISceneRendererComponent {
+    Close(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+  }
+
+  class SceneSurfaceMaterialInput extends Windows.UI.Composition.Scenes.SceneMaterialInput implements Windows.UI.Composition.Scenes.ISceneSurfaceMaterialInput {
+    Close(): void;
+    static Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Scenes.SceneSurfaceMaterialInput;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    BitmapInterpolationMode: number;
+    Surface: Windows.UI.Composition.ICompositionSurface;
+    WrappingUMode: number;
+    WrappingVMode: number;
+  }
+
+  class SceneVisual extends Windows.UI.Composition.ContainerVisual implements Windows.UI.Composition.Scenes.ISceneVisual {
+    Close(): void;
+    static Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Scenes.SceneVisual;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StartAnimation(propertyName: string, animation: Windows.UI.Composition.CompositionAnimation, animationController: Windows.UI.Composition.AnimationController): void;
+    StartAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationGroupWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static StartAnimationWithIAnimationObject(target: Windows.UI.Composition.IAnimationObject, propertyName: string, animation: Windows.UI.Composition.CompositionAnimation): void;
+    StopAnimation(propertyName: string): void;
+    StopAnimationGroup(value: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryGetAnimationController(propertyName: string): Windows.UI.Composition.AnimationController;
+    Root: Windows.UI.Composition.Scenes.SceneNode;
+  }
+
+  enum SceneAlphaMode {
+    Opaque = 0,
+    AlphaTest = 1,
+    Blend = 2,
+  }
+
+  enum SceneAttributeSemantic {
+    Index = 0,
+    Vertex = 1,
+    Normal = 2,
+    TexCoord0 = 3,
+    TexCoord1 = 4,
+    Color = 5,
+    Tangent = 6,
+  }
+
+  enum SceneComponentType {
+    MeshRendererComponent = 0,
+  }
+
+  enum SceneWrappingMode {
+    ClampToEdge = 0,
+    MirroredRepeat = 1,
+    Repeat = 2,
+  }
+
+  interface ISceneBoundingBox {
+    readonly Center: Windows.Foundation.Numerics.Vector3;
+    readonly Extents: Windows.Foundation.Numerics.Vector3;
+    readonly Max: Windows.Foundation.Numerics.Vector3;
+    readonly Min: Windows.Foundation.Numerics.Vector3;
+    readonly Size: Windows.Foundation.Numerics.Vector3;
+  }
+  var ISceneBoundingBox: abstract new (...args: any[]) => ISceneBoundingBox;
+
+  interface ISceneComponent {
+    readonly ComponentType: number;
+  }
+  var ISceneComponent: abstract new (...args: any[]) => ISceneComponent;
+
+  interface ISceneComponentCollection {
+  }
+  var ISceneComponentCollection: abstract new (...args: any[]) => ISceneComponentCollection;
+
+  interface ISceneComponentFactory {
+  }
+  var ISceneComponentFactory: abstract new (...args: any[]) => ISceneComponentFactory;
+
+  interface ISceneMaterial {
+  }
+  var ISceneMaterial: abstract new (...args: any[]) => ISceneMaterial;
+
+  interface ISceneMaterialFactory {
+  }
+  var ISceneMaterialFactory: abstract new (...args: any[]) => ISceneMaterialFactory;
+
+  interface ISceneMaterialInput {
+  }
+  var ISceneMaterialInput: abstract new (...args: any[]) => ISceneMaterialInput;
+
+  interface ISceneMaterialInputFactory {
+  }
+  var ISceneMaterialInputFactory: abstract new (...args: any[]) => ISceneMaterialInputFactory;
+
+  interface ISceneMesh {
+    FillMeshAttribute(semantic: number, format: number, memory: Windows.Foundation.MemoryBuffer): void;
+    readonly Bounds: Windows.UI.Composition.Scenes.SceneBoundingBox;
+    PrimitiveTopology: number;
+  }
+  var ISceneMesh: abstract new (...args: any[]) => ISceneMesh;
+
+  interface ISceneMeshMaterialAttributeMap {
+  }
+  var ISceneMeshMaterialAttributeMap: abstract new (...args: any[]) => ISceneMeshMaterialAttributeMap;
+
+  interface ISceneMeshRendererComponent {
+    Material: Windows.UI.Composition.Scenes.SceneMaterial;
+    Mesh: Windows.UI.Composition.Scenes.SceneMesh;
+    readonly UVMappings: Windows.UI.Composition.Scenes.SceneMeshMaterialAttributeMap;
+  }
+  var ISceneMeshRendererComponent: abstract new (...args: any[]) => ISceneMeshRendererComponent;
+
+  interface ISceneMeshRendererComponentStatics {
+    Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Scenes.SceneMeshRendererComponent;
+  }
+  var ISceneMeshRendererComponentStatics: abstract new (...args: any[]) => ISceneMeshRendererComponentStatics;
+
+  interface ISceneMeshStatics {
+    Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Scenes.SceneMesh;
+  }
+  var ISceneMeshStatics: abstract new (...args: any[]) => ISceneMeshStatics;
+
+  interface ISceneMetallicRoughnessMaterial {
+    BaseColorFactor: Windows.Foundation.Numerics.Vector4;
+    BaseColorInput: Windows.UI.Composition.Scenes.SceneMaterialInput;
+    MetallicFactor: number;
+    MetallicRoughnessInput: Windows.UI.Composition.Scenes.SceneMaterialInput;
+    RoughnessFactor: number;
+  }
+  var ISceneMetallicRoughnessMaterial: abstract new (...args: any[]) => ISceneMetallicRoughnessMaterial;
+
+  interface ISceneMetallicRoughnessMaterialStatics {
+    Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Scenes.SceneMetallicRoughnessMaterial;
+  }
+  var ISceneMetallicRoughnessMaterialStatics: abstract new (...args: any[]) => ISceneMetallicRoughnessMaterialStatics;
+
+  interface ISceneModelTransform {
+    Orientation: Windows.Foundation.Numerics.Quaternion;
+    RotationAngle: number;
+    RotationAngleInDegrees: number;
+    RotationAxis: Windows.Foundation.Numerics.Vector3;
+    Scale: Windows.Foundation.Numerics.Vector3;
+    Translation: Windows.Foundation.Numerics.Vector3;
+  }
+  var ISceneModelTransform: abstract new (...args: any[]) => ISceneModelTransform;
+
+  interface ISceneNode {
+    FindFirstComponentOfType(value: number): Windows.UI.Composition.Scenes.SceneComponent;
+    readonly Children: Windows.UI.Composition.Scenes.SceneNodeCollection;
+    readonly Components: Windows.UI.Composition.Scenes.SceneComponentCollection;
+    readonly Parent: Windows.UI.Composition.Scenes.SceneNode;
+    readonly Transform: Windows.UI.Composition.Scenes.SceneModelTransform;
+  }
+  var ISceneNode: abstract new (...args: any[]) => ISceneNode;
+
+  interface ISceneNodeCollection {
+  }
+  var ISceneNodeCollection: abstract new (...args: any[]) => ISceneNodeCollection;
+
+  interface ISceneNodeStatics {
+    Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Scenes.SceneNode;
+  }
+  var ISceneNodeStatics: abstract new (...args: any[]) => ISceneNodeStatics;
+
+  interface ISceneObject {
+  }
+  var ISceneObject: abstract new (...args: any[]) => ISceneObject;
+
+  interface ISceneObjectFactory {
+  }
+  var ISceneObjectFactory: abstract new (...args: any[]) => ISceneObjectFactory;
+
+  interface IScenePbrMaterial {
+    AlphaCutoff: number;
+    AlphaMode: number;
+    EmissiveFactor: Windows.Foundation.Numerics.Vector3;
+    EmissiveInput: Windows.UI.Composition.Scenes.SceneMaterialInput;
+    IsDoubleSided: boolean;
+    NormalInput: Windows.UI.Composition.Scenes.SceneMaterialInput;
+    NormalScale: number;
+    OcclusionInput: Windows.UI.Composition.Scenes.SceneMaterialInput;
+    OcclusionStrength: number;
+  }
+  var IScenePbrMaterial: abstract new (...args: any[]) => IScenePbrMaterial;
+
+  interface IScenePbrMaterialFactory {
+  }
+  var IScenePbrMaterialFactory: abstract new (...args: any[]) => IScenePbrMaterialFactory;
+
+  interface ISceneRendererComponent {
+  }
+  var ISceneRendererComponent: abstract new (...args: any[]) => ISceneRendererComponent;
+
+  interface ISceneRendererComponentFactory {
+  }
+  var ISceneRendererComponentFactory: abstract new (...args: any[]) => ISceneRendererComponentFactory;
+
+  interface ISceneSurfaceMaterialInput {
+    BitmapInterpolationMode: number;
+    Surface: Windows.UI.Composition.ICompositionSurface;
+    WrappingUMode: number;
+    WrappingVMode: number;
+  }
+  var ISceneSurfaceMaterialInput: abstract new (...args: any[]) => ISceneSurfaceMaterialInput;
+
+  interface ISceneSurfaceMaterialInputStatics {
+    Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Scenes.SceneSurfaceMaterialInput;
+  }
+  var ISceneSurfaceMaterialInputStatics: abstract new (...args: any[]) => ISceneSurfaceMaterialInputStatics;
+
+  interface ISceneVisual {
+    Root: Windows.UI.Composition.Scenes.SceneNode;
+  }
+  var ISceneVisual: abstract new (...args: any[]) => ISceneVisual;
+
+  interface ISceneVisualStatics {
+    Create(compositor: Windows.UI.Composition.Compositor): Windows.UI.Composition.Scenes.SceneVisual;
+  }
+  var ISceneVisualStatics: abstract new (...args: any[]) => ISceneVisualStatics;
+
+}
+
+declare namespace Windows.UI.Core {
+  class AcceleratorKeyEventArgs implements Windows.UI.Core.IAcceleratorKeyEventArgs, Windows.UI.Core.IAcceleratorKeyEventArgs2, Windows.UI.Core.ICoreWindowEventArgs {
+    readonly DeviceId: string;
+    readonly EventType: number;
+    Handled: boolean;
+    readonly KeyStatus: Windows.UI.Core.CorePhysicalKeyStatus;
+    readonly VirtualKey: number;
+  }
+
+  class AutomationProviderRequestedEventArgs implements Windows.UI.Core.IAutomationProviderRequestedEventArgs, Windows.UI.Core.ICoreWindowEventArgs {
+    AutomationProvider: Object;
+    Handled: boolean;
+  }
+
+  class BackRequestedEventArgs implements Windows.UI.Core.IBackRequestedEventArgs {
+    Handled: boolean;
+  }
+
+  class CharacterReceivedEventArgs implements Windows.UI.Core.ICharacterReceivedEventArgs, Windows.UI.Core.ICoreWindowEventArgs {
+    Handled: boolean;
+    readonly KeyCode: number;
+    readonly KeyStatus: Windows.UI.Core.CorePhysicalKeyStatus;
+  }
+
+  class ClosestInteractiveBoundsRequestedEventArgs implements Windows.UI.Core.IClosestInteractiveBoundsRequestedEventArgs {
+    ClosestInteractiveBounds: Windows.Foundation.Rect;
+    readonly PointerPosition: Windows.Foundation.Point;
+    readonly SearchBounds: Windows.Foundation.Rect;
+  }
+
+  class CoreAcceleratorKeys implements Windows.UI.Core.ICoreAcceleratorKeys {
+    AcceleratorKeyActivated: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreDispatcher, Windows.UI.Core.AcceleratorKeyEventArgs> | null;
+  }
+
+  class CoreComponentInputSource implements Windows.UI.Core.ICoreClosestInteractiveBoundsRequested, Windows.UI.Core.ICoreComponentFocusable, Windows.UI.Core.ICoreInputSourceBase, Windows.UI.Core.ICoreKeyboardInputSource, Windows.UI.Core.ICoreKeyboardInputSource2, Windows.UI.Core.ICorePointerInputSource, Windows.UI.Core.ICorePointerInputSource2, Windows.UI.Core.ICoreTouchHitTesting {
+    GetCurrentKeyEventDeviceId(): string;
+    GetCurrentKeyState(virtualKey: number): number;
+    ReleasePointerCapture(): void;
+    SetPointerCapture(): void;
+    readonly Dispatcher: Windows.UI.Core.CoreDispatcher;
+    readonly DispatcherQueue: Windows.System.DispatcherQueue;
+    readonly HasCapture: boolean;
+    readonly HasFocus: boolean;
+    IsInputEnabled: boolean;
+    PointerCursor: Windows.UI.Core.CoreCursor;
+    readonly PointerPosition: Windows.Foundation.Point;
+    InputEnabled: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.InputEnabledEventArgs> | null;
+    PointerCaptureLost: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    PointerEntered: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    PointerExited: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    PointerMoved: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    PointerPressed: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    PointerReleased: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    PointerWheelChanged: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    CharacterReceived: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.CharacterReceivedEventArgs> | null;
+    KeyDown: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.KeyEventArgs> | null;
+    KeyUp: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.KeyEventArgs> | null;
+    GotFocus: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.CoreWindowEventArgs> | null;
+    LostFocus: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.CoreWindowEventArgs> | null;
+    TouchHitTesting: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.TouchHitTestingEventArgs> | null;
+    ClosestInteractiveBoundsRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreComponentInputSource, Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs> | null;
+  }
+
+  class CoreCursor implements Windows.UI.Core.ICoreCursor {
+    constructor(type: number, id: number);
+    readonly Id: number;
+    readonly Type: number;
+  }
+
+  class CoreDispatcher implements Windows.UI.Core.ICoreAcceleratorKeys, Windows.UI.Core.ICoreDispatcher, Windows.UI.Core.ICoreDispatcher2, Windows.UI.Core.ICoreDispatcherWithTaskPriority {
+    ProcessEvents(options: number): void;
+    RunAsync(priority: number, agileCallback: Windows.UI.Core.DispatchedHandler): Windows.Foundation.IAsyncAction;
+    RunIdleAsync(agileCallback: Windows.UI.Core.IdleDispatchedHandler): Windows.Foundation.IAsyncAction;
+    ShouldYield(): boolean;
+    ShouldYield(priority: number): boolean;
+    StopProcessEvents(): void;
+    TryRunAsync(priority: number, agileCallback: Windows.UI.Core.DispatchedHandler): Windows.Foundation.IAsyncOperation<boolean>;
+    TryRunIdleAsync(agileCallback: Windows.UI.Core.IdleDispatchedHandler): Windows.Foundation.IAsyncOperation<boolean>;
+    CurrentPriority: number;
+    readonly HasThreadAccess: boolean;
+    AcceleratorKeyActivated: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreDispatcher, Windows.UI.Core.AcceleratorKeyEventArgs> | null;
+  }
+
+  class CoreIndependentInputSource implements Windows.UI.Core.ICoreInputSourceBase, Windows.UI.Core.ICorePointerInputSource, Windows.UI.Core.ICorePointerInputSource2, Windows.UI.Core.ICorePointerRedirector {
+    ReleasePointerCapture(): void;
+    SetPointerCapture(): void;
+    readonly Dispatcher: Windows.UI.Core.CoreDispatcher;
+    readonly DispatcherQueue: Windows.System.DispatcherQueue;
+    readonly HasCapture: boolean;
+    IsInputEnabled: boolean;
+    PointerCursor: Windows.UI.Core.CoreCursor;
+    readonly PointerPosition: Windows.Foundation.Point;
+    InputEnabled: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.InputEnabledEventArgs> | null;
+    PointerCaptureLost: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    PointerEntered: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    PointerExited: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    PointerMoved: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    PointerPressed: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    PointerReleased: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    PointerWheelChanged: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    PointerRoutedAway: Windows.Foundation.TypedEventHandler<Windows.UI.Core.ICorePointerRedirector, Windows.UI.Core.PointerEventArgs> | null;
+    PointerRoutedReleased: Windows.Foundation.TypedEventHandler<Windows.UI.Core.ICorePointerRedirector, Windows.UI.Core.PointerEventArgs> | null;
+    PointerRoutedTo: Windows.Foundation.TypedEventHandler<Windows.UI.Core.ICorePointerRedirector, Windows.UI.Core.PointerEventArgs> | null;
+  }
+
+  class CoreIndependentInputSourceController implements Windows.Foundation.IClosable, Windows.UI.Core.ICoreIndependentInputSourceController {
+    Close(): void;
+    static CreateForIVisualElement(visualElement: Windows.UI.Composition.IVisualElement): Windows.UI.Core.CoreIndependentInputSourceController;
+    static CreateForVisual(visual: Windows.UI.Composition.Visual): Windows.UI.Core.CoreIndependentInputSourceController;
+    SetControlledInput(inputTypes: number): void;
+    SetControlledInput(inputTypes: number, required: number, excluded: number): void;
+    IsPalmRejectionEnabled: boolean;
+    IsTransparentForUncontrolledInput: boolean;
+    readonly Source: Windows.UI.Core.CoreIndependentInputSource;
+  }
+
+  class CoreWindow implements Windows.UI.Core.ICorePointerRedirector, Windows.UI.Core.ICoreWindow, Windows.UI.Core.ICoreWindow2, Windows.UI.Core.ICoreWindow3, Windows.UI.Core.ICoreWindow4, Windows.UI.Core.ICoreWindow5, Windows.UI.Core.ICoreWindowWithContext {
+    Activate(): void;
+    Close(): void;
+    GetAsyncKeyState(virtualKey: number): number;
+    GetCurrentKeyEventDeviceId(): string;
+    static GetForCurrentThread(): Windows.UI.Core.CoreWindow;
+    GetKeyState(virtualKey: number): number;
+    ReleasePointerCapture(): void;
+    SetPointerCapture(): void;
+    readonly ActivationMode: number;
+    readonly AutomationHostProvider: Object;
+    readonly Bounds: Windows.Foundation.Rect;
+    readonly CustomProperties: Windows.Foundation.Collections.IPropertySet;
+    readonly Dispatcher: Windows.UI.Core.CoreDispatcher;
+    readonly DispatcherQueue: Windows.System.DispatcherQueue;
+    FlowDirection: number;
+    IsInputEnabled: boolean;
+    PointerCursor: Windows.UI.Core.CoreCursor;
+    PointerPosition: Windows.Foundation.Point;
+    readonly UIContext: Windows.UI.UIContext;
+    readonly Visible: boolean;
+    Activated: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.WindowActivatedEventArgs> | null;
+    AutomationProviderRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.AutomationProviderRequestedEventArgs> | null;
+    CharacterReceived: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.CharacterReceivedEventArgs> | null;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.CoreWindowEventArgs> | null;
+    InputEnabled: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.InputEnabledEventArgs> | null;
+    KeyDown: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.KeyEventArgs> | null;
+    KeyUp: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.KeyEventArgs> | null;
+    PointerCaptureLost: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.PointerEventArgs> | null;
+    PointerEntered: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.PointerEventArgs> | null;
+    PointerExited: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.PointerEventArgs> | null;
+    PointerMoved: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.PointerEventArgs> | null;
+    PointerPressed: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.PointerEventArgs> | null;
+    PointerReleased: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.PointerEventArgs> | null;
+    PointerWheelChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.PointerEventArgs> | null;
+    SizeChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.WindowSizeChangedEventArgs> | null;
+    TouchHitTesting: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.TouchHitTestingEventArgs> | null;
+    VisibilityChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.VisibilityChangedEventArgs> | null;
+    PointerRoutedAway: Windows.Foundation.TypedEventHandler<Windows.UI.Core.ICorePointerRedirector, Windows.UI.Core.PointerEventArgs> | null;
+    PointerRoutedReleased: Windows.Foundation.TypedEventHandler<Windows.UI.Core.ICorePointerRedirector, Windows.UI.Core.PointerEventArgs> | null;
+    PointerRoutedTo: Windows.Foundation.TypedEventHandler<Windows.UI.Core.ICorePointerRedirector, Windows.UI.Core.PointerEventArgs> | null;
+    ClosestInteractiveBoundsRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs> | null;
+    ResizeCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Object> | null;
+    ResizeStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Object> | null;
+  }
+
+  class CoreWindowDialog implements Windows.UI.Core.ICoreWindowDialog {
+    constructor(title: string);
+    constructor();
+    ShowAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.Popups.IUICommand>;
+    BackButtonCommand: Windows.UI.Popups.UICommandInvokedHandler;
+    CancelCommandIndex: number;
+    readonly Commands: Windows.Foundation.Collections.IVector<Windows.UI.Popups.IUICommand> | Windows.UI.Popups.IUICommand[];
+    DefaultCommandIndex: number;
+    IsInteractionDelayed: number;
+    readonly MaxSize: Windows.Foundation.Size;
+    readonly MinSize: Windows.Foundation.Size;
+    Title: string;
+    Showing: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.CoreWindowPopupShowingEventArgs> | null;
+  }
+
+  class CoreWindowEventArgs implements Windows.UI.Core.ICoreWindowEventArgs {
+    Handled: boolean;
+  }
+
+  class CoreWindowFlyout implements Windows.UI.Core.ICoreWindowFlyout {
+    constructor(position: Windows.Foundation.Point);
+    constructor(position: Windows.Foundation.Point, title: string);
+    ShowAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.Popups.IUICommand>;
+    BackButtonCommand: Windows.UI.Popups.UICommandInvokedHandler;
+    readonly Commands: Windows.Foundation.Collections.IVector<Windows.UI.Popups.IUICommand> | Windows.UI.Popups.IUICommand[];
+    DefaultCommandIndex: number;
+    IsInteractionDelayed: number;
+    readonly MaxSize: Windows.Foundation.Size;
+    readonly MinSize: Windows.Foundation.Size;
+    Title: string;
+    Showing: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.CoreWindowPopupShowingEventArgs> | null;
+  }
+
+  class CoreWindowPopupShowingEventArgs implements Windows.UI.Core.ICoreWindowPopupShowingEventArgs {
+    SetDesiredSize(value: Windows.Foundation.Size): void;
+  }
+
+  class CoreWindowResizeManager implements Windows.UI.Core.ICoreWindowResizeManager, Windows.UI.Core.ICoreWindowResizeManagerLayoutCapability {
+    static GetForCurrentView(): Windows.UI.Core.CoreWindowResizeManager;
+    NotifyLayoutCompleted(): void;
+    ShouldWaitForLayoutCompletion: boolean;
+  }
+
+  class IdleDispatchedHandlerArgs implements Windows.UI.Core.IIdleDispatchedHandlerArgs {
+    readonly IsDispatcherIdle: boolean;
+  }
+
+  class InputEnabledEventArgs implements Windows.UI.Core.ICoreWindowEventArgs, Windows.UI.Core.IInputEnabledEventArgs {
+    Handled: boolean;
+    readonly InputEnabled: boolean;
+  }
+
+  class KeyEventArgs implements Windows.UI.Core.ICoreWindowEventArgs, Windows.UI.Core.IKeyEventArgs, Windows.UI.Core.IKeyEventArgs2 {
+    readonly DeviceId: string;
+    Handled: boolean;
+    readonly KeyStatus: Windows.UI.Core.CorePhysicalKeyStatus;
+    readonly VirtualKey: number;
+  }
+
+  class PointerEventArgs implements Windows.UI.Core.ICoreWindowEventArgs, Windows.UI.Core.IPointerEventArgs {
+    GetIntermediatePoints(): Windows.Foundation.Collections.IVector<Windows.UI.Input.PointerPoint> | Windows.UI.Input.PointerPoint[];
+    readonly CurrentPoint: Windows.UI.Input.PointerPoint;
+    Handled: boolean;
+    readonly KeyModifiers: number;
+  }
+
+  class SystemNavigationManager implements Windows.UI.Core.ISystemNavigationManager, Windows.UI.Core.ISystemNavigationManager2 {
+    static GetForCurrentView(): Windows.UI.Core.SystemNavigationManager;
+    AppViewBackButtonVisibility: number;
+    BackRequested: Windows.Foundation.EventHandler<Windows.UI.Core.BackRequestedEventArgs> | null;
+  }
+
+  class TouchHitTestingEventArgs implements Windows.UI.Core.ICoreWindowEventArgs, Windows.UI.Core.ITouchHitTestingEventArgs {
+    EvaluateProximity(controlBoundingBox: Windows.Foundation.Rect): Windows.UI.Core.CoreProximityEvaluation;
+    readonly BoundingBox: Windows.Foundation.Rect;
+    Handled: boolean;
+    readonly Point: Windows.Foundation.Point;
+    ProximityEvaluation: Windows.UI.Core.CoreProximityEvaluation;
+  }
+
+  class VisibilityChangedEventArgs implements Windows.UI.Core.ICoreWindowEventArgs, Windows.UI.Core.IVisibilityChangedEventArgs {
+    Handled: boolean;
+    readonly Visible: boolean;
+  }
+
+  class WindowActivatedEventArgs implements Windows.UI.Core.ICoreWindowEventArgs, Windows.UI.Core.IWindowActivatedEventArgs {
+    Handled: boolean;
+    readonly WindowActivationState: number;
+  }
+
+  class WindowSizeChangedEventArgs implements Windows.UI.Core.ICoreWindowEventArgs, Windows.UI.Core.IWindowSizeChangedEventArgs {
+    Handled: boolean;
+    readonly Size: Windows.Foundation.Size;
+  }
+
+  enum AppViewBackButtonVisibility {
+    Visible = 0,
+    Collapsed = 1,
+    Disabled = 2,
+  }
+
+  enum CoreAcceleratorKeyEventType {
+    Character = 2,
+    DeadCharacter = 3,
+    KeyDown = 0,
+    KeyUp = 1,
+    SystemCharacter = 6,
+    SystemDeadCharacter = 7,
+    SystemKeyDown = 4,
+    SystemKeyUp = 5,
+    UnicodeCharacter = 8,
+  }
+
+  enum CoreCursorType {
+    Arrow = 0,
+    Cross = 1,
+    Custom = 2,
+    Hand = 3,
+    Help = 4,
+    IBeam = 5,
+    SizeAll = 6,
+    SizeNortheastSouthwest = 7,
+    SizeNorthSouth = 8,
+    SizeNorthwestSoutheast = 9,
+    SizeWestEast = 10,
+    UniversalNo = 11,
+    UpArrow = 12,
+    Wait = 13,
+    Pin = 14,
+    Person = 15,
+  }
+
+  enum CoreDispatcherPriority {
+    Idle = -2,
+    Low = -1,
+    Normal = 0,
+    High = 1,
+  }
+
+  enum CoreIndependentInputFilters {
+    None = 0,
+    MouseButton = 1,
+    MouseWheel = 2,
+    MouseHover = 4,
+    PenWithBarrel = 8,
+    PenInverted = 16,
+  }
+
+  enum CoreInputDeviceTypes {
+    None = 0,
+    Touch = 1,
+    Pen = 2,
+    Mouse = 4,
+  }
+
+  enum CoreProcessEventsOption {
+    ProcessOneAndAllPending = 0,
+    ProcessOneIfPresent = 1,
+    ProcessUntilQuit = 2,
+    ProcessAllIfPresent = 3,
+  }
+
+  enum CoreProximityEvaluationScore {
+    Closest = 0,
+    Farthest = 2147483647,
+  }
+
+  enum CoreVirtualKeyStates {
+    None = 0,
+    Down = 1,
+    Locked = 2,
+  }
+
+  enum CoreWindowActivationMode {
+    None = 0,
+    Deactivated = 1,
+    ActivatedNotForeground = 2,
+    ActivatedInForeground = 3,
+  }
+
+  enum CoreWindowActivationState {
+    CodeActivated = 0,
+    Deactivated = 1,
+    PointerActivated = 2,
+  }
+
+  enum CoreWindowFlowDirection {
+    LeftToRight = 0,
+    RightToLeft = 1,
+  }
+
+  interface CorePhysicalKeyStatus {
+    RepeatCount: number;
+    ScanCode: number;
+    IsExtendedKey: boolean;
+    IsMenuKeyDown: boolean;
+    WasKeyDown: boolean;
+    IsKeyReleased: boolean;
+  }
+  var CorePhysicalKeyStatus: {
+    new(repeatCount: number, scanCode: number, isExtendedKey: boolean, isMenuKeyDown: boolean, wasKeyDown: boolean, isKeyReleased: boolean): CorePhysicalKeyStatus;
+    new(fields: { RepeatCount?: number; ScanCode?: number; IsExtendedKey?: boolean; IsMenuKeyDown?: boolean; WasKeyDown?: boolean; IsKeyReleased?: boolean }): CorePhysicalKeyStatus;
+  };
+
+  interface CoreProximityEvaluation {
+    Score: number;
+    AdjustedPoint: Windows.Foundation.Point;
+  }
+  var CoreProximityEvaluation: {
+    new(score: number, adjustedPoint: Windows.Foundation.Point): CoreProximityEvaluation;
+    new(fields: { Score?: number; AdjustedPoint?: Windows.Foundation.Point }): CoreProximityEvaluation;
+  };
+
+  interface CoreWindowDialogsContract {
+  }
+  var CoreWindowDialogsContract: {
+    new(fields: {  }): CoreWindowDialogsContract;
+  };
+
+  interface DispatchedHandler {
+    (): void;
+  }
+  var DispatchedHandler: {
+    new(callback: () => void): DispatchedHandler;
+  };
+
+  interface IAcceleratorKeyEventArgs extends Windows.UI.Core.ICoreWindowEventArgs {
+    readonly EventType: number;
+    readonly KeyStatus: Windows.UI.Core.CorePhysicalKeyStatus;
+    readonly VirtualKey: number;
+  }
+  var IAcceleratorKeyEventArgs: abstract new (...args: any[]) => IAcceleratorKeyEventArgs;
+
+  interface IAcceleratorKeyEventArgs2 extends Windows.UI.Core.ICoreWindowEventArgs {
+    readonly DeviceId: string;
+  }
+  var IAcceleratorKeyEventArgs2: abstract new (...args: any[]) => IAcceleratorKeyEventArgs2;
+
+  interface IAutomationProviderRequestedEventArgs extends Windows.UI.Core.ICoreWindowEventArgs {
+    AutomationProvider: Object;
+  }
+  var IAutomationProviderRequestedEventArgs: abstract new (...args: any[]) => IAutomationProviderRequestedEventArgs;
+
+  interface IBackRequestedEventArgs {
+    Handled: boolean;
+  }
+  var IBackRequestedEventArgs: abstract new (...args: any[]) => IBackRequestedEventArgs;
+
+  interface ICharacterReceivedEventArgs extends Windows.UI.Core.ICoreWindowEventArgs {
+    readonly KeyCode: number;
+    readonly KeyStatus: Windows.UI.Core.CorePhysicalKeyStatus;
+  }
+  var ICharacterReceivedEventArgs: abstract new (...args: any[]) => ICharacterReceivedEventArgs;
+
+  interface IClosestInteractiveBoundsRequestedEventArgs {
+    ClosestInteractiveBounds: Windows.Foundation.Rect;
+    readonly PointerPosition: Windows.Foundation.Point;
+    readonly SearchBounds: Windows.Foundation.Rect;
+  }
+  var IClosestInteractiveBoundsRequestedEventArgs: abstract new (...args: any[]) => IClosestInteractiveBoundsRequestedEventArgs;
+
+  interface ICoreAcceleratorKeys {
+    AcceleratorKeyActivated: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreDispatcher, Windows.UI.Core.AcceleratorKeyEventArgs> | null;
+  }
+  var ICoreAcceleratorKeys: abstract new (...args: any[]) => ICoreAcceleratorKeys;
+
+  interface ICoreClosestInteractiveBoundsRequested {
+    ClosestInteractiveBoundsRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreComponentInputSource, Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs> | null;
+  }
+  var ICoreClosestInteractiveBoundsRequested: abstract new (...args: any[]) => ICoreClosestInteractiveBoundsRequested;
+
+  interface ICoreComponentFocusable {
+    readonly HasFocus: boolean;
+    GotFocus: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.CoreWindowEventArgs> | null;
+    LostFocus: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.CoreWindowEventArgs> | null;
+  }
+  var ICoreComponentFocusable: abstract new (...args: any[]) => ICoreComponentFocusable;
+
+  interface ICoreCursor {
+    readonly Id: number;
+    readonly Type: number;
+  }
+  var ICoreCursor: abstract new (...args: any[]) => ICoreCursor;
+
+  interface ICoreCursorFactory {
+    CreateCursor(type: number, id: number): Windows.UI.Core.CoreCursor;
+  }
+  var ICoreCursorFactory: abstract new (...args: any[]) => ICoreCursorFactory;
+
+  interface ICoreDispatcher extends Windows.UI.Core.ICoreAcceleratorKeys {
+    ProcessEvents(options: number): void;
+    RunAsync(priority: number, agileCallback: Windows.UI.Core.DispatchedHandler): Windows.Foundation.IAsyncAction;
+    RunIdleAsync(agileCallback: Windows.UI.Core.IdleDispatchedHandler): Windows.Foundation.IAsyncAction;
+    readonly HasThreadAccess: boolean;
+  }
+  var ICoreDispatcher: abstract new (...args: any[]) => ICoreDispatcher;
+
+  interface ICoreDispatcher2 {
+    TryRunAsync(priority: number, agileCallback: Windows.UI.Core.DispatchedHandler): Windows.Foundation.IAsyncOperation<boolean>;
+    TryRunIdleAsync(agileCallback: Windows.UI.Core.IdleDispatchedHandler): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var ICoreDispatcher2: abstract new (...args: any[]) => ICoreDispatcher2;
+
+  interface ICoreDispatcherWithTaskPriority {
+    ShouldYield(): boolean;
+    ShouldYield(priority: number): boolean;
+    StopProcessEvents(): void;
+    CurrentPriority: number;
+  }
+  var ICoreDispatcherWithTaskPriority: abstract new (...args: any[]) => ICoreDispatcherWithTaskPriority;
+
+  interface ICoreIndependentInputSourceController {
+    SetControlledInput(inputTypes: number): void;
+    SetControlledInput(inputTypes: number, required: number, excluded: number): void;
+    IsPalmRejectionEnabled: boolean;
+    IsTransparentForUncontrolledInput: boolean;
+    readonly Source: Windows.UI.Core.CoreIndependentInputSource;
+  }
+  var ICoreIndependentInputSourceController: abstract new (...args: any[]) => ICoreIndependentInputSourceController;
+
+  interface ICoreIndependentInputSourceControllerStatics {
+    CreateForIVisualElement(visualElement: Windows.UI.Composition.IVisualElement): Windows.UI.Core.CoreIndependentInputSourceController;
+    CreateForVisual(visual: Windows.UI.Composition.Visual): Windows.UI.Core.CoreIndependentInputSourceController;
+  }
+  var ICoreIndependentInputSourceControllerStatics: abstract new (...args: any[]) => ICoreIndependentInputSourceControllerStatics;
+
+  interface ICoreInputSourceBase {
+    readonly Dispatcher: Windows.UI.Core.CoreDispatcher;
+    IsInputEnabled: boolean;
+    InputEnabled: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.InputEnabledEventArgs> | null;
+  }
+  var ICoreInputSourceBase: abstract new (...args: any[]) => ICoreInputSourceBase;
+
+  interface ICoreKeyboardInputSource {
+    GetCurrentKeyState(virtualKey: number): number;
+    CharacterReceived: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.CharacterReceivedEventArgs> | null;
+    KeyDown: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.KeyEventArgs> | null;
+    KeyUp: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.KeyEventArgs> | null;
+  }
+  var ICoreKeyboardInputSource: abstract new (...args: any[]) => ICoreKeyboardInputSource;
+
+  interface ICoreKeyboardInputSource2 {
+    GetCurrentKeyEventDeviceId(): string;
+  }
+  var ICoreKeyboardInputSource2: abstract new (...args: any[]) => ICoreKeyboardInputSource2;
+
+  interface ICorePointerInputSource {
+    ReleasePointerCapture(): void;
+    SetPointerCapture(): void;
+    readonly HasCapture: boolean;
+    PointerCursor: Windows.UI.Core.CoreCursor;
+    readonly PointerPosition: Windows.Foundation.Point;
+    PointerCaptureLost: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    PointerEntered: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    PointerExited: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    PointerMoved: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    PointerPressed: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    PointerReleased: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+    PointerWheelChanged: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.PointerEventArgs> | null;
+  }
+  var ICorePointerInputSource: abstract new (...args: any[]) => ICorePointerInputSource;
+
+  interface ICorePointerInputSource2 extends Windows.UI.Core.ICorePointerInputSource {
+    ReleasePointerCapture(): void;
+    SetPointerCapture(): void;
+    readonly DispatcherQueue: Windows.System.DispatcherQueue;
+  }
+  var ICorePointerInputSource2: abstract new (...args: any[]) => ICorePointerInputSource2;
+
+  interface ICorePointerRedirector {
+    PointerRoutedAway: Windows.Foundation.TypedEventHandler<Windows.UI.Core.ICorePointerRedirector, Windows.UI.Core.PointerEventArgs> | null;
+    PointerRoutedReleased: Windows.Foundation.TypedEventHandler<Windows.UI.Core.ICorePointerRedirector, Windows.UI.Core.PointerEventArgs> | null;
+    PointerRoutedTo: Windows.Foundation.TypedEventHandler<Windows.UI.Core.ICorePointerRedirector, Windows.UI.Core.PointerEventArgs> | null;
+  }
+  var ICorePointerRedirector: abstract new (...args: any[]) => ICorePointerRedirector;
+
+  interface ICoreTouchHitTesting {
+    TouchHitTesting: Windows.Foundation.TypedEventHandler<Object, Windows.UI.Core.TouchHitTestingEventArgs> | null;
+  }
+  var ICoreTouchHitTesting: abstract new (...args: any[]) => ICoreTouchHitTesting;
+
+  interface ICoreWindow {
+    Activate(): void;
+    Close(): void;
+    GetAsyncKeyState(virtualKey: number): number;
+    GetKeyState(virtualKey: number): number;
+    ReleasePointerCapture(): void;
+    SetPointerCapture(): void;
+    readonly AutomationHostProvider: Object;
+    readonly Bounds: Windows.Foundation.Rect;
+    readonly CustomProperties: Windows.Foundation.Collections.IPropertySet;
+    readonly Dispatcher: Windows.UI.Core.CoreDispatcher;
+    FlowDirection: number;
+    IsInputEnabled: boolean;
+    PointerCursor: Windows.UI.Core.CoreCursor;
+    readonly PointerPosition: Windows.Foundation.Point;
+    readonly Visible: boolean;
+    Activated: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.WindowActivatedEventArgs> | null;
+    AutomationProviderRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.AutomationProviderRequestedEventArgs> | null;
+    CharacterReceived: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.CharacterReceivedEventArgs> | null;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.CoreWindowEventArgs> | null;
+    InputEnabled: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.InputEnabledEventArgs> | null;
+    KeyDown: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.KeyEventArgs> | null;
+    KeyUp: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.KeyEventArgs> | null;
+    PointerCaptureLost: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.PointerEventArgs> | null;
+    PointerEntered: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.PointerEventArgs> | null;
+    PointerExited: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.PointerEventArgs> | null;
+    PointerMoved: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.PointerEventArgs> | null;
+    PointerPressed: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.PointerEventArgs> | null;
+    PointerReleased: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.PointerEventArgs> | null;
+    PointerWheelChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.PointerEventArgs> | null;
+    SizeChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.WindowSizeChangedEventArgs> | null;
+    TouchHitTesting: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.TouchHitTestingEventArgs> | null;
+    VisibilityChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.VisibilityChangedEventArgs> | null;
+  }
+  var ICoreWindow: abstract new (...args: any[]) => ICoreWindow;
+
+  interface ICoreWindow2 {
+    PointerPosition: Object;
+  }
+  var ICoreWindow2: abstract new (...args: any[]) => ICoreWindow2;
+
+  interface ICoreWindow3 {
+    GetCurrentKeyEventDeviceId(): string;
+    ClosestInteractiveBoundsRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.ClosestInteractiveBoundsRequestedEventArgs> | null;
+  }
+  var ICoreWindow3: abstract new (...args: any[]) => ICoreWindow3;
+
+  interface ICoreWindow4 {
+    ResizeCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Object> | null;
+    ResizeStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Object> | null;
+  }
+  var ICoreWindow4: abstract new (...args: any[]) => ICoreWindow4;
+
+  interface ICoreWindow5 {
+    readonly ActivationMode: number;
+    readonly DispatcherQueue: Windows.System.DispatcherQueue;
+  }
+  var ICoreWindow5: abstract new (...args: any[]) => ICoreWindow5;
+
+  interface ICoreWindowDialog {
+    ShowAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.Popups.IUICommand>;
+    BackButtonCommand: Windows.UI.Popups.UICommandInvokedHandler;
+    CancelCommandIndex: number;
+    readonly Commands: Windows.Foundation.Collections.IVector<Windows.UI.Popups.IUICommand> | Windows.UI.Popups.IUICommand[];
+    DefaultCommandIndex: number;
+    IsInteractionDelayed: number;
+    readonly MaxSize: Windows.Foundation.Size;
+    readonly MinSize: Windows.Foundation.Size;
+    Title: string;
+    Showing: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.CoreWindowPopupShowingEventArgs> | null;
+  }
+  var ICoreWindowDialog: abstract new (...args: any[]) => ICoreWindowDialog;
+
+  interface ICoreWindowDialogFactory {
+    CreateWithTitle(title: string): Windows.UI.Core.CoreWindowDialog;
+  }
+  var ICoreWindowDialogFactory: abstract new (...args: any[]) => ICoreWindowDialogFactory;
+
+  interface ICoreWindowEventArgs {
+    Handled: boolean;
+  }
+  var ICoreWindowEventArgs: abstract new (...args: any[]) => ICoreWindowEventArgs;
+
+  interface ICoreWindowFlyout {
+    ShowAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.Popups.IUICommand>;
+    BackButtonCommand: Windows.UI.Popups.UICommandInvokedHandler;
+    readonly Commands: Windows.Foundation.Collections.IVector<Windows.UI.Popups.IUICommand> | Windows.UI.Popups.IUICommand[];
+    DefaultCommandIndex: number;
+    IsInteractionDelayed: number;
+    readonly MaxSize: Windows.Foundation.Size;
+    readonly MinSize: Windows.Foundation.Size;
+    Title: string;
+    Showing: Windows.Foundation.TypedEventHandler<Windows.UI.Core.CoreWindow, Windows.UI.Core.CoreWindowPopupShowingEventArgs> | null;
+  }
+  var ICoreWindowFlyout: abstract new (...args: any[]) => ICoreWindowFlyout;
+
+  interface ICoreWindowFlyoutFactory {
+    Create(position: Windows.Foundation.Point): Windows.UI.Core.CoreWindowFlyout;
+    CreateWithTitle(position: Windows.Foundation.Point, title: string): Windows.UI.Core.CoreWindowFlyout;
+  }
+  var ICoreWindowFlyoutFactory: abstract new (...args: any[]) => ICoreWindowFlyoutFactory;
+
+  interface ICoreWindowPopupShowingEventArgs {
+    SetDesiredSize(value: Windows.Foundation.Size): void;
+  }
+  var ICoreWindowPopupShowingEventArgs: abstract new (...args: any[]) => ICoreWindowPopupShowingEventArgs;
+
+  interface ICoreWindowResizeManager {
+    NotifyLayoutCompleted(): void;
+  }
+  var ICoreWindowResizeManager: abstract new (...args: any[]) => ICoreWindowResizeManager;
+
+  interface ICoreWindowResizeManagerLayoutCapability {
+    ShouldWaitForLayoutCompletion: boolean;
+  }
+  var ICoreWindowResizeManagerLayoutCapability: abstract new (...args: any[]) => ICoreWindowResizeManagerLayoutCapability;
+
+  interface ICoreWindowResizeManagerStatics {
+    GetForCurrentView(): Windows.UI.Core.CoreWindowResizeManager;
+  }
+  var ICoreWindowResizeManagerStatics: abstract new (...args: any[]) => ICoreWindowResizeManagerStatics;
+
+  interface ICoreWindowStatic {
+    GetForCurrentThread(): Windows.UI.Core.CoreWindow;
+  }
+  var ICoreWindowStatic: abstract new (...args: any[]) => ICoreWindowStatic;
+
+  interface ICoreWindowWithContext {
+    readonly UIContext: Windows.UI.UIContext;
+  }
+  var ICoreWindowWithContext: abstract new (...args: any[]) => ICoreWindowWithContext;
+
+  interface IIdleDispatchedHandlerArgs {
+    readonly IsDispatcherIdle: boolean;
+  }
+  var IIdleDispatchedHandlerArgs: abstract new (...args: any[]) => IIdleDispatchedHandlerArgs;
+
+  interface IInitializeWithCoreWindow {
+    Initialize(window: Windows.UI.Core.CoreWindow): void;
+  }
+  var IInitializeWithCoreWindow: abstract new (...args: any[]) => IInitializeWithCoreWindow;
+
+  interface IInputEnabledEventArgs extends Windows.UI.Core.ICoreWindowEventArgs {
+    readonly InputEnabled: boolean;
+  }
+  var IInputEnabledEventArgs: abstract new (...args: any[]) => IInputEnabledEventArgs;
+
+  interface IKeyEventArgs extends Windows.UI.Core.ICoreWindowEventArgs {
+    readonly KeyStatus: Windows.UI.Core.CorePhysicalKeyStatus;
+    readonly VirtualKey: number;
+  }
+  var IKeyEventArgs: abstract new (...args: any[]) => IKeyEventArgs;
+
+  interface IKeyEventArgs2 extends Windows.UI.Core.ICoreWindowEventArgs {
+    readonly DeviceId: string;
+  }
+  var IKeyEventArgs2: abstract new (...args: any[]) => IKeyEventArgs2;
+
+  interface IPointerEventArgs extends Windows.UI.Core.ICoreWindowEventArgs {
+    GetIntermediatePoints(): Windows.Foundation.Collections.IVector<Windows.UI.Input.PointerPoint> | Windows.UI.Input.PointerPoint[];
+    readonly CurrentPoint: Windows.UI.Input.PointerPoint;
+    readonly KeyModifiers: number;
+  }
+  var IPointerEventArgs: abstract new (...args: any[]) => IPointerEventArgs;
+
+  interface ISystemNavigationManager {
+    BackRequested: Windows.Foundation.EventHandler<Windows.UI.Core.BackRequestedEventArgs> | null;
+  }
+  var ISystemNavigationManager: abstract new (...args: any[]) => ISystemNavigationManager;
+
+  interface ISystemNavigationManager2 {
+    AppViewBackButtonVisibility: number;
+  }
+  var ISystemNavigationManager2: abstract new (...args: any[]) => ISystemNavigationManager2;
+
+  interface ISystemNavigationManagerStatics {
+    GetForCurrentView(): Windows.UI.Core.SystemNavigationManager;
+  }
+  var ISystemNavigationManagerStatics: abstract new (...args: any[]) => ISystemNavigationManagerStatics;
+
+  interface ITouchHitTestingEventArgs extends Windows.UI.Core.ICoreWindowEventArgs {
+    EvaluateProximity(controlBoundingBox: Windows.Foundation.Rect): Windows.UI.Core.CoreProximityEvaluation;
+    readonly BoundingBox: Windows.Foundation.Rect;
+    readonly Point: Windows.Foundation.Point;
+    ProximityEvaluation: Windows.UI.Core.CoreProximityEvaluation;
+  }
+  var ITouchHitTestingEventArgs: abstract new (...args: any[]) => ITouchHitTestingEventArgs;
+
+  interface IVisibilityChangedEventArgs extends Windows.UI.Core.ICoreWindowEventArgs {
+    readonly Visible: boolean;
+  }
+  var IVisibilityChangedEventArgs: abstract new (...args: any[]) => IVisibilityChangedEventArgs;
+
+  interface IWindowActivatedEventArgs extends Windows.UI.Core.ICoreWindowEventArgs {
+    readonly WindowActivationState: number;
+  }
+  var IWindowActivatedEventArgs: abstract new (...args: any[]) => IWindowActivatedEventArgs;
+
+  interface IWindowSizeChangedEventArgs extends Windows.UI.Core.ICoreWindowEventArgs {
+    readonly Size: Windows.Foundation.Size;
+  }
+  var IWindowSizeChangedEventArgs: abstract new (...args: any[]) => IWindowSizeChangedEventArgs;
+
+  interface IdleDispatchedHandler {
+    (e: Windows.UI.Core.IdleDispatchedHandlerArgs): void;
+  }
+  var IdleDispatchedHandler: {
+    new(callback: (e: Windows.UI.Core.IdleDispatchedHandlerArgs) => void): IdleDispatchedHandler;
+  };
+
+}
+
+declare namespace Windows.UI.Core.AnimationMetrics {
+  class AnimationDescription implements Windows.UI.Core.AnimationMetrics.IAnimationDescription {
+    constructor(effect: number, target: number);
+    readonly Animations: Windows.Foundation.Collections.IVectorView<Windows.UI.Core.AnimationMetrics.IPropertyAnimation> | Windows.UI.Core.AnimationMetrics.IPropertyAnimation[];
+    readonly DelayLimit: Windows.Foundation.TimeSpan;
+    readonly StaggerDelay: Windows.Foundation.TimeSpan;
+    readonly StaggerDelayFactor: number;
+    readonly ZOrder: number;
+  }
+
+  class OpacityAnimation implements Windows.UI.Core.AnimationMetrics.IOpacityAnimation, Windows.UI.Core.AnimationMetrics.IPropertyAnimation {
+    readonly Control1: Windows.Foundation.Point;
+    readonly Control2: Windows.Foundation.Point;
+    readonly Delay: Windows.Foundation.TimeSpan;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly FinalOpacity: number;
+    readonly InitialOpacity: number | null;
+    readonly Type: number;
+  }
+
+  class PropertyAnimation implements Windows.UI.Core.AnimationMetrics.IPropertyAnimation {
+    readonly Control1: Windows.Foundation.Point;
+    readonly Control2: Windows.Foundation.Point;
+    readonly Delay: Windows.Foundation.TimeSpan;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+  }
+
+  class ScaleAnimation implements Windows.UI.Core.AnimationMetrics.IPropertyAnimation, Windows.UI.Core.AnimationMetrics.IScaleAnimation {
+    readonly Control1: Windows.Foundation.Point;
+    readonly Control2: Windows.Foundation.Point;
+    readonly Delay: Windows.Foundation.TimeSpan;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly FinalScaleX: number;
+    readonly FinalScaleY: number;
+    readonly InitialScaleX: number | null;
+    readonly InitialScaleY: number | null;
+    readonly NormalizedOrigin: Windows.Foundation.Point;
+    readonly Type: number;
+  }
+
+  class TranslationAnimation implements Windows.UI.Core.AnimationMetrics.IPropertyAnimation {
+    readonly Control1: Windows.Foundation.Point;
+    readonly Control2: Windows.Foundation.Point;
+    readonly Delay: Windows.Foundation.TimeSpan;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+  }
+
+  enum AnimationEffect {
+    Expand = 0,
+    Collapse = 1,
+    Reposition = 2,
+    FadeIn = 3,
+    FadeOut = 4,
+    AddToList = 5,
+    DeleteFromList = 6,
+    AddToGrid = 7,
+    DeleteFromGrid = 8,
+    AddToSearchGrid = 9,
+    DeleteFromSearchGrid = 10,
+    AddToSearchList = 11,
+    DeleteFromSearchList = 12,
+    ShowEdgeUI = 13,
+    ShowPanel = 14,
+    HideEdgeUI = 15,
+    HidePanel = 16,
+    ShowPopup = 17,
+    HidePopup = 18,
+    PointerDown = 19,
+    PointerUp = 20,
+    DragSourceStart = 21,
+    DragSourceEnd = 22,
+    TransitionContent = 23,
+    Reveal = 24,
+    Hide = 25,
+    DragBetweenEnter = 26,
+    DragBetweenLeave = 27,
+    SwipeSelect = 28,
+    SwipeDeselect = 29,
+    SwipeReveal = 30,
+    EnterPage = 31,
+    TransitionPage = 32,
+    CrossFade = 33,
+    Peek = 34,
+    UpdateBadge = 35,
+  }
+
+  enum AnimationEffectTarget {
+    Primary = 0,
+    Added = 1,
+    Affected = 2,
+    Background = 3,
+    Content = 4,
+    Deleted = 5,
+    Deselected = 6,
+    DragSource = 7,
+    Hidden = 8,
+    Incoming = 9,
+    Outgoing = 10,
+    Outline = 11,
+    Remaining = 12,
+    Revealed = 13,
+    RowIn = 14,
+    RowOut = 15,
+    Selected = 16,
+    Selection = 17,
+    Shown = 18,
+    Tapped = 19,
+  }
+
+  enum PropertyAnimationType {
+    Scale = 0,
+    Translation = 1,
+    Opacity = 2,
+  }
+
+  interface AnimationMetricsContract {
+  }
+  var AnimationMetricsContract: {
+    new(fields: {  }): AnimationMetricsContract;
+  };
+
+  interface IAnimationDescription {
+    readonly Animations: Windows.Foundation.Collections.IVectorView<Windows.UI.Core.AnimationMetrics.IPropertyAnimation> | Windows.UI.Core.AnimationMetrics.IPropertyAnimation[];
+    readonly DelayLimit: Windows.Foundation.TimeSpan;
+    readonly StaggerDelay: Windows.Foundation.TimeSpan;
+    readonly StaggerDelayFactor: number;
+    readonly ZOrder: number;
+  }
+  var IAnimationDescription: abstract new (...args: any[]) => IAnimationDescription;
+
+  interface IAnimationDescriptionFactory {
+    CreateInstance(effect: number, target: number): Windows.UI.Core.AnimationMetrics.AnimationDescription;
+  }
+  var IAnimationDescriptionFactory: abstract new (...args: any[]) => IAnimationDescriptionFactory;
+
+  interface IOpacityAnimation extends Windows.UI.Core.AnimationMetrics.IPropertyAnimation {
+    readonly FinalOpacity: number;
+    readonly InitialOpacity: number | null;
+  }
+  var IOpacityAnimation: abstract new (...args: any[]) => IOpacityAnimation;
+
+  interface IPropertyAnimation {
+    readonly Control1: Windows.Foundation.Point;
+    readonly Control2: Windows.Foundation.Point;
+    readonly Delay: Windows.Foundation.TimeSpan;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly Type: number;
+  }
+  var IPropertyAnimation: abstract new (...args: any[]) => IPropertyAnimation;
+
+  interface IScaleAnimation extends Windows.UI.Core.AnimationMetrics.IPropertyAnimation {
+    readonly FinalScaleX: number;
+    readonly FinalScaleY: number;
+    readonly InitialScaleX: number | null;
+    readonly InitialScaleY: number | null;
+    readonly NormalizedOrigin: Windows.Foundation.Point;
+  }
+  var IScaleAnimation: abstract new (...args: any[]) => IScaleAnimation;
+
+}
+
+declare namespace Windows.UI.Core.Preview {
+  class CoreAppWindowPreview implements Windows.UI.Core.Preview.ICoreAppWindowPreview {
+    static GetIdFromWindow(window: Windows.UI.WindowManagement.AppWindow): number;
+  }
+
+  class SystemNavigationCloseRequestedPreviewEventArgs implements Windows.UI.Core.Preview.ISystemNavigationCloseRequestedPreviewEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+
+  class SystemNavigationManagerPreview implements Windows.UI.Core.Preview.ISystemNavigationManagerPreview {
+    static GetForCurrentView(): Windows.UI.Core.Preview.SystemNavigationManagerPreview;
+    CloseRequested: Windows.Foundation.EventHandler<Windows.UI.Core.Preview.SystemNavigationCloseRequestedPreviewEventArgs> | null;
+  }
+
+  interface ICoreAppWindowPreview {
+  }
+  var ICoreAppWindowPreview: abstract new (...args: any[]) => ICoreAppWindowPreview;
+
+  interface ICoreAppWindowPreviewStatics {
+    GetIdFromWindow(window: Windows.UI.WindowManagement.AppWindow): number;
+  }
+  var ICoreAppWindowPreviewStatics: abstract new (...args: any[]) => ICoreAppWindowPreviewStatics;
+
+  interface ISystemNavigationCloseRequestedPreviewEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+  }
+  var ISystemNavigationCloseRequestedPreviewEventArgs: abstract new (...args: any[]) => ISystemNavigationCloseRequestedPreviewEventArgs;
+
+  interface ISystemNavigationManagerPreview {
+    CloseRequested: Windows.Foundation.EventHandler<Windows.UI.Core.Preview.SystemNavigationCloseRequestedPreviewEventArgs> | null;
+  }
+  var ISystemNavigationManagerPreview: abstract new (...args: any[]) => ISystemNavigationManagerPreview;
+
+  interface ISystemNavigationManagerPreviewStatics {
+    GetForCurrentView(): Windows.UI.Core.Preview.SystemNavigationManagerPreview;
+  }
+  var ISystemNavigationManagerPreviewStatics: abstract new (...args: any[]) => ISystemNavigationManagerPreviewStatics;
+
+}
+
+declare namespace Windows.UI.Input {
+  class AttachableInputObject implements Windows.Foundation.IClosable, Windows.UI.Input.IAttachableInputObject {
+    Close(): void;
+  }
+
+  class CrossSlidingEventArgs implements Windows.UI.Input.ICrossSlidingEventArgs, Windows.UI.Input.ICrossSlidingEventArgs2 {
+    readonly ContactCount: number;
+    readonly CrossSlidingState: number;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+  }
+
+  class DraggingEventArgs implements Windows.UI.Input.IDraggingEventArgs, Windows.UI.Input.IDraggingEventArgs2 {
+    readonly ContactCount: number;
+    readonly DraggingState: number;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+  }
+
+  class EdgeGesture implements Windows.UI.Input.IEdgeGesture {
+    static GetForCurrentView(): Windows.UI.Input.EdgeGesture;
+    Canceled: Windows.Foundation.TypedEventHandler<Windows.UI.Input.EdgeGesture, Windows.UI.Input.EdgeGestureEventArgs> | null;
+    Completed: Windows.Foundation.TypedEventHandler<Windows.UI.Input.EdgeGesture, Windows.UI.Input.EdgeGestureEventArgs> | null;
+    Starting: Windows.Foundation.TypedEventHandler<Windows.UI.Input.EdgeGesture, Windows.UI.Input.EdgeGestureEventArgs> | null;
+  }
+
+  class EdgeGestureEventArgs implements Windows.UI.Input.IEdgeGestureEventArgs {
+    readonly Kind: number;
+  }
+
+  class GestureRecognizer implements Windows.UI.Input.IGestureRecognizer, Windows.UI.Input.IGestureRecognizer2 {
+    constructor();
+    CanBeDoubleTap(value: Windows.UI.Input.PointerPoint): boolean;
+    CompleteGesture(): void;
+    ProcessDownEvent(value: Windows.UI.Input.PointerPoint): void;
+    ProcessInertia(): void;
+    ProcessMouseWheelEvent(value: Windows.UI.Input.PointerPoint, isShiftKeyDown: boolean, isControlKeyDown: boolean): void;
+    ProcessMoveEvents(value: Windows.Foundation.Collections.IVector<Windows.UI.Input.PointerPoint> | Windows.UI.Input.PointerPoint[]): void;
+    ProcessUpEvent(value: Windows.UI.Input.PointerPoint): void;
+    AutoProcessInertia: boolean;
+    CrossSlideExact: boolean;
+    CrossSlideHorizontally: boolean;
+    CrossSlideThresholds: Windows.UI.Input.CrossSlideThresholds;
+    GestureSettings: number;
+    HoldMaxContactCount: number;
+    HoldMinContactCount: number;
+    HoldRadius: number;
+    HoldStartDelay: Windows.Foundation.TimeSpan;
+    InertiaExpansion: number;
+    InertiaExpansionDeceleration: number;
+    InertiaRotationAngle: number;
+    InertiaRotationDeceleration: number;
+    InertiaTranslationDeceleration: number;
+    InertiaTranslationDisplacement: number;
+    readonly IsActive: boolean;
+    readonly IsInertial: boolean;
+    ManipulationExact: boolean;
+    readonly MouseWheelParameters: Windows.UI.Input.MouseWheelParameters;
+    PivotCenter: Windows.Foundation.Point;
+    PivotRadius: number;
+    ShowGestureFeedback: boolean;
+    TapMaxContactCount: number;
+    TapMinContactCount: number;
+    TranslationMaxContactCount: number;
+    TranslationMinContactCount: number;
+    CrossSliding: Windows.Foundation.TypedEventHandler<Windows.UI.Input.GestureRecognizer, Windows.UI.Input.CrossSlidingEventArgs> | null;
+    Dragging: Windows.Foundation.TypedEventHandler<Windows.UI.Input.GestureRecognizer, Windows.UI.Input.DraggingEventArgs> | null;
+    Holding: Windows.Foundation.TypedEventHandler<Windows.UI.Input.GestureRecognizer, Windows.UI.Input.HoldingEventArgs> | null;
+    ManipulationCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.GestureRecognizer, Windows.UI.Input.ManipulationCompletedEventArgs> | null;
+    ManipulationInertiaStarting: Windows.Foundation.TypedEventHandler<Windows.UI.Input.GestureRecognizer, Windows.UI.Input.ManipulationInertiaStartingEventArgs> | null;
+    ManipulationStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.GestureRecognizer, Windows.UI.Input.ManipulationStartedEventArgs> | null;
+    ManipulationUpdated: Windows.Foundation.TypedEventHandler<Windows.UI.Input.GestureRecognizer, Windows.UI.Input.ManipulationUpdatedEventArgs> | null;
+    RightTapped: Windows.Foundation.TypedEventHandler<Windows.UI.Input.GestureRecognizer, Windows.UI.Input.RightTappedEventArgs> | null;
+    Tapped: Windows.Foundation.TypedEventHandler<Windows.UI.Input.GestureRecognizer, Windows.UI.Input.TappedEventArgs> | null;
+  }
+
+  class HoldingEventArgs implements Windows.UI.Input.IHoldingEventArgs, Windows.UI.Input.IHoldingEventArgs2 {
+    readonly ContactCount: number;
+    readonly CurrentContactCount: number;
+    readonly HoldingState: number;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+  }
+
+  class InputActivationListener extends Windows.UI.Input.AttachableInputObject implements Windows.UI.Input.IInputActivationListener {
+    Close(): void;
+    readonly State: number;
+    InputActivationChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Input.InputActivationListener, Windows.UI.Input.InputActivationListenerActivationChangedEventArgs> | null;
+  }
+
+  class InputActivationListenerActivationChangedEventArgs implements Windows.UI.Input.IInputActivationListenerActivationChangedEventArgs {
+    readonly State: number;
+  }
+
+  class KeyboardDeliveryInterceptor implements Windows.UI.Input.IKeyboardDeliveryInterceptor {
+    static GetForCurrentView(): Windows.UI.Input.KeyboardDeliveryInterceptor;
+    IsInterceptionEnabledWhenInForeground: boolean;
+    KeyDown: Windows.Foundation.TypedEventHandler<Windows.UI.Input.KeyboardDeliveryInterceptor, Windows.UI.Core.KeyEventArgs> | null;
+    KeyUp: Windows.Foundation.TypedEventHandler<Windows.UI.Input.KeyboardDeliveryInterceptor, Windows.UI.Core.KeyEventArgs> | null;
+  }
+
+  class ManipulationCompletedEventArgs implements Windows.UI.Input.IManipulationCompletedEventArgs, Windows.UI.Input.IManipulationCompletedEventArgs2 {
+    readonly ContactCount: number;
+    readonly Cumulative: Windows.UI.Input.ManipulationDelta;
+    readonly CurrentContactCount: number;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+    readonly Velocities: Windows.UI.Input.ManipulationVelocities;
+  }
+
+  class ManipulationInertiaStartingEventArgs implements Windows.UI.Input.IManipulationInertiaStartingEventArgs, Windows.UI.Input.IManipulationInertiaStartingEventArgs2 {
+    readonly ContactCount: number;
+    readonly Cumulative: Windows.UI.Input.ManipulationDelta;
+    readonly Delta: Windows.UI.Input.ManipulationDelta;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+    readonly Velocities: Windows.UI.Input.ManipulationVelocities;
+  }
+
+  class ManipulationStartedEventArgs implements Windows.UI.Input.IManipulationStartedEventArgs, Windows.UI.Input.IManipulationStartedEventArgs2 {
+    readonly ContactCount: number;
+    readonly Cumulative: Windows.UI.Input.ManipulationDelta;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+  }
+
+  class ManipulationUpdatedEventArgs implements Windows.UI.Input.IManipulationUpdatedEventArgs, Windows.UI.Input.IManipulationUpdatedEventArgs2 {
+    readonly ContactCount: number;
+    readonly Cumulative: Windows.UI.Input.ManipulationDelta;
+    readonly CurrentContactCount: number;
+    readonly Delta: Windows.UI.Input.ManipulationDelta;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+    readonly Velocities: Windows.UI.Input.ManipulationVelocities;
+  }
+
+  class MouseWheelParameters implements Windows.UI.Input.IMouseWheelParameters {
+    CharTranslation: Windows.Foundation.Point;
+    DeltaRotationAngle: number;
+    DeltaScale: number;
+    PageTranslation: Windows.Foundation.Point;
+  }
+
+  class PhysicalGestureRecognizer implements Windows.UI.Input.IPhysicalGestureRecognizer {
+    constructor();
+    CompleteGesture(): void;
+    ProcessDownEvent(value: Windows.UI.Input.PointerPoint): void;
+    ProcessMoveEvents(value: Windows.Foundation.Collections.IVector<Windows.UI.Input.PointerPoint> | Windows.UI.Input.PointerPoint[]): void;
+    ProcessUpEvent(value: Windows.UI.Input.PointerPoint): void;
+    GestureSettings: number;
+    HoldMaxContactCount: number;
+    HoldMinContactCount: number;
+    HoldRadius: number;
+    HoldStartDelay: Windows.Foundation.TimeSpan;
+    readonly IsActive: boolean;
+    TapMaxContactCount: number;
+    TapMinContactCount: number;
+    TranslationMaxContactCount: number;
+    TranslationMinContactCount: number;
+    Holding: Windows.Foundation.TypedEventHandler<Windows.UI.Input.PhysicalGestureRecognizer, Windows.UI.Input.HoldingEventArgs> | null;
+    ManipulationCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.PhysicalGestureRecognizer, Windows.UI.Input.ManipulationCompletedEventArgs> | null;
+    ManipulationStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.PhysicalGestureRecognizer, Windows.UI.Input.ManipulationStartedEventArgs> | null;
+    ManipulationUpdated: Windows.Foundation.TypedEventHandler<Windows.UI.Input.PhysicalGestureRecognizer, Windows.UI.Input.ManipulationUpdatedEventArgs> | null;
+    Tapped: Windows.Foundation.TypedEventHandler<Windows.UI.Input.PhysicalGestureRecognizer, Windows.UI.Input.TappedEventArgs> | null;
+  }
+
+  class PointerPoint implements Windows.UI.Input.IPointerPoint, Windows.UI.Input.IPointerPointPhysicalPosition {
+    static GetCurrentPoint(pointerId: number): Windows.UI.Input.PointerPoint;
+    static GetCurrentPoint(pointerId: number, transform: Windows.UI.Input.IPointerPointTransform): Windows.UI.Input.PointerPoint;
+    static GetIntermediatePoints(pointerId: number): Windows.Foundation.Collections.IVector<Windows.UI.Input.PointerPoint> | Windows.UI.Input.PointerPoint[];
+    static GetIntermediatePoints(pointerId: number, transform: Windows.UI.Input.IPointerPointTransform): Windows.Foundation.Collections.IVector<Windows.UI.Input.PointerPoint> | Windows.UI.Input.PointerPoint[];
+    readonly FrameId: number;
+    readonly IsInContact: boolean;
+    readonly IsPhysicalPositionSupported: boolean;
+    readonly PhysicalPosition: Windows.Foundation.Point;
+    readonly PointerDevice: Windows.Devices.Input.PointerDevice;
+    readonly PointerId: number;
+    readonly Position: Windows.Foundation.Point;
+    readonly Properties: Windows.UI.Input.PointerPointProperties;
+    readonly RawPosition: Windows.Foundation.Point;
+    readonly Timestamp: number | bigint;
+  }
+
+  class PointerPointProperties implements Windows.UI.Input.IPointerPointProperties, Windows.UI.Input.IPointerPointProperties2 {
+    GetUsageValue(usagePage: number, usageId: number): number;
+    HasUsage(usagePage: number, usageId: number): boolean;
+    readonly ContactRect: Windows.Foundation.Rect;
+    readonly ContactRectRaw: Windows.Foundation.Rect;
+    readonly IsBarrelButtonPressed: boolean;
+    readonly IsCanceled: boolean;
+    readonly IsEraser: boolean;
+    readonly IsHorizontalMouseWheel: boolean;
+    readonly IsInRange: boolean;
+    readonly IsInverted: boolean;
+    readonly IsLeftButtonPressed: boolean;
+    readonly IsMiddleButtonPressed: boolean;
+    readonly IsPrimary: boolean;
+    readonly IsRightButtonPressed: boolean;
+    readonly IsXButton1Pressed: boolean;
+    readonly IsXButton2Pressed: boolean;
+    readonly MouseWheelDelta: number;
+    readonly Orientation: number;
+    readonly PointerUpdateKind: number;
+    readonly Pressure: number;
+    readonly TouchConfidence: boolean;
+    readonly Twist: number;
+    readonly XTilt: number;
+    readonly YTilt: number;
+    readonly ZDistance: number | null;
+  }
+
+  class PointerVisualizationSettings implements Windows.UI.Input.IPointerVisualizationSettings {
+    static GetForCurrentView(): Windows.UI.Input.PointerVisualizationSettings;
+    IsBarrelButtonFeedbackEnabled: boolean;
+    IsContactFeedbackEnabled: boolean;
+  }
+
+  class RadialController implements Windows.UI.Input.IRadialController, Windows.UI.Input.IRadialController2 {
+    static CreateForCurrentView(): Windows.UI.Input.RadialController;
+    static IsSupported(): boolean;
+    readonly Menu: Windows.UI.Input.RadialControllerMenu;
+    RotationResolutionInDegrees: number;
+    UseAutomaticHapticFeedback: boolean;
+    ButtonClicked: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Windows.UI.Input.RadialControllerButtonClickedEventArgs> | null;
+    ControlAcquired: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Windows.UI.Input.RadialControllerControlAcquiredEventArgs> | null;
+    ControlLost: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Object> | null;
+    RotationChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Windows.UI.Input.RadialControllerRotationChangedEventArgs> | null;
+    ScreenContactContinued: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs> | null;
+    ScreenContactEnded: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Object> | null;
+    ScreenContactStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Windows.UI.Input.RadialControllerScreenContactStartedEventArgs> | null;
+    ButtonHolding: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Windows.UI.Input.RadialControllerButtonHoldingEventArgs> | null;
+    ButtonPressed: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Windows.UI.Input.RadialControllerButtonPressedEventArgs> | null;
+    ButtonReleased: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Windows.UI.Input.RadialControllerButtonReleasedEventArgs> | null;
+  }
+
+  class RadialControllerButtonClickedEventArgs implements Windows.UI.Input.IRadialControllerButtonClickedEventArgs, Windows.UI.Input.IRadialControllerButtonClickedEventArgs2 {
+    readonly Contact: Windows.UI.Input.RadialControllerScreenContact;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+
+  class RadialControllerButtonHoldingEventArgs implements Windows.UI.Input.IRadialControllerButtonHoldingEventArgs {
+    readonly Contact: Windows.UI.Input.RadialControllerScreenContact;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+
+  class RadialControllerButtonPressedEventArgs implements Windows.UI.Input.IRadialControllerButtonPressedEventArgs {
+    readonly Contact: Windows.UI.Input.RadialControllerScreenContact;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+
+  class RadialControllerButtonReleasedEventArgs implements Windows.UI.Input.IRadialControllerButtonReleasedEventArgs {
+    readonly Contact: Windows.UI.Input.RadialControllerScreenContact;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+
+  class RadialControllerConfiguration implements Windows.UI.Input.IRadialControllerConfiguration, Windows.UI.Input.IRadialControllerConfiguration2 {
+    static GetForCurrentView(): Windows.UI.Input.RadialControllerConfiguration;
+    ResetToDefaultMenuItems(): void;
+    SetDefaultMenuItems(buttons: Windows.Foundation.Collections.IIterable<number> | number[]): void;
+    TrySelectDefaultMenuItem(type: number): boolean;
+    ActiveControllerWhenMenuIsSuppressed: Windows.UI.Input.RadialController;
+    static AppController: Windows.UI.Input.RadialController;
+    static IsAppControllerEnabled: boolean;
+    IsMenuSuppressed: boolean;
+  }
+
+  class RadialControllerControlAcquiredEventArgs implements Windows.UI.Input.IRadialControllerControlAcquiredEventArgs, Windows.UI.Input.IRadialControllerControlAcquiredEventArgs2 {
+    readonly Contact: Windows.UI.Input.RadialControllerScreenContact;
+    readonly IsButtonPressed: boolean;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+
+  class RadialControllerMenu implements Windows.UI.Input.IRadialControllerMenu {
+    GetSelectedMenuItem(): Windows.UI.Input.RadialControllerMenuItem;
+    SelectMenuItem(menuItem: Windows.UI.Input.RadialControllerMenuItem): void;
+    TrySelectPreviouslySelectedMenuItem(): boolean;
+    IsEnabled: boolean;
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.UI.Input.RadialControllerMenuItem> | Windows.UI.Input.RadialControllerMenuItem[];
+  }
+
+  class RadialControllerMenuItem implements Windows.UI.Input.IRadialControllerMenuItem {
+    static CreateFromFontGlyph(displayText: string, glyph: string, fontFamily: string): Windows.UI.Input.RadialControllerMenuItem;
+    static CreateFromFontGlyph(displayText: string, glyph: string, fontFamily: string, fontUri: Windows.Foundation.Uri): Windows.UI.Input.RadialControllerMenuItem;
+    static CreateFromIcon(displayText: string, icon: Windows.Storage.Streams.RandomAccessStreamReference): Windows.UI.Input.RadialControllerMenuItem;
+    static CreateFromKnownIcon(displayText: string, value: number): Windows.UI.Input.RadialControllerMenuItem;
+    readonly DisplayText: string;
+    Tag: Object;
+    Invoked: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialControllerMenuItem, Object> | null;
+  }
+
+  class RadialControllerRotationChangedEventArgs implements Windows.UI.Input.IRadialControllerRotationChangedEventArgs, Windows.UI.Input.IRadialControllerRotationChangedEventArgs2 {
+    readonly Contact: Windows.UI.Input.RadialControllerScreenContact;
+    readonly IsButtonPressed: boolean;
+    readonly RotationDeltaInDegrees: number;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+
+  class RadialControllerScreenContact implements Windows.UI.Input.IRadialControllerScreenContact {
+    readonly Bounds: Windows.Foundation.Rect;
+    readonly Position: Windows.Foundation.Point;
+  }
+
+  class RadialControllerScreenContactContinuedEventArgs implements Windows.UI.Input.IRadialControllerScreenContactContinuedEventArgs, Windows.UI.Input.IRadialControllerScreenContactContinuedEventArgs2 {
+    readonly Contact: Windows.UI.Input.RadialControllerScreenContact;
+    readonly IsButtonPressed: boolean;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+
+  class RadialControllerScreenContactEndedEventArgs implements Windows.UI.Input.IRadialControllerScreenContactEndedEventArgs {
+    readonly IsButtonPressed: boolean;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+
+  class RadialControllerScreenContactStartedEventArgs implements Windows.UI.Input.IRadialControllerScreenContactStartedEventArgs, Windows.UI.Input.IRadialControllerScreenContactStartedEventArgs2 {
+    readonly Contact: Windows.UI.Input.RadialControllerScreenContact;
+    readonly IsButtonPressed: boolean;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+
+  class RightTappedEventArgs implements Windows.UI.Input.IRightTappedEventArgs, Windows.UI.Input.IRightTappedEventArgs2 {
+    readonly ContactCount: number;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+  }
+
+  class SystemButtonEventController extends Windows.UI.Input.AttachableInputObject implements Windows.UI.Input.ISystemButtonEventController {
+    Close(): void;
+    static CreateForDispatcherQueue(queue: Windows.System.DispatcherQueue): Windows.UI.Input.SystemButtonEventController;
+    SystemFunctionButtonPressed: Windows.Foundation.TypedEventHandler<Windows.UI.Input.SystemButtonEventController, Windows.UI.Input.SystemFunctionButtonEventArgs> | null;
+    SystemFunctionButtonReleased: Windows.Foundation.TypedEventHandler<Windows.UI.Input.SystemButtonEventController, Windows.UI.Input.SystemFunctionButtonEventArgs> | null;
+    SystemFunctionLockChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Input.SystemButtonEventController, Windows.UI.Input.SystemFunctionLockChangedEventArgs> | null;
+    SystemFunctionLockIndicatorChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Input.SystemButtonEventController, Windows.UI.Input.SystemFunctionLockIndicatorChangedEventArgs> | null;
+  }
+
+  class SystemFunctionButtonEventArgs implements Windows.UI.Input.ISystemFunctionButtonEventArgs {
+    Handled: boolean;
+    readonly Timestamp: number | bigint;
+  }
+
+  class SystemFunctionLockChangedEventArgs implements Windows.UI.Input.ISystemFunctionLockChangedEventArgs {
+    Handled: boolean;
+    readonly IsLocked: boolean;
+    readonly Timestamp: number | bigint;
+  }
+
+  class SystemFunctionLockIndicatorChangedEventArgs implements Windows.UI.Input.ISystemFunctionLockIndicatorChangedEventArgs {
+    Handled: boolean;
+    readonly IsIndicatorOn: boolean;
+    readonly Timestamp: number | bigint;
+  }
+
+  class TappedEventArgs implements Windows.UI.Input.ITappedEventArgs, Windows.UI.Input.ITappedEventArgs2 {
+    readonly ContactCount: number;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+    readonly TapCount: number;
+  }
+
+  class TouchpadGesturesController implements Windows.UI.Input.ITouchpadGesturesController {
+    static CreateForProcess(): Windows.UI.Input.TouchpadGesturesController;
+    static IsSupported(): boolean;
+    Enabled: boolean;
+    SupportedGestures: number;
+    GlobalActionPerformed: Windows.Foundation.TypedEventHandler<Windows.UI.Input.TouchpadGesturesController, Windows.UI.Input.TouchpadGlobalActionEventArgs> | null;
+    PointerMoved: Windows.Foundation.TypedEventHandler<Windows.UI.Input.TouchpadGesturesController, Windows.UI.Core.PointerEventArgs> | null;
+    PointerPressed: Windows.Foundation.TypedEventHandler<Windows.UI.Input.TouchpadGesturesController, Windows.UI.Core.PointerEventArgs> | null;
+    PointerReleased: Windows.Foundation.TypedEventHandler<Windows.UI.Input.TouchpadGesturesController, Windows.UI.Core.PointerEventArgs> | null;
+  }
+
+  class TouchpadGlobalActionEventArgs implements Windows.UI.Input.ITouchpadGlobalActionEventArgs {
+    readonly Action: number;
+    readonly PointerDevice: Windows.Devices.Input.PointerDevice;
+  }
+
+  enum CrossSlidingState {
+    Started = 0,
+    Dragging = 1,
+    Selecting = 2,
+    SelectSpeedBumping = 3,
+    SpeedBumping = 4,
+    Rearranging = 5,
+    Completed = 6,
+  }
+
+  enum DraggingState {
+    Started = 0,
+    Continuing = 1,
+    Completed = 2,
+  }
+
+  enum EdgeGestureKind {
+    Touch = 0,
+    Keyboard = 1,
+    Mouse = 2,
+  }
+
+  enum GazeInputAccessStatus {
+    Unspecified = 0,
+    Allowed = 1,
+    DeniedByUser = 2,
+    DeniedBySystem = 3,
+  }
+
+  enum GestureSettings {
+    None = 0,
+    Tap = 1,
+    DoubleTap = 2,
+    Hold = 4,
+    HoldWithMouse = 8,
+    RightTap = 16,
+    Drag = 32,
+    ManipulationTranslateX = 64,
+    ManipulationTranslateY = 128,
+    ManipulationTranslateRailsX = 256,
+    ManipulationTranslateRailsY = 512,
+    ManipulationRotate = 1024,
+    ManipulationScale = 2048,
+    ManipulationTranslateInertia = 4096,
+    ManipulationRotateInertia = 8192,
+    ManipulationScaleInertia = 16384,
+    CrossSlide = 32768,
+    ManipulationMultipleFingerPanning = 65536,
+  }
+
+  enum HoldingState {
+    Started = 0,
+    Completed = 1,
+    Canceled = 2,
+  }
+
+  enum InputActivationState {
+    None = 0,
+    Deactivated = 1,
+    ActivatedNotForeground = 2,
+    ActivatedInForeground = 3,
+  }
+
+  enum PointerUpdateKind {
+    Other = 0,
+    LeftButtonPressed = 1,
+    LeftButtonReleased = 2,
+    RightButtonPressed = 3,
+    RightButtonReleased = 4,
+    MiddleButtonPressed = 5,
+    MiddleButtonReleased = 6,
+    XButton1Pressed = 7,
+    XButton1Released = 8,
+    XButton2Pressed = 9,
+    XButton2Released = 10,
+  }
+
+  enum RadialControllerMenuKnownIcon {
+    Scroll = 0,
+    Zoom = 1,
+    UndoRedo = 2,
+    Volume = 3,
+    NextPreviousTrack = 4,
+    Ruler = 5,
+    InkColor = 6,
+    InkThickness = 7,
+    PenType = 8,
+  }
+
+  enum RadialControllerSystemMenuItemKind {
+    Scroll = 0,
+    Zoom = 1,
+    UndoRedo = 2,
+    Volume = 3,
+    NextPreviousTrack = 4,
+  }
+
+  enum TouchpadGlobalAction {
+    ThreeFingerTap = 0,
+    FourFingerTap = 1,
+    FiveFingerTap = 2,
+    ThreeFingerPressDown = 3,
+    FourFingerPressDown = 4,
+    FiveFingerPressDown = 5,
+    ThreeFingerPressUp = 6,
+    FourFingerPressUp = 7,
+    FiveFingerPressUp = 8,
+  }
+
+  enum TouchpadGlobalGestureKinds {
+    None = 0,
+    ThreeFingerManipulations = 1,
+    FourFingerManipulations = 2,
+    FiveFingerManipulations = 4,
+    ThreeFingerActions = 8,
+    FourFingerActions = 16,
+    FiveFingerActions = 32,
+  }
+
+  interface CrossSlideThresholds {
+    SelectionStart: number;
+    SpeedBumpStart: number;
+    SpeedBumpEnd: number;
+    RearrangeStart: number;
+  }
+  var CrossSlideThresholds: {
+    new(selectionStart: number, speedBumpStart: number, speedBumpEnd: number, rearrangeStart: number): CrossSlideThresholds;
+    new(fields: { SelectionStart?: number; SpeedBumpStart?: number; SpeedBumpEnd?: number; RearrangeStart?: number }): CrossSlideThresholds;
+  };
+
+  interface IAttachableInputObject {
+  }
+  var IAttachableInputObject: abstract new (...args: any[]) => IAttachableInputObject;
+
+  interface IAttachableInputObjectFactory {
+  }
+  var IAttachableInputObjectFactory: abstract new (...args: any[]) => IAttachableInputObjectFactory;
+
+  interface ICrossSlidingEventArgs {
+    readonly CrossSlidingState: number;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+  }
+  var ICrossSlidingEventArgs: abstract new (...args: any[]) => ICrossSlidingEventArgs;
+
+  interface ICrossSlidingEventArgs2 {
+    readonly ContactCount: number;
+  }
+  var ICrossSlidingEventArgs2: abstract new (...args: any[]) => ICrossSlidingEventArgs2;
+
+  interface IDraggingEventArgs {
+    readonly DraggingState: number;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+  }
+  var IDraggingEventArgs: abstract new (...args: any[]) => IDraggingEventArgs;
+
+  interface IDraggingEventArgs2 {
+    readonly ContactCount: number;
+  }
+  var IDraggingEventArgs2: abstract new (...args: any[]) => IDraggingEventArgs2;
+
+  interface IEdgeGesture {
+    Canceled: Windows.Foundation.TypedEventHandler<Windows.UI.Input.EdgeGesture, Windows.UI.Input.EdgeGestureEventArgs> | null;
+    Completed: Windows.Foundation.TypedEventHandler<Windows.UI.Input.EdgeGesture, Windows.UI.Input.EdgeGestureEventArgs> | null;
+    Starting: Windows.Foundation.TypedEventHandler<Windows.UI.Input.EdgeGesture, Windows.UI.Input.EdgeGestureEventArgs> | null;
+  }
+  var IEdgeGesture: abstract new (...args: any[]) => IEdgeGesture;
+
+  interface IEdgeGestureEventArgs {
+    readonly Kind: number;
+  }
+  var IEdgeGestureEventArgs: abstract new (...args: any[]) => IEdgeGestureEventArgs;
+
+  interface IEdgeGestureStatics {
+    GetForCurrentView(): Windows.UI.Input.EdgeGesture;
+  }
+  var IEdgeGestureStatics: abstract new (...args: any[]) => IEdgeGestureStatics;
+
+  interface IGestureRecognizer {
+    CanBeDoubleTap(value: Windows.UI.Input.PointerPoint): boolean;
+    CompleteGesture(): void;
+    ProcessDownEvent(value: Windows.UI.Input.PointerPoint): void;
+    ProcessInertia(): void;
+    ProcessMouseWheelEvent(value: Windows.UI.Input.PointerPoint, isShiftKeyDown: boolean, isControlKeyDown: boolean): void;
+    ProcessMoveEvents(value: Windows.Foundation.Collections.IVector<Windows.UI.Input.PointerPoint> | Windows.UI.Input.PointerPoint[]): void;
+    ProcessUpEvent(value: Windows.UI.Input.PointerPoint): void;
+    AutoProcessInertia: boolean;
+    CrossSlideExact: boolean;
+    CrossSlideHorizontally: boolean;
+    CrossSlideThresholds: Windows.UI.Input.CrossSlideThresholds;
+    GestureSettings: number;
+    InertiaExpansion: number;
+    InertiaExpansionDeceleration: number;
+    InertiaRotationAngle: number;
+    InertiaRotationDeceleration: number;
+    InertiaTranslationDeceleration: number;
+    InertiaTranslationDisplacement: number;
+    readonly IsActive: boolean;
+    readonly IsInertial: boolean;
+    ManipulationExact: boolean;
+    readonly MouseWheelParameters: Windows.UI.Input.MouseWheelParameters;
+    PivotCenter: Windows.Foundation.Point;
+    PivotRadius: number;
+    ShowGestureFeedback: boolean;
+    CrossSliding: Windows.Foundation.TypedEventHandler<Windows.UI.Input.GestureRecognizer, Windows.UI.Input.CrossSlidingEventArgs> | null;
+    Dragging: Windows.Foundation.TypedEventHandler<Windows.UI.Input.GestureRecognizer, Windows.UI.Input.DraggingEventArgs> | null;
+    Holding: Windows.Foundation.TypedEventHandler<Windows.UI.Input.GestureRecognizer, Windows.UI.Input.HoldingEventArgs> | null;
+    ManipulationCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.GestureRecognizer, Windows.UI.Input.ManipulationCompletedEventArgs> | null;
+    ManipulationInertiaStarting: Windows.Foundation.TypedEventHandler<Windows.UI.Input.GestureRecognizer, Windows.UI.Input.ManipulationInertiaStartingEventArgs> | null;
+    ManipulationStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.GestureRecognizer, Windows.UI.Input.ManipulationStartedEventArgs> | null;
+    ManipulationUpdated: Windows.Foundation.TypedEventHandler<Windows.UI.Input.GestureRecognizer, Windows.UI.Input.ManipulationUpdatedEventArgs> | null;
+    RightTapped: Windows.Foundation.TypedEventHandler<Windows.UI.Input.GestureRecognizer, Windows.UI.Input.RightTappedEventArgs> | null;
+    Tapped: Windows.Foundation.TypedEventHandler<Windows.UI.Input.GestureRecognizer, Windows.UI.Input.TappedEventArgs> | null;
+  }
+  var IGestureRecognizer: abstract new (...args: any[]) => IGestureRecognizer;
+
+  interface IGestureRecognizer2 {
+    HoldMaxContactCount: number;
+    HoldMinContactCount: number;
+    HoldRadius: number;
+    HoldStartDelay: Windows.Foundation.TimeSpan;
+    TapMaxContactCount: number;
+    TapMinContactCount: number;
+    TranslationMaxContactCount: number;
+    TranslationMinContactCount: number;
+  }
+  var IGestureRecognizer2: abstract new (...args: any[]) => IGestureRecognizer2;
+
+  interface IHoldingEventArgs {
+    readonly HoldingState: number;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+  }
+  var IHoldingEventArgs: abstract new (...args: any[]) => IHoldingEventArgs;
+
+  interface IHoldingEventArgs2 {
+    readonly ContactCount: number;
+    readonly CurrentContactCount: number;
+  }
+  var IHoldingEventArgs2: abstract new (...args: any[]) => IHoldingEventArgs2;
+
+  interface IInputActivationListener {
+    readonly State: number;
+    InputActivationChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Input.InputActivationListener, Windows.UI.Input.InputActivationListenerActivationChangedEventArgs> | null;
+  }
+  var IInputActivationListener: abstract new (...args: any[]) => IInputActivationListener;
+
+  interface IInputActivationListenerActivationChangedEventArgs {
+    readonly State: number;
+  }
+  var IInputActivationListenerActivationChangedEventArgs: abstract new (...args: any[]) => IInputActivationListenerActivationChangedEventArgs;
+
+  interface IKeyboardDeliveryInterceptor {
+    IsInterceptionEnabledWhenInForeground: boolean;
+    KeyDown: Windows.Foundation.TypedEventHandler<Windows.UI.Input.KeyboardDeliveryInterceptor, Windows.UI.Core.KeyEventArgs> | null;
+    KeyUp: Windows.Foundation.TypedEventHandler<Windows.UI.Input.KeyboardDeliveryInterceptor, Windows.UI.Core.KeyEventArgs> | null;
+  }
+  var IKeyboardDeliveryInterceptor: abstract new (...args: any[]) => IKeyboardDeliveryInterceptor;
+
+  interface IKeyboardDeliveryInterceptorStatics {
+    GetForCurrentView(): Windows.UI.Input.KeyboardDeliveryInterceptor;
+  }
+  var IKeyboardDeliveryInterceptorStatics: abstract new (...args: any[]) => IKeyboardDeliveryInterceptorStatics;
+
+  interface IManipulationCompletedEventArgs {
+    readonly Cumulative: Windows.UI.Input.ManipulationDelta;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+    readonly Velocities: Windows.UI.Input.ManipulationVelocities;
+  }
+  var IManipulationCompletedEventArgs: abstract new (...args: any[]) => IManipulationCompletedEventArgs;
+
+  interface IManipulationCompletedEventArgs2 {
+    readonly ContactCount: number;
+    readonly CurrentContactCount: number;
+  }
+  var IManipulationCompletedEventArgs2: abstract new (...args: any[]) => IManipulationCompletedEventArgs2;
+
+  interface IManipulationInertiaStartingEventArgs {
+    readonly Cumulative: Windows.UI.Input.ManipulationDelta;
+    readonly Delta: Windows.UI.Input.ManipulationDelta;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+    readonly Velocities: Windows.UI.Input.ManipulationVelocities;
+  }
+  var IManipulationInertiaStartingEventArgs: abstract new (...args: any[]) => IManipulationInertiaStartingEventArgs;
+
+  interface IManipulationInertiaStartingEventArgs2 {
+    readonly ContactCount: number;
+  }
+  var IManipulationInertiaStartingEventArgs2: abstract new (...args: any[]) => IManipulationInertiaStartingEventArgs2;
+
+  interface IManipulationStartedEventArgs {
+    readonly Cumulative: Windows.UI.Input.ManipulationDelta;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+  }
+  var IManipulationStartedEventArgs: abstract new (...args: any[]) => IManipulationStartedEventArgs;
+
+  interface IManipulationStartedEventArgs2 {
+    readonly ContactCount: number;
+  }
+  var IManipulationStartedEventArgs2: abstract new (...args: any[]) => IManipulationStartedEventArgs2;
+
+  interface IManipulationUpdatedEventArgs {
+    readonly Cumulative: Windows.UI.Input.ManipulationDelta;
+    readonly Delta: Windows.UI.Input.ManipulationDelta;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+    readonly Velocities: Windows.UI.Input.ManipulationVelocities;
+  }
+  var IManipulationUpdatedEventArgs: abstract new (...args: any[]) => IManipulationUpdatedEventArgs;
+
+  interface IManipulationUpdatedEventArgs2 {
+    readonly ContactCount: number;
+    readonly CurrentContactCount: number;
+  }
+  var IManipulationUpdatedEventArgs2: abstract new (...args: any[]) => IManipulationUpdatedEventArgs2;
+
+  interface IMouseWheelParameters {
+    CharTranslation: Windows.Foundation.Point;
+    DeltaRotationAngle: number;
+    DeltaScale: number;
+    PageTranslation: Windows.Foundation.Point;
+  }
+  var IMouseWheelParameters: abstract new (...args: any[]) => IMouseWheelParameters;
+
+  interface IPhysicalGestureRecognizer {
+    CompleteGesture(): void;
+    ProcessDownEvent(value: Windows.UI.Input.PointerPoint): void;
+    ProcessMoveEvents(value: Windows.Foundation.Collections.IVector<Windows.UI.Input.PointerPoint> | Windows.UI.Input.PointerPoint[]): void;
+    ProcessUpEvent(value: Windows.UI.Input.PointerPoint): void;
+    GestureSettings: number;
+    HoldMaxContactCount: number;
+    HoldMinContactCount: number;
+    HoldRadius: number;
+    HoldStartDelay: Windows.Foundation.TimeSpan;
+    readonly IsActive: boolean;
+    TapMaxContactCount: number;
+    TapMinContactCount: number;
+    TranslationMaxContactCount: number;
+    TranslationMinContactCount: number;
+    Holding: Windows.Foundation.TypedEventHandler<Windows.UI.Input.PhysicalGestureRecognizer, Windows.UI.Input.HoldingEventArgs> | null;
+    ManipulationCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.PhysicalGestureRecognizer, Windows.UI.Input.ManipulationCompletedEventArgs> | null;
+    ManipulationStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.PhysicalGestureRecognizer, Windows.UI.Input.ManipulationStartedEventArgs> | null;
+    ManipulationUpdated: Windows.Foundation.TypedEventHandler<Windows.UI.Input.PhysicalGestureRecognizer, Windows.UI.Input.ManipulationUpdatedEventArgs> | null;
+    Tapped: Windows.Foundation.TypedEventHandler<Windows.UI.Input.PhysicalGestureRecognizer, Windows.UI.Input.TappedEventArgs> | null;
+  }
+  var IPhysicalGestureRecognizer: abstract new (...args: any[]) => IPhysicalGestureRecognizer;
+
+  interface IPointerPoint {
+    readonly FrameId: number;
+    readonly IsInContact: boolean;
+    readonly PointerDevice: Windows.Devices.Input.PointerDevice;
+    readonly PointerId: number;
+    readonly Position: Windows.Foundation.Point;
+    readonly Properties: Windows.UI.Input.PointerPointProperties;
+    readonly RawPosition: Windows.Foundation.Point;
+    readonly Timestamp: number | bigint;
+  }
+  var IPointerPoint: abstract new (...args: any[]) => IPointerPoint;
+
+  interface IPointerPointPhysicalPosition {
+    readonly IsPhysicalPositionSupported: boolean;
+    readonly PhysicalPosition: Windows.Foundation.Point;
+  }
+  var IPointerPointPhysicalPosition: abstract new (...args: any[]) => IPointerPointPhysicalPosition;
+
+  interface IPointerPointProperties {
+    GetUsageValue(usagePage: number, usageId: number): number;
+    HasUsage(usagePage: number, usageId: number): boolean;
+    readonly ContactRect: Windows.Foundation.Rect;
+    readonly ContactRectRaw: Windows.Foundation.Rect;
+    readonly IsBarrelButtonPressed: boolean;
+    readonly IsCanceled: boolean;
+    readonly IsEraser: boolean;
+    readonly IsHorizontalMouseWheel: boolean;
+    readonly IsInRange: boolean;
+    readonly IsInverted: boolean;
+    readonly IsLeftButtonPressed: boolean;
+    readonly IsMiddleButtonPressed: boolean;
+    readonly IsPrimary: boolean;
+    readonly IsRightButtonPressed: boolean;
+    readonly IsXButton1Pressed: boolean;
+    readonly IsXButton2Pressed: boolean;
+    readonly MouseWheelDelta: number;
+    readonly Orientation: number;
+    readonly PointerUpdateKind: number;
+    readonly Pressure: number;
+    readonly TouchConfidence: boolean;
+    readonly Twist: number;
+    readonly XTilt: number;
+    readonly YTilt: number;
+  }
+  var IPointerPointProperties: abstract new (...args: any[]) => IPointerPointProperties;
+
+  interface IPointerPointProperties2 {
+    readonly ZDistance: number | null;
+  }
+  var IPointerPointProperties2: abstract new (...args: any[]) => IPointerPointProperties2;
+
+  interface IPointerPointStatics {
+    GetCurrentPoint(pointerId: number): Windows.UI.Input.PointerPoint;
+    GetCurrentPoint(pointerId: number, transform: Windows.UI.Input.IPointerPointTransform): Windows.UI.Input.PointerPoint;
+    GetIntermediatePoints(pointerId: number): Windows.Foundation.Collections.IVector<Windows.UI.Input.PointerPoint> | Windows.UI.Input.PointerPoint[];
+    GetIntermediatePoints(pointerId: number, transform: Windows.UI.Input.IPointerPointTransform): Windows.Foundation.Collections.IVector<Windows.UI.Input.PointerPoint> | Windows.UI.Input.PointerPoint[];
+  }
+  var IPointerPointStatics: abstract new (...args: any[]) => IPointerPointStatics;
+
+  interface IPointerPointTransform {
+    TransformBounds(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TryTransform(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    readonly Inverse: Windows.UI.Input.IPointerPointTransform;
+  }
+  var IPointerPointTransform: abstract new (...args: any[]) => IPointerPointTransform;
+
+  interface IPointerVisualizationSettings {
+    IsBarrelButtonFeedbackEnabled: boolean;
+    IsContactFeedbackEnabled: boolean;
+  }
+  var IPointerVisualizationSettings: abstract new (...args: any[]) => IPointerVisualizationSettings;
+
+  interface IPointerVisualizationSettingsStatics {
+    GetForCurrentView(): Windows.UI.Input.PointerVisualizationSettings;
+  }
+  var IPointerVisualizationSettingsStatics: abstract new (...args: any[]) => IPointerVisualizationSettingsStatics;
+
+  interface IRadialController {
+    readonly Menu: Windows.UI.Input.RadialControllerMenu;
+    RotationResolutionInDegrees: number;
+    UseAutomaticHapticFeedback: boolean;
+    ButtonClicked: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Windows.UI.Input.RadialControllerButtonClickedEventArgs> | null;
+    ControlAcquired: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Windows.UI.Input.RadialControllerControlAcquiredEventArgs> | null;
+    ControlLost: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Object> | null;
+    RotationChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Windows.UI.Input.RadialControllerRotationChangedEventArgs> | null;
+    ScreenContactContinued: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Windows.UI.Input.RadialControllerScreenContactContinuedEventArgs> | null;
+    ScreenContactEnded: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Object> | null;
+    ScreenContactStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Windows.UI.Input.RadialControllerScreenContactStartedEventArgs> | null;
+  }
+  var IRadialController: abstract new (...args: any[]) => IRadialController;
+
+  interface IRadialController2 {
+    ButtonHolding: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Windows.UI.Input.RadialControllerButtonHoldingEventArgs> | null;
+    ButtonPressed: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Windows.UI.Input.RadialControllerButtonPressedEventArgs> | null;
+    ButtonReleased: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialController, Windows.UI.Input.RadialControllerButtonReleasedEventArgs> | null;
+  }
+  var IRadialController2: abstract new (...args: any[]) => IRadialController2;
+
+  interface IRadialControllerButtonClickedEventArgs {
+    readonly Contact: Windows.UI.Input.RadialControllerScreenContact;
+  }
+  var IRadialControllerButtonClickedEventArgs: abstract new (...args: any[]) => IRadialControllerButtonClickedEventArgs;
+
+  interface IRadialControllerButtonClickedEventArgs2 {
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+  var IRadialControllerButtonClickedEventArgs2: abstract new (...args: any[]) => IRadialControllerButtonClickedEventArgs2;
+
+  interface IRadialControllerButtonHoldingEventArgs {
+    readonly Contact: Windows.UI.Input.RadialControllerScreenContact;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+  var IRadialControllerButtonHoldingEventArgs: abstract new (...args: any[]) => IRadialControllerButtonHoldingEventArgs;
+
+  interface IRadialControllerButtonPressedEventArgs {
+    readonly Contact: Windows.UI.Input.RadialControllerScreenContact;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+  var IRadialControllerButtonPressedEventArgs: abstract new (...args: any[]) => IRadialControllerButtonPressedEventArgs;
+
+  interface IRadialControllerButtonReleasedEventArgs {
+    readonly Contact: Windows.UI.Input.RadialControllerScreenContact;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+  var IRadialControllerButtonReleasedEventArgs: abstract new (...args: any[]) => IRadialControllerButtonReleasedEventArgs;
+
+  interface IRadialControllerConfiguration {
+    ResetToDefaultMenuItems(): void;
+    SetDefaultMenuItems(buttons: Windows.Foundation.Collections.IIterable<number> | number[]): void;
+    TrySelectDefaultMenuItem(type: number): boolean;
+  }
+  var IRadialControllerConfiguration: abstract new (...args: any[]) => IRadialControllerConfiguration;
+
+  interface IRadialControllerConfiguration2 {
+    ActiveControllerWhenMenuIsSuppressed: Windows.UI.Input.RadialController;
+    IsMenuSuppressed: boolean;
+  }
+  var IRadialControllerConfiguration2: abstract new (...args: any[]) => IRadialControllerConfiguration2;
+
+  interface IRadialControllerConfigurationStatics {
+    GetForCurrentView(): Windows.UI.Input.RadialControllerConfiguration;
+  }
+  var IRadialControllerConfigurationStatics: abstract new (...args: any[]) => IRadialControllerConfigurationStatics;
+
+  interface IRadialControllerConfigurationStatics2 {
+    AppController: Windows.UI.Input.RadialController;
+    IsAppControllerEnabled: boolean;
+  }
+  var IRadialControllerConfigurationStatics2: abstract new (...args: any[]) => IRadialControllerConfigurationStatics2;
+
+  interface IRadialControllerControlAcquiredEventArgs {
+    readonly Contact: Windows.UI.Input.RadialControllerScreenContact;
+  }
+  var IRadialControllerControlAcquiredEventArgs: abstract new (...args: any[]) => IRadialControllerControlAcquiredEventArgs;
+
+  interface IRadialControllerControlAcquiredEventArgs2 {
+    readonly IsButtonPressed: boolean;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+  var IRadialControllerControlAcquiredEventArgs2: abstract new (...args: any[]) => IRadialControllerControlAcquiredEventArgs2;
+
+  interface IRadialControllerMenu {
+    GetSelectedMenuItem(): Windows.UI.Input.RadialControllerMenuItem;
+    SelectMenuItem(menuItem: Windows.UI.Input.RadialControllerMenuItem): void;
+    TrySelectPreviouslySelectedMenuItem(): boolean;
+    IsEnabled: boolean;
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.UI.Input.RadialControllerMenuItem> | Windows.UI.Input.RadialControllerMenuItem[];
+  }
+  var IRadialControllerMenu: abstract new (...args: any[]) => IRadialControllerMenu;
+
+  interface IRadialControllerMenuItem {
+    readonly DisplayText: string;
+    Tag: Object;
+    Invoked: Windows.Foundation.TypedEventHandler<Windows.UI.Input.RadialControllerMenuItem, Object> | null;
+  }
+  var IRadialControllerMenuItem: abstract new (...args: any[]) => IRadialControllerMenuItem;
+
+  interface IRadialControllerMenuItemStatics {
+    CreateFromIcon(displayText: string, icon: Windows.Storage.Streams.RandomAccessStreamReference): Windows.UI.Input.RadialControllerMenuItem;
+    CreateFromKnownIcon(displayText: string, value: number): Windows.UI.Input.RadialControllerMenuItem;
+  }
+  var IRadialControllerMenuItemStatics: abstract new (...args: any[]) => IRadialControllerMenuItemStatics;
+
+  interface IRadialControllerMenuItemStatics2 {
+    CreateFromFontGlyph(displayText: string, glyph: string, fontFamily: string): Windows.UI.Input.RadialControllerMenuItem;
+    CreateFromFontGlyph(displayText: string, glyph: string, fontFamily: string, fontUri: Windows.Foundation.Uri): Windows.UI.Input.RadialControllerMenuItem;
+  }
+  var IRadialControllerMenuItemStatics2: abstract new (...args: any[]) => IRadialControllerMenuItemStatics2;
+
+  interface IRadialControllerRotationChangedEventArgs {
+    readonly Contact: Windows.UI.Input.RadialControllerScreenContact;
+    readonly RotationDeltaInDegrees: number;
+  }
+  var IRadialControllerRotationChangedEventArgs: abstract new (...args: any[]) => IRadialControllerRotationChangedEventArgs;
+
+  interface IRadialControllerRotationChangedEventArgs2 {
+    readonly IsButtonPressed: boolean;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+  var IRadialControllerRotationChangedEventArgs2: abstract new (...args: any[]) => IRadialControllerRotationChangedEventArgs2;
+
+  interface IRadialControllerScreenContact {
+    readonly Bounds: Windows.Foundation.Rect;
+    readonly Position: Windows.Foundation.Point;
+  }
+  var IRadialControllerScreenContact: abstract new (...args: any[]) => IRadialControllerScreenContact;
+
+  interface IRadialControllerScreenContactContinuedEventArgs {
+    readonly Contact: Windows.UI.Input.RadialControllerScreenContact;
+  }
+  var IRadialControllerScreenContactContinuedEventArgs: abstract new (...args: any[]) => IRadialControllerScreenContactContinuedEventArgs;
+
+  interface IRadialControllerScreenContactContinuedEventArgs2 {
+    readonly IsButtonPressed: boolean;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+  var IRadialControllerScreenContactContinuedEventArgs2: abstract new (...args: any[]) => IRadialControllerScreenContactContinuedEventArgs2;
+
+  interface IRadialControllerScreenContactEndedEventArgs {
+    readonly IsButtonPressed: boolean;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+  var IRadialControllerScreenContactEndedEventArgs: abstract new (...args: any[]) => IRadialControllerScreenContactEndedEventArgs;
+
+  interface IRadialControllerScreenContactStartedEventArgs {
+    readonly Contact: Windows.UI.Input.RadialControllerScreenContact;
+  }
+  var IRadialControllerScreenContactStartedEventArgs: abstract new (...args: any[]) => IRadialControllerScreenContactStartedEventArgs;
+
+  interface IRadialControllerScreenContactStartedEventArgs2 {
+    readonly IsButtonPressed: boolean;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+  }
+  var IRadialControllerScreenContactStartedEventArgs2: abstract new (...args: any[]) => IRadialControllerScreenContactStartedEventArgs2;
+
+  interface IRadialControllerStatics {
+    CreateForCurrentView(): Windows.UI.Input.RadialController;
+    IsSupported(): boolean;
+  }
+  var IRadialControllerStatics: abstract new (...args: any[]) => IRadialControllerStatics;
+
+  interface IRightTappedEventArgs {
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+  }
+  var IRightTappedEventArgs: abstract new (...args: any[]) => IRightTappedEventArgs;
+
+  interface IRightTappedEventArgs2 {
+    readonly ContactCount: number;
+  }
+  var IRightTappedEventArgs2: abstract new (...args: any[]) => IRightTappedEventArgs2;
+
+  interface ISystemButtonEventController {
+    SystemFunctionButtonPressed: Windows.Foundation.TypedEventHandler<Windows.UI.Input.SystemButtonEventController, Windows.UI.Input.SystemFunctionButtonEventArgs> | null;
+    SystemFunctionButtonReleased: Windows.Foundation.TypedEventHandler<Windows.UI.Input.SystemButtonEventController, Windows.UI.Input.SystemFunctionButtonEventArgs> | null;
+    SystemFunctionLockChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Input.SystemButtonEventController, Windows.UI.Input.SystemFunctionLockChangedEventArgs> | null;
+    SystemFunctionLockIndicatorChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Input.SystemButtonEventController, Windows.UI.Input.SystemFunctionLockIndicatorChangedEventArgs> | null;
+  }
+  var ISystemButtonEventController: abstract new (...args: any[]) => ISystemButtonEventController;
+
+  interface ISystemButtonEventControllerStatics {
+    CreateForDispatcherQueue(queue: Windows.System.DispatcherQueue): Windows.UI.Input.SystemButtonEventController;
+  }
+  var ISystemButtonEventControllerStatics: abstract new (...args: any[]) => ISystemButtonEventControllerStatics;
+
+  interface ISystemFunctionButtonEventArgs {
+    Handled: boolean;
+    readonly Timestamp: number | bigint;
+  }
+  var ISystemFunctionButtonEventArgs: abstract new (...args: any[]) => ISystemFunctionButtonEventArgs;
+
+  interface ISystemFunctionLockChangedEventArgs {
+    Handled: boolean;
+    readonly IsLocked: boolean;
+    readonly Timestamp: number | bigint;
+  }
+  var ISystemFunctionLockChangedEventArgs: abstract new (...args: any[]) => ISystemFunctionLockChangedEventArgs;
+
+  interface ISystemFunctionLockIndicatorChangedEventArgs {
+    Handled: boolean;
+    readonly IsIndicatorOn: boolean;
+    readonly Timestamp: number | bigint;
+  }
+  var ISystemFunctionLockIndicatorChangedEventArgs: abstract new (...args: any[]) => ISystemFunctionLockIndicatorChangedEventArgs;
+
+  interface ITappedEventArgs {
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+    readonly TapCount: number;
+  }
+  var ITappedEventArgs: abstract new (...args: any[]) => ITappedEventArgs;
+
+  interface ITappedEventArgs2 {
+    readonly ContactCount: number;
+  }
+  var ITappedEventArgs2: abstract new (...args: any[]) => ITappedEventArgs2;
+
+  interface ITouchpadGesturesController {
+    Enabled: boolean;
+    SupportedGestures: number;
+    GlobalActionPerformed: Windows.Foundation.TypedEventHandler<Windows.UI.Input.TouchpadGesturesController, Windows.UI.Input.TouchpadGlobalActionEventArgs> | null;
+    PointerMoved: Windows.Foundation.TypedEventHandler<Windows.UI.Input.TouchpadGesturesController, Windows.UI.Core.PointerEventArgs> | null;
+    PointerPressed: Windows.Foundation.TypedEventHandler<Windows.UI.Input.TouchpadGesturesController, Windows.UI.Core.PointerEventArgs> | null;
+    PointerReleased: Windows.Foundation.TypedEventHandler<Windows.UI.Input.TouchpadGesturesController, Windows.UI.Core.PointerEventArgs> | null;
+  }
+  var ITouchpadGesturesController: abstract new (...args: any[]) => ITouchpadGesturesController;
+
+  interface ITouchpadGesturesControllerStatics {
+    CreateForProcess(): Windows.UI.Input.TouchpadGesturesController;
+    IsSupported(): boolean;
+  }
+  var ITouchpadGesturesControllerStatics: abstract new (...args: any[]) => ITouchpadGesturesControllerStatics;
+
+  interface ITouchpadGlobalActionEventArgs {
+    readonly Action: number;
+    readonly PointerDevice: Windows.Devices.Input.PointerDevice;
+  }
+  var ITouchpadGlobalActionEventArgs: abstract new (...args: any[]) => ITouchpadGlobalActionEventArgs;
+
+  interface ManipulationDelta {
+    Translation: Windows.Foundation.Point;
+    Scale: number;
+    Rotation: number;
+    Expansion: number;
+  }
+  var ManipulationDelta: {
+    new(translation: Windows.Foundation.Point, scale: number, rotation: number, expansion: number): ManipulationDelta;
+    new(fields: { Translation?: Windows.Foundation.Point; Scale?: number; Rotation?: number; Expansion?: number }): ManipulationDelta;
+  };
+
+  interface ManipulationVelocities {
+    Linear: Windows.Foundation.Point;
+    Angular: number;
+    Expansion: number;
+  }
+  var ManipulationVelocities: {
+    new(linear: Windows.Foundation.Point, angular: number, expansion: number): ManipulationVelocities;
+    new(fields: { Linear?: Windows.Foundation.Point; Angular?: number; Expansion?: number }): ManipulationVelocities;
+  };
+
+}
+
+declare namespace Windows.UI.Input.Core {
+  class RadialControllerIndependentInputSource implements Windows.UI.Input.Core.IRadialControllerIndependentInputSource, Windows.UI.Input.Core.IRadialControllerIndependentInputSource2 {
+    static CreateForView(view: Windows.ApplicationModel.Core.CoreApplicationView): Windows.UI.Input.Core.RadialControllerIndependentInputSource;
+    readonly Controller: Windows.UI.Input.RadialController;
+    readonly Dispatcher: Windows.UI.Core.CoreDispatcher;
+    readonly DispatcherQueue: Windows.System.DispatcherQueue;
+  }
+
+  interface IRadialControllerIndependentInputSource {
+    readonly Controller: Windows.UI.Input.RadialController;
+    readonly Dispatcher: Windows.UI.Core.CoreDispatcher;
+  }
+  var IRadialControllerIndependentInputSource: abstract new (...args: any[]) => IRadialControllerIndependentInputSource;
+
+  interface IRadialControllerIndependentInputSource2 {
+    readonly DispatcherQueue: Windows.System.DispatcherQueue;
+  }
+  var IRadialControllerIndependentInputSource2: abstract new (...args: any[]) => IRadialControllerIndependentInputSource2;
+
+  interface IRadialControllerIndependentInputSourceStatics {
+    CreateForView(view: Windows.ApplicationModel.Core.CoreApplicationView): Windows.UI.Input.Core.RadialControllerIndependentInputSource;
+  }
+  var IRadialControllerIndependentInputSourceStatics: abstract new (...args: any[]) => IRadialControllerIndependentInputSourceStatics;
+
+}
+
+declare namespace Windows.UI.Input.Inking {
+  class InkDrawingAttributes implements Windows.UI.Input.Inking.IInkDrawingAttributes, Windows.UI.Input.Inking.IInkDrawingAttributes2, Windows.UI.Input.Inking.IInkDrawingAttributes3, Windows.UI.Input.Inking.IInkDrawingAttributes4, Windows.UI.Input.Inking.IInkDrawingAttributes5 {
+    constructor();
+    static CreateForPencil(): Windows.UI.Input.Inking.InkDrawingAttributes;
+    Color: Windows.UI.Color;
+    DrawAsHighlighter: boolean;
+    FitToCurve: boolean;
+    IgnorePressure: boolean;
+    IgnoreTilt: boolean;
+    readonly Kind: number;
+    readonly ModelerAttributes: Windows.UI.Input.Inking.InkModelerAttributes;
+    PenTip: number;
+    PenTipTransform: Windows.Foundation.Numerics.Matrix3x2;
+    readonly PencilProperties: Windows.UI.Input.Inking.InkDrawingAttributesPencilProperties;
+    Size: Windows.Foundation.Size;
+  }
+
+  class InkDrawingAttributesPencilProperties implements Windows.UI.Input.Inking.IInkDrawingAttributesPencilProperties {
+    Opacity: number;
+  }
+
+  class InkInputConfiguration implements Windows.UI.Input.Inking.IInkInputConfiguration, Windows.UI.Input.Inking.IInkInputConfiguration2 {
+    IsEraserInputEnabled: boolean;
+    IsPenHapticFeedbackEnabled: boolean;
+    IsPrimaryBarrelButtonInputEnabled: boolean;
+  }
+
+  class InkInputProcessingConfiguration implements Windows.UI.Input.Inking.IInkInputProcessingConfiguration {
+    Mode: number;
+    RightDragAction: number;
+  }
+
+  class InkManager implements Windows.UI.Input.Inking.IInkManager, Windows.UI.Input.Inking.IInkRecognizerContainer, Windows.UI.Input.Inking.IInkStrokeContainer {
+    constructor();
+    AddStroke(stroke: Windows.UI.Input.Inking.InkStroke): void;
+    CanPasteFromClipboard(): boolean;
+    CopySelectedToClipboard(): void;
+    DeleteSelected(): Windows.Foundation.Rect;
+    GetRecognitionResults(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkRecognitionResult> | Windows.UI.Input.Inking.InkRecognitionResult[];
+    GetRecognizers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkRecognizer> | Windows.UI.Input.Inking.InkRecognizer[];
+    GetStrokes(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkStroke> | Windows.UI.Input.Inking.InkStroke[];
+    LoadAsync(inputStream: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncActionWithProgress<number | bigint>;
+    MoveSelected(translation: Windows.Foundation.Point): Windows.Foundation.Rect;
+    PasteFromClipboard(position: Windows.Foundation.Point): Windows.Foundation.Rect;
+    ProcessPointerDown(pointerPoint: Windows.UI.Input.PointerPoint): void;
+    ProcessPointerUp(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.Rect;
+    ProcessPointerUpdate(pointerPoint: Windows.UI.Input.PointerPoint): Object;
+    RecognizeAsync(recognitionTarget: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkRecognitionResult> | Windows.UI.Input.Inking.InkRecognitionResult[]>;
+    RecognizeAsync(strokeCollection: Windows.UI.Input.Inking.InkStrokeContainer, recognitionTarget: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkRecognitionResult> | Windows.UI.Input.Inking.InkRecognitionResult[]>;
+    SaveAsync(outputStream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    SelectWithLine(from: Windows.Foundation.Point, to: Windows.Foundation.Point): Windows.Foundation.Rect;
+    SelectWithPolyLine(polyline: Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]): Windows.Foundation.Rect;
+    SetDefaultDrawingAttributes(drawingAttributes: Windows.UI.Input.Inking.InkDrawingAttributes): void;
+    SetDefaultRecognizer(recognizer: Windows.UI.Input.Inking.InkRecognizer): void;
+    UpdateRecognitionResults(recognitionResults: Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkRecognitionResult> | Windows.UI.Input.Inking.InkRecognitionResult[]): void;
+    readonly BoundingRect: Windows.Foundation.Rect;
+    Mode: number;
+  }
+
+  class InkModelerAttributes implements Windows.UI.Input.Inking.IInkModelerAttributes, Windows.UI.Input.Inking.IInkModelerAttributes2 {
+    PredictionTime: Windows.Foundation.TimeSpan;
+    ScalingFactor: number;
+    UseVelocityBasedPressure: boolean;
+  }
+
+  class InkPoint implements Windows.UI.Input.Inking.IInkPoint, Windows.UI.Input.Inking.IInkPoint2 {
+    constructor(position: Windows.Foundation.Point, pressure: number, tiltX: number, tiltY: number, timestamp: number | bigint);
+    constructor(position: Windows.Foundation.Point, pressure: number);
+    readonly Position: Windows.Foundation.Point;
+    readonly Pressure: number;
+    readonly TiltX: number;
+    readonly TiltY: number;
+    readonly Timestamp: number | bigint;
+  }
+
+  class InkPresenter implements Windows.UI.Input.Inking.IInkPresenter, Windows.UI.Input.Inking.IInkPresenter2, Windows.UI.Input.Inking.IInkPresenter3 {
+    ActivateCustomDrying(): Windows.UI.Input.Inking.InkSynchronizer;
+    CopyDefaultDrawingAttributes(): Windows.UI.Input.Inking.InkDrawingAttributes;
+    SetPredefinedConfiguration(value: number): void;
+    UpdateDefaultDrawingAttributes(value: Windows.UI.Input.Inking.InkDrawingAttributes): void;
+    HighContrastAdjustment: number;
+    readonly InputConfiguration: Windows.UI.Input.Inking.InkInputConfiguration;
+    InputDeviceTypes: number;
+    readonly InputProcessingConfiguration: Windows.UI.Input.Inking.InkInputProcessingConfiguration;
+    IsInputEnabled: boolean;
+    StrokeContainer: Windows.UI.Input.Inking.InkStrokeContainer;
+    readonly StrokeInput: Windows.UI.Input.Inking.InkStrokeInput;
+    readonly UnprocessedInput: Windows.UI.Input.Inking.InkUnprocessedInput;
+    StrokesCollected: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkPresenter, Windows.UI.Input.Inking.InkStrokesCollectedEventArgs> | null;
+    StrokesErased: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkPresenter, Windows.UI.Input.Inking.InkStrokesErasedEventArgs> | null;
+  }
+
+  class InkPresenterProtractor implements Windows.UI.Input.Inking.IInkPresenterProtractor, Windows.UI.Input.Inking.IInkPresenterStencil {
+    constructor(inkPresenter: Windows.UI.Input.Inking.InkPresenter);
+    AccentColor: Windows.UI.Color;
+    AreRaysVisible: boolean;
+    AreTickMarksVisible: boolean;
+    BackgroundColor: Windows.UI.Color;
+    ForegroundColor: Windows.UI.Color;
+    IsAngleReadoutVisible: boolean;
+    IsCenterMarkerVisible: boolean;
+    IsResizable: boolean;
+    IsVisible: boolean;
+    readonly Kind: number;
+    Radius: number;
+    Transform: Windows.Foundation.Numerics.Matrix3x2;
+  }
+
+  class InkPresenterRuler implements Windows.UI.Input.Inking.IInkPresenterRuler, Windows.UI.Input.Inking.IInkPresenterRuler2, Windows.UI.Input.Inking.IInkPresenterStencil {
+    constructor(inkPresenter: Windows.UI.Input.Inking.InkPresenter);
+    AreTickMarksVisible: boolean;
+    BackgroundColor: Windows.UI.Color;
+    ForegroundColor: Windows.UI.Color;
+    IsCompassVisible: boolean;
+    IsVisible: boolean;
+    readonly Kind: number;
+    Length: number;
+    Transform: Windows.Foundation.Numerics.Matrix3x2;
+    Width: number;
+  }
+
+  class InkRecognitionResult implements Windows.UI.Input.Inking.IInkRecognitionResult {
+    GetStrokes(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkStroke> | Windows.UI.Input.Inking.InkStroke[];
+    GetTextCandidates(): Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly BoundingRect: Windows.Foundation.Rect;
+  }
+
+  class InkRecognizer implements Windows.UI.Input.Inking.IInkRecognizer {
+    readonly Name: string;
+  }
+
+  class InkRecognizerContainer implements Windows.UI.Input.Inking.IInkRecognizerContainer {
+    constructor();
+    GetRecognizers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkRecognizer> | Windows.UI.Input.Inking.InkRecognizer[];
+    RecognizeAsync(strokeCollection: Windows.UI.Input.Inking.InkStrokeContainer, recognitionTarget: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkRecognitionResult> | Windows.UI.Input.Inking.InkRecognitionResult[]>;
+    SetDefaultRecognizer(recognizer: Windows.UI.Input.Inking.InkRecognizer): void;
+  }
+
+  class InkStroke implements Windows.UI.Input.Inking.IInkStroke, Windows.UI.Input.Inking.IInkStroke2, Windows.UI.Input.Inking.IInkStroke3, Windows.UI.Input.Inking.IInkStroke4 {
+    Clone(): Windows.UI.Input.Inking.InkStroke;
+    GetInkPoints(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkPoint> | Windows.UI.Input.Inking.InkPoint[];
+    GetRenderingSegments(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkStrokeRenderingSegment> | Windows.UI.Input.Inking.InkStrokeRenderingSegment[];
+    readonly BoundingRect: Windows.Foundation.Rect;
+    DrawingAttributes: Windows.UI.Input.Inking.InkDrawingAttributes;
+    readonly Id: number;
+    PointTransform: Windows.Foundation.Numerics.Matrix3x2;
+    readonly PointerId: number;
+    readonly Recognized: boolean;
+    Selected: boolean;
+    StrokeDuration: Windows.Foundation.TimeSpan | null;
+    StrokeStartedTime: Windows.Foundation.DateTime | null;
+  }
+
+  class InkStrokeBuilder implements Windows.UI.Input.Inking.IInkStrokeBuilder, Windows.UI.Input.Inking.IInkStrokeBuilder2, Windows.UI.Input.Inking.IInkStrokeBuilder3 {
+    constructor();
+    AppendToStroke(pointerPoint: Windows.UI.Input.PointerPoint): Windows.UI.Input.PointerPoint;
+    BeginStroke(pointerPoint: Windows.UI.Input.PointerPoint): void;
+    CreateStroke(points: Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]): Windows.UI.Input.Inking.InkStroke;
+    CreateStrokeFromInkPoints(inkPoints: Windows.Foundation.Collections.IIterable<Windows.UI.Input.Inking.InkPoint> | Windows.UI.Input.Inking.InkPoint[], transform: Windows.Foundation.Numerics.Matrix3x2): Windows.UI.Input.Inking.InkStroke;
+    CreateStrokeFromInkPoints(inkPoints: Windows.Foundation.Collections.IIterable<Windows.UI.Input.Inking.InkPoint> | Windows.UI.Input.Inking.InkPoint[], transform: Windows.Foundation.Numerics.Matrix3x2, strokeStartedTime: Windows.Foundation.DateTime | null, strokeDuration: Windows.Foundation.TimeSpan | null): Windows.UI.Input.Inking.InkStroke;
+    EndStroke(pointerPoint: Windows.UI.Input.PointerPoint): Windows.UI.Input.Inking.InkStroke;
+    SetDefaultDrawingAttributes(drawingAttributes: Windows.UI.Input.Inking.InkDrawingAttributes): void;
+  }
+
+  class InkStrokeContainer implements Windows.UI.Input.Inking.IInkStrokeContainer, Windows.UI.Input.Inking.IInkStrokeContainer2, Windows.UI.Input.Inking.IInkStrokeContainer3 {
+    constructor();
+    AddStroke(stroke: Windows.UI.Input.Inking.InkStroke): void;
+    AddStrokes(strokes: Windows.Foundation.Collections.IIterable<Windows.UI.Input.Inking.InkStroke> | Windows.UI.Input.Inking.InkStroke[]): void;
+    CanPasteFromClipboard(): boolean;
+    Clear(): void;
+    CopySelectedToClipboard(): void;
+    DeleteSelected(): Windows.Foundation.Rect;
+    GetRecognitionResults(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkRecognitionResult> | Windows.UI.Input.Inking.InkRecognitionResult[];
+    GetStrokeById(id: number): Windows.UI.Input.Inking.InkStroke;
+    GetStrokes(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkStroke> | Windows.UI.Input.Inking.InkStroke[];
+    LoadAsync(inputStream: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncActionWithProgress<number | bigint>;
+    MoveSelected(translation: Windows.Foundation.Point): Windows.Foundation.Rect;
+    PasteFromClipboard(position: Windows.Foundation.Point): Windows.Foundation.Rect;
+    SaveAsync(outputStream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    SaveAsync(outputStream: Windows.Storage.Streams.IOutputStream, inkPersistenceFormat: number): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    SelectWithLine(from: Windows.Foundation.Point, to: Windows.Foundation.Point): Windows.Foundation.Rect;
+    SelectWithPolyLine(polyline: Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]): Windows.Foundation.Rect;
+    UpdateRecognitionResults(recognitionResults: Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkRecognitionResult> | Windows.UI.Input.Inking.InkRecognitionResult[]): void;
+    readonly BoundingRect: Windows.Foundation.Rect;
+  }
+
+  class InkStrokeInput implements Windows.UI.Input.Inking.IInkStrokeInput {
+    readonly InkPresenter: Windows.UI.Input.Inking.InkPresenter;
+    StrokeCanceled: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkStrokeInput, Windows.UI.Core.PointerEventArgs> | null;
+    StrokeContinued: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkStrokeInput, Windows.UI.Core.PointerEventArgs> | null;
+    StrokeEnded: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkStrokeInput, Windows.UI.Core.PointerEventArgs> | null;
+    StrokeStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkStrokeInput, Windows.UI.Core.PointerEventArgs> | null;
+  }
+
+  class InkStrokeRenderingSegment implements Windows.UI.Input.Inking.IInkStrokeRenderingSegment {
+    readonly BezierControlPoint1: Windows.Foundation.Point;
+    readonly BezierControlPoint2: Windows.Foundation.Point;
+    readonly Position: Windows.Foundation.Point;
+    readonly Pressure: number;
+    readonly TiltX: number;
+    readonly TiltY: number;
+    readonly Twist: number;
+  }
+
+  class InkStrokesCollectedEventArgs implements Windows.UI.Input.Inking.IInkStrokesCollectedEventArgs {
+    readonly Strokes: Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkStroke> | Windows.UI.Input.Inking.InkStroke[];
+  }
+
+  class InkStrokesErasedEventArgs implements Windows.UI.Input.Inking.IInkStrokesErasedEventArgs {
+    readonly Strokes: Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkStroke> | Windows.UI.Input.Inking.InkStroke[];
+  }
+
+  class InkSynchronizer implements Windows.UI.Input.Inking.IInkSynchronizer {
+    BeginDry(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkStroke> | Windows.UI.Input.Inking.InkStroke[];
+    EndDry(): void;
+  }
+
+  class InkUnprocessedInput implements Windows.UI.Input.Inking.IInkUnprocessedInput {
+    readonly InkPresenter: Windows.UI.Input.Inking.InkPresenter;
+    PointerEntered: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkUnprocessedInput, Windows.UI.Core.PointerEventArgs> | null;
+    PointerExited: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkUnprocessedInput, Windows.UI.Core.PointerEventArgs> | null;
+    PointerHovered: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkUnprocessedInput, Windows.UI.Core.PointerEventArgs> | null;
+    PointerLost: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkUnprocessedInput, Windows.UI.Core.PointerEventArgs> | null;
+    PointerMoved: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkUnprocessedInput, Windows.UI.Core.PointerEventArgs> | null;
+    PointerPressed: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkUnprocessedInput, Windows.UI.Core.PointerEventArgs> | null;
+    PointerReleased: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkUnprocessedInput, Windows.UI.Core.PointerEventArgs> | null;
+  }
+
+  class PenAndInkSettings implements Windows.UI.Input.Inking.IPenAndInkSettings, Windows.UI.Input.Inking.IPenAndInkSettings2 {
+    static GetDefault(): Windows.UI.Input.Inking.PenAndInkSettings;
+    SetPenHandedness(value: number): void;
+    readonly FontFamilyName: string;
+    readonly HandwritingLineHeight: number;
+    readonly IsHandwritingDirectlyIntoTextFieldEnabled: boolean;
+    readonly IsTouchHandwritingEnabled: boolean;
+    readonly PenHandedness: number;
+    readonly UserConsentsToHandwritingTelemetryCollection: boolean;
+  }
+
+  enum HandwritingLineHeight {
+    Small = 0,
+    Medium = 1,
+    Large = 2,
+  }
+
+  enum InkDrawingAttributesKind {
+    Default = 0,
+    Pencil = 1,
+  }
+
+  enum InkHighContrastAdjustment {
+    UseSystemColorsWhenNecessary = 0,
+    UseSystemColors = 1,
+    UseOriginalColors = 2,
+  }
+
+  enum InkInputProcessingMode {
+    None = 0,
+    Inking = 1,
+    Erasing = 2,
+  }
+
+  enum InkInputRightDragAction {
+    LeaveUnprocessed = 0,
+    AllowProcessing = 1,
+  }
+
+  enum InkManipulationMode {
+    Inking = 0,
+    Erasing = 1,
+    Selecting = 2,
+  }
+
+  enum InkPersistenceFormat {
+    GifWithEmbeddedIsf = 0,
+    Isf = 1,
+  }
+
+  enum InkPresenterPredefinedConfiguration {
+    SimpleSinglePointer = 0,
+    SimpleMultiplePointer = 1,
+  }
+
+  enum InkPresenterStencilKind {
+    Other = 0,
+    Ruler = 1,
+    Protractor = 2,
+  }
+
+  enum InkRecognitionTarget {
+    All = 0,
+    Selected = 1,
+    Recent = 2,
+  }
+
+  enum PenHandedness {
+    Right = 0,
+    Left = 1,
+  }
+
+  enum PenTipShape {
+    Circle = 0,
+    Rectangle = 1,
+  }
+
+  interface IInkDrawingAttributes {
+    Color: Windows.UI.Color;
+    FitToCurve: boolean;
+    IgnorePressure: boolean;
+    PenTip: number;
+    Size: Windows.Foundation.Size;
+  }
+  var IInkDrawingAttributes: abstract new (...args: any[]) => IInkDrawingAttributes;
+
+  interface IInkDrawingAttributes2 {
+    DrawAsHighlighter: boolean;
+    PenTipTransform: Windows.Foundation.Numerics.Matrix3x2;
+  }
+  var IInkDrawingAttributes2: abstract new (...args: any[]) => IInkDrawingAttributes2;
+
+  interface IInkDrawingAttributes3 {
+    readonly Kind: number;
+    readonly PencilProperties: Windows.UI.Input.Inking.InkDrawingAttributesPencilProperties;
+  }
+  var IInkDrawingAttributes3: abstract new (...args: any[]) => IInkDrawingAttributes3;
+
+  interface IInkDrawingAttributes4 {
+    IgnoreTilt: boolean;
+  }
+  var IInkDrawingAttributes4: abstract new (...args: any[]) => IInkDrawingAttributes4;
+
+  interface IInkDrawingAttributes5 {
+    readonly ModelerAttributes: Windows.UI.Input.Inking.InkModelerAttributes;
+  }
+  var IInkDrawingAttributes5: abstract new (...args: any[]) => IInkDrawingAttributes5;
+
+  interface IInkDrawingAttributesPencilProperties {
+    Opacity: number;
+  }
+  var IInkDrawingAttributesPencilProperties: abstract new (...args: any[]) => IInkDrawingAttributesPencilProperties;
+
+  interface IInkDrawingAttributesStatics {
+    CreateForPencil(): Windows.UI.Input.Inking.InkDrawingAttributes;
+  }
+  var IInkDrawingAttributesStatics: abstract new (...args: any[]) => IInkDrawingAttributesStatics;
+
+  interface IInkInputConfiguration {
+    IsEraserInputEnabled: boolean;
+    IsPrimaryBarrelButtonInputEnabled: boolean;
+  }
+  var IInkInputConfiguration: abstract new (...args: any[]) => IInkInputConfiguration;
+
+  interface IInkInputConfiguration2 {
+    IsPenHapticFeedbackEnabled: boolean;
+  }
+  var IInkInputConfiguration2: abstract new (...args: any[]) => IInkInputConfiguration2;
+
+  interface IInkInputProcessingConfiguration {
+    Mode: number;
+    RightDragAction: number;
+  }
+  var IInkInputProcessingConfiguration: abstract new (...args: any[]) => IInkInputProcessingConfiguration;
+
+  interface IInkManager extends Windows.UI.Input.Inking.IInkRecognizerContainer, Windows.UI.Input.Inking.IInkStrokeContainer {
+    AddStroke(stroke: Windows.UI.Input.Inking.InkStroke): void;
+    CanPasteFromClipboard(): boolean;
+    CopySelectedToClipboard(): void;
+    DeleteSelected(): Windows.Foundation.Rect;
+    GetRecognitionResults(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkRecognitionResult> | Windows.UI.Input.Inking.InkRecognitionResult[];
+    GetRecognizers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkRecognizer> | Windows.UI.Input.Inking.InkRecognizer[];
+    GetStrokes(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkStroke> | Windows.UI.Input.Inking.InkStroke[];
+    LoadAsync(inputStream: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncActionWithProgress<number | bigint>;
+    MoveSelected(translation: Windows.Foundation.Point): Windows.Foundation.Rect;
+    PasteFromClipboard(position: Windows.Foundation.Point): Windows.Foundation.Rect;
+    ProcessPointerDown(pointerPoint: Windows.UI.Input.PointerPoint): void;
+    ProcessPointerUp(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.Rect;
+    ProcessPointerUpdate(pointerPoint: Windows.UI.Input.PointerPoint): Object;
+    RecognizeAsync(recognitionTarget: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkRecognitionResult> | Windows.UI.Input.Inking.InkRecognitionResult[]>;
+    RecognizeAsync(strokeCollection: Windows.UI.Input.Inking.InkStrokeContainer, recognitionTarget: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkRecognitionResult> | Windows.UI.Input.Inking.InkRecognitionResult[]>;
+    SaveAsync(outputStream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    SelectWithLine(from: Windows.Foundation.Point, to: Windows.Foundation.Point): Windows.Foundation.Rect;
+    SelectWithPolyLine(polyline: Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]): Windows.Foundation.Rect;
+    SetDefaultDrawingAttributes(drawingAttributes: Windows.UI.Input.Inking.InkDrawingAttributes): void;
+    SetDefaultRecognizer(recognizer: Windows.UI.Input.Inking.InkRecognizer): void;
+    UpdateRecognitionResults(recognitionResults: Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkRecognitionResult> | Windows.UI.Input.Inking.InkRecognitionResult[]): void;
+    Mode: number;
+  }
+  var IInkManager: abstract new (...args: any[]) => IInkManager;
+
+  interface IInkModelerAttributes {
+    PredictionTime: Windows.Foundation.TimeSpan;
+    ScalingFactor: number;
+  }
+  var IInkModelerAttributes: abstract new (...args: any[]) => IInkModelerAttributes;
+
+  interface IInkModelerAttributes2 {
+    UseVelocityBasedPressure: boolean;
+  }
+  var IInkModelerAttributes2: abstract new (...args: any[]) => IInkModelerAttributes2;
+
+  interface IInkPoint {
+    readonly Position: Windows.Foundation.Point;
+    readonly Pressure: number;
+  }
+  var IInkPoint: abstract new (...args: any[]) => IInkPoint;
+
+  interface IInkPoint2 {
+    readonly TiltX: number;
+    readonly TiltY: number;
+    readonly Timestamp: number | bigint;
+  }
+  var IInkPoint2: abstract new (...args: any[]) => IInkPoint2;
+
+  interface IInkPointFactory {
+    CreateInkPoint(position: Windows.Foundation.Point, pressure: number): Windows.UI.Input.Inking.InkPoint;
+  }
+  var IInkPointFactory: abstract new (...args: any[]) => IInkPointFactory;
+
+  interface IInkPointFactory2 {
+    CreateInkPointWithTiltAndTimestamp(position: Windows.Foundation.Point, pressure: number, tiltX: number, tiltY: number, timestamp: number | bigint): Windows.UI.Input.Inking.InkPoint;
+  }
+  var IInkPointFactory2: abstract new (...args: any[]) => IInkPointFactory2;
+
+  interface IInkPresenter {
+    ActivateCustomDrying(): Windows.UI.Input.Inking.InkSynchronizer;
+    CopyDefaultDrawingAttributes(): Windows.UI.Input.Inking.InkDrawingAttributes;
+    SetPredefinedConfiguration(value: number): void;
+    UpdateDefaultDrawingAttributes(value: Windows.UI.Input.Inking.InkDrawingAttributes): void;
+    InputDeviceTypes: number;
+    readonly InputProcessingConfiguration: Windows.UI.Input.Inking.InkInputProcessingConfiguration;
+    IsInputEnabled: boolean;
+    StrokeContainer: Windows.UI.Input.Inking.InkStrokeContainer;
+    readonly StrokeInput: Windows.UI.Input.Inking.InkStrokeInput;
+    readonly UnprocessedInput: Windows.UI.Input.Inking.InkUnprocessedInput;
+    StrokesCollected: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkPresenter, Windows.UI.Input.Inking.InkStrokesCollectedEventArgs> | null;
+    StrokesErased: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkPresenter, Windows.UI.Input.Inking.InkStrokesErasedEventArgs> | null;
+  }
+  var IInkPresenter: abstract new (...args: any[]) => IInkPresenter;
+
+  interface IInkPresenter2 extends Windows.UI.Input.Inking.IInkPresenter {
+    ActivateCustomDrying(): Windows.UI.Input.Inking.InkSynchronizer;
+    CopyDefaultDrawingAttributes(): Windows.UI.Input.Inking.InkDrawingAttributes;
+    SetPredefinedConfiguration(value: number): void;
+    UpdateDefaultDrawingAttributes(value: Windows.UI.Input.Inking.InkDrawingAttributes): void;
+    HighContrastAdjustment: number;
+  }
+  var IInkPresenter2: abstract new (...args: any[]) => IInkPresenter2;
+
+  interface IInkPresenter3 {
+    readonly InputConfiguration: Windows.UI.Input.Inking.InkInputConfiguration;
+  }
+  var IInkPresenter3: abstract new (...args: any[]) => IInkPresenter3;
+
+  interface IInkPresenterProtractor extends Windows.UI.Input.Inking.IInkPresenterStencil {
+    AccentColor: Windows.UI.Color;
+    AreRaysVisible: boolean;
+    AreTickMarksVisible: boolean;
+    IsAngleReadoutVisible: boolean;
+    IsCenterMarkerVisible: boolean;
+    IsResizable: boolean;
+    Radius: number;
+  }
+  var IInkPresenterProtractor: abstract new (...args: any[]) => IInkPresenterProtractor;
+
+  interface IInkPresenterProtractorFactory {
+    Create(inkPresenter: Windows.UI.Input.Inking.InkPresenter): Windows.UI.Input.Inking.InkPresenterProtractor;
+  }
+  var IInkPresenterProtractorFactory: abstract new (...args: any[]) => IInkPresenterProtractorFactory;
+
+  interface IInkPresenterRuler extends Windows.UI.Input.Inking.IInkPresenterStencil {
+    Length: number;
+    Width: number;
+  }
+  var IInkPresenterRuler: abstract new (...args: any[]) => IInkPresenterRuler;
+
+  interface IInkPresenterRuler2 {
+    AreTickMarksVisible: boolean;
+    IsCompassVisible: boolean;
+  }
+  var IInkPresenterRuler2: abstract new (...args: any[]) => IInkPresenterRuler2;
+
+  interface IInkPresenterRulerFactory {
+    Create(inkPresenter: Windows.UI.Input.Inking.InkPresenter): Windows.UI.Input.Inking.InkPresenterRuler;
+  }
+  var IInkPresenterRulerFactory: abstract new (...args: any[]) => IInkPresenterRulerFactory;
+
+  interface IInkPresenterStencil {
+    BackgroundColor: Windows.UI.Color;
+    ForegroundColor: Windows.UI.Color;
+    IsVisible: boolean;
+    readonly Kind: number;
+    Transform: Windows.Foundation.Numerics.Matrix3x2;
+  }
+  var IInkPresenterStencil: abstract new (...args: any[]) => IInkPresenterStencil;
+
+  interface IInkRecognitionResult {
+    GetStrokes(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkStroke> | Windows.UI.Input.Inking.InkStroke[];
+    GetTextCandidates(): Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly BoundingRect: Windows.Foundation.Rect;
+  }
+  var IInkRecognitionResult: abstract new (...args: any[]) => IInkRecognitionResult;
+
+  interface IInkRecognizer {
+    readonly Name: string;
+  }
+  var IInkRecognizer: abstract new (...args: any[]) => IInkRecognizer;
+
+  interface IInkRecognizerContainer {
+    GetRecognizers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkRecognizer> | Windows.UI.Input.Inking.InkRecognizer[];
+    RecognizeAsync(strokeCollection: Windows.UI.Input.Inking.InkStrokeContainer, recognitionTarget: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkRecognitionResult> | Windows.UI.Input.Inking.InkRecognitionResult[]>;
+    SetDefaultRecognizer(recognizer: Windows.UI.Input.Inking.InkRecognizer): void;
+  }
+  var IInkRecognizerContainer: abstract new (...args: any[]) => IInkRecognizerContainer;
+
+  interface IInkStroke {
+    Clone(): Windows.UI.Input.Inking.InkStroke;
+    GetRenderingSegments(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkStrokeRenderingSegment> | Windows.UI.Input.Inking.InkStrokeRenderingSegment[];
+    readonly BoundingRect: Windows.Foundation.Rect;
+    DrawingAttributes: Windows.UI.Input.Inking.InkDrawingAttributes;
+    readonly Recognized: boolean;
+    Selected: boolean;
+  }
+  var IInkStroke: abstract new (...args: any[]) => IInkStroke;
+
+  interface IInkStroke2 {
+    GetInkPoints(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkPoint> | Windows.UI.Input.Inking.InkPoint[];
+    PointTransform: Windows.Foundation.Numerics.Matrix3x2;
+  }
+  var IInkStroke2: abstract new (...args: any[]) => IInkStroke2;
+
+  interface IInkStroke3 {
+    readonly Id: number;
+    StrokeDuration: Windows.Foundation.TimeSpan | null;
+    StrokeStartedTime: Windows.Foundation.DateTime | null;
+  }
+  var IInkStroke3: abstract new (...args: any[]) => IInkStroke3;
+
+  interface IInkStroke4 {
+    readonly PointerId: number;
+  }
+  var IInkStroke4: abstract new (...args: any[]) => IInkStroke4;
+
+  interface IInkStrokeBuilder {
+    AppendToStroke(pointerPoint: Windows.UI.Input.PointerPoint): Windows.UI.Input.PointerPoint;
+    BeginStroke(pointerPoint: Windows.UI.Input.PointerPoint): void;
+    CreateStroke(points: Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]): Windows.UI.Input.Inking.InkStroke;
+    EndStroke(pointerPoint: Windows.UI.Input.PointerPoint): Windows.UI.Input.Inking.InkStroke;
+    SetDefaultDrawingAttributes(drawingAttributes: Windows.UI.Input.Inking.InkDrawingAttributes): void;
+  }
+  var IInkStrokeBuilder: abstract new (...args: any[]) => IInkStrokeBuilder;
+
+  interface IInkStrokeBuilder2 {
+    CreateStrokeFromInkPoints(inkPoints: Windows.Foundation.Collections.IIterable<Windows.UI.Input.Inking.InkPoint> | Windows.UI.Input.Inking.InkPoint[], transform: Windows.Foundation.Numerics.Matrix3x2): Windows.UI.Input.Inking.InkStroke;
+  }
+  var IInkStrokeBuilder2: abstract new (...args: any[]) => IInkStrokeBuilder2;
+
+  interface IInkStrokeBuilder3 {
+    CreateStrokeFromInkPoints(inkPoints: Windows.Foundation.Collections.IIterable<Windows.UI.Input.Inking.InkPoint> | Windows.UI.Input.Inking.InkPoint[], transform: Windows.Foundation.Numerics.Matrix3x2, strokeStartedTime: Windows.Foundation.DateTime | null, strokeDuration: Windows.Foundation.TimeSpan | null): Windows.UI.Input.Inking.InkStroke;
+  }
+  var IInkStrokeBuilder3: abstract new (...args: any[]) => IInkStrokeBuilder3;
+
+  interface IInkStrokeContainer {
+    AddStroke(stroke: Windows.UI.Input.Inking.InkStroke): void;
+    CanPasteFromClipboard(): boolean;
+    CopySelectedToClipboard(): void;
+    DeleteSelected(): Windows.Foundation.Rect;
+    GetRecognitionResults(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkRecognitionResult> | Windows.UI.Input.Inking.InkRecognitionResult[];
+    GetStrokes(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkStroke> | Windows.UI.Input.Inking.InkStroke[];
+    LoadAsync(inputStream: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncActionWithProgress<number | bigint>;
+    MoveSelected(translation: Windows.Foundation.Point): Windows.Foundation.Rect;
+    PasteFromClipboard(position: Windows.Foundation.Point): Windows.Foundation.Rect;
+    SaveAsync(outputStream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+    SelectWithLine(from: Windows.Foundation.Point, to: Windows.Foundation.Point): Windows.Foundation.Rect;
+    SelectWithPolyLine(polyline: Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]): Windows.Foundation.Rect;
+    UpdateRecognitionResults(recognitionResults: Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkRecognitionResult> | Windows.UI.Input.Inking.InkRecognitionResult[]): void;
+    readonly BoundingRect: Windows.Foundation.Rect;
+  }
+  var IInkStrokeContainer: abstract new (...args: any[]) => IInkStrokeContainer;
+
+  interface IInkStrokeContainer2 {
+    AddStrokes(strokes: Windows.Foundation.Collections.IIterable<Windows.UI.Input.Inking.InkStroke> | Windows.UI.Input.Inking.InkStroke[]): void;
+    Clear(): void;
+  }
+  var IInkStrokeContainer2: abstract new (...args: any[]) => IInkStrokeContainer2;
+
+  interface IInkStrokeContainer3 {
+    GetStrokeById(id: number): Windows.UI.Input.Inking.InkStroke;
+    SaveAsync(outputStream: Windows.Storage.Streams.IOutputStream, inkPersistenceFormat: number): Windows.Foundation.IAsyncOperationWithProgress<number, number>;
+  }
+  var IInkStrokeContainer3: abstract new (...args: any[]) => IInkStrokeContainer3;
+
+  interface IInkStrokeInput {
+    readonly InkPresenter: Windows.UI.Input.Inking.InkPresenter;
+    StrokeCanceled: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkStrokeInput, Windows.UI.Core.PointerEventArgs> | null;
+    StrokeContinued: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkStrokeInput, Windows.UI.Core.PointerEventArgs> | null;
+    StrokeEnded: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkStrokeInput, Windows.UI.Core.PointerEventArgs> | null;
+    StrokeStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkStrokeInput, Windows.UI.Core.PointerEventArgs> | null;
+  }
+  var IInkStrokeInput: abstract new (...args: any[]) => IInkStrokeInput;
+
+  interface IInkStrokeRenderingSegment {
+    readonly BezierControlPoint1: Windows.Foundation.Point;
+    readonly BezierControlPoint2: Windows.Foundation.Point;
+    readonly Position: Windows.Foundation.Point;
+    readonly Pressure: number;
+    readonly TiltX: number;
+    readonly TiltY: number;
+    readonly Twist: number;
+  }
+  var IInkStrokeRenderingSegment: abstract new (...args: any[]) => IInkStrokeRenderingSegment;
+
+  interface IInkStrokesCollectedEventArgs {
+    readonly Strokes: Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkStroke> | Windows.UI.Input.Inking.InkStroke[];
+  }
+  var IInkStrokesCollectedEventArgs: abstract new (...args: any[]) => IInkStrokesCollectedEventArgs;
+
+  interface IInkStrokesErasedEventArgs {
+    readonly Strokes: Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkStroke> | Windows.UI.Input.Inking.InkStroke[];
+  }
+  var IInkStrokesErasedEventArgs: abstract new (...args: any[]) => IInkStrokesErasedEventArgs;
+
+  interface IInkSynchronizer {
+    BeginDry(): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.InkStroke> | Windows.UI.Input.Inking.InkStroke[];
+    EndDry(): void;
+  }
+  var IInkSynchronizer: abstract new (...args: any[]) => IInkSynchronizer;
+
+  interface IInkUnprocessedInput {
+    readonly InkPresenter: Windows.UI.Input.Inking.InkPresenter;
+    PointerEntered: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkUnprocessedInput, Windows.UI.Core.PointerEventArgs> | null;
+    PointerExited: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkUnprocessedInput, Windows.UI.Core.PointerEventArgs> | null;
+    PointerHovered: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkUnprocessedInput, Windows.UI.Core.PointerEventArgs> | null;
+    PointerLost: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkUnprocessedInput, Windows.UI.Core.PointerEventArgs> | null;
+    PointerMoved: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkUnprocessedInput, Windows.UI.Core.PointerEventArgs> | null;
+    PointerPressed: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkUnprocessedInput, Windows.UI.Core.PointerEventArgs> | null;
+    PointerReleased: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.InkUnprocessedInput, Windows.UI.Core.PointerEventArgs> | null;
+  }
+  var IInkUnprocessedInput: abstract new (...args: any[]) => IInkUnprocessedInput;
+
+  interface IPenAndInkSettings {
+    readonly FontFamilyName: string;
+    readonly HandwritingLineHeight: number;
+    readonly IsHandwritingDirectlyIntoTextFieldEnabled: boolean;
+    readonly IsTouchHandwritingEnabled: boolean;
+    readonly PenHandedness: number;
+    readonly UserConsentsToHandwritingTelemetryCollection: boolean;
+  }
+  var IPenAndInkSettings: abstract new (...args: any[]) => IPenAndInkSettings;
+
+  interface IPenAndInkSettings2 {
+    SetPenHandedness(value: number): void;
+  }
+  var IPenAndInkSettings2: abstract new (...args: any[]) => IPenAndInkSettings2;
+
+  interface IPenAndInkSettingsStatics {
+    GetDefault(): Windows.UI.Input.Inking.PenAndInkSettings;
+  }
+  var IPenAndInkSettingsStatics: abstract new (...args: any[]) => IPenAndInkSettingsStatics;
+
+}
+
+declare namespace Windows.UI.Input.Inking.Analysis {
+  class InkAnalysisInkBullet implements Windows.UI.Input.Inking.Analysis.IInkAnalysisInkBullet, Windows.UI.Input.Inking.Analysis.IInkAnalysisNode {
+    GetStrokeIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly BoundingRect: Windows.Foundation.Rect;
+    readonly Children: Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.Analysis.IInkAnalysisNode> | Windows.UI.Input.Inking.Analysis.IInkAnalysisNode[];
+    readonly Id: number;
+    readonly Kind: number;
+    readonly Parent: Windows.UI.Input.Inking.Analysis.IInkAnalysisNode;
+    readonly RecognizedText: string;
+    readonly RotatedBoundingRect: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Point> | Windows.Foundation.Point[];
+  }
+
+  class InkAnalysisInkDrawing implements Windows.UI.Input.Inking.Analysis.IInkAnalysisInkDrawing, Windows.UI.Input.Inking.Analysis.IInkAnalysisNode {
+    GetStrokeIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly BoundingRect: Windows.Foundation.Rect;
+    readonly Center: Windows.Foundation.Point;
+    readonly Children: Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.Analysis.IInkAnalysisNode> | Windows.UI.Input.Inking.Analysis.IInkAnalysisNode[];
+    readonly DrawingKind: number;
+    readonly Id: number;
+    readonly Kind: number;
+    readonly Parent: Windows.UI.Input.Inking.Analysis.IInkAnalysisNode;
+    readonly Points: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Point> | Windows.Foundation.Point[];
+    readonly RotatedBoundingRect: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Point> | Windows.Foundation.Point[];
+  }
+
+  class InkAnalysisInkWord implements Windows.UI.Input.Inking.Analysis.IInkAnalysisInkWord, Windows.UI.Input.Inking.Analysis.IInkAnalysisNode {
+    GetStrokeIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly BoundingRect: Windows.Foundation.Rect;
+    readonly Children: Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.Analysis.IInkAnalysisNode> | Windows.UI.Input.Inking.Analysis.IInkAnalysisNode[];
+    readonly Id: number;
+    readonly Kind: number;
+    readonly Parent: Windows.UI.Input.Inking.Analysis.IInkAnalysisNode;
+    readonly RecognizedText: string;
+    readonly RotatedBoundingRect: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Point> | Windows.Foundation.Point[];
+    readonly TextAlternates: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+
+  class InkAnalysisLine implements Windows.UI.Input.Inking.Analysis.IInkAnalysisLine, Windows.UI.Input.Inking.Analysis.IInkAnalysisNode {
+    GetStrokeIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly BoundingRect: Windows.Foundation.Rect;
+    readonly Children: Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.Analysis.IInkAnalysisNode> | Windows.UI.Input.Inking.Analysis.IInkAnalysisNode[];
+    readonly Id: number;
+    readonly IndentLevel: number;
+    readonly Kind: number;
+    readonly Parent: Windows.UI.Input.Inking.Analysis.IInkAnalysisNode;
+    readonly RecognizedText: string;
+    readonly RotatedBoundingRect: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Point> | Windows.Foundation.Point[];
+  }
+
+  class InkAnalysisListItem implements Windows.UI.Input.Inking.Analysis.IInkAnalysisListItem, Windows.UI.Input.Inking.Analysis.IInkAnalysisNode {
+    GetStrokeIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly BoundingRect: Windows.Foundation.Rect;
+    readonly Children: Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.Analysis.IInkAnalysisNode> | Windows.UI.Input.Inking.Analysis.IInkAnalysisNode[];
+    readonly Id: number;
+    readonly Kind: number;
+    readonly Parent: Windows.UI.Input.Inking.Analysis.IInkAnalysisNode;
+    readonly RecognizedText: string;
+    readonly RotatedBoundingRect: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Point> | Windows.Foundation.Point[];
+  }
+
+  class InkAnalysisNode implements Windows.UI.Input.Inking.Analysis.IInkAnalysisNode {
+    GetStrokeIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly BoundingRect: Windows.Foundation.Rect;
+    readonly Children: Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.Analysis.IInkAnalysisNode> | Windows.UI.Input.Inking.Analysis.IInkAnalysisNode[];
+    readonly Id: number;
+    readonly Kind: number;
+    readonly Parent: Windows.UI.Input.Inking.Analysis.IInkAnalysisNode;
+    readonly RotatedBoundingRect: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Point> | Windows.Foundation.Point[];
+  }
+
+  class InkAnalysisParagraph implements Windows.UI.Input.Inking.Analysis.IInkAnalysisNode, Windows.UI.Input.Inking.Analysis.IInkAnalysisParagraph {
+    GetStrokeIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly BoundingRect: Windows.Foundation.Rect;
+    readonly Children: Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.Analysis.IInkAnalysisNode> | Windows.UI.Input.Inking.Analysis.IInkAnalysisNode[];
+    readonly Id: number;
+    readonly Kind: number;
+    readonly Parent: Windows.UI.Input.Inking.Analysis.IInkAnalysisNode;
+    readonly RecognizedText: string;
+    readonly RotatedBoundingRect: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Point> | Windows.Foundation.Point[];
+  }
+
+  class InkAnalysisResult implements Windows.UI.Input.Inking.Analysis.IInkAnalysisResult {
+    readonly Status: number;
+  }
+
+  class InkAnalysisRoot implements Windows.UI.Input.Inking.Analysis.IInkAnalysisNode, Windows.UI.Input.Inking.Analysis.IInkAnalysisRoot {
+    FindNodes(nodeKind: number): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.Analysis.IInkAnalysisNode> | Windows.UI.Input.Inking.Analysis.IInkAnalysisNode[];
+    GetStrokeIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly BoundingRect: Windows.Foundation.Rect;
+    readonly Children: Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.Analysis.IInkAnalysisNode> | Windows.UI.Input.Inking.Analysis.IInkAnalysisNode[];
+    readonly Id: number;
+    readonly Kind: number;
+    readonly Parent: Windows.UI.Input.Inking.Analysis.IInkAnalysisNode;
+    readonly RecognizedText: string;
+    readonly RotatedBoundingRect: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Point> | Windows.Foundation.Point[];
+  }
+
+  class InkAnalysisWritingRegion implements Windows.UI.Input.Inking.Analysis.IInkAnalysisNode, Windows.UI.Input.Inking.Analysis.IInkAnalysisWritingRegion {
+    GetStrokeIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly BoundingRect: Windows.Foundation.Rect;
+    readonly Children: Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.Analysis.IInkAnalysisNode> | Windows.UI.Input.Inking.Analysis.IInkAnalysisNode[];
+    readonly Id: number;
+    readonly Kind: number;
+    readonly Parent: Windows.UI.Input.Inking.Analysis.IInkAnalysisNode;
+    readonly RecognizedText: string;
+    readonly RotatedBoundingRect: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Point> | Windows.Foundation.Point[];
+  }
+
+  class InkAnalyzer implements Windows.UI.Input.Inking.Analysis.IInkAnalyzer {
+    constructor();
+    AddDataForStroke(stroke: Windows.UI.Input.Inking.InkStroke): void;
+    AddDataForStrokes(strokes: Windows.Foundation.Collections.IIterable<Windows.UI.Input.Inking.InkStroke> | Windows.UI.Input.Inking.InkStroke[]): void;
+    AnalyzeAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.Input.Inking.Analysis.InkAnalysisResult>;
+    ClearDataForAllStrokes(): void;
+    RemoveDataForStroke(strokeId: number): void;
+    RemoveDataForStrokes(strokeIds: Windows.Foundation.Collections.IIterable<number> | number[]): void;
+    ReplaceDataForStroke(stroke: Windows.UI.Input.Inking.InkStroke): void;
+    SetStrokeDataKind(strokeId: number, strokeKind: number): void;
+    readonly AnalysisRoot: Windows.UI.Input.Inking.Analysis.InkAnalysisRoot;
+    readonly IsAnalyzing: boolean;
+  }
+
+  enum InkAnalysisDrawingKind {
+    Drawing = 0,
+    Circle = 1,
+    Ellipse = 2,
+    Triangle = 3,
+    IsoscelesTriangle = 4,
+    EquilateralTriangle = 5,
+    RightTriangle = 6,
+    Quadrilateral = 7,
+    Rectangle = 8,
+    Square = 9,
+    Diamond = 10,
+    Trapezoid = 11,
+    Parallelogram = 12,
+    Pentagon = 13,
+    Hexagon = 14,
+  }
+
+  enum InkAnalysisNodeKind {
+    UnclassifiedInk = 0,
+    Root = 1,
+    WritingRegion = 2,
+    Paragraph = 3,
+    Line = 4,
+    InkWord = 5,
+    InkBullet = 6,
+    InkDrawing = 7,
+    ListItem = 8,
+  }
+
+  enum InkAnalysisStatus {
+    Updated = 0,
+    Unchanged = 1,
+  }
+
+  enum InkAnalysisStrokeKind {
+    Auto = 0,
+    Writing = 1,
+    Drawing = 2,
+  }
+
+  interface IInkAnalysisInkBullet extends Windows.UI.Input.Inking.Analysis.IInkAnalysisNode {
+    GetStrokeIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly RecognizedText: string;
+  }
+  var IInkAnalysisInkBullet: abstract new (...args: any[]) => IInkAnalysisInkBullet;
+
+  interface IInkAnalysisInkDrawing extends Windows.UI.Input.Inking.Analysis.IInkAnalysisNode {
+    GetStrokeIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly Center: Windows.Foundation.Point;
+    readonly DrawingKind: number;
+    readonly Points: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Point> | Windows.Foundation.Point[];
+  }
+  var IInkAnalysisInkDrawing: abstract new (...args: any[]) => IInkAnalysisInkDrawing;
+
+  interface IInkAnalysisInkWord extends Windows.UI.Input.Inking.Analysis.IInkAnalysisNode {
+    GetStrokeIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly RecognizedText: string;
+    readonly TextAlternates: Windows.Foundation.Collections.IVectorView<string> | string[];
+  }
+  var IInkAnalysisInkWord: abstract new (...args: any[]) => IInkAnalysisInkWord;
+
+  interface IInkAnalysisLine extends Windows.UI.Input.Inking.Analysis.IInkAnalysisNode {
+    GetStrokeIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly IndentLevel: number;
+    readonly RecognizedText: string;
+  }
+  var IInkAnalysisLine: abstract new (...args: any[]) => IInkAnalysisLine;
+
+  interface IInkAnalysisListItem extends Windows.UI.Input.Inking.Analysis.IInkAnalysisNode {
+    GetStrokeIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly RecognizedText: string;
+  }
+  var IInkAnalysisListItem: abstract new (...args: any[]) => IInkAnalysisListItem;
+
+  interface IInkAnalysisNode {
+    GetStrokeIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly BoundingRect: Windows.Foundation.Rect;
+    readonly Children: Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.Analysis.IInkAnalysisNode> | Windows.UI.Input.Inking.Analysis.IInkAnalysisNode[];
+    readonly Id: number;
+    readonly Kind: number;
+    readonly Parent: Windows.UI.Input.Inking.Analysis.IInkAnalysisNode;
+    readonly RotatedBoundingRect: Windows.Foundation.Collections.IVectorView<Windows.Foundation.Point> | Windows.Foundation.Point[];
+  }
+  var IInkAnalysisNode: abstract new (...args: any[]) => IInkAnalysisNode;
+
+  interface IInkAnalysisParagraph extends Windows.UI.Input.Inking.Analysis.IInkAnalysisNode {
+    GetStrokeIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly RecognizedText: string;
+  }
+  var IInkAnalysisParagraph: abstract new (...args: any[]) => IInkAnalysisParagraph;
+
+  interface IInkAnalysisResult {
+    readonly Status: number;
+  }
+  var IInkAnalysisResult: abstract new (...args: any[]) => IInkAnalysisResult;
+
+  interface IInkAnalysisRoot extends Windows.UI.Input.Inking.Analysis.IInkAnalysisNode {
+    FindNodes(nodeKind: number): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Inking.Analysis.IInkAnalysisNode> | Windows.UI.Input.Inking.Analysis.IInkAnalysisNode[];
+    GetStrokeIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly RecognizedText: string;
+  }
+  var IInkAnalysisRoot: abstract new (...args: any[]) => IInkAnalysisRoot;
+
+  interface IInkAnalysisWritingRegion extends Windows.UI.Input.Inking.Analysis.IInkAnalysisNode {
+    GetStrokeIds(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly RecognizedText: string;
+  }
+  var IInkAnalysisWritingRegion: abstract new (...args: any[]) => IInkAnalysisWritingRegion;
+
+  interface IInkAnalyzer {
+    AddDataForStroke(stroke: Windows.UI.Input.Inking.InkStroke): void;
+    AddDataForStrokes(strokes: Windows.Foundation.Collections.IIterable<Windows.UI.Input.Inking.InkStroke> | Windows.UI.Input.Inking.InkStroke[]): void;
+    AnalyzeAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.Input.Inking.Analysis.InkAnalysisResult>;
+    ClearDataForAllStrokes(): void;
+    RemoveDataForStroke(strokeId: number): void;
+    RemoveDataForStrokes(strokeIds: Windows.Foundation.Collections.IIterable<number> | number[]): void;
+    ReplaceDataForStroke(stroke: Windows.UI.Input.Inking.InkStroke): void;
+    SetStrokeDataKind(strokeId: number, strokeKind: number): void;
+    readonly AnalysisRoot: Windows.UI.Input.Inking.Analysis.InkAnalysisRoot;
+    readonly IsAnalyzing: boolean;
+  }
+  var IInkAnalyzer: abstract new (...args: any[]) => IInkAnalyzer;
+
+  interface IInkAnalyzerFactory {
+    CreateAnalyzer(): Windows.UI.Input.Inking.Analysis.InkAnalyzer;
+  }
+  var IInkAnalyzerFactory: abstract new (...args: any[]) => IInkAnalyzerFactory;
+
+}
+
+declare namespace Windows.UI.Input.Inking.Core {
+  class CoreIncrementalInkStroke implements Windows.UI.Input.Inking.Core.ICoreIncrementalInkStroke {
+    constructor(drawingAttributes: Windows.UI.Input.Inking.InkDrawingAttributes, pointTransform: Windows.Foundation.Numerics.Matrix3x2);
+    AppendInkPoints(inkPoints: Windows.Foundation.Collections.IIterable<Windows.UI.Input.Inking.InkPoint> | Windows.UI.Input.Inking.InkPoint[]): Windows.Foundation.Rect;
+    CreateInkStroke(): Windows.UI.Input.Inking.InkStroke;
+    readonly BoundingRect: Windows.Foundation.Rect;
+    readonly DrawingAttributes: Windows.UI.Input.Inking.InkDrawingAttributes;
+    readonly PointTransform: Windows.Foundation.Numerics.Matrix3x2;
+  }
+
+  class CoreInkIndependentInputSource implements Windows.UI.Input.Inking.Core.ICoreInkIndependentInputSource, Windows.UI.Input.Inking.Core.ICoreInkIndependentInputSource2 {
+    static Create(inkPresenter: Windows.UI.Input.Inking.InkPresenter): Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource;
+    readonly InkPresenter: Windows.UI.Input.Inking.InkPresenter;
+    PointerCursor: Windows.UI.Core.CoreCursor;
+    PointerEntering: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource, Windows.UI.Core.PointerEventArgs> | null;
+    PointerExiting: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource, Windows.UI.Core.PointerEventArgs> | null;
+    PointerHovering: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource, Windows.UI.Core.PointerEventArgs> | null;
+    PointerLost: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource, Windows.UI.Core.PointerEventArgs> | null;
+    PointerMoving: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource, Windows.UI.Core.PointerEventArgs> | null;
+    PointerPressing: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource, Windows.UI.Core.PointerEventArgs> | null;
+    PointerReleasing: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource, Windows.UI.Core.PointerEventArgs> | null;
+  }
+
+  class CoreInkPresenterHost implements Windows.UI.Input.Inking.Core.ICoreInkPresenterHost {
+    constructor();
+    readonly InkPresenter: Windows.UI.Input.Inking.InkPresenter;
+    RootVisual: Windows.UI.Composition.ContainerVisual;
+  }
+
+  class CoreWetStrokeUpdateEventArgs implements Windows.UI.Input.Inking.Core.ICoreWetStrokeUpdateEventArgs {
+    Disposition: number;
+    readonly NewInkPoints: Windows.Foundation.Collections.IVector<Windows.UI.Input.Inking.InkPoint> | Windows.UI.Input.Inking.InkPoint[];
+    readonly PointerId: number;
+  }
+
+  class CoreWetStrokeUpdateSource implements Windows.UI.Input.Inking.Core.ICoreWetStrokeUpdateSource {
+    static Create(inkPresenter: Windows.UI.Input.Inking.InkPresenter): Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource;
+    readonly InkPresenter: Windows.UI.Input.Inking.InkPresenter;
+    WetStrokeCanceled: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource, Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs> | null;
+    WetStrokeCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource, Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs> | null;
+    WetStrokeContinuing: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource, Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs> | null;
+    WetStrokeStarting: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource, Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs> | null;
+    WetStrokeStopping: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource, Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs> | null;
+  }
+
+  enum CoreWetStrokeDisposition {
+    Inking = 0,
+    Completed = 1,
+    Canceled = 2,
+  }
+
+  interface ICoreIncrementalInkStroke {
+    AppendInkPoints(inkPoints: Windows.Foundation.Collections.IIterable<Windows.UI.Input.Inking.InkPoint> | Windows.UI.Input.Inking.InkPoint[]): Windows.Foundation.Rect;
+    CreateInkStroke(): Windows.UI.Input.Inking.InkStroke;
+    readonly BoundingRect: Windows.Foundation.Rect;
+    readonly DrawingAttributes: Windows.UI.Input.Inking.InkDrawingAttributes;
+    readonly PointTransform: Windows.Foundation.Numerics.Matrix3x2;
+  }
+  var ICoreIncrementalInkStroke: abstract new (...args: any[]) => ICoreIncrementalInkStroke;
+
+  interface ICoreIncrementalInkStrokeFactory {
+    Create(drawingAttributes: Windows.UI.Input.Inking.InkDrawingAttributes, pointTransform: Windows.Foundation.Numerics.Matrix3x2): Windows.UI.Input.Inking.Core.CoreIncrementalInkStroke;
+  }
+  var ICoreIncrementalInkStrokeFactory: abstract new (...args: any[]) => ICoreIncrementalInkStrokeFactory;
+
+  interface ICoreInkIndependentInputSource {
+    readonly InkPresenter: Windows.UI.Input.Inking.InkPresenter;
+    PointerEntering: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource, Windows.UI.Core.PointerEventArgs> | null;
+    PointerExiting: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource, Windows.UI.Core.PointerEventArgs> | null;
+    PointerHovering: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource, Windows.UI.Core.PointerEventArgs> | null;
+    PointerLost: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource, Windows.UI.Core.PointerEventArgs> | null;
+    PointerMoving: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource, Windows.UI.Core.PointerEventArgs> | null;
+    PointerPressing: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource, Windows.UI.Core.PointerEventArgs> | null;
+    PointerReleasing: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource, Windows.UI.Core.PointerEventArgs> | null;
+  }
+  var ICoreInkIndependentInputSource: abstract new (...args: any[]) => ICoreInkIndependentInputSource;
+
+  interface ICoreInkIndependentInputSource2 {
+    PointerCursor: Windows.UI.Core.CoreCursor;
+  }
+  var ICoreInkIndependentInputSource2: abstract new (...args: any[]) => ICoreInkIndependentInputSource2;
+
+  interface ICoreInkIndependentInputSourceStatics {
+    Create(inkPresenter: Windows.UI.Input.Inking.InkPresenter): Windows.UI.Input.Inking.Core.CoreInkIndependentInputSource;
+  }
+  var ICoreInkIndependentInputSourceStatics: abstract new (...args: any[]) => ICoreInkIndependentInputSourceStatics;
+
+  interface ICoreInkPresenterHost {
+    readonly InkPresenter: Windows.UI.Input.Inking.InkPresenter;
+    RootVisual: Windows.UI.Composition.ContainerVisual;
+  }
+  var ICoreInkPresenterHost: abstract new (...args: any[]) => ICoreInkPresenterHost;
+
+  interface ICoreWetStrokeUpdateEventArgs {
+    Disposition: number;
+    readonly NewInkPoints: Windows.Foundation.Collections.IVector<Windows.UI.Input.Inking.InkPoint> | Windows.UI.Input.Inking.InkPoint[];
+    readonly PointerId: number;
+  }
+  var ICoreWetStrokeUpdateEventArgs: abstract new (...args: any[]) => ICoreWetStrokeUpdateEventArgs;
+
+  interface ICoreWetStrokeUpdateSource {
+    readonly InkPresenter: Windows.UI.Input.Inking.InkPresenter;
+    WetStrokeCanceled: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource, Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs> | null;
+    WetStrokeCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource, Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs> | null;
+    WetStrokeContinuing: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource, Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs> | null;
+    WetStrokeStarting: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource, Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs> | null;
+    WetStrokeStopping: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource, Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateEventArgs> | null;
+  }
+  var ICoreWetStrokeUpdateSource: abstract new (...args: any[]) => ICoreWetStrokeUpdateSource;
+
+  interface ICoreWetStrokeUpdateSourceStatics {
+    Create(inkPresenter: Windows.UI.Input.Inking.InkPresenter): Windows.UI.Input.Inking.Core.CoreWetStrokeUpdateSource;
+  }
+  var ICoreWetStrokeUpdateSourceStatics: abstract new (...args: any[]) => ICoreWetStrokeUpdateSourceStatics;
+
+}
+
+declare namespace Windows.UI.Input.Inking.Preview {
+  class PalmRejectionDelayZonePreview implements Windows.Foundation.IClosable, Windows.UI.Input.Inking.Preview.IPalmRejectionDelayZonePreview {
+    Close(): void;
+    static CreateForVisual(inputPanelVisual: Windows.UI.Composition.Visual, inputPanelRect: Windows.Foundation.Rect): Windows.UI.Input.Inking.Preview.PalmRejectionDelayZonePreview;
+    static CreateForVisual(inputPanelVisual: Windows.UI.Composition.Visual, inputPanelRect: Windows.Foundation.Rect, viewportVisual: Windows.UI.Composition.Visual, viewportRect: Windows.Foundation.Rect): Windows.UI.Input.Inking.Preview.PalmRejectionDelayZonePreview;
+  }
+
+  interface IPalmRejectionDelayZonePreview {
+  }
+  var IPalmRejectionDelayZonePreview: abstract new (...args: any[]) => IPalmRejectionDelayZonePreview;
+
+  interface IPalmRejectionDelayZonePreviewStatics {
+    CreateForVisual(inputPanelVisual: Windows.UI.Composition.Visual, inputPanelRect: Windows.Foundation.Rect): Windows.UI.Input.Inking.Preview.PalmRejectionDelayZonePreview;
+    CreateForVisual(inputPanelVisual: Windows.UI.Composition.Visual, inputPanelRect: Windows.Foundation.Rect, viewportVisual: Windows.UI.Composition.Visual, viewportRect: Windows.Foundation.Rect): Windows.UI.Input.Inking.Preview.PalmRejectionDelayZonePreview;
+  }
+  var IPalmRejectionDelayZonePreviewStatics: abstract new (...args: any[]) => IPalmRejectionDelayZonePreviewStatics;
+
+}
+
+declare namespace Windows.UI.Input.Preview {
+  class InputActivationListenerPreview {
+    static CreateForApplicationWindow(window: Windows.UI.WindowManagement.AppWindow): Windows.UI.Input.InputActivationListener;
+  }
+
+  interface IInputActivationListenerPreviewStatics {
+    CreateForApplicationWindow(window: Windows.UI.WindowManagement.AppWindow): Windows.UI.Input.InputActivationListener;
+  }
+  var IInputActivationListenerPreviewStatics: abstract new (...args: any[]) => IInputActivationListenerPreviewStatics;
+
+}
+
+declare namespace Windows.UI.Input.Preview.Injection {
+  class InjectedInputGamepadInfo implements Windows.UI.Input.Preview.Injection.IInjectedInputGamepadInfo {
+    constructor(reading: Windows.Gaming.Input.GamepadReading);
+    constructor();
+    Buttons: number;
+    LeftThumbstickX: number;
+    LeftThumbstickY: number;
+    LeftTrigger: number;
+    RightThumbstickX: number;
+    RightThumbstickY: number;
+    RightTrigger: number;
+  }
+
+  class InjectedInputKeyboardInfo implements Windows.UI.Input.Preview.Injection.IInjectedInputKeyboardInfo {
+    constructor();
+    KeyOptions: number;
+    ScanCode: number;
+    VirtualKey: number;
+  }
+
+  class InjectedInputMouseInfo implements Windows.UI.Input.Preview.Injection.IInjectedInputMouseInfo {
+    constructor();
+    DeltaX: number;
+    DeltaY: number;
+    MouseData: number;
+    MouseOptions: number;
+    TimeOffsetInMilliseconds: number;
+  }
+
+  class InjectedInputPenInfo implements Windows.UI.Input.Preview.Injection.IInjectedInputPenInfo {
+    constructor();
+    PenButtons: number;
+    PenParameters: number;
+    PointerInfo: Windows.UI.Input.Preview.Injection.InjectedInputPointerInfo;
+    Pressure: number;
+    Rotation: number;
+    TiltX: number;
+    TiltY: number;
+  }
+
+  class InjectedInputTouchInfo implements Windows.UI.Input.Preview.Injection.IInjectedInputTouchInfo {
+    constructor();
+    Contact: Windows.UI.Input.Preview.Injection.InjectedInputRectangle;
+    Orientation: number;
+    PointerInfo: Windows.UI.Input.Preview.Injection.InjectedInputPointerInfo;
+    Pressure: number;
+    TouchParameters: number;
+  }
+
+  class InputInjector implements Windows.UI.Input.Preview.Injection.IInputInjector, Windows.UI.Input.Preview.Injection.IInputInjector2 {
+    InitializeGamepadInjection(): void;
+    InitializePenInjection(visualMode: number): void;
+    InitializeTouchInjection(visualMode: number): void;
+    InjectGamepadInput(input: Windows.UI.Input.Preview.Injection.InjectedInputGamepadInfo): void;
+    InjectKeyboardInput(input: Windows.Foundation.Collections.IIterable<Windows.UI.Input.Preview.Injection.InjectedInputKeyboardInfo> | Windows.UI.Input.Preview.Injection.InjectedInputKeyboardInfo[]): void;
+    InjectMouseInput(input: Windows.Foundation.Collections.IIterable<Windows.UI.Input.Preview.Injection.InjectedInputMouseInfo> | Windows.UI.Input.Preview.Injection.InjectedInputMouseInfo[]): void;
+    InjectPenInput(input: Windows.UI.Input.Preview.Injection.InjectedInputPenInfo): void;
+    InjectShortcut(shortcut: number): void;
+    InjectTouchInput(input: Windows.Foundation.Collections.IIterable<Windows.UI.Input.Preview.Injection.InjectedInputTouchInfo> | Windows.UI.Input.Preview.Injection.InjectedInputTouchInfo[]): void;
+    static TryCreate(): Windows.UI.Input.Preview.Injection.InputInjector;
+    static TryCreateForAppBroadcastOnly(): Windows.UI.Input.Preview.Injection.InputInjector;
+    UninitializeGamepadInjection(): void;
+    UninitializePenInjection(): void;
+    UninitializeTouchInjection(): void;
+  }
+
+  enum InjectedInputButtonChangeKind {
+    None = 0,
+    FirstButtonDown = 1,
+    FirstButtonUp = 2,
+    SecondButtonDown = 3,
+    SecondButtonUp = 4,
+    ThirdButtonDown = 5,
+    ThirdButtonUp = 6,
+    FourthButtonDown = 7,
+    FourthButtonUp = 8,
+    FifthButtonDown = 9,
+    FifthButtonUp = 10,
+  }
+
+  enum InjectedInputKeyOptions {
+    None = 0,
+    ExtendedKey = 1,
+    KeyUp = 2,
+    ScanCode = 8,
+    Unicode = 4,
+  }
+
+  enum InjectedInputMouseOptions {
+    None = 0,
+    Move = 1,
+    LeftDown = 2,
+    LeftUp = 4,
+    RightDown = 8,
+    RightUp = 16,
+    MiddleDown = 32,
+    MiddleUp = 64,
+    XDown = 128,
+    XUp = 256,
+    Wheel = 2048,
+    HWheel = 4096,
+    MoveNoCoalesce = 8192,
+    VirtualDesk = 16384,
+    Absolute = 32768,
+  }
+
+  enum InjectedInputPenButtons {
+    None = 0,
+    Barrel = 1,
+    Inverted = 2,
+    Eraser = 4,
+  }
+
+  enum InjectedInputPenParameters {
+    None = 0,
+    Pressure = 1,
+    Rotation = 2,
+    TiltX = 4,
+    TiltY = 8,
+  }
+
+  enum InjectedInputPointerOptions {
+    None = 0,
+    New = 1,
+    InRange = 2,
+    InContact = 4,
+    FirstButton = 16,
+    SecondButton = 32,
+    Primary = 8192,
+    Confidence = 16384,
+    Canceled = 32768,
+    PointerDown = 65536,
+    Update = 131072,
+    PointerUp = 262144,
+    CaptureChanged = 2097152,
+  }
+
+  enum InjectedInputShortcut {
+    Back = 0,
+    Start = 1,
+    Search = 2,
+  }
+
+  enum InjectedInputTouchParameters {
+    None = 0,
+    Contact = 1,
+    Orientation = 2,
+    Pressure = 4,
+  }
+
+  enum InjectedInputVisualizationMode {
+    None = 0,
+    Default = 1,
+    Indirect = 2,
+  }
+
+  interface IInjectedInputGamepadInfo {
+    Buttons: number;
+    LeftThumbstickX: number;
+    LeftThumbstickY: number;
+    LeftTrigger: number;
+    RightThumbstickX: number;
+    RightThumbstickY: number;
+    RightTrigger: number;
+  }
+  var IInjectedInputGamepadInfo: abstract new (...args: any[]) => IInjectedInputGamepadInfo;
+
+  interface IInjectedInputGamepadInfoFactory {
+    CreateInstance(reading: Windows.Gaming.Input.GamepadReading): Windows.UI.Input.Preview.Injection.InjectedInputGamepadInfo;
+  }
+  var IInjectedInputGamepadInfoFactory: abstract new (...args: any[]) => IInjectedInputGamepadInfoFactory;
+
+  interface IInjectedInputKeyboardInfo {
+    KeyOptions: number;
+    ScanCode: number;
+    VirtualKey: number;
+  }
+  var IInjectedInputKeyboardInfo: abstract new (...args: any[]) => IInjectedInputKeyboardInfo;
+
+  interface IInjectedInputMouseInfo {
+    DeltaX: number;
+    DeltaY: number;
+    MouseData: number;
+    MouseOptions: number;
+    TimeOffsetInMilliseconds: number;
+  }
+  var IInjectedInputMouseInfo: abstract new (...args: any[]) => IInjectedInputMouseInfo;
+
+  interface IInjectedInputPenInfo {
+    PenButtons: number;
+    PenParameters: number;
+    PointerInfo: Windows.UI.Input.Preview.Injection.InjectedInputPointerInfo;
+    Pressure: number;
+    Rotation: number;
+    TiltX: number;
+    TiltY: number;
+  }
+  var IInjectedInputPenInfo: abstract new (...args: any[]) => IInjectedInputPenInfo;
+
+  interface IInjectedInputTouchInfo {
+    Contact: Windows.UI.Input.Preview.Injection.InjectedInputRectangle;
+    Orientation: number;
+    PointerInfo: Windows.UI.Input.Preview.Injection.InjectedInputPointerInfo;
+    Pressure: number;
+    TouchParameters: number;
+  }
+  var IInjectedInputTouchInfo: abstract new (...args: any[]) => IInjectedInputTouchInfo;
+
+  interface IInputInjector {
+    InitializePenInjection(visualMode: number): void;
+    InitializeTouchInjection(visualMode: number): void;
+    InjectKeyboardInput(input: Windows.Foundation.Collections.IIterable<Windows.UI.Input.Preview.Injection.InjectedInputKeyboardInfo> | Windows.UI.Input.Preview.Injection.InjectedInputKeyboardInfo[]): void;
+    InjectMouseInput(input: Windows.Foundation.Collections.IIterable<Windows.UI.Input.Preview.Injection.InjectedInputMouseInfo> | Windows.UI.Input.Preview.Injection.InjectedInputMouseInfo[]): void;
+    InjectPenInput(input: Windows.UI.Input.Preview.Injection.InjectedInputPenInfo): void;
+    InjectShortcut(shortcut: number): void;
+    InjectTouchInput(input: Windows.Foundation.Collections.IIterable<Windows.UI.Input.Preview.Injection.InjectedInputTouchInfo> | Windows.UI.Input.Preview.Injection.InjectedInputTouchInfo[]): void;
+    UninitializePenInjection(): void;
+    UninitializeTouchInjection(): void;
+  }
+  var IInputInjector: abstract new (...args: any[]) => IInputInjector;
+
+  interface IInputInjector2 extends Windows.UI.Input.Preview.Injection.IInputInjector {
+    InitializeGamepadInjection(): void;
+    InitializePenInjection(visualMode: number): void;
+    InitializeTouchInjection(visualMode: number): void;
+    InjectGamepadInput(input: Windows.UI.Input.Preview.Injection.InjectedInputGamepadInfo): void;
+    InjectKeyboardInput(input: Windows.Foundation.Collections.IIterable<Windows.UI.Input.Preview.Injection.InjectedInputKeyboardInfo> | Windows.UI.Input.Preview.Injection.InjectedInputKeyboardInfo[]): void;
+    InjectMouseInput(input: Windows.Foundation.Collections.IIterable<Windows.UI.Input.Preview.Injection.InjectedInputMouseInfo> | Windows.UI.Input.Preview.Injection.InjectedInputMouseInfo[]): void;
+    InjectPenInput(input: Windows.UI.Input.Preview.Injection.InjectedInputPenInfo): void;
+    InjectShortcut(shortcut: number): void;
+    InjectTouchInput(input: Windows.Foundation.Collections.IIterable<Windows.UI.Input.Preview.Injection.InjectedInputTouchInfo> | Windows.UI.Input.Preview.Injection.InjectedInputTouchInfo[]): void;
+    UninitializeGamepadInjection(): void;
+    UninitializePenInjection(): void;
+    UninitializeTouchInjection(): void;
+  }
+  var IInputInjector2: abstract new (...args: any[]) => IInputInjector2;
+
+  interface IInputInjectorStatics {
+    TryCreate(): Windows.UI.Input.Preview.Injection.InputInjector;
+  }
+  var IInputInjectorStatics: abstract new (...args: any[]) => IInputInjectorStatics;
+
+  interface IInputInjectorStatics2 extends Windows.UI.Input.Preview.Injection.IInputInjectorStatics {
+    TryCreate(): Windows.UI.Input.Preview.Injection.InputInjector;
+    TryCreateForAppBroadcastOnly(): Windows.UI.Input.Preview.Injection.InputInjector;
+  }
+  var IInputInjectorStatics2: abstract new (...args: any[]) => IInputInjectorStatics2;
+
+  interface InjectedInputPoint {
+    PositionX: number;
+    PositionY: number;
+  }
+  var InjectedInputPoint: {
+    new(positionX: number, positionY: number): InjectedInputPoint;
+    new(fields: { PositionX?: number; PositionY?: number }): InjectedInputPoint;
+  };
+
+  interface InjectedInputPointerInfo {
+    PointerId: number;
+    PointerOptions: number;
+    PixelLocation: Windows.UI.Input.Preview.Injection.InjectedInputPoint;
+    TimeOffsetInMilliseconds: number;
+    PerformanceCount: number | bigint;
+  }
+  var InjectedInputPointerInfo: {
+    new(pointerId: number, pointerOptions: number, pixelLocation: Windows.UI.Input.Preview.Injection.InjectedInputPoint, timeOffsetInMilliseconds: number, performanceCount: number | bigint): InjectedInputPointerInfo;
+    new(fields: { PointerId?: number; PointerOptions?: number; PixelLocation?: Windows.UI.Input.Preview.Injection.InjectedInputPoint; TimeOffsetInMilliseconds?: number; PerformanceCount?: number | bigint }): InjectedInputPointerInfo;
+  };
+
+  interface InjectedInputRectangle {
+    Left: number;
+    Top: number;
+    Bottom: number;
+    Right: number;
+  }
+  var InjectedInputRectangle: {
+    new(left: number, top: number, bottom: number, right: number): InjectedInputRectangle;
+    new(fields: { Left?: number; Top?: number; Bottom?: number; Right?: number }): InjectedInputRectangle;
+  };
+
+}
+
+declare namespace Windows.UI.Input.Spatial {
+  class SpatialGestureRecognizer implements Windows.UI.Input.Spatial.ISpatialGestureRecognizer {
+    constructor(settings: number);
+    CancelPendingGestures(): void;
+    CaptureInteraction(interaction: Windows.UI.Input.Spatial.SpatialInteraction): void;
+    TrySetGestureSettings(settings: number): boolean;
+    readonly GestureSettings: number;
+    HoldCanceled: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialHoldCanceledEventArgs> | null;
+    HoldCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialHoldCompletedEventArgs> | null;
+    HoldStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialHoldStartedEventArgs> | null;
+    ManipulationCanceled: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialManipulationCanceledEventArgs> | null;
+    ManipulationCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialManipulationCompletedEventArgs> | null;
+    ManipulationStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialManipulationStartedEventArgs> | null;
+    ManipulationUpdated: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialManipulationUpdatedEventArgs> | null;
+    NavigationCanceled: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialNavigationCanceledEventArgs> | null;
+    NavigationCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialNavigationCompletedEventArgs> | null;
+    NavigationStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialNavigationStartedEventArgs> | null;
+    NavigationUpdated: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialNavigationUpdatedEventArgs> | null;
+    RecognitionEnded: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialRecognitionEndedEventArgs> | null;
+    RecognitionStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialRecognitionStartedEventArgs> | null;
+    Tapped: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialTappedEventArgs> | null;
+  }
+
+  class SpatialHoldCanceledEventArgs implements Windows.UI.Input.Spatial.ISpatialHoldCanceledEventArgs {
+    readonly InteractionSourceKind: number;
+  }
+
+  class SpatialHoldCompletedEventArgs implements Windows.UI.Input.Spatial.ISpatialHoldCompletedEventArgs {
+    readonly InteractionSourceKind: number;
+  }
+
+  class SpatialHoldStartedEventArgs implements Windows.UI.Input.Spatial.ISpatialHoldStartedEventArgs {
+    TryGetPointerPose(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialPointerPose;
+    readonly InteractionSourceKind: number;
+  }
+
+  class SpatialInteraction implements Windows.UI.Input.Spatial.ISpatialInteraction {
+    readonly SourceState: Windows.UI.Input.Spatial.SpatialInteractionSourceState;
+  }
+
+  class SpatialInteractionController implements Windows.UI.Input.Spatial.ISpatialInteractionController, Windows.UI.Input.Spatial.ISpatialInteractionController2, Windows.UI.Input.Spatial.ISpatialInteractionController3 {
+    TryGetBatteryReport(): Windows.Devices.Power.BatteryReport;
+    TryGetRenderableModelAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamWithContentType>;
+    readonly HasThumbstick: boolean;
+    readonly HasTouchpad: boolean;
+    readonly ProductId: number;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+    readonly VendorId: number;
+    readonly Version: number;
+  }
+
+  class SpatialInteractionControllerProperties implements Windows.UI.Input.Spatial.ISpatialInteractionControllerProperties {
+    readonly IsThumbstickPressed: boolean;
+    readonly IsTouchpadPressed: boolean;
+    readonly IsTouchpadTouched: boolean;
+    readonly ThumbstickX: number;
+    readonly ThumbstickY: number;
+    readonly TouchpadX: number;
+    readonly TouchpadY: number;
+  }
+
+  class SpatialInteractionDetectedEventArgs implements Windows.UI.Input.Spatial.ISpatialInteractionDetectedEventArgs, Windows.UI.Input.Spatial.ISpatialInteractionDetectedEventArgs2 {
+    TryGetPointerPose(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialPointerPose;
+    readonly Interaction: Windows.UI.Input.Spatial.SpatialInteraction;
+    readonly InteractionSource: Windows.UI.Input.Spatial.SpatialInteractionSource;
+    readonly InteractionSourceKind: number;
+  }
+
+  class SpatialInteractionManager implements Windows.UI.Input.Spatial.ISpatialInteractionManager {
+    GetDetectedSourcesAtTimestamp(timeStamp: Windows.Perception.PerceptionTimestamp): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Spatial.SpatialInteractionSourceState> | Windows.UI.Input.Spatial.SpatialInteractionSourceState[];
+    static GetForCurrentView(): Windows.UI.Input.Spatial.SpatialInteractionManager;
+    static IsSourceKindSupported(kind: number): boolean;
+    InteractionDetected: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialInteractionManager, Windows.UI.Input.Spatial.SpatialInteractionDetectedEventArgs> | null;
+    SourceDetected: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialInteractionManager, Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs> | null;
+    SourceLost: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialInteractionManager, Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs> | null;
+    SourcePressed: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialInteractionManager, Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs> | null;
+    SourceReleased: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialInteractionManager, Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs> | null;
+    SourceUpdated: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialInteractionManager, Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs> | null;
+  }
+
+  class SpatialInteractionSource implements Windows.UI.Input.Spatial.ISpatialInteractionSource, Windows.UI.Input.Spatial.ISpatialInteractionSource2, Windows.UI.Input.Spatial.ISpatialInteractionSource3, Windows.UI.Input.Spatial.ISpatialInteractionSource4 {
+    TryCreateHandMeshObserver(): Windows.Perception.People.HandMeshObserver;
+    TryCreateHandMeshObserverAsync(): Windows.Foundation.IAsyncOperation<Windows.Perception.People.HandMeshObserver>;
+    TryGetStateAtTimestamp(timestamp: Windows.Perception.PerceptionTimestamp): Windows.UI.Input.Spatial.SpatialInteractionSourceState;
+    readonly Controller: Windows.UI.Input.Spatial.SpatialInteractionController;
+    readonly Handedness: number;
+    readonly Id: number;
+    readonly IsGraspSupported: boolean;
+    readonly IsMenuSupported: boolean;
+    readonly IsPointingSupported: boolean;
+    readonly Kind: number;
+  }
+
+  class SpatialInteractionSourceEventArgs implements Windows.UI.Input.Spatial.ISpatialInteractionSourceEventArgs, Windows.UI.Input.Spatial.ISpatialInteractionSourceEventArgs2 {
+    readonly PressKind: number;
+    readonly State: Windows.UI.Input.Spatial.SpatialInteractionSourceState;
+  }
+
+  class SpatialInteractionSourceLocation implements Windows.UI.Input.Spatial.ISpatialInteractionSourceLocation, Windows.UI.Input.Spatial.ISpatialInteractionSourceLocation2, Windows.UI.Input.Spatial.ISpatialInteractionSourceLocation3 {
+    readonly AngularVelocity: Windows.Foundation.Numerics.Vector3 | null;
+    readonly Orientation: Windows.Foundation.Numerics.Quaternion | null;
+    readonly Position: Windows.Foundation.Numerics.Vector3 | null;
+    readonly PositionAccuracy: number;
+    readonly SourcePointerPose: Windows.UI.Input.Spatial.SpatialPointerInteractionSourcePose;
+    readonly Velocity: Windows.Foundation.Numerics.Vector3 | null;
+  }
+
+  class SpatialInteractionSourceProperties implements Windows.UI.Input.Spatial.ISpatialInteractionSourceProperties {
+    TryGetLocation(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialInteractionSourceLocation;
+    TryGetSourceLossMitigationDirection(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Foundation.Numerics.Vector3 | null;
+    readonly SourceLossRisk: number;
+  }
+
+  class SpatialInteractionSourceState implements Windows.UI.Input.Spatial.ISpatialInteractionSourceState, Windows.UI.Input.Spatial.ISpatialInteractionSourceState2, Windows.UI.Input.Spatial.ISpatialInteractionSourceState3 {
+    TryGetHandPose(): Windows.Perception.People.HandPose;
+    TryGetPointerPose(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialPointerPose;
+    readonly ControllerProperties: Windows.UI.Input.Spatial.SpatialInteractionControllerProperties;
+    readonly IsGrasped: boolean;
+    readonly IsMenuPressed: boolean;
+    readonly IsPressed: boolean;
+    readonly IsSelectPressed: boolean;
+    readonly Properties: Windows.UI.Input.Spatial.SpatialInteractionSourceProperties;
+    readonly SelectPressedValue: number;
+    readonly Source: Windows.UI.Input.Spatial.SpatialInteractionSource;
+    readonly Timestamp: Windows.Perception.PerceptionTimestamp;
+  }
+
+  class SpatialManipulationCanceledEventArgs implements Windows.UI.Input.Spatial.ISpatialManipulationCanceledEventArgs {
+    readonly InteractionSourceKind: number;
+  }
+
+  class SpatialManipulationCompletedEventArgs implements Windows.UI.Input.Spatial.ISpatialManipulationCompletedEventArgs {
+    TryGetCumulativeDelta(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialManipulationDelta;
+    readonly InteractionSourceKind: number;
+  }
+
+  class SpatialManipulationDelta implements Windows.UI.Input.Spatial.ISpatialManipulationDelta {
+    readonly Translation: Windows.Foundation.Numerics.Vector3;
+  }
+
+  class SpatialManipulationStartedEventArgs implements Windows.UI.Input.Spatial.ISpatialManipulationStartedEventArgs {
+    TryGetPointerPose(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialPointerPose;
+    readonly InteractionSourceKind: number;
+  }
+
+  class SpatialManipulationUpdatedEventArgs implements Windows.UI.Input.Spatial.ISpatialManipulationUpdatedEventArgs {
+    TryGetCumulativeDelta(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialManipulationDelta;
+    readonly InteractionSourceKind: number;
+  }
+
+  class SpatialNavigationCanceledEventArgs implements Windows.UI.Input.Spatial.ISpatialNavigationCanceledEventArgs {
+    readonly InteractionSourceKind: number;
+  }
+
+  class SpatialNavigationCompletedEventArgs implements Windows.UI.Input.Spatial.ISpatialNavigationCompletedEventArgs {
+    readonly InteractionSourceKind: number;
+    readonly NormalizedOffset: Windows.Foundation.Numerics.Vector3;
+  }
+
+  class SpatialNavigationStartedEventArgs implements Windows.UI.Input.Spatial.ISpatialNavigationStartedEventArgs {
+    TryGetPointerPose(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialPointerPose;
+    readonly InteractionSourceKind: number;
+    readonly IsNavigatingX: boolean;
+    readonly IsNavigatingY: boolean;
+    readonly IsNavigatingZ: boolean;
+  }
+
+  class SpatialNavigationUpdatedEventArgs implements Windows.UI.Input.Spatial.ISpatialNavigationUpdatedEventArgs {
+    readonly InteractionSourceKind: number;
+    readonly NormalizedOffset: Windows.Foundation.Numerics.Vector3;
+  }
+
+  class SpatialPointerInteractionSourcePose implements Windows.UI.Input.Spatial.ISpatialPointerInteractionSourcePose, Windows.UI.Input.Spatial.ISpatialPointerInteractionSourcePose2 {
+    readonly ForwardDirection: Windows.Foundation.Numerics.Vector3;
+    readonly Orientation: Windows.Foundation.Numerics.Quaternion;
+    readonly Position: Windows.Foundation.Numerics.Vector3;
+    readonly PositionAccuracy: number;
+    readonly UpDirection: Windows.Foundation.Numerics.Vector3;
+  }
+
+  class SpatialPointerPose implements Windows.UI.Input.Spatial.ISpatialPointerPose, Windows.UI.Input.Spatial.ISpatialPointerPose2, Windows.UI.Input.Spatial.ISpatialPointerPose3 {
+    static TryGetAtTimestamp(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, timestamp: Windows.Perception.PerceptionTimestamp): Windows.UI.Input.Spatial.SpatialPointerPose;
+    TryGetInteractionSourcePose(source: Windows.UI.Input.Spatial.SpatialInteractionSource): Windows.UI.Input.Spatial.SpatialPointerInteractionSourcePose;
+    readonly Eyes: Windows.Perception.People.EyesPose;
+    readonly Head: Windows.Perception.People.HeadPose;
+    readonly IsHeadCapturedBySystem: boolean;
+    readonly Timestamp: Windows.Perception.PerceptionTimestamp;
+  }
+
+  class SpatialRecognitionEndedEventArgs implements Windows.UI.Input.Spatial.ISpatialRecognitionEndedEventArgs {
+    readonly InteractionSourceKind: number;
+  }
+
+  class SpatialRecognitionStartedEventArgs implements Windows.UI.Input.Spatial.ISpatialRecognitionStartedEventArgs {
+    IsGesturePossible(gesture: number): boolean;
+    TryGetPointerPose(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialPointerPose;
+    readonly InteractionSourceKind: number;
+  }
+
+  class SpatialTappedEventArgs implements Windows.UI.Input.Spatial.ISpatialTappedEventArgs {
+    TryGetPointerPose(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialPointerPose;
+    readonly InteractionSourceKind: number;
+    readonly TapCount: number;
+  }
+
+  enum SpatialGestureSettings {
+    None = 0,
+    Tap = 1,
+    DoubleTap = 2,
+    Hold = 4,
+    ManipulationTranslate = 8,
+    NavigationX = 16,
+    NavigationY = 32,
+    NavigationZ = 64,
+    NavigationRailsX = 128,
+    NavigationRailsY = 256,
+    NavigationRailsZ = 512,
+  }
+
+  enum SpatialInteractionPressKind {
+    None = 0,
+    Select = 1,
+    Menu = 2,
+    Grasp = 3,
+    Touchpad = 4,
+    Thumbstick = 5,
+  }
+
+  enum SpatialInteractionSourceHandedness {
+    Unspecified = 0,
+    Left = 1,
+    Right = 2,
+  }
+
+  enum SpatialInteractionSourceKind {
+    Other = 0,
+    Hand = 1,
+    Voice = 2,
+    Controller = 3,
+  }
+
+  enum SpatialInteractionSourcePositionAccuracy {
+    High = 0,
+    Approximate = 1,
+  }
+
+  interface ISpatialGestureRecognizer {
+    CancelPendingGestures(): void;
+    CaptureInteraction(interaction: Windows.UI.Input.Spatial.SpatialInteraction): void;
+    TrySetGestureSettings(settings: number): boolean;
+    readonly GestureSettings: number;
+    HoldCanceled: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialHoldCanceledEventArgs> | null;
+    HoldCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialHoldCompletedEventArgs> | null;
+    HoldStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialHoldStartedEventArgs> | null;
+    ManipulationCanceled: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialManipulationCanceledEventArgs> | null;
+    ManipulationCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialManipulationCompletedEventArgs> | null;
+    ManipulationStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialManipulationStartedEventArgs> | null;
+    ManipulationUpdated: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialManipulationUpdatedEventArgs> | null;
+    NavigationCanceled: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialNavigationCanceledEventArgs> | null;
+    NavigationCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialNavigationCompletedEventArgs> | null;
+    NavigationStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialNavigationStartedEventArgs> | null;
+    NavigationUpdated: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialNavigationUpdatedEventArgs> | null;
+    RecognitionEnded: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialRecognitionEndedEventArgs> | null;
+    RecognitionStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialRecognitionStartedEventArgs> | null;
+    Tapped: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialGestureRecognizer, Windows.UI.Input.Spatial.SpatialTappedEventArgs> | null;
+  }
+  var ISpatialGestureRecognizer: abstract new (...args: any[]) => ISpatialGestureRecognizer;
+
+  interface ISpatialGestureRecognizerFactory {
+    Create(settings: number): Windows.UI.Input.Spatial.SpatialGestureRecognizer;
+  }
+  var ISpatialGestureRecognizerFactory: abstract new (...args: any[]) => ISpatialGestureRecognizerFactory;
+
+  interface ISpatialHoldCanceledEventArgs {
+    readonly InteractionSourceKind: number;
+  }
+  var ISpatialHoldCanceledEventArgs: abstract new (...args: any[]) => ISpatialHoldCanceledEventArgs;
+
+  interface ISpatialHoldCompletedEventArgs {
+    readonly InteractionSourceKind: number;
+  }
+  var ISpatialHoldCompletedEventArgs: abstract new (...args: any[]) => ISpatialHoldCompletedEventArgs;
+
+  interface ISpatialHoldStartedEventArgs {
+    TryGetPointerPose(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialPointerPose;
+    readonly InteractionSourceKind: number;
+  }
+  var ISpatialHoldStartedEventArgs: abstract new (...args: any[]) => ISpatialHoldStartedEventArgs;
+
+  interface ISpatialInteraction {
+    readonly SourceState: Windows.UI.Input.Spatial.SpatialInteractionSourceState;
+  }
+  var ISpatialInteraction: abstract new (...args: any[]) => ISpatialInteraction;
+
+  interface ISpatialInteractionController {
+    readonly HasThumbstick: boolean;
+    readonly HasTouchpad: boolean;
+    readonly ProductId: number;
+    readonly SimpleHapticsController: Windows.Devices.Haptics.SimpleHapticsController;
+    readonly VendorId: number;
+    readonly Version: number;
+  }
+  var ISpatialInteractionController: abstract new (...args: any[]) => ISpatialInteractionController;
+
+  interface ISpatialInteractionController2 extends Windows.UI.Input.Spatial.ISpatialInteractionController {
+    TryGetRenderableModelAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamWithContentType>;
+  }
+  var ISpatialInteractionController2: abstract new (...args: any[]) => ISpatialInteractionController2;
+
+  interface ISpatialInteractionController3 extends Windows.UI.Input.Spatial.ISpatialInteractionController, Windows.UI.Input.Spatial.ISpatialInteractionController2 {
+    TryGetBatteryReport(): Windows.Devices.Power.BatteryReport;
+    TryGetRenderableModelAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStreamWithContentType>;
+  }
+  var ISpatialInteractionController3: abstract new (...args: any[]) => ISpatialInteractionController3;
+
+  interface ISpatialInteractionControllerProperties {
+    readonly IsThumbstickPressed: boolean;
+    readonly IsTouchpadPressed: boolean;
+    readonly IsTouchpadTouched: boolean;
+    readonly ThumbstickX: number;
+    readonly ThumbstickY: number;
+    readonly TouchpadX: number;
+    readonly TouchpadY: number;
+  }
+  var ISpatialInteractionControllerProperties: abstract new (...args: any[]) => ISpatialInteractionControllerProperties;
+
+  interface ISpatialInteractionDetectedEventArgs {
+    TryGetPointerPose(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialPointerPose;
+    readonly Interaction: Windows.UI.Input.Spatial.SpatialInteraction;
+    readonly InteractionSourceKind: number;
+  }
+  var ISpatialInteractionDetectedEventArgs: abstract new (...args: any[]) => ISpatialInteractionDetectedEventArgs;
+
+  interface ISpatialInteractionDetectedEventArgs2 extends Windows.UI.Input.Spatial.ISpatialInteractionDetectedEventArgs {
+    TryGetPointerPose(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialPointerPose;
+    readonly InteractionSource: Windows.UI.Input.Spatial.SpatialInteractionSource;
+  }
+  var ISpatialInteractionDetectedEventArgs2: abstract new (...args: any[]) => ISpatialInteractionDetectedEventArgs2;
+
+  interface ISpatialInteractionManager {
+    GetDetectedSourcesAtTimestamp(timeStamp: Windows.Perception.PerceptionTimestamp): Windows.Foundation.Collections.IVectorView<Windows.UI.Input.Spatial.SpatialInteractionSourceState> | Windows.UI.Input.Spatial.SpatialInteractionSourceState[];
+    InteractionDetected: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialInteractionManager, Windows.UI.Input.Spatial.SpatialInteractionDetectedEventArgs> | null;
+    SourceDetected: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialInteractionManager, Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs> | null;
+    SourceLost: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialInteractionManager, Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs> | null;
+    SourcePressed: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialInteractionManager, Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs> | null;
+    SourceReleased: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialInteractionManager, Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs> | null;
+    SourceUpdated: Windows.Foundation.TypedEventHandler<Windows.UI.Input.Spatial.SpatialInteractionManager, Windows.UI.Input.Spatial.SpatialInteractionSourceEventArgs> | null;
+  }
+  var ISpatialInteractionManager: abstract new (...args: any[]) => ISpatialInteractionManager;
+
+  interface ISpatialInteractionManagerStatics {
+    GetForCurrentView(): Windows.UI.Input.Spatial.SpatialInteractionManager;
+  }
+  var ISpatialInteractionManagerStatics: abstract new (...args: any[]) => ISpatialInteractionManagerStatics;
+
+  interface ISpatialInteractionManagerStatics2 {
+    IsSourceKindSupported(kind: number): boolean;
+  }
+  var ISpatialInteractionManagerStatics2: abstract new (...args: any[]) => ISpatialInteractionManagerStatics2;
+
+  interface ISpatialInteractionSource {
+    readonly Id: number;
+    readonly Kind: number;
+  }
+  var ISpatialInteractionSource: abstract new (...args: any[]) => ISpatialInteractionSource;
+
+  interface ISpatialInteractionSource2 extends Windows.UI.Input.Spatial.ISpatialInteractionSource {
+    TryGetStateAtTimestamp(timestamp: Windows.Perception.PerceptionTimestamp): Windows.UI.Input.Spatial.SpatialInteractionSourceState;
+    readonly Controller: Windows.UI.Input.Spatial.SpatialInteractionController;
+    readonly IsGraspSupported: boolean;
+    readonly IsMenuSupported: boolean;
+    readonly IsPointingSupported: boolean;
+  }
+  var ISpatialInteractionSource2: abstract new (...args: any[]) => ISpatialInteractionSource2;
+
+  interface ISpatialInteractionSource3 extends Windows.UI.Input.Spatial.ISpatialInteractionSource, Windows.UI.Input.Spatial.ISpatialInteractionSource2 {
+    TryGetStateAtTimestamp(timestamp: Windows.Perception.PerceptionTimestamp): Windows.UI.Input.Spatial.SpatialInteractionSourceState;
+    readonly Handedness: number;
+  }
+  var ISpatialInteractionSource3: abstract new (...args: any[]) => ISpatialInteractionSource3;
+
+  interface ISpatialInteractionSource4 {
+    TryCreateHandMeshObserver(): Windows.Perception.People.HandMeshObserver;
+    TryCreateHandMeshObserverAsync(): Windows.Foundation.IAsyncOperation<Windows.Perception.People.HandMeshObserver>;
+  }
+  var ISpatialInteractionSource4: abstract new (...args: any[]) => ISpatialInteractionSource4;
+
+  interface ISpatialInteractionSourceEventArgs {
+    readonly State: Windows.UI.Input.Spatial.SpatialInteractionSourceState;
+  }
+  var ISpatialInteractionSourceEventArgs: abstract new (...args: any[]) => ISpatialInteractionSourceEventArgs;
+
+  interface ISpatialInteractionSourceEventArgs2 extends Windows.UI.Input.Spatial.ISpatialInteractionSourceEventArgs {
+    readonly PressKind: number;
+  }
+  var ISpatialInteractionSourceEventArgs2: abstract new (...args: any[]) => ISpatialInteractionSourceEventArgs2;
+
+  interface ISpatialInteractionSourceLocation {
+    readonly Position: Windows.Foundation.Numerics.Vector3 | null;
+    readonly Velocity: Windows.Foundation.Numerics.Vector3 | null;
+  }
+  var ISpatialInteractionSourceLocation: abstract new (...args: any[]) => ISpatialInteractionSourceLocation;
+
+  interface ISpatialInteractionSourceLocation2 {
+    readonly Orientation: Windows.Foundation.Numerics.Quaternion | null;
+  }
+  var ISpatialInteractionSourceLocation2: abstract new (...args: any[]) => ISpatialInteractionSourceLocation2;
+
+  interface ISpatialInteractionSourceLocation3 extends Windows.UI.Input.Spatial.ISpatialInteractionSourceLocation2 {
+    readonly AngularVelocity: Windows.Foundation.Numerics.Vector3 | null;
+    readonly PositionAccuracy: number;
+    readonly SourcePointerPose: Windows.UI.Input.Spatial.SpatialPointerInteractionSourcePose;
+  }
+  var ISpatialInteractionSourceLocation3: abstract new (...args: any[]) => ISpatialInteractionSourceLocation3;
+
+  interface ISpatialInteractionSourceProperties {
+    TryGetLocation(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialInteractionSourceLocation;
+    TryGetSourceLossMitigationDirection(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.Foundation.Numerics.Vector3 | null;
+    readonly SourceLossRisk: number;
+  }
+  var ISpatialInteractionSourceProperties: abstract new (...args: any[]) => ISpatialInteractionSourceProperties;
+
+  interface ISpatialInteractionSourceState {
+    TryGetPointerPose(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialPointerPose;
+    readonly IsPressed: boolean;
+    readonly Properties: Windows.UI.Input.Spatial.SpatialInteractionSourceProperties;
+    readonly Source: Windows.UI.Input.Spatial.SpatialInteractionSource;
+    readonly Timestamp: Windows.Perception.PerceptionTimestamp;
+  }
+  var ISpatialInteractionSourceState: abstract new (...args: any[]) => ISpatialInteractionSourceState;
+
+  interface ISpatialInteractionSourceState2 extends Windows.UI.Input.Spatial.ISpatialInteractionSourceState {
+    TryGetPointerPose(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialPointerPose;
+    readonly ControllerProperties: Windows.UI.Input.Spatial.SpatialInteractionControllerProperties;
+    readonly IsGrasped: boolean;
+    readonly IsMenuPressed: boolean;
+    readonly IsSelectPressed: boolean;
+    readonly SelectPressedValue: number;
+  }
+  var ISpatialInteractionSourceState2: abstract new (...args: any[]) => ISpatialInteractionSourceState2;
+
+  interface ISpatialInteractionSourceState3 extends Windows.UI.Input.Spatial.ISpatialInteractionSourceState, Windows.UI.Input.Spatial.ISpatialInteractionSourceState2 {
+    TryGetHandPose(): Windows.Perception.People.HandPose;
+    TryGetPointerPose(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialPointerPose;
+  }
+  var ISpatialInteractionSourceState3: abstract new (...args: any[]) => ISpatialInteractionSourceState3;
+
+  interface ISpatialManipulationCanceledEventArgs {
+    readonly InteractionSourceKind: number;
+  }
+  var ISpatialManipulationCanceledEventArgs: abstract new (...args: any[]) => ISpatialManipulationCanceledEventArgs;
+
+  interface ISpatialManipulationCompletedEventArgs {
+    TryGetCumulativeDelta(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialManipulationDelta;
+    readonly InteractionSourceKind: number;
+  }
+  var ISpatialManipulationCompletedEventArgs: abstract new (...args: any[]) => ISpatialManipulationCompletedEventArgs;
+
+  interface ISpatialManipulationDelta {
+    readonly Translation: Windows.Foundation.Numerics.Vector3;
+  }
+  var ISpatialManipulationDelta: abstract new (...args: any[]) => ISpatialManipulationDelta;
+
+  interface ISpatialManipulationStartedEventArgs {
+    TryGetPointerPose(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialPointerPose;
+    readonly InteractionSourceKind: number;
+  }
+  var ISpatialManipulationStartedEventArgs: abstract new (...args: any[]) => ISpatialManipulationStartedEventArgs;
+
+  interface ISpatialManipulationUpdatedEventArgs {
+    TryGetCumulativeDelta(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialManipulationDelta;
+    readonly InteractionSourceKind: number;
+  }
+  var ISpatialManipulationUpdatedEventArgs: abstract new (...args: any[]) => ISpatialManipulationUpdatedEventArgs;
+
+  interface ISpatialNavigationCanceledEventArgs {
+    readonly InteractionSourceKind: number;
+  }
+  var ISpatialNavigationCanceledEventArgs: abstract new (...args: any[]) => ISpatialNavigationCanceledEventArgs;
+
+  interface ISpatialNavigationCompletedEventArgs {
+    readonly InteractionSourceKind: number;
+    readonly NormalizedOffset: Windows.Foundation.Numerics.Vector3;
+  }
+  var ISpatialNavigationCompletedEventArgs: abstract new (...args: any[]) => ISpatialNavigationCompletedEventArgs;
+
+  interface ISpatialNavigationStartedEventArgs {
+    TryGetPointerPose(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialPointerPose;
+    readonly InteractionSourceKind: number;
+    readonly IsNavigatingX: boolean;
+    readonly IsNavigatingY: boolean;
+    readonly IsNavigatingZ: boolean;
+  }
+  var ISpatialNavigationStartedEventArgs: abstract new (...args: any[]) => ISpatialNavigationStartedEventArgs;
+
+  interface ISpatialNavigationUpdatedEventArgs {
+    readonly InteractionSourceKind: number;
+    readonly NormalizedOffset: Windows.Foundation.Numerics.Vector3;
+  }
+  var ISpatialNavigationUpdatedEventArgs: abstract new (...args: any[]) => ISpatialNavigationUpdatedEventArgs;
+
+  interface ISpatialPointerInteractionSourcePose {
+    readonly ForwardDirection: Windows.Foundation.Numerics.Vector3;
+    readonly Position: Windows.Foundation.Numerics.Vector3;
+    readonly UpDirection: Windows.Foundation.Numerics.Vector3;
+  }
+  var ISpatialPointerInteractionSourcePose: abstract new (...args: any[]) => ISpatialPointerInteractionSourcePose;
+
+  interface ISpatialPointerInteractionSourcePose2 extends Windows.UI.Input.Spatial.ISpatialPointerInteractionSourcePose {
+    readonly Orientation: Windows.Foundation.Numerics.Quaternion;
+    readonly PositionAccuracy: number;
+  }
+  var ISpatialPointerInteractionSourcePose2: abstract new (...args: any[]) => ISpatialPointerInteractionSourcePose2;
+
+  interface ISpatialPointerPose {
+    readonly Head: Windows.Perception.People.HeadPose;
+    readonly Timestamp: Windows.Perception.PerceptionTimestamp;
+  }
+  var ISpatialPointerPose: abstract new (...args: any[]) => ISpatialPointerPose;
+
+  interface ISpatialPointerPose2 extends Windows.UI.Input.Spatial.ISpatialPointerPose {
+    TryGetInteractionSourcePose(source: Windows.UI.Input.Spatial.SpatialInteractionSource): Windows.UI.Input.Spatial.SpatialPointerInteractionSourcePose;
+  }
+  var ISpatialPointerPose2: abstract new (...args: any[]) => ISpatialPointerPose2;
+
+  interface ISpatialPointerPose3 {
+    readonly Eyes: Windows.Perception.People.EyesPose;
+    readonly IsHeadCapturedBySystem: boolean;
+  }
+  var ISpatialPointerPose3: abstract new (...args: any[]) => ISpatialPointerPose3;
+
+  interface ISpatialPointerPoseStatics {
+    TryGetAtTimestamp(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem, timestamp: Windows.Perception.PerceptionTimestamp): Windows.UI.Input.Spatial.SpatialPointerPose;
+  }
+  var ISpatialPointerPoseStatics: abstract new (...args: any[]) => ISpatialPointerPoseStatics;
+
+  interface ISpatialRecognitionEndedEventArgs {
+    readonly InteractionSourceKind: number;
+  }
+  var ISpatialRecognitionEndedEventArgs: abstract new (...args: any[]) => ISpatialRecognitionEndedEventArgs;
+
+  interface ISpatialRecognitionStartedEventArgs {
+    IsGesturePossible(gesture: number): boolean;
+    TryGetPointerPose(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialPointerPose;
+    readonly InteractionSourceKind: number;
+  }
+  var ISpatialRecognitionStartedEventArgs: abstract new (...args: any[]) => ISpatialRecognitionStartedEventArgs;
+
+  interface ISpatialTappedEventArgs {
+    TryGetPointerPose(coordinateSystem: Windows.Perception.Spatial.SpatialCoordinateSystem): Windows.UI.Input.Spatial.SpatialPointerPose;
+    readonly InteractionSourceKind: number;
+    readonly TapCount: number;
+  }
+  var ISpatialTappedEventArgs: abstract new (...args: any[]) => ISpatialTappedEventArgs;
+
+}
+
+declare namespace Windows.UI.Notifications {
+  class AdaptiveNotificationText implements Windows.UI.Notifications.IAdaptiveNotificationContent, Windows.UI.Notifications.IAdaptiveNotificationText {
+    constructor();
+    readonly Hints: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    readonly Kind: number;
+    Language: string;
+    Text: string;
+  }
+
+  class BadgeNotification implements Windows.UI.Notifications.IBadgeNotification {
+    constructor(content: Windows.Data.Xml.Dom.XmlDocument);
+    readonly Content: Windows.Data.Xml.Dom.XmlDocument;
+    ExpirationTime: Windows.Foundation.DateTime | null;
+  }
+
+  class BadgeUpdateManager {
+    static CreateBadgeUpdaterForApplication(): Windows.UI.Notifications.BadgeUpdater;
+    static CreateBadgeUpdaterForApplication(applicationId: string): Windows.UI.Notifications.BadgeUpdater;
+    static CreateBadgeUpdaterForSecondaryTile(tileId: string): Windows.UI.Notifications.BadgeUpdater;
+    static GetForUser(user: Windows.System.User): Windows.UI.Notifications.BadgeUpdateManagerForUser;
+    static GetTemplateContent(type: number): Windows.Data.Xml.Dom.XmlDocument;
+  }
+
+  class BadgeUpdateManagerForUser implements Windows.UI.Notifications.IBadgeUpdateManagerForUser {
+    CreateBadgeUpdaterForApplication(): Windows.UI.Notifications.BadgeUpdater;
+    CreateBadgeUpdaterForApplication(applicationId: string): Windows.UI.Notifications.BadgeUpdater;
+    CreateBadgeUpdaterForSecondaryTile(tileId: string): Windows.UI.Notifications.BadgeUpdater;
+    readonly User: Windows.System.User;
+  }
+
+  class BadgeUpdater implements Windows.UI.Notifications.IBadgeUpdater {
+    Clear(): void;
+    StartPeriodicUpdate(badgeContent: Windows.Foundation.Uri, requestedInterval: number): void;
+    StartPeriodicUpdate(badgeContent: Windows.Foundation.Uri, startTime: Windows.Foundation.DateTime, requestedInterval: number): void;
+    StopPeriodicUpdate(): void;
+    Update(notification: Windows.UI.Notifications.BadgeNotification): void;
+  }
+
+  class KnownAdaptiveNotificationHints {
+    static readonly Align: string;
+    static readonly MaxLines: string;
+    static readonly MinLines: string;
+    static readonly Style: string;
+    static readonly TextStacking: string;
+    static readonly Wrap: string;
+  }
+
+  class KnownAdaptiveNotificationTextStyles {
+    static readonly Base: string;
+    static readonly BaseSubtle: string;
+    static readonly Body: string;
+    static readonly BodySubtle: string;
+    static readonly Caption: string;
+    static readonly CaptionSubtle: string;
+    static readonly Header: string;
+    static readonly HeaderNumeral: string;
+    static readonly HeaderNumeralSubtle: string;
+    static readonly HeaderSubtle: string;
+    static readonly Subheader: string;
+    static readonly SubheaderNumeral: string;
+    static readonly SubheaderNumeralSubtle: string;
+    static readonly SubheaderSubtle: string;
+    static readonly Subtitle: string;
+    static readonly SubtitleSubtle: string;
+    static readonly Title: string;
+    static readonly TitleNumeral: string;
+    static readonly TitleSubtle: string;
+  }
+
+  class KnownNotificationBindings {
+    static readonly ToastGeneric: string;
+  }
+
+  class Notification implements Windows.UI.Notifications.INotification {
+    constructor();
+    ExpirationTime: Windows.Foundation.DateTime | null;
+    Visual: Windows.UI.Notifications.NotificationVisual;
+  }
+
+  class NotificationBinding implements Windows.UI.Notifications.INotificationBinding {
+    GetTextElements(): Windows.Foundation.Collections.IVectorView<Windows.UI.Notifications.AdaptiveNotificationText> | Windows.UI.Notifications.AdaptiveNotificationText[];
+    readonly Hints: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    Language: string;
+    Template: string;
+  }
+
+  class NotificationData implements Windows.UI.Notifications.INotificationData {
+    constructor(initialValues: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, string>> | Windows.Foundation.Collections.IKeyValuePair<string, string>[], sequenceNumber: number);
+    constructor(initialValues: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, string>> | Windows.Foundation.Collections.IKeyValuePair<string, string>[]);
+    constructor();
+    SequenceNumber: number;
+    readonly Values: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+  }
+
+  class NotificationVisual implements Windows.UI.Notifications.INotificationVisual {
+    GetBinding(templateName: string): Windows.UI.Notifications.NotificationBinding;
+    readonly Bindings: Windows.Foundation.Collections.IVector<Windows.UI.Notifications.NotificationBinding> | Windows.UI.Notifications.NotificationBinding[];
+    Language: string;
+  }
+
+  class ScheduledTileNotification implements Windows.UI.Notifications.IScheduledTileNotification {
+    constructor(content: Windows.Data.Xml.Dom.XmlDocument, deliveryTime: Windows.Foundation.DateTime);
+    readonly Content: Windows.Data.Xml.Dom.XmlDocument;
+    readonly DeliveryTime: Windows.Foundation.DateTime;
+    ExpirationTime: Windows.Foundation.DateTime | null;
+    Id: string;
+    Tag: string;
+  }
+
+  class ScheduledToastNotification implements Windows.UI.Notifications.IScheduledToastNotification, Windows.UI.Notifications.IScheduledToastNotification2, Windows.UI.Notifications.IScheduledToastNotification3, Windows.UI.Notifications.IScheduledToastNotification4 {
+    constructor(content: Windows.Data.Xml.Dom.XmlDocument, deliveryTime: Windows.Foundation.DateTime);
+    constructor(content: Windows.Data.Xml.Dom.XmlDocument, deliveryTime: Windows.Foundation.DateTime, snoozeInterval: Windows.Foundation.TimeSpan, maximumSnoozeCount: number);
+    readonly Content: Windows.Data.Xml.Dom.XmlDocument;
+    readonly DeliveryTime: Windows.Foundation.DateTime;
+    ExpirationTime: Windows.Foundation.DateTime | null;
+    Group: string;
+    Id: string;
+    readonly MaximumSnoozeCount: number;
+    NotificationMirroring: number;
+    RemoteId: string;
+    readonly SnoozeInterval: Windows.Foundation.TimeSpan | null;
+    SuppressPopup: boolean;
+    Tag: string;
+  }
+
+  class ScheduledToastNotificationShowingEventArgs implements Windows.UI.Notifications.IScheduledToastNotificationShowingEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Cancel: boolean;
+    readonly ScheduledToastNotification: Windows.UI.Notifications.ScheduledToastNotification;
+  }
+
+  class ShownTileNotification implements Windows.UI.Notifications.IShownTileNotification {
+    readonly Arguments: string;
+  }
+
+  class TileFlyoutNotification implements Windows.UI.Notifications.ITileFlyoutNotification {
+    constructor(content: Windows.Data.Xml.Dom.XmlDocument);
+    readonly Content: Windows.Data.Xml.Dom.XmlDocument;
+    ExpirationTime: Windows.Foundation.DateTime | null;
+  }
+
+  class TileFlyoutUpdateManager {
+    static CreateTileFlyoutUpdaterForApplication(): Windows.UI.Notifications.TileFlyoutUpdater;
+    static CreateTileFlyoutUpdaterForApplication(applicationId: string): Windows.UI.Notifications.TileFlyoutUpdater;
+    static CreateTileFlyoutUpdaterForSecondaryTile(tileId: string): Windows.UI.Notifications.TileFlyoutUpdater;
+    static GetTemplateContent(type: number): Windows.Data.Xml.Dom.XmlDocument;
+  }
+
+  class TileFlyoutUpdater implements Windows.UI.Notifications.ITileFlyoutUpdater {
+    Clear(): void;
+    StartPeriodicUpdate(tileFlyoutContent: Windows.Foundation.Uri, requestedInterval: number): void;
+    StartPeriodicUpdate(tileFlyoutContent: Windows.Foundation.Uri, startTime: Windows.Foundation.DateTime, requestedInterval: number): void;
+    StopPeriodicUpdate(): void;
+    Update(notification: Windows.UI.Notifications.TileFlyoutNotification): void;
+    readonly Setting: number;
+  }
+
+  class TileNotification implements Windows.UI.Notifications.ITileNotification {
+    constructor(content: Windows.Data.Xml.Dom.XmlDocument);
+    readonly Content: Windows.Data.Xml.Dom.XmlDocument;
+    ExpirationTime: Windows.Foundation.DateTime | null;
+    Tag: string;
+  }
+
+  class TileUpdateManager {
+    static CreateTileUpdaterForApplication(): Windows.UI.Notifications.TileUpdater;
+    static CreateTileUpdaterForApplication(applicationId: string): Windows.UI.Notifications.TileUpdater;
+    static CreateTileUpdaterForSecondaryTile(tileId: string): Windows.UI.Notifications.TileUpdater;
+    static GetForUser(user: Windows.System.User): Windows.UI.Notifications.TileUpdateManagerForUser;
+    static GetTemplateContent(type: number): Windows.Data.Xml.Dom.XmlDocument;
+  }
+
+  class TileUpdateManagerForUser implements Windows.UI.Notifications.ITileUpdateManagerForUser {
+    CreateTileUpdaterForApplication(applicationId: string): Windows.UI.Notifications.TileUpdater;
+    CreateTileUpdaterForApplicationForUser(): Windows.UI.Notifications.TileUpdater;
+    CreateTileUpdaterForSecondaryTile(tileId: string): Windows.UI.Notifications.TileUpdater;
+    readonly User: Windows.System.User;
+  }
+
+  class TileUpdater implements Windows.UI.Notifications.ITileUpdater, Windows.UI.Notifications.ITileUpdater2 {
+    AddToSchedule(scheduledTile: Windows.UI.Notifications.ScheduledTileNotification): void;
+    Clear(): void;
+    EnableNotificationQueue(enable: boolean): void;
+    EnableNotificationQueueForSquare150x150(enable: boolean): void;
+    EnableNotificationQueueForSquare310x310(enable: boolean): void;
+    EnableNotificationQueueForWide310x150(enable: boolean): void;
+    GetScheduledTileNotifications(): Windows.Foundation.Collections.IVectorView<Windows.UI.Notifications.ScheduledTileNotification> | Windows.UI.Notifications.ScheduledTileNotification[];
+    RemoveFromSchedule(scheduledTile: Windows.UI.Notifications.ScheduledTileNotification): void;
+    StartPeriodicUpdate(tileContent: Windows.Foundation.Uri, requestedInterval: number): void;
+    StartPeriodicUpdate(tileContent: Windows.Foundation.Uri, startTime: Windows.Foundation.DateTime, requestedInterval: number): void;
+    StartPeriodicUpdateBatch(tileContents: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], requestedInterval: number): void;
+    StartPeriodicUpdateBatch(tileContents: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], startTime: Windows.Foundation.DateTime, requestedInterval: number): void;
+    StopPeriodicUpdate(): void;
+    Update(notification: Windows.UI.Notifications.TileNotification): void;
+    readonly Setting: number;
+  }
+
+  class ToastActivatedEventArgs implements Windows.UI.Notifications.IToastActivatedEventArgs, Windows.UI.Notifications.IToastActivatedEventArgs2 {
+    readonly Arguments: string;
+    readonly UserInput: Windows.Foundation.Collections.ValueSet;
+  }
+
+  class ToastCollection implements Windows.UI.Notifications.IToastCollection {
+    constructor(collectionId: string, displayName: string, launchArgs: string, iconUri: Windows.Foundation.Uri);
+    DisplayName: string;
+    Icon: Windows.Foundation.Uri;
+    readonly Id: string;
+    LaunchArgs: string;
+  }
+
+  class ToastCollectionManager implements Windows.UI.Notifications.IToastCollectionManager {
+    FindAllToastCollectionsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.UI.Notifications.ToastCollection> | Windows.UI.Notifications.ToastCollection[]>;
+    GetToastCollectionAsync(collectionId: string): Windows.Foundation.IAsyncOperation<Windows.UI.Notifications.ToastCollection>;
+    RemoveAllToastCollectionsAsync(): Windows.Foundation.IAsyncAction;
+    RemoveToastCollectionAsync(collectionId: string): Windows.Foundation.IAsyncAction;
+    SaveToastCollectionAsync(collection: Windows.UI.Notifications.ToastCollection): Windows.Foundation.IAsyncAction;
+    readonly AppId: string;
+    readonly User: Windows.System.User;
+  }
+
+  class ToastDismissedEventArgs implements Windows.UI.Notifications.IToastDismissedEventArgs {
+    readonly Reason: number;
+  }
+
+  class ToastFailedEventArgs implements Windows.UI.Notifications.IToastFailedEventArgs {
+    readonly ErrorCode: Windows.Foundation.HResult;
+  }
+
+  class ToastNotification implements Windows.UI.Notifications.IToastNotification, Windows.UI.Notifications.IToastNotification2, Windows.UI.Notifications.IToastNotification3, Windows.UI.Notifications.IToastNotification4, Windows.UI.Notifications.IToastNotification6 {
+    constructor(content: Windows.Data.Xml.Dom.XmlDocument);
+    readonly Content: Windows.Data.Xml.Dom.XmlDocument;
+    Data: Windows.UI.Notifications.NotificationData;
+    ExpirationTime: Windows.Foundation.DateTime | null;
+    ExpiresOnReboot: boolean;
+    Group: string;
+    NotificationMirroring: number;
+    Priority: number;
+    RemoteId: string;
+    SuppressPopup: boolean;
+    Tag: string;
+    Activated: Windows.Foundation.TypedEventHandler<Windows.UI.Notifications.ToastNotification, Object> | null;
+    Dismissed: Windows.Foundation.TypedEventHandler<Windows.UI.Notifications.ToastNotification, Windows.UI.Notifications.ToastDismissedEventArgs> | null;
+    Failed: Windows.Foundation.TypedEventHandler<Windows.UI.Notifications.ToastNotification, Windows.UI.Notifications.ToastFailedEventArgs> | null;
+  }
+
+  class ToastNotificationActionTriggerDetail implements Windows.UI.Notifications.IToastNotificationActionTriggerDetail {
+    readonly Argument: string;
+    readonly UserInput: Windows.Foundation.Collections.ValueSet;
+  }
+
+  class ToastNotificationHistory implements Windows.UI.Notifications.IToastNotificationHistory, Windows.UI.Notifications.IToastNotificationHistory2 {
+    Clear(): void;
+    Clear(applicationId: string): void;
+    GetHistory(): Windows.Foundation.Collections.IVectorView<Windows.UI.Notifications.ToastNotification> | Windows.UI.Notifications.ToastNotification[];
+    GetHistory(applicationId: string): Windows.Foundation.Collections.IVectorView<Windows.UI.Notifications.ToastNotification> | Windows.UI.Notifications.ToastNotification[];
+    Remove(tag: string, group: string, applicationId: string): void;
+    Remove(tag: string, group: string): void;
+    Remove(tag: string): void;
+    RemoveGroup(group: string): void;
+    RemoveGroup(group: string, applicationId: string): void;
+  }
+
+  class ToastNotificationHistoryChangedTriggerDetail implements Windows.UI.Notifications.IToastNotificationHistoryChangedTriggerDetail, Windows.UI.Notifications.IToastNotificationHistoryChangedTriggerDetail2 {
+    readonly ChangeType: number;
+    readonly CollectionId: string;
+  }
+
+  class ToastNotificationManager {
+    static ConfigureNotificationMirroring(value: number): void;
+    static CreateToastNotifier(): Windows.UI.Notifications.ToastNotifier;
+    static CreateToastNotifier(applicationId: string): Windows.UI.Notifications.ToastNotifier;
+    static GetDefault(): Windows.UI.Notifications.ToastNotificationManagerForUser;
+    static GetForUser(user: Windows.System.User): Windows.UI.Notifications.ToastNotificationManagerForUser;
+    static GetTemplateContent(type: number): Windows.Data.Xml.Dom.XmlDocument;
+    static readonly History: Windows.UI.Notifications.ToastNotificationHistory;
+  }
+
+  class ToastNotificationManagerForUser implements Windows.UI.Notifications.IToastNotificationManagerForUser, Windows.UI.Notifications.IToastNotificationManagerForUser2, Windows.UI.Notifications.IToastNotificationManagerForUser3 {
+    CreateToastNotifier(): Windows.UI.Notifications.ToastNotifier;
+    CreateToastNotifier(applicationId: string): Windows.UI.Notifications.ToastNotifier;
+    GetHistoryForToastCollectionIdAsync(collectionId: string): Windows.Foundation.IAsyncOperation<Windows.UI.Notifications.ToastNotificationHistory>;
+    GetToastCollectionManager(): Windows.UI.Notifications.ToastCollectionManager;
+    GetToastCollectionManager(appId: string): Windows.UI.Notifications.ToastCollectionManager;
+    GetToastNotifierForToastCollectionIdAsync(collectionId: string): Windows.Foundation.IAsyncOperation<Windows.UI.Notifications.ToastNotifier>;
+    readonly History: Windows.UI.Notifications.ToastNotificationHistory;
+    readonly NotificationMode: number;
+    readonly User: Windows.System.User;
+    NotificationModeChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Notifications.ToastNotificationManagerForUser, Object> | null;
+  }
+
+  class ToastNotifier implements Windows.UI.Notifications.IToastNotifier, Windows.UI.Notifications.IToastNotifier2, Windows.UI.Notifications.IToastNotifier3 {
+    AddToSchedule(scheduledToast: Windows.UI.Notifications.ScheduledToastNotification): void;
+    GetScheduledToastNotifications(): Windows.Foundation.Collections.IVectorView<Windows.UI.Notifications.ScheduledToastNotification> | Windows.UI.Notifications.ScheduledToastNotification[];
+    Hide(notification: Windows.UI.Notifications.ToastNotification): void;
+    RemoveFromSchedule(scheduledToast: Windows.UI.Notifications.ScheduledToastNotification): void;
+    Show(notification: Windows.UI.Notifications.ToastNotification): void;
+    Update(data: Windows.UI.Notifications.NotificationData, tag: string, group: string): number;
+    Update(data: Windows.UI.Notifications.NotificationData, tag: string): number;
+    readonly Setting: number;
+    ScheduledToastNotificationShowing: Windows.Foundation.TypedEventHandler<Windows.UI.Notifications.ToastNotifier, Windows.UI.Notifications.ScheduledToastNotificationShowingEventArgs> | null;
+  }
+
+  class UserNotification implements Windows.UI.Notifications.IUserNotification {
+    readonly AppInfo: Windows.ApplicationModel.AppInfo;
+    readonly CreationTime: Windows.Foundation.DateTime;
+    readonly Id: number;
+    readonly Notification: Windows.UI.Notifications.Notification;
+  }
+
+  class UserNotificationChangedEventArgs implements Windows.UI.Notifications.IUserNotificationChangedEventArgs {
+    readonly ChangeKind: number;
+    readonly UserNotificationId: number;
+  }
+
+  enum AdaptiveNotificationContentKind {
+    Text = 0,
+  }
+
+  enum BadgeTemplateType {
+    BadgeGlyph = 0,
+    BadgeNumber = 1,
+  }
+
+  enum NotificationKinds {
+    Unknown = 0,
+    Toast = 1,
+  }
+
+  enum NotificationMirroring {
+    Allowed = 0,
+    Disabled = 1,
+  }
+
+  enum NotificationSetting {
+    Enabled = 0,
+    DisabledForApplication = 1,
+    DisabledForUser = 2,
+    DisabledByGroupPolicy = 3,
+    DisabledByManifest = 4,
+  }
+
+  enum NotificationUpdateResult {
+    Succeeded = 0,
+    Failed = 1,
+    NotificationNotFound = 2,
+  }
+
+  enum PeriodicUpdateRecurrence {
+    HalfHour = 0,
+    Hour = 1,
+    SixHours = 2,
+    TwelveHours = 3,
+    Daily = 4,
+  }
+
+  enum TileFlyoutTemplateType {
+    TileFlyoutTemplate01 = 0,
+  }
+
+  enum TileTemplateType {
+    TileSquareImage = 0,
+    TileSquareBlock = 1,
+    TileSquareText01 = 2,
+    TileSquareText02 = 3,
+    TileSquareText03 = 4,
+    TileSquareText04 = 5,
+    TileSquarePeekImageAndText01 = 6,
+    TileSquarePeekImageAndText02 = 7,
+    TileSquarePeekImageAndText03 = 8,
+    TileSquarePeekImageAndText04 = 9,
+    TileWideImage = 10,
+    TileWideImageCollection = 11,
+    TileWideImageAndText01 = 12,
+    TileWideImageAndText02 = 13,
+    TileWideBlockAndText01 = 14,
+    TileWideBlockAndText02 = 15,
+    TileWidePeekImageCollection01 = 16,
+    TileWidePeekImageCollection02 = 17,
+    TileWidePeekImageCollection03 = 18,
+    TileWidePeekImageCollection04 = 19,
+    TileWidePeekImageCollection05 = 20,
+    TileWidePeekImageCollection06 = 21,
+    TileWidePeekImageAndText01 = 22,
+    TileWidePeekImageAndText02 = 23,
+    TileWidePeekImage01 = 24,
+    TileWidePeekImage02 = 25,
+    TileWidePeekImage03 = 26,
+    TileWidePeekImage04 = 27,
+    TileWidePeekImage05 = 28,
+    TileWidePeekImage06 = 29,
+    TileWideSmallImageAndText01 = 30,
+    TileWideSmallImageAndText02 = 31,
+    TileWideSmallImageAndText03 = 32,
+    TileWideSmallImageAndText04 = 33,
+    TileWideSmallImageAndText05 = 34,
+    TileWideText01 = 35,
+    TileWideText02 = 36,
+    TileWideText03 = 37,
+    TileWideText04 = 38,
+    TileWideText05 = 39,
+    TileWideText06 = 40,
+    TileWideText07 = 41,
+    TileWideText08 = 42,
+    TileWideText09 = 43,
+    TileWideText10 = 44,
+    TileWideText11 = 45,
+    TileSquare150x150Image = 0,
+    TileSquare150x150Block = 1,
+    TileSquare150x150Text01 = 2,
+    TileSquare150x150Text02 = 3,
+    TileSquare150x150Text03 = 4,
+    TileSquare150x150Text04 = 5,
+    TileSquare150x150PeekImageAndText01 = 6,
+    TileSquare150x150PeekImageAndText02 = 7,
+    TileSquare150x150PeekImageAndText03 = 8,
+    TileSquare150x150PeekImageAndText04 = 9,
+    TileWide310x150Image = 10,
+    TileWide310x150ImageCollection = 11,
+    TileWide310x150ImageAndText01 = 12,
+    TileWide310x150ImageAndText02 = 13,
+    TileWide310x150BlockAndText01 = 14,
+    TileWide310x150BlockAndText02 = 15,
+    TileWide310x150PeekImageCollection01 = 16,
+    TileWide310x150PeekImageCollection02 = 17,
+    TileWide310x150PeekImageCollection03 = 18,
+    TileWide310x150PeekImageCollection04 = 19,
+    TileWide310x150PeekImageCollection05 = 20,
+    TileWide310x150PeekImageCollection06 = 21,
+    TileWide310x150PeekImageAndText01 = 22,
+    TileWide310x150PeekImageAndText02 = 23,
+    TileWide310x150PeekImage01 = 24,
+    TileWide310x150PeekImage02 = 25,
+    TileWide310x150PeekImage03 = 26,
+    TileWide310x150PeekImage04 = 27,
+    TileWide310x150PeekImage05 = 28,
+    TileWide310x150PeekImage06 = 29,
+    TileWide310x150SmallImageAndText01 = 30,
+    TileWide310x150SmallImageAndText02 = 31,
+    TileWide310x150SmallImageAndText03 = 32,
+    TileWide310x150SmallImageAndText04 = 33,
+    TileWide310x150SmallImageAndText05 = 34,
+    TileWide310x150Text01 = 35,
+    TileWide310x150Text02 = 36,
+    TileWide310x150Text03 = 37,
+    TileWide310x150Text04 = 38,
+    TileWide310x150Text05 = 39,
+    TileWide310x150Text06 = 40,
+    TileWide310x150Text07 = 41,
+    TileWide310x150Text08 = 42,
+    TileWide310x150Text09 = 43,
+    TileWide310x150Text10 = 44,
+    TileWide310x150Text11 = 45,
+    TileSquare310x310BlockAndText01 = 46,
+    TileSquare310x310BlockAndText02 = 47,
+    TileSquare310x310Image = 48,
+    TileSquare310x310ImageAndText01 = 49,
+    TileSquare310x310ImageAndText02 = 50,
+    TileSquare310x310ImageAndTextOverlay01 = 51,
+    TileSquare310x310ImageAndTextOverlay02 = 52,
+    TileSquare310x310ImageAndTextOverlay03 = 53,
+    TileSquare310x310ImageCollectionAndText01 = 54,
+    TileSquare310x310ImageCollectionAndText02 = 55,
+    TileSquare310x310ImageCollection = 56,
+    TileSquare310x310SmallImagesAndTextList01 = 57,
+    TileSquare310x310SmallImagesAndTextList02 = 58,
+    TileSquare310x310SmallImagesAndTextList03 = 59,
+    TileSquare310x310SmallImagesAndTextList04 = 60,
+    TileSquare310x310Text01 = 61,
+    TileSquare310x310Text02 = 62,
+    TileSquare310x310Text03 = 63,
+    TileSquare310x310Text04 = 64,
+    TileSquare310x310Text05 = 65,
+    TileSquare310x310Text06 = 66,
+    TileSquare310x310Text07 = 67,
+    TileSquare310x310Text08 = 68,
+    TileSquare310x310TextList01 = 69,
+    TileSquare310x310TextList02 = 70,
+    TileSquare310x310TextList03 = 71,
+    TileSquare310x310SmallImageAndText01 = 72,
+    TileSquare310x310SmallImagesAndTextList05 = 73,
+    TileSquare310x310Text09 = 74,
+    TileSquare71x71IconWithBadge = 75,
+    TileSquare150x150IconWithBadge = 76,
+    TileWide310x150IconWithBadgeAndText = 77,
+    TileSquare71x71Image = 78,
+    TileTall150x310Image = 79,
+  }
+
+  enum ToastDismissalReason {
+    UserCanceled = 0,
+    ApplicationHidden = 1,
+    TimedOut = 2,
+  }
+
+  enum ToastHistoryChangedType {
+    Cleared = 0,
+    Removed = 1,
+    Expired = 2,
+    Added = 3,
+  }
+
+  enum ToastNotificationMode {
+    Unrestricted = 0,
+    PriorityOnly = 1,
+    AlarmsOnly = 2,
+  }
+
+  enum ToastNotificationPriority {
+    Default = 0,
+    High = 1,
+  }
+
+  enum ToastTemplateType {
+    ToastImageAndText01 = 0,
+    ToastImageAndText02 = 1,
+    ToastImageAndText03 = 2,
+    ToastImageAndText04 = 3,
+    ToastText01 = 4,
+    ToastText02 = 5,
+    ToastText03 = 6,
+    ToastText04 = 7,
+  }
+
+  enum UserNotificationChangedKind {
+    Added = 0,
+    Removed = 1,
+  }
+
+  interface IAdaptiveNotificationContent {
+    readonly Hints: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    readonly Kind: number;
+  }
+  var IAdaptiveNotificationContent: abstract new (...args: any[]) => IAdaptiveNotificationContent;
+
+  interface IAdaptiveNotificationText {
+    Language: string;
+    Text: string;
+  }
+  var IAdaptiveNotificationText: abstract new (...args: any[]) => IAdaptiveNotificationText;
+
+  interface IBadgeNotification {
+    readonly Content: Windows.Data.Xml.Dom.XmlDocument;
+    ExpirationTime: Windows.Foundation.DateTime | null;
+  }
+  var IBadgeNotification: abstract new (...args: any[]) => IBadgeNotification;
+
+  interface IBadgeNotificationFactory {
+    CreateBadgeNotification(content: Windows.Data.Xml.Dom.XmlDocument): Windows.UI.Notifications.BadgeNotification;
+  }
+  var IBadgeNotificationFactory: abstract new (...args: any[]) => IBadgeNotificationFactory;
+
+  interface IBadgeUpdateManagerForUser {
+    CreateBadgeUpdaterForApplication(): Windows.UI.Notifications.BadgeUpdater;
+    CreateBadgeUpdaterForApplication(applicationId: string): Windows.UI.Notifications.BadgeUpdater;
+    CreateBadgeUpdaterForSecondaryTile(tileId: string): Windows.UI.Notifications.BadgeUpdater;
+    readonly User: Windows.System.User;
+  }
+  var IBadgeUpdateManagerForUser: abstract new (...args: any[]) => IBadgeUpdateManagerForUser;
+
+  interface IBadgeUpdateManagerStatics {
+    CreateBadgeUpdaterForApplication(): Windows.UI.Notifications.BadgeUpdater;
+    CreateBadgeUpdaterForApplication(applicationId: string): Windows.UI.Notifications.BadgeUpdater;
+    CreateBadgeUpdaterForSecondaryTile(tileId: string): Windows.UI.Notifications.BadgeUpdater;
+    GetTemplateContent(type: number): Windows.Data.Xml.Dom.XmlDocument;
+  }
+  var IBadgeUpdateManagerStatics: abstract new (...args: any[]) => IBadgeUpdateManagerStatics;
+
+  interface IBadgeUpdateManagerStatics2 {
+    GetForUser(user: Windows.System.User): Windows.UI.Notifications.BadgeUpdateManagerForUser;
+  }
+  var IBadgeUpdateManagerStatics2: abstract new (...args: any[]) => IBadgeUpdateManagerStatics2;
+
+  interface IBadgeUpdater {
+    Clear(): void;
+    StartPeriodicUpdate(badgeContent: Windows.Foundation.Uri, requestedInterval: number): void;
+    StartPeriodicUpdate(badgeContent: Windows.Foundation.Uri, startTime: Windows.Foundation.DateTime, requestedInterval: number): void;
+    StopPeriodicUpdate(): void;
+    Update(notification: Windows.UI.Notifications.BadgeNotification): void;
+  }
+  var IBadgeUpdater: abstract new (...args: any[]) => IBadgeUpdater;
+
+  interface IKnownAdaptiveNotificationHintsStatics {
+    readonly Align: string;
+    readonly MaxLines: string;
+    readonly MinLines: string;
+    readonly Style: string;
+    readonly TextStacking: string;
+    readonly Wrap: string;
+  }
+  var IKnownAdaptiveNotificationHintsStatics: abstract new (...args: any[]) => IKnownAdaptiveNotificationHintsStatics;
+
+  interface IKnownAdaptiveNotificationTextStylesStatics {
+    readonly Base: string;
+    readonly BaseSubtle: string;
+    readonly Body: string;
+    readonly BodySubtle: string;
+    readonly Caption: string;
+    readonly CaptionSubtle: string;
+    readonly Header: string;
+    readonly HeaderNumeral: string;
+    readonly HeaderNumeralSubtle: string;
+    readonly HeaderSubtle: string;
+    readonly Subheader: string;
+    readonly SubheaderNumeral: string;
+    readonly SubheaderNumeralSubtle: string;
+    readonly SubheaderSubtle: string;
+    readonly Subtitle: string;
+    readonly SubtitleSubtle: string;
+    readonly Title: string;
+    readonly TitleNumeral: string;
+    readonly TitleSubtle: string;
+  }
+  var IKnownAdaptiveNotificationTextStylesStatics: abstract new (...args: any[]) => IKnownAdaptiveNotificationTextStylesStatics;
+
+  interface IKnownNotificationBindingsStatics {
+    readonly ToastGeneric: string;
+  }
+  var IKnownNotificationBindingsStatics: abstract new (...args: any[]) => IKnownNotificationBindingsStatics;
+
+  interface INotification {
+    ExpirationTime: Windows.Foundation.DateTime | null;
+    Visual: Windows.UI.Notifications.NotificationVisual;
+  }
+  var INotification: abstract new (...args: any[]) => INotification;
+
+  interface INotificationBinding {
+    GetTextElements(): Windows.Foundation.Collections.IVectorView<Windows.UI.Notifications.AdaptiveNotificationText> | Windows.UI.Notifications.AdaptiveNotificationText[];
+    readonly Hints: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    Language: string;
+    Template: string;
+  }
+  var INotificationBinding: abstract new (...args: any[]) => INotificationBinding;
+
+  interface INotificationData {
+    SequenceNumber: number;
+    readonly Values: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+  }
+  var INotificationData: abstract new (...args: any[]) => INotificationData;
+
+  interface INotificationDataFactory {
+    CreateNotificationData(initialValues: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, string>> | Windows.Foundation.Collections.IKeyValuePair<string, string>[], sequenceNumber: number): Windows.UI.Notifications.NotificationData;
+    CreateNotificationData(initialValues: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, string>> | Windows.Foundation.Collections.IKeyValuePair<string, string>[]): Windows.UI.Notifications.NotificationData;
+  }
+  var INotificationDataFactory: abstract new (...args: any[]) => INotificationDataFactory;
+
+  interface INotificationVisual {
+    GetBinding(templateName: string): Windows.UI.Notifications.NotificationBinding;
+    readonly Bindings: Windows.Foundation.Collections.IVector<Windows.UI.Notifications.NotificationBinding> | Windows.UI.Notifications.NotificationBinding[];
+    Language: string;
+  }
+  var INotificationVisual: abstract new (...args: any[]) => INotificationVisual;
+
+  interface IScheduledTileNotification {
+    readonly Content: Windows.Data.Xml.Dom.XmlDocument;
+    readonly DeliveryTime: Windows.Foundation.DateTime;
+    ExpirationTime: Windows.Foundation.DateTime | null;
+    Id: string;
+    Tag: string;
+  }
+  var IScheduledTileNotification: abstract new (...args: any[]) => IScheduledTileNotification;
+
+  interface IScheduledTileNotificationFactory {
+    CreateScheduledTileNotification(content: Windows.Data.Xml.Dom.XmlDocument, deliveryTime: Windows.Foundation.DateTime): Windows.UI.Notifications.ScheduledTileNotification;
+  }
+  var IScheduledTileNotificationFactory: abstract new (...args: any[]) => IScheduledTileNotificationFactory;
+
+  interface IScheduledToastNotification {
+    readonly Content: Windows.Data.Xml.Dom.XmlDocument;
+    readonly DeliveryTime: Windows.Foundation.DateTime;
+    Id: string;
+    readonly MaximumSnoozeCount: number;
+    readonly SnoozeInterval: Windows.Foundation.TimeSpan | null;
+  }
+  var IScheduledToastNotification: abstract new (...args: any[]) => IScheduledToastNotification;
+
+  interface IScheduledToastNotification2 {
+    Group: string;
+    SuppressPopup: boolean;
+    Tag: string;
+  }
+  var IScheduledToastNotification2: abstract new (...args: any[]) => IScheduledToastNotification2;
+
+  interface IScheduledToastNotification3 {
+    NotificationMirroring: number;
+    RemoteId: string;
+  }
+  var IScheduledToastNotification3: abstract new (...args: any[]) => IScheduledToastNotification3;
+
+  interface IScheduledToastNotification4 {
+    ExpirationTime: Windows.Foundation.DateTime | null;
+  }
+  var IScheduledToastNotification4: abstract new (...args: any[]) => IScheduledToastNotification4;
+
+  interface IScheduledToastNotificationFactory {
+    CreateScheduledToastNotification(content: Windows.Data.Xml.Dom.XmlDocument, deliveryTime: Windows.Foundation.DateTime): Windows.UI.Notifications.ScheduledToastNotification;
+    CreateScheduledToastNotificationRecurring(content: Windows.Data.Xml.Dom.XmlDocument, deliveryTime: Windows.Foundation.DateTime, snoozeInterval: Windows.Foundation.TimeSpan, maximumSnoozeCount: number): Windows.UI.Notifications.ScheduledToastNotification;
+  }
+  var IScheduledToastNotificationFactory: abstract new (...args: any[]) => IScheduledToastNotificationFactory;
+
+  interface IScheduledToastNotificationShowingEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Cancel: boolean;
+    readonly ScheduledToastNotification: Windows.UI.Notifications.ScheduledToastNotification;
+  }
+  var IScheduledToastNotificationShowingEventArgs: abstract new (...args: any[]) => IScheduledToastNotificationShowingEventArgs;
+
+  interface IShownTileNotification {
+    readonly Arguments: string;
+  }
+  var IShownTileNotification: abstract new (...args: any[]) => IShownTileNotification;
+
+  interface ITileFlyoutNotification {
+    readonly Content: Windows.Data.Xml.Dom.XmlDocument;
+    ExpirationTime: Windows.Foundation.DateTime | null;
+  }
+  var ITileFlyoutNotification: abstract new (...args: any[]) => ITileFlyoutNotification;
+
+  interface ITileFlyoutNotificationFactory {
+    CreateTileFlyoutNotification(content: Windows.Data.Xml.Dom.XmlDocument): Windows.UI.Notifications.TileFlyoutNotification;
+  }
+  var ITileFlyoutNotificationFactory: abstract new (...args: any[]) => ITileFlyoutNotificationFactory;
+
+  interface ITileFlyoutUpdateManagerStatics {
+    CreateTileFlyoutUpdaterForApplication(): Windows.UI.Notifications.TileFlyoutUpdater;
+    CreateTileFlyoutUpdaterForApplication(applicationId: string): Windows.UI.Notifications.TileFlyoutUpdater;
+    CreateTileFlyoutUpdaterForSecondaryTile(tileId: string): Windows.UI.Notifications.TileFlyoutUpdater;
+    GetTemplateContent(type: number): Windows.Data.Xml.Dom.XmlDocument;
+  }
+  var ITileFlyoutUpdateManagerStatics: abstract new (...args: any[]) => ITileFlyoutUpdateManagerStatics;
+
+  interface ITileFlyoutUpdater {
+    Clear(): void;
+    StartPeriodicUpdate(tileFlyoutContent: Windows.Foundation.Uri, requestedInterval: number): void;
+    StartPeriodicUpdate(tileFlyoutContent: Windows.Foundation.Uri, startTime: Windows.Foundation.DateTime, requestedInterval: number): void;
+    StopPeriodicUpdate(): void;
+    Update(notification: Windows.UI.Notifications.TileFlyoutNotification): void;
+    readonly Setting: number;
+  }
+  var ITileFlyoutUpdater: abstract new (...args: any[]) => ITileFlyoutUpdater;
+
+  interface ITileNotification {
+    readonly Content: Windows.Data.Xml.Dom.XmlDocument;
+    ExpirationTime: Windows.Foundation.DateTime | null;
+    Tag: string;
+  }
+  var ITileNotification: abstract new (...args: any[]) => ITileNotification;
+
+  interface ITileNotificationFactory {
+    CreateTileNotification(content: Windows.Data.Xml.Dom.XmlDocument): Windows.UI.Notifications.TileNotification;
+  }
+  var ITileNotificationFactory: abstract new (...args: any[]) => ITileNotificationFactory;
+
+  interface ITileUpdateManagerForUser {
+    CreateTileUpdaterForApplication(applicationId: string): Windows.UI.Notifications.TileUpdater;
+    CreateTileUpdaterForApplicationForUser(): Windows.UI.Notifications.TileUpdater;
+    CreateTileUpdaterForSecondaryTile(tileId: string): Windows.UI.Notifications.TileUpdater;
+    readonly User: Windows.System.User;
+  }
+  var ITileUpdateManagerForUser: abstract new (...args: any[]) => ITileUpdateManagerForUser;
+
+  interface ITileUpdateManagerStatics {
+    CreateTileUpdaterForApplication(): Windows.UI.Notifications.TileUpdater;
+    CreateTileUpdaterForApplication(applicationId: string): Windows.UI.Notifications.TileUpdater;
+    CreateTileUpdaterForSecondaryTile(tileId: string): Windows.UI.Notifications.TileUpdater;
+    GetTemplateContent(type: number): Windows.Data.Xml.Dom.XmlDocument;
+  }
+  var ITileUpdateManagerStatics: abstract new (...args: any[]) => ITileUpdateManagerStatics;
+
+  interface ITileUpdateManagerStatics2 {
+    GetForUser(user: Windows.System.User): Windows.UI.Notifications.TileUpdateManagerForUser;
+  }
+  var ITileUpdateManagerStatics2: abstract new (...args: any[]) => ITileUpdateManagerStatics2;
+
+  interface ITileUpdater {
+    AddToSchedule(scheduledTile: Windows.UI.Notifications.ScheduledTileNotification): void;
+    Clear(): void;
+    EnableNotificationQueue(enable: boolean): void;
+    GetScheduledTileNotifications(): Windows.Foundation.Collections.IVectorView<Windows.UI.Notifications.ScheduledTileNotification> | Windows.UI.Notifications.ScheduledTileNotification[];
+    RemoveFromSchedule(scheduledTile: Windows.UI.Notifications.ScheduledTileNotification): void;
+    StartPeriodicUpdate(tileContent: Windows.Foundation.Uri, requestedInterval: number): void;
+    StartPeriodicUpdate(tileContent: Windows.Foundation.Uri, startTime: Windows.Foundation.DateTime, requestedInterval: number): void;
+    StartPeriodicUpdateBatch(tileContents: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], requestedInterval: number): void;
+    StartPeriodicUpdateBatch(tileContents: Windows.Foundation.Collections.IIterable<Windows.Foundation.Uri> | Windows.Foundation.Uri[], startTime: Windows.Foundation.DateTime, requestedInterval: number): void;
+    StopPeriodicUpdate(): void;
+    Update(notification: Windows.UI.Notifications.TileNotification): void;
+    readonly Setting: number;
+  }
+  var ITileUpdater: abstract new (...args: any[]) => ITileUpdater;
+
+  interface ITileUpdater2 {
+    EnableNotificationQueueForSquare150x150(enable: boolean): void;
+    EnableNotificationQueueForSquare310x310(enable: boolean): void;
+    EnableNotificationQueueForWide310x150(enable: boolean): void;
+  }
+  var ITileUpdater2: abstract new (...args: any[]) => ITileUpdater2;
+
+  interface IToastActivatedEventArgs {
+    readonly Arguments: string;
+  }
+  var IToastActivatedEventArgs: abstract new (...args: any[]) => IToastActivatedEventArgs;
+
+  interface IToastActivatedEventArgs2 {
+    readonly UserInput: Windows.Foundation.Collections.ValueSet;
+  }
+  var IToastActivatedEventArgs2: abstract new (...args: any[]) => IToastActivatedEventArgs2;
+
+  interface IToastCollection {
+    DisplayName: string;
+    Icon: Windows.Foundation.Uri;
+    readonly Id: string;
+    LaunchArgs: string;
+  }
+  var IToastCollection: abstract new (...args: any[]) => IToastCollection;
+
+  interface IToastCollectionFactory {
+    CreateInstance(collectionId: string, displayName: string, launchArgs: string, iconUri: Windows.Foundation.Uri): Windows.UI.Notifications.ToastCollection;
+  }
+  var IToastCollectionFactory: abstract new (...args: any[]) => IToastCollectionFactory;
+
+  interface IToastCollectionManager {
+    FindAllToastCollectionsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.UI.Notifications.ToastCollection> | Windows.UI.Notifications.ToastCollection[]>;
+    GetToastCollectionAsync(collectionId: string): Windows.Foundation.IAsyncOperation<Windows.UI.Notifications.ToastCollection>;
+    RemoveAllToastCollectionsAsync(): Windows.Foundation.IAsyncAction;
+    RemoveToastCollectionAsync(collectionId: string): Windows.Foundation.IAsyncAction;
+    SaveToastCollectionAsync(collection: Windows.UI.Notifications.ToastCollection): Windows.Foundation.IAsyncAction;
+    readonly AppId: string;
+    readonly User: Windows.System.User;
+  }
+  var IToastCollectionManager: abstract new (...args: any[]) => IToastCollectionManager;
+
+  interface IToastDismissedEventArgs {
+    readonly Reason: number;
+  }
+  var IToastDismissedEventArgs: abstract new (...args: any[]) => IToastDismissedEventArgs;
+
+  interface IToastFailedEventArgs {
+    readonly ErrorCode: Windows.Foundation.HResult;
+  }
+  var IToastFailedEventArgs: abstract new (...args: any[]) => IToastFailedEventArgs;
+
+  interface IToastNotification {
+    readonly Content: Windows.Data.Xml.Dom.XmlDocument;
+    ExpirationTime: Windows.Foundation.DateTime | null;
+    Activated: Windows.Foundation.TypedEventHandler<Windows.UI.Notifications.ToastNotification, Object> | null;
+    Dismissed: Windows.Foundation.TypedEventHandler<Windows.UI.Notifications.ToastNotification, Windows.UI.Notifications.ToastDismissedEventArgs> | null;
+    Failed: Windows.Foundation.TypedEventHandler<Windows.UI.Notifications.ToastNotification, Windows.UI.Notifications.ToastFailedEventArgs> | null;
+  }
+  var IToastNotification: abstract new (...args: any[]) => IToastNotification;
+
+  interface IToastNotification2 {
+    Group: string;
+    SuppressPopup: boolean;
+    Tag: string;
+  }
+  var IToastNotification2: abstract new (...args: any[]) => IToastNotification2;
+
+  interface IToastNotification3 {
+    NotificationMirroring: number;
+    RemoteId: string;
+  }
+  var IToastNotification3: abstract new (...args: any[]) => IToastNotification3;
+
+  interface IToastNotification4 {
+    Data: Windows.UI.Notifications.NotificationData;
+    Priority: number;
+  }
+  var IToastNotification4: abstract new (...args: any[]) => IToastNotification4;
+
+  interface IToastNotification6 {
+    ExpiresOnReboot: boolean;
+  }
+  var IToastNotification6: abstract new (...args: any[]) => IToastNotification6;
+
+  interface IToastNotificationActionTriggerDetail {
+    readonly Argument: string;
+    readonly UserInput: Windows.Foundation.Collections.ValueSet;
+  }
+  var IToastNotificationActionTriggerDetail: abstract new (...args: any[]) => IToastNotificationActionTriggerDetail;
+
+  interface IToastNotificationFactory {
+    CreateToastNotification(content: Windows.Data.Xml.Dom.XmlDocument): Windows.UI.Notifications.ToastNotification;
+  }
+  var IToastNotificationFactory: abstract new (...args: any[]) => IToastNotificationFactory;
+
+  interface IToastNotificationHistory {
+    Clear(): void;
+    Clear(applicationId: string): void;
+    Remove(tag: string, group: string, applicationId: string): void;
+    Remove(tag: string, group: string): void;
+    Remove(tag: string): void;
+    RemoveGroup(group: string): void;
+    RemoveGroup(group: string, applicationId: string): void;
+  }
+  var IToastNotificationHistory: abstract new (...args: any[]) => IToastNotificationHistory;
+
+  interface IToastNotificationHistory2 {
+    GetHistory(): Windows.Foundation.Collections.IVectorView<Windows.UI.Notifications.ToastNotification> | Windows.UI.Notifications.ToastNotification[];
+    GetHistory(applicationId: string): Windows.Foundation.Collections.IVectorView<Windows.UI.Notifications.ToastNotification> | Windows.UI.Notifications.ToastNotification[];
+  }
+  var IToastNotificationHistory2: abstract new (...args: any[]) => IToastNotificationHistory2;
+
+  interface IToastNotificationHistoryChangedTriggerDetail {
+    readonly ChangeType: number;
+  }
+  var IToastNotificationHistoryChangedTriggerDetail: abstract new (...args: any[]) => IToastNotificationHistoryChangedTriggerDetail;
+
+  interface IToastNotificationHistoryChangedTriggerDetail2 {
+    readonly CollectionId: string;
+  }
+  var IToastNotificationHistoryChangedTriggerDetail2: abstract new (...args: any[]) => IToastNotificationHistoryChangedTriggerDetail2;
+
+  interface IToastNotificationManagerForUser {
+    CreateToastNotifier(): Windows.UI.Notifications.ToastNotifier;
+    CreateToastNotifier(applicationId: string): Windows.UI.Notifications.ToastNotifier;
+    readonly History: Windows.UI.Notifications.ToastNotificationHistory;
+    readonly User: Windows.System.User;
+  }
+  var IToastNotificationManagerForUser: abstract new (...args: any[]) => IToastNotificationManagerForUser;
+
+  interface IToastNotificationManagerForUser2 {
+    GetHistoryForToastCollectionIdAsync(collectionId: string): Windows.Foundation.IAsyncOperation<Windows.UI.Notifications.ToastNotificationHistory>;
+    GetToastCollectionManager(): Windows.UI.Notifications.ToastCollectionManager;
+    GetToastCollectionManager(appId: string): Windows.UI.Notifications.ToastCollectionManager;
+    GetToastNotifierForToastCollectionIdAsync(collectionId: string): Windows.Foundation.IAsyncOperation<Windows.UI.Notifications.ToastNotifier>;
+  }
+  var IToastNotificationManagerForUser2: abstract new (...args: any[]) => IToastNotificationManagerForUser2;
+
+  interface IToastNotificationManagerForUser3 {
+    readonly NotificationMode: number;
+    NotificationModeChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Notifications.ToastNotificationManagerForUser, Object> | null;
+  }
+  var IToastNotificationManagerForUser3: abstract new (...args: any[]) => IToastNotificationManagerForUser3;
+
+  interface IToastNotificationManagerStatics {
+    CreateToastNotifier(): Windows.UI.Notifications.ToastNotifier;
+    CreateToastNotifier(applicationId: string): Windows.UI.Notifications.ToastNotifier;
+    GetTemplateContent(type: number): Windows.Data.Xml.Dom.XmlDocument;
+  }
+  var IToastNotificationManagerStatics: abstract new (...args: any[]) => IToastNotificationManagerStatics;
+
+  interface IToastNotificationManagerStatics2 {
+    readonly History: Windows.UI.Notifications.ToastNotificationHistory;
+  }
+  var IToastNotificationManagerStatics2: abstract new (...args: any[]) => IToastNotificationManagerStatics2;
+
+  interface IToastNotificationManagerStatics4 {
+    ConfigureNotificationMirroring(value: number): void;
+    GetForUser(user: Windows.System.User): Windows.UI.Notifications.ToastNotificationManagerForUser;
+  }
+  var IToastNotificationManagerStatics4: abstract new (...args: any[]) => IToastNotificationManagerStatics4;
+
+  interface IToastNotificationManagerStatics5 {
+    GetDefault(): Windows.UI.Notifications.ToastNotificationManagerForUser;
+  }
+  var IToastNotificationManagerStatics5: abstract new (...args: any[]) => IToastNotificationManagerStatics5;
+
+  interface IToastNotifier {
+    AddToSchedule(scheduledToast: Windows.UI.Notifications.ScheduledToastNotification): void;
+    GetScheduledToastNotifications(): Windows.Foundation.Collections.IVectorView<Windows.UI.Notifications.ScheduledToastNotification> | Windows.UI.Notifications.ScheduledToastNotification[];
+    Hide(notification: Windows.UI.Notifications.ToastNotification): void;
+    RemoveFromSchedule(scheduledToast: Windows.UI.Notifications.ScheduledToastNotification): void;
+    Show(notification: Windows.UI.Notifications.ToastNotification): void;
+    readonly Setting: number;
+  }
+  var IToastNotifier: abstract new (...args: any[]) => IToastNotifier;
+
+  interface IToastNotifier2 {
+    Update(data: Windows.UI.Notifications.NotificationData, tag: string, group: string): number;
+    Update(data: Windows.UI.Notifications.NotificationData, tag: string): number;
+  }
+  var IToastNotifier2: abstract new (...args: any[]) => IToastNotifier2;
+
+  interface IToastNotifier3 {
+    ScheduledToastNotificationShowing: Windows.Foundation.TypedEventHandler<Windows.UI.Notifications.ToastNotifier, Windows.UI.Notifications.ScheduledToastNotificationShowingEventArgs> | null;
+  }
+  var IToastNotifier3: abstract new (...args: any[]) => IToastNotifier3;
+
+  interface IUserNotification {
+    readonly AppInfo: Windows.ApplicationModel.AppInfo;
+    readonly CreationTime: Windows.Foundation.DateTime;
+    readonly Id: number;
+    readonly Notification: Windows.UI.Notifications.Notification;
+  }
+  var IUserNotification: abstract new (...args: any[]) => IUserNotification;
+
+  interface IUserNotificationChangedEventArgs {
+    readonly ChangeKind: number;
+    readonly UserNotificationId: number;
+  }
+  var IUserNotificationChangedEventArgs: abstract new (...args: any[]) => IUserNotificationChangedEventArgs;
+
+}
+
+declare namespace Windows.UI.Notifications.Management {
+  class UserNotificationListener implements Windows.UI.Notifications.Management.IUserNotificationListener {
+    ClearNotifications(): void;
+    GetAccessStatus(): number;
+    GetNotification(notificationId: number): Windows.UI.Notifications.UserNotification;
+    GetNotificationsAsync(kinds: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.UI.Notifications.UserNotification> | Windows.UI.Notifications.UserNotification[]>;
+    RemoveNotification(notificationId: number): void;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    static readonly Current: Windows.UI.Notifications.Management.UserNotificationListener;
+    NotificationChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Notifications.Management.UserNotificationListener, Windows.UI.Notifications.UserNotificationChangedEventArgs> | null;
+  }
+
+  enum UserNotificationListenerAccessStatus {
+    Unspecified = 0,
+    Allowed = 1,
+    Denied = 2,
+  }
+
+  interface IUserNotificationListener {
+    ClearNotifications(): void;
+    GetAccessStatus(): number;
+    GetNotification(notificationId: number): Windows.UI.Notifications.UserNotification;
+    GetNotificationsAsync(kinds: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.UI.Notifications.UserNotification> | Windows.UI.Notifications.UserNotification[]>;
+    RemoveNotification(notificationId: number): void;
+    RequestAccessAsync(): Windows.Foundation.IAsyncOperation<number>;
+    NotificationChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Notifications.Management.UserNotificationListener, Windows.UI.Notifications.UserNotificationChangedEventArgs> | null;
+  }
+  var IUserNotificationListener: abstract new (...args: any[]) => IUserNotificationListener;
+
+  interface IUserNotificationListenerStatics {
+    readonly Current: Windows.UI.Notifications.Management.UserNotificationListener;
+  }
+  var IUserNotificationListenerStatics: abstract new (...args: any[]) => IUserNotificationListenerStatics;
+
+}
+
+declare namespace Windows.UI.Notifications.Preview {
+  class ToastOcclusionManagerPreview {
+    static SetToastWindowMargin(appWindowId: Windows.UI.WindowId, margin: number): void;
+  }
+
+  interface IToastOcclusionManagerPreviewStatics {
+    SetToastWindowMargin(appWindowId: Windows.UI.WindowId, margin: number): void;
+  }
+  var IToastOcclusionManagerPreviewStatics: abstract new (...args: any[]) => IToastOcclusionManagerPreviewStatics;
+
+}
+
+declare namespace Windows.UI.Popups {
+  class MessageDialog implements Windows.UI.Popups.IMessageDialog {
+    constructor(content: string);
+    constructor(content: string, title: string);
+    ShowAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.Popups.IUICommand>;
+    CancelCommandIndex: number;
+    readonly Commands: Windows.Foundation.Collections.IVector<Windows.UI.Popups.IUICommand> | Windows.UI.Popups.IUICommand[];
+    Content: string;
+    DefaultCommandIndex: number;
+    Options: number;
+    Title: string;
+  }
+
+  class PopupMenu implements Windows.UI.Popups.IPopupMenu {
+    constructor();
+    ShowAsync(invocationPoint: Windows.Foundation.Point): Windows.Foundation.IAsyncOperation<Windows.UI.Popups.IUICommand>;
+    ShowForSelectionAsync(selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<Windows.UI.Popups.IUICommand>;
+    ShowForSelectionAsync(selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<Windows.UI.Popups.IUICommand>;
+    readonly Commands: Windows.Foundation.Collections.IVector<Windows.UI.Popups.IUICommand> | Windows.UI.Popups.IUICommand[];
+  }
+
+  class UICommand implements Windows.UI.Popups.IUICommand {
+    constructor(label: string);
+    constructor(label: string, action: Windows.UI.Popups.UICommandInvokedHandler);
+    constructor(label: string, action: Windows.UI.Popups.UICommandInvokedHandler, commandId: Object);
+    constructor();
+    Id: Object;
+    Invoked: Windows.UI.Popups.UICommandInvokedHandler;
+    Label: string;
+  }
+
+  class UICommandSeparator implements Windows.UI.Popups.IUICommand {
+    constructor();
+    Id: Object;
+    Invoked: Windows.UI.Popups.UICommandInvokedHandler;
+    Label: string;
+  }
+
+  enum MessageDialogOptions {
+    None = 0,
+    AcceptUserInputAfterDelay = 1,
+  }
+
+  enum Placement {
+    Default = 0,
+    Above = 1,
+    Below = 2,
+    Left = 3,
+    Right = 4,
+  }
+
+  interface IMessageDialog {
+    ShowAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.Popups.IUICommand>;
+    CancelCommandIndex: number;
+    readonly Commands: Windows.Foundation.Collections.IVector<Windows.UI.Popups.IUICommand> | Windows.UI.Popups.IUICommand[];
+    Content: string;
+    DefaultCommandIndex: number;
+    Options: number;
+    Title: string;
+  }
+  var IMessageDialog: abstract new (...args: any[]) => IMessageDialog;
+
+  interface IMessageDialogFactory {
+    Create(content: string): Windows.UI.Popups.MessageDialog;
+    CreateWithTitle(content: string, title: string): Windows.UI.Popups.MessageDialog;
+  }
+  var IMessageDialogFactory: abstract new (...args: any[]) => IMessageDialogFactory;
+
+  interface IPopupMenu {
+    ShowAsync(invocationPoint: Windows.Foundation.Point): Windows.Foundation.IAsyncOperation<Windows.UI.Popups.IUICommand>;
+    ShowForSelectionAsync(selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<Windows.UI.Popups.IUICommand>;
+    ShowForSelectionAsync(selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<Windows.UI.Popups.IUICommand>;
+    readonly Commands: Windows.Foundation.Collections.IVector<Windows.UI.Popups.IUICommand> | Windows.UI.Popups.IUICommand[];
+  }
+  var IPopupMenu: abstract new (...args: any[]) => IPopupMenu;
+
+  interface IUICommand {
+    Id: Object;
+    Invoked: Windows.UI.Popups.UICommandInvokedHandler;
+    Label: string;
+  }
+  var IUICommand: abstract new (...args: any[]) => IUICommand;
+
+  interface IUICommandFactory {
+    Create(label: string): Windows.UI.Popups.UICommand;
+    CreateWithHandler(label: string, action: Windows.UI.Popups.UICommandInvokedHandler): Windows.UI.Popups.UICommand;
+    CreateWithHandlerAndId(label: string, action: Windows.UI.Popups.UICommandInvokedHandler, commandId: Object): Windows.UI.Popups.UICommand;
+  }
+  var IUICommandFactory: abstract new (...args: any[]) => IUICommandFactory;
+
+  interface UICommandInvokedHandler {
+    (command: Windows.UI.Popups.IUICommand): void;
+  }
+  var UICommandInvokedHandler: {
+    new(callback: (command: Windows.UI.Popups.IUICommand) => void): UICommandInvokedHandler;
+  };
+
+}
+
+declare namespace Windows.UI.Shell {
+  class AdaptiveCardBuilder {
+    static CreateAdaptiveCardFromJson(value: string): Windows.UI.Shell.IAdaptiveCard;
+  }
+
+  class FocusSession implements Windows.UI.Shell.IFocusSession {
+    End(): void;
+    readonly Id: string;
+  }
+
+  class FocusSessionManager implements Windows.UI.Shell.IFocusSessionManager {
+    DeactivateFocus(): void;
+    static GetDefault(): Windows.UI.Shell.FocusSessionManager;
+    GetSession(id: string): Windows.UI.Shell.FocusSession;
+    TryStartFocusSession(): Windows.UI.Shell.FocusSession;
+    TryStartFocusSession(endTime: Windows.Foundation.DateTime): Windows.UI.Shell.FocusSession;
+    readonly IsFocusActive: boolean;
+    static readonly IsSupported: boolean;
+    IsFocusActiveChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Shell.FocusSessionManager, Object> | null;
+  }
+
+  class SecurityAppManager implements Windows.UI.Shell.ISecurityAppManager {
+    constructor();
+    Register(kind: number, displayName: string, detailsUri: Windows.Foundation.Uri, registerPerUser: boolean): Guid;
+    Unregister(kind: number, guidRegistration: Guid): void;
+    UpdateState(kind: number, guidRegistration: Guid, state: number, substatus: number, detailsUri: Windows.Foundation.Uri): void;
+  }
+
+  class ShareWindowCommandEventArgs implements Windows.UI.Shell.IShareWindowCommandEventArgs {
+    Command: number;
+    readonly WindowId: Windows.UI.WindowId;
+  }
+
+  class ShareWindowCommandSource implements Windows.UI.Shell.IShareWindowCommandSource {
+    static GetForCurrentView(): Windows.UI.Shell.ShareWindowCommandSource;
+    ReportCommandChanged(): void;
+    Start(): void;
+    Stop(): void;
+    CommandInvoked: Windows.Foundation.TypedEventHandler<Windows.UI.Shell.ShareWindowCommandSource, Windows.UI.Shell.ShareWindowCommandEventArgs> | null;
+    CommandRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Shell.ShareWindowCommandSource, Windows.UI.Shell.ShareWindowCommandEventArgs> | null;
+  }
+
+  class TaskbarManager implements Windows.UI.Shell.ITaskbarManager, Windows.UI.Shell.ITaskbarManager2 {
+    static GetDefault(): Windows.UI.Shell.TaskbarManager;
+    IsAppListEntryPinnedAsync(appListEntry: Windows.ApplicationModel.Core.AppListEntry): Windows.Foundation.IAsyncOperation<boolean>;
+    IsCurrentAppPinnedAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    IsSecondaryTilePinnedAsync(tileId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestPinAppListEntryAsync(appListEntry: Windows.ApplicationModel.Core.AppListEntry): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestPinCurrentAppAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestPinSecondaryTileAsync(secondaryTile: Windows.UI.StartScreen.SecondaryTile): Windows.Foundation.IAsyncOperation<boolean>;
+    TryUnpinSecondaryTileAsync(tileId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly IsPinningAllowed: boolean;
+    readonly IsSupported: boolean;
+  }
+
+  class WindowTab implements Windows.UI.Shell.IWindowTab {
+    constructor();
+    ReportThumbnailAvailable(): void;
+    Group: Windows.UI.Shell.WindowTabGroup;
+    Icon: Windows.UI.Shell.WindowTabIcon;
+    Tag: Object;
+    Title: string;
+    TreatAsSecondaryTileId: string;
+  }
+
+  class WindowTabCloseRequestedEventArgs implements Windows.UI.Shell.IWindowTabCloseRequestedEventArgs {
+    readonly Tab: Windows.UI.Shell.WindowTab;
+  }
+
+  class WindowTabCollection implements Windows.UI.Shell.IWindowTabCollection {
+    Append(value: Windows.UI.Shell.WindowTab): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Shell.WindowTab>;
+    GetAt(index: number): Windows.UI.Shell.WindowTab;
+    GetMany(startIndex: number, items: Windows.UI.Shell.WindowTab[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Shell.WindowTab> | Windows.UI.Shell.WindowTab[];
+    IndexOf(value: Windows.UI.Shell.WindowTab, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Shell.WindowTab): void;
+    MoveTab(tab: Windows.UI.Shell.WindowTab, index: number): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Shell.WindowTab[]): void;
+    SetAt(index: number, value: Windows.UI.Shell.WindowTab): void;
+    readonly Size: number;
+  }
+
+  class WindowTabGroup implements Windows.UI.Shell.IWindowTabGroup {
+    constructor();
+    Icon: Windows.UI.Shell.WindowTabIcon;
+    Title: string;
+  }
+
+  class WindowTabIcon implements Windows.UI.Shell.IWindowTabIcon {
+    static CreateFromFontGlyph(glyph: string, fontFamily: string): Windows.UI.Shell.WindowTabIcon;
+    static CreateFromFontGlyph(glyph: string, fontFamily: string, fontUri: Windows.Foundation.Uri): Windows.UI.Shell.WindowTabIcon;
+    static CreateFromImage(image: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.UI.Shell.WindowTabIcon;
+  }
+
+  class WindowTabManager implements Windows.UI.Shell.IWindowTabManager {
+    static GetForWindow(id: Windows.UI.WindowId): Windows.UI.Shell.WindowTabManager;
+    static IsSupported(): boolean;
+    static IsTabTearOutSupported(): boolean;
+    SetActiveTab(tab: Windows.UI.Shell.WindowTab): void;
+    readonly Tabs: Windows.UI.Shell.WindowTabCollection;
+    TabCloseRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Shell.WindowTabManager, Windows.UI.Shell.WindowTabCloseRequestedEventArgs> | null;
+    TabSwitchRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Shell.WindowTabManager, Windows.UI.Shell.WindowTabSwitchRequestedEventArgs> | null;
+    TabTearOutRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Shell.WindowTabManager, Windows.UI.Shell.WindowTabTearOutRequestedEventArgs> | null;
+    TabThumbnailRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Shell.WindowTabManager, Windows.UI.Shell.WindowTabThumbnailRequestedEventArgs> | null;
+  }
+
+  class WindowTabSwitchRequestedEventArgs implements Windows.UI.Shell.IWindowTabSwitchRequestedEventArgs {
+    readonly Tab: Windows.UI.Shell.WindowTab;
+  }
+
+  class WindowTabTearOutRequestedEventArgs implements Windows.UI.Shell.IWindowTabTearOutRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Tab: Windows.UI.Shell.WindowTab;
+    WindowId: number | bigint;
+  }
+
+  class WindowTabThumbnailRequestedEventArgs implements Windows.UI.Shell.IWindowTabThumbnailRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Image: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly IsCompositedOnWindow: boolean;
+    readonly RequestedSize: Windows.Graphics.Imaging.BitmapSize;
+    readonly Tab: Windows.UI.Shell.WindowTab;
+  }
+
+  enum SecurityAppKind {
+    WebProtection = 0,
+  }
+
+  enum SecurityAppState {
+    Disabled = 0,
+    Enabled = 1,
+  }
+
+  enum SecurityAppSubstatus {
+    Undetermined = 0,
+    NoActionNeeded = 1,
+    ActionRecommended = 2,
+    ActionNeeded = 3,
+  }
+
+  enum ShareWindowCommand {
+    None = 0,
+    StartSharing = 1,
+    StopSharing = 2,
+  }
+
+  interface IAdaptiveCard {
+    ToJson(): string;
+  }
+  var IAdaptiveCard: abstract new (...args: any[]) => IAdaptiveCard;
+
+  interface IAdaptiveCardBuilderStatics {
+    CreateAdaptiveCardFromJson(value: string): Windows.UI.Shell.IAdaptiveCard;
+  }
+  var IAdaptiveCardBuilderStatics: abstract new (...args: any[]) => IAdaptiveCardBuilderStatics;
+
+  interface IFocusSession {
+    End(): void;
+    readonly Id: string;
+  }
+  var IFocusSession: abstract new (...args: any[]) => IFocusSession;
+
+  interface IFocusSessionManager {
+    DeactivateFocus(): void;
+    GetSession(id: string): Windows.UI.Shell.FocusSession;
+    TryStartFocusSession(): Windows.UI.Shell.FocusSession;
+    TryStartFocusSession(endTime: Windows.Foundation.DateTime): Windows.UI.Shell.FocusSession;
+    readonly IsFocusActive: boolean;
+    IsFocusActiveChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Shell.FocusSessionManager, Object> | null;
+  }
+  var IFocusSessionManager: abstract new (...args: any[]) => IFocusSessionManager;
+
+  interface IFocusSessionManagerStatics {
+    GetDefault(): Windows.UI.Shell.FocusSessionManager;
+    readonly IsSupported: boolean;
+  }
+  var IFocusSessionManagerStatics: abstract new (...args: any[]) => IFocusSessionManagerStatics;
+
+  interface ISecurityAppManager {
+    Register(kind: number, displayName: string, detailsUri: Windows.Foundation.Uri, registerPerUser: boolean): Guid;
+    Unregister(kind: number, guidRegistration: Guid): void;
+    UpdateState(kind: number, guidRegistration: Guid, state: number, substatus: number, detailsUri: Windows.Foundation.Uri): void;
+  }
+  var ISecurityAppManager: abstract new (...args: any[]) => ISecurityAppManager;
+
+  interface IShareWindowCommandEventArgs {
+    Command: number;
+    readonly WindowId: Windows.UI.WindowId;
+  }
+  var IShareWindowCommandEventArgs: abstract new (...args: any[]) => IShareWindowCommandEventArgs;
+
+  interface IShareWindowCommandSource {
+    ReportCommandChanged(): void;
+    Start(): void;
+    Stop(): void;
+    CommandInvoked: Windows.Foundation.TypedEventHandler<Windows.UI.Shell.ShareWindowCommandSource, Windows.UI.Shell.ShareWindowCommandEventArgs> | null;
+    CommandRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Shell.ShareWindowCommandSource, Windows.UI.Shell.ShareWindowCommandEventArgs> | null;
+  }
+  var IShareWindowCommandSource: abstract new (...args: any[]) => IShareWindowCommandSource;
+
+  interface IShareWindowCommandSourceStatics {
+    GetForCurrentView(): Windows.UI.Shell.ShareWindowCommandSource;
+  }
+  var IShareWindowCommandSourceStatics: abstract new (...args: any[]) => IShareWindowCommandSourceStatics;
+
+  interface ITaskbarManager {
+    IsAppListEntryPinnedAsync(appListEntry: Windows.ApplicationModel.Core.AppListEntry): Windows.Foundation.IAsyncOperation<boolean>;
+    IsCurrentAppPinnedAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestPinAppListEntryAsync(appListEntry: Windows.ApplicationModel.Core.AppListEntry): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestPinCurrentAppAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly IsPinningAllowed: boolean;
+    readonly IsSupported: boolean;
+  }
+  var ITaskbarManager: abstract new (...args: any[]) => ITaskbarManager;
+
+  interface ITaskbarManager2 extends Windows.UI.Shell.ITaskbarManager {
+    IsAppListEntryPinnedAsync(appListEntry: Windows.ApplicationModel.Core.AppListEntry): Windows.Foundation.IAsyncOperation<boolean>;
+    IsCurrentAppPinnedAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    IsSecondaryTilePinnedAsync(tileId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestPinAppListEntryAsync(appListEntry: Windows.ApplicationModel.Core.AppListEntry): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestPinCurrentAppAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestPinSecondaryTileAsync(secondaryTile: Windows.UI.StartScreen.SecondaryTile): Windows.Foundation.IAsyncOperation<boolean>;
+    TryUnpinSecondaryTileAsync(tileId: string): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var ITaskbarManager2: abstract new (...args: any[]) => ITaskbarManager2;
+
+  interface ITaskbarManagerDesktopAppSupportStatics {
+  }
+  var ITaskbarManagerDesktopAppSupportStatics: abstract new (...args: any[]) => ITaskbarManagerDesktopAppSupportStatics;
+
+  interface ITaskbarManagerStatics {
+    GetDefault(): Windows.UI.Shell.TaskbarManager;
+  }
+  var ITaskbarManagerStatics: abstract new (...args: any[]) => ITaskbarManagerStatics;
+
+  interface IWindowTab {
+    ReportThumbnailAvailable(): void;
+    Group: Windows.UI.Shell.WindowTabGroup;
+    Icon: Windows.UI.Shell.WindowTabIcon;
+    Tag: Object;
+    Title: string;
+    TreatAsSecondaryTileId: string;
+  }
+  var IWindowTab: abstract new (...args: any[]) => IWindowTab;
+
+  interface IWindowTabCloseRequestedEventArgs {
+    readonly Tab: Windows.UI.Shell.WindowTab;
+  }
+  var IWindowTabCloseRequestedEventArgs: abstract new (...args: any[]) => IWindowTabCloseRequestedEventArgs;
+
+  interface IWindowTabCollection {
+    MoveTab(tab: Windows.UI.Shell.WindowTab, index: number): void;
+  }
+  var IWindowTabCollection: abstract new (...args: any[]) => IWindowTabCollection;
+
+  interface IWindowTabGroup {
+    Icon: Windows.UI.Shell.WindowTabIcon;
+    Title: string;
+  }
+  var IWindowTabGroup: abstract new (...args: any[]) => IWindowTabGroup;
+
+  interface IWindowTabIcon {
+  }
+  var IWindowTabIcon: abstract new (...args: any[]) => IWindowTabIcon;
+
+  interface IWindowTabIconStatics {
+    CreateFromFontGlyph(glyph: string, fontFamily: string): Windows.UI.Shell.WindowTabIcon;
+    CreateFromFontGlyph(glyph: string, fontFamily: string, fontUri: Windows.Foundation.Uri): Windows.UI.Shell.WindowTabIcon;
+    CreateFromImage(image: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.UI.Shell.WindowTabIcon;
+  }
+  var IWindowTabIconStatics: abstract new (...args: any[]) => IWindowTabIconStatics;
+
+  interface IWindowTabManager {
+    SetActiveTab(tab: Windows.UI.Shell.WindowTab): void;
+    readonly Tabs: Windows.UI.Shell.WindowTabCollection;
+    TabCloseRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Shell.WindowTabManager, Windows.UI.Shell.WindowTabCloseRequestedEventArgs> | null;
+    TabSwitchRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Shell.WindowTabManager, Windows.UI.Shell.WindowTabSwitchRequestedEventArgs> | null;
+    TabTearOutRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Shell.WindowTabManager, Windows.UI.Shell.WindowTabTearOutRequestedEventArgs> | null;
+    TabThumbnailRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Shell.WindowTabManager, Windows.UI.Shell.WindowTabThumbnailRequestedEventArgs> | null;
+  }
+  var IWindowTabManager: abstract new (...args: any[]) => IWindowTabManager;
+
+  interface IWindowTabManagerStatics {
+    GetForWindow(id: Windows.UI.WindowId): Windows.UI.Shell.WindowTabManager;
+    IsSupported(): boolean;
+    IsTabTearOutSupported(): boolean;
+  }
+  var IWindowTabManagerStatics: abstract new (...args: any[]) => IWindowTabManagerStatics;
+
+  interface IWindowTabSwitchRequestedEventArgs {
+    readonly Tab: Windows.UI.Shell.WindowTab;
+  }
+  var IWindowTabSwitchRequestedEventArgs: abstract new (...args: any[]) => IWindowTabSwitchRequestedEventArgs;
+
+  interface IWindowTabTearOutRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Tab: Windows.UI.Shell.WindowTab;
+    WindowId: number | bigint;
+  }
+  var IWindowTabTearOutRequestedEventArgs: abstract new (...args: any[]) => IWindowTabTearOutRequestedEventArgs;
+
+  interface IWindowTabThumbnailRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Image: Windows.Storage.Streams.IRandomAccessStreamReference;
+    readonly IsCompositedOnWindow: boolean;
+    readonly RequestedSize: Windows.Graphics.Imaging.BitmapSize;
+    readonly Tab: Windows.UI.Shell.WindowTab;
+  }
+  var IWindowTabThumbnailRequestedEventArgs: abstract new (...args: any[]) => IWindowTabThumbnailRequestedEventArgs;
+
+  interface SecurityAppManagerContract {
+  }
+  var SecurityAppManagerContract: {
+    new(fields: {  }): SecurityAppManagerContract;
+  };
+
+  interface WindowTabManagerContract {
+  }
+  var WindowTabManagerContract: {
+    new(fields: {  }): WindowTabManagerContract;
+  };
+
+}
+
+declare namespace Windows.UI.StartScreen {
+  class JumpList implements Windows.UI.StartScreen.IJumpList {
+    static IsSupported(): boolean;
+    static LoadCurrentAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.StartScreen.JumpList>;
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.UI.StartScreen.JumpListItem> | Windows.UI.StartScreen.JumpListItem[];
+    SystemGroupKind: number;
+  }
+
+  class JumpListItem implements Windows.UI.StartScreen.IJumpListItem {
+    static CreateSeparator(): Windows.UI.StartScreen.JumpListItem;
+    static CreateWithArguments(arguments_: string, displayName: string): Windows.UI.StartScreen.JumpListItem;
+    readonly Arguments: string;
+    Description: string;
+    DisplayName: string;
+    GroupName: string;
+    readonly Kind: number;
+    Logo: Windows.Foundation.Uri;
+    readonly RemovedByUser: boolean;
+  }
+
+  class SecondaryTile implements Windows.UI.StartScreen.ISecondaryTile, Windows.UI.StartScreen.ISecondaryTile2 {
+    constructor(tileId: string, displayName: string, arguments_: string, square150x150Logo: Windows.Foundation.Uri, desiredSize: number);
+    constructor(tileId: string, shortName: string, displayName: string, arguments_: string, tileOptions: number, logoReference: Windows.Foundation.Uri);
+    constructor(tileId: string, shortName: string, displayName: string, arguments_: string, tileOptions: number, logoReference: Windows.Foundation.Uri, wideLogoReference: Windows.Foundation.Uri);
+    constructor(tileId: string);
+    constructor();
+    static Exists(tileId: string): boolean;
+    static FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.UI.StartScreen.SecondaryTile> | Windows.UI.StartScreen.SecondaryTile[]>;
+    static FindAllAsync(applicationId: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.UI.StartScreen.SecondaryTile> | Windows.UI.StartScreen.SecondaryTile[]>;
+    static FindAllForPackageAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.UI.StartScreen.SecondaryTile> | Windows.UI.StartScreen.SecondaryTile[]>;
+    RequestCreateAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestCreateAsync(invocationPoint: Windows.Foundation.Point): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestCreateForSelectionAsync(selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestCreateForSelectionAsync(selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestDeleteAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestDeleteAsync(invocationPoint: Windows.Foundation.Point): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestDeleteForSelectionAsync(selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestDeleteForSelectionAsync(selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<boolean>;
+    UpdateAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    Arguments: string;
+    BackgroundColor: Windows.UI.Color;
+    DisplayName: string;
+    ForegroundText: number;
+    LockScreenBadgeLogo: Windows.Foundation.Uri;
+    LockScreenDisplayBadgeAndTileText: boolean;
+    Logo: Windows.Foundation.Uri;
+    PhoneticName: string;
+    RoamingEnabled: boolean;
+    ShortName: string;
+    SmallLogo: Windows.Foundation.Uri;
+    TileId: string;
+    TileOptions: number;
+    readonly VisualElements: Windows.UI.StartScreen.SecondaryTileVisualElements;
+    WideLogo: Windows.Foundation.Uri;
+    VisualElementsRequested: Windows.Foundation.TypedEventHandler<Windows.UI.StartScreen.SecondaryTile, Windows.UI.StartScreen.VisualElementsRequestedEventArgs> | null;
+  }
+
+  class SecondaryTileVisualElements implements Windows.UI.StartScreen.ISecondaryTileVisualElements, Windows.UI.StartScreen.ISecondaryTileVisualElements2, Windows.UI.StartScreen.ISecondaryTileVisualElements3, Windows.UI.StartScreen.ISecondaryTileVisualElements4 {
+    BackgroundColor: Windows.UI.Color;
+    ForegroundText: number;
+    readonly MixedRealityModel: Windows.UI.StartScreen.TileMixedRealityModel;
+    ShowNameOnSquare150x150Logo: boolean;
+    ShowNameOnSquare310x310Logo: boolean;
+    ShowNameOnWide310x150Logo: boolean;
+    Square150x150Logo: Windows.Foundation.Uri;
+    Square30x30Logo: Windows.Foundation.Uri;
+    Square310x310Logo: Windows.Foundation.Uri;
+    Square44x44Logo: Windows.Foundation.Uri;
+    Square70x70Logo: Windows.Foundation.Uri;
+    Square71x71Logo: Windows.Foundation.Uri;
+    Wide310x150Logo: Windows.Foundation.Uri;
+  }
+
+  class StartScreenManager implements Windows.UI.StartScreen.IStartScreenManager, Windows.UI.StartScreen.IStartScreenManager2 {
+    ContainsAppListEntryAsync(appListEntry: Windows.ApplicationModel.Core.AppListEntry): Windows.Foundation.IAsyncOperation<boolean>;
+    ContainsSecondaryTileAsync(tileId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    static GetDefault(): Windows.UI.StartScreen.StartScreenManager;
+    static GetForUser(user: Windows.System.User): Windows.UI.StartScreen.StartScreenManager;
+    RequestAddAppListEntryAsync(appListEntry: Windows.ApplicationModel.Core.AppListEntry): Windows.Foundation.IAsyncOperation<boolean>;
+    SupportsAppListEntry(appListEntry: Windows.ApplicationModel.Core.AppListEntry): boolean;
+    TryRemoveSecondaryTileAsync(tileId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly User: Windows.System.User;
+  }
+
+  class TileMixedRealityModel implements Windows.UI.StartScreen.ITileMixedRealityModel, Windows.UI.StartScreen.ITileMixedRealityModel2 {
+    ActivationBehavior: number;
+    BoundingBox: Windows.Perception.Spatial.SpatialBoundingBox | null;
+    Uri: Windows.Foundation.Uri;
+  }
+
+  class VisualElementsRequest implements Windows.UI.StartScreen.IVisualElementsRequest {
+    GetDeferral(): Windows.UI.StartScreen.VisualElementsRequestDeferral;
+    readonly AlternateVisualElements: Windows.Foundation.Collections.IVectorView<Windows.UI.StartScreen.SecondaryTileVisualElements> | Windows.UI.StartScreen.SecondaryTileVisualElements[];
+    readonly Deadline: Windows.Foundation.DateTime;
+    readonly VisualElements: Windows.UI.StartScreen.SecondaryTileVisualElements;
+  }
+
+  class VisualElementsRequestDeferral implements Windows.UI.StartScreen.IVisualElementsRequestDeferral {
+    Complete(): void;
+  }
+
+  class VisualElementsRequestedEventArgs implements Windows.UI.StartScreen.IVisualElementsRequestedEventArgs {
+    readonly Request: Windows.UI.StartScreen.VisualElementsRequest;
+  }
+
+  enum ForegroundText {
+    Dark = 0,
+    Light = 1,
+  }
+
+  enum JumpListItemKind {
+    Arguments = 0,
+    Separator = 1,
+  }
+
+  enum JumpListSystemGroupKind {
+    None = 0,
+    Frequent = 1,
+    Recent = 2,
+  }
+
+  enum TileMixedRealityModelActivationBehavior {
+    Default = 0,
+    None = 1,
+  }
+
+  enum TileOptions {
+    None = 0,
+    ShowNameOnLogo = 1,
+    ShowNameOnWideLogo = 2,
+    CopyOnDeployment = 4,
+  }
+
+  enum TileSize {
+    Default = 0,
+    Square30x30 = 1,
+    Square70x70 = 2,
+    Square150x150 = 3,
+    Wide310x150 = 4,
+    Square310x310 = 5,
+    Square71x71 = 6,
+    Square44x44 = 7,
+  }
+
+  interface IJumpList {
+    SaveAsync(): Windows.Foundation.IAsyncAction;
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.UI.StartScreen.JumpListItem> | Windows.UI.StartScreen.JumpListItem[];
+    SystemGroupKind: number;
+  }
+  var IJumpList: abstract new (...args: any[]) => IJumpList;
+
+  interface IJumpListItem {
+    readonly Arguments: string;
+    Description: string;
+    DisplayName: string;
+    GroupName: string;
+    readonly Kind: number;
+    Logo: Windows.Foundation.Uri;
+    readonly RemovedByUser: boolean;
+  }
+  var IJumpListItem: abstract new (...args: any[]) => IJumpListItem;
+
+  interface IJumpListItemStatics {
+    CreateSeparator(): Windows.UI.StartScreen.JumpListItem;
+    CreateWithArguments(arguments_: string, displayName: string): Windows.UI.StartScreen.JumpListItem;
+  }
+  var IJumpListItemStatics: abstract new (...args: any[]) => IJumpListItemStatics;
+
+  interface IJumpListStatics {
+    IsSupported(): boolean;
+    LoadCurrentAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.StartScreen.JumpList>;
+  }
+  var IJumpListStatics: abstract new (...args: any[]) => IJumpListStatics;
+
+  interface ISecondaryTile {
+    RequestCreateAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestCreateAsync(invocationPoint: Windows.Foundation.Point): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestCreateForSelectionAsync(selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestCreateForSelectionAsync(selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestDeleteAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestDeleteAsync(invocationPoint: Windows.Foundation.Point): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestDeleteForSelectionAsync(selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestDeleteForSelectionAsync(selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<boolean>;
+    UpdateAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    Arguments: string;
+    BackgroundColor: Windows.UI.Color;
+    DisplayName: string;
+    ForegroundText: number;
+    LockScreenBadgeLogo: Windows.Foundation.Uri;
+    LockScreenDisplayBadgeAndTileText: boolean;
+    Logo: Windows.Foundation.Uri;
+    ShortName: string;
+    SmallLogo: Windows.Foundation.Uri;
+    TileId: string;
+    TileOptions: number;
+    WideLogo: Windows.Foundation.Uri;
+  }
+  var ISecondaryTile: abstract new (...args: any[]) => ISecondaryTile;
+
+  interface ISecondaryTile2 extends Windows.UI.StartScreen.ISecondaryTile {
+    RequestCreateAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestCreateAsync(invocationPoint: Windows.Foundation.Point): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestCreateForSelectionAsync(selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestCreateForSelectionAsync(selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestDeleteAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestDeleteAsync(invocationPoint: Windows.Foundation.Point): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestDeleteForSelectionAsync(selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestDeleteForSelectionAsync(selection: Windows.Foundation.Rect, preferredPlacement: number): Windows.Foundation.IAsyncOperation<boolean>;
+    UpdateAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    PhoneticName: string;
+    RoamingEnabled: boolean;
+    readonly VisualElements: Windows.UI.StartScreen.SecondaryTileVisualElements;
+    VisualElementsRequested: Windows.Foundation.TypedEventHandler<Windows.UI.StartScreen.SecondaryTile, Windows.UI.StartScreen.VisualElementsRequestedEventArgs> | null;
+  }
+  var ISecondaryTile2: abstract new (...args: any[]) => ISecondaryTile2;
+
+  interface ISecondaryTileFactory {
+    CreateTile(tileId: string, shortName: string, displayName: string, arguments_: string, tileOptions: number, logoReference: Windows.Foundation.Uri): Windows.UI.StartScreen.SecondaryTile;
+    CreateWideTile(tileId: string, shortName: string, displayName: string, arguments_: string, tileOptions: number, logoReference: Windows.Foundation.Uri, wideLogoReference: Windows.Foundation.Uri): Windows.UI.StartScreen.SecondaryTile;
+    CreateWithId(tileId: string): Windows.UI.StartScreen.SecondaryTile;
+  }
+  var ISecondaryTileFactory: abstract new (...args: any[]) => ISecondaryTileFactory;
+
+  interface ISecondaryTileFactory2 extends Windows.UI.StartScreen.ISecondaryTileFactory {
+    CreateMinimalTile(tileId: string, displayName: string, arguments_: string, square150x150Logo: Windows.Foundation.Uri, desiredSize: number): Windows.UI.StartScreen.SecondaryTile;
+    CreateTile(tileId: string, shortName: string, displayName: string, arguments_: string, tileOptions: number, logoReference: Windows.Foundation.Uri): Windows.UI.StartScreen.SecondaryTile;
+    CreateWideTile(tileId: string, shortName: string, displayName: string, arguments_: string, tileOptions: number, logoReference: Windows.Foundation.Uri, wideLogoReference: Windows.Foundation.Uri): Windows.UI.StartScreen.SecondaryTile;
+    CreateWithId(tileId: string): Windows.UI.StartScreen.SecondaryTile;
+  }
+  var ISecondaryTileFactory2: abstract new (...args: any[]) => ISecondaryTileFactory2;
+
+  interface ISecondaryTileStatics {
+    Exists(tileId: string): boolean;
+    FindAllAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.UI.StartScreen.SecondaryTile> | Windows.UI.StartScreen.SecondaryTile[]>;
+    FindAllAsync(applicationId: string): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.UI.StartScreen.SecondaryTile> | Windows.UI.StartScreen.SecondaryTile[]>;
+    FindAllForPackageAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.UI.StartScreen.SecondaryTile> | Windows.UI.StartScreen.SecondaryTile[]>;
+  }
+  var ISecondaryTileStatics: abstract new (...args: any[]) => ISecondaryTileStatics;
+
+  interface ISecondaryTileVisualElements {
+    BackgroundColor: Windows.UI.Color;
+    ForegroundText: number;
+    ShowNameOnSquare150x150Logo: boolean;
+    ShowNameOnSquare310x310Logo: boolean;
+    ShowNameOnWide310x150Logo: boolean;
+    Square150x150Logo: Windows.Foundation.Uri;
+    Square30x30Logo: Windows.Foundation.Uri;
+    Square310x310Logo: Windows.Foundation.Uri;
+    Square70x70Logo: Windows.Foundation.Uri;
+    Wide310x150Logo: Windows.Foundation.Uri;
+  }
+  var ISecondaryTileVisualElements: abstract new (...args: any[]) => ISecondaryTileVisualElements;
+
+  interface ISecondaryTileVisualElements2 {
+    Square71x71Logo: Windows.Foundation.Uri;
+  }
+  var ISecondaryTileVisualElements2: abstract new (...args: any[]) => ISecondaryTileVisualElements2;
+
+  interface ISecondaryTileVisualElements3 {
+    Square44x44Logo: Windows.Foundation.Uri;
+  }
+  var ISecondaryTileVisualElements3: abstract new (...args: any[]) => ISecondaryTileVisualElements3;
+
+  interface ISecondaryTileVisualElements4 {
+    readonly MixedRealityModel: Windows.UI.StartScreen.TileMixedRealityModel;
+  }
+  var ISecondaryTileVisualElements4: abstract new (...args: any[]) => ISecondaryTileVisualElements4;
+
+  interface IStartScreenManager {
+    ContainsAppListEntryAsync(appListEntry: Windows.ApplicationModel.Core.AppListEntry): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestAddAppListEntryAsync(appListEntry: Windows.ApplicationModel.Core.AppListEntry): Windows.Foundation.IAsyncOperation<boolean>;
+    SupportsAppListEntry(appListEntry: Windows.ApplicationModel.Core.AppListEntry): boolean;
+    readonly User: Windows.System.User;
+  }
+  var IStartScreenManager: abstract new (...args: any[]) => IStartScreenManager;
+
+  interface IStartScreenManager2 extends Windows.UI.StartScreen.IStartScreenManager {
+    ContainsAppListEntryAsync(appListEntry: Windows.ApplicationModel.Core.AppListEntry): Windows.Foundation.IAsyncOperation<boolean>;
+    ContainsSecondaryTileAsync(tileId: string): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestAddAppListEntryAsync(appListEntry: Windows.ApplicationModel.Core.AppListEntry): Windows.Foundation.IAsyncOperation<boolean>;
+    SupportsAppListEntry(appListEntry: Windows.ApplicationModel.Core.AppListEntry): boolean;
+    TryRemoveSecondaryTileAsync(tileId: string): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IStartScreenManager2: abstract new (...args: any[]) => IStartScreenManager2;
+
+  interface IStartScreenManagerStatics {
+    GetDefault(): Windows.UI.StartScreen.StartScreenManager;
+    GetForUser(user: Windows.System.User): Windows.UI.StartScreen.StartScreenManager;
+  }
+  var IStartScreenManagerStatics: abstract new (...args: any[]) => IStartScreenManagerStatics;
+
+  interface ITileMixedRealityModel {
+    BoundingBox: Windows.Perception.Spatial.SpatialBoundingBox | null;
+    Uri: Windows.Foundation.Uri;
+  }
+  var ITileMixedRealityModel: abstract new (...args: any[]) => ITileMixedRealityModel;
+
+  interface ITileMixedRealityModel2 {
+    ActivationBehavior: number;
+  }
+  var ITileMixedRealityModel2: abstract new (...args: any[]) => ITileMixedRealityModel2;
+
+  interface IVisualElementsRequest {
+    GetDeferral(): Windows.UI.StartScreen.VisualElementsRequestDeferral;
+    readonly AlternateVisualElements: Windows.Foundation.Collections.IVectorView<Windows.UI.StartScreen.SecondaryTileVisualElements> | Windows.UI.StartScreen.SecondaryTileVisualElements[];
+    readonly Deadline: Windows.Foundation.DateTime;
+    readonly VisualElements: Windows.UI.StartScreen.SecondaryTileVisualElements;
+  }
+  var IVisualElementsRequest: abstract new (...args: any[]) => IVisualElementsRequest;
+
+  interface IVisualElementsRequestDeferral {
+    Complete(): void;
+  }
+  var IVisualElementsRequestDeferral: abstract new (...args: any[]) => IVisualElementsRequestDeferral;
+
+  interface IVisualElementsRequestedEventArgs {
+    readonly Request: Windows.UI.StartScreen.VisualElementsRequest;
+  }
+  var IVisualElementsRequestedEventArgs: abstract new (...args: any[]) => IVisualElementsRequestedEventArgs;
+
+}
+
+declare namespace Windows.UI.Text {
+  class ContentLinkInfo implements Windows.UI.Text.IContentLinkInfo {
+    constructor();
+    DisplayText: string;
+    Id: number;
+    LinkContentKind: string;
+    SecondaryText: string;
+    Uri: Windows.Foundation.Uri;
+  }
+
+  class FontWeights implements Windows.UI.Text.IFontWeights {
+    static readonly Black: Windows.UI.Text.FontWeight;
+    static readonly Bold: Windows.UI.Text.FontWeight;
+    static readonly ExtraBlack: Windows.UI.Text.FontWeight;
+    static readonly ExtraBold: Windows.UI.Text.FontWeight;
+    static readonly ExtraLight: Windows.UI.Text.FontWeight;
+    static readonly Light: Windows.UI.Text.FontWeight;
+    static readonly Medium: Windows.UI.Text.FontWeight;
+    static readonly Normal: Windows.UI.Text.FontWeight;
+    static readonly SemiBold: Windows.UI.Text.FontWeight;
+    static readonly SemiLight: Windows.UI.Text.FontWeight;
+    static readonly Thin: Windows.UI.Text.FontWeight;
+  }
+
+  class RichEditTextDocument implements Windows.UI.Text.ITextDocument, Windows.UI.Text.ITextDocument2, Windows.UI.Text.ITextDocument3, Windows.UI.Text.ITextDocument4 {
+    ApplyDisplayUpdates(): number;
+    BatchDisplayUpdates(): number;
+    BeginUndoGroup(): void;
+    CanCopy(): boolean;
+    CanPaste(): boolean;
+    CanRedo(): boolean;
+    CanUndo(): boolean;
+    ClearUndoRedoHistory(): void;
+    EndUndoGroup(): void;
+    GetDefaultCharacterFormat(): Windows.UI.Text.ITextCharacterFormat;
+    GetDefaultParagraphFormat(): Windows.UI.Text.ITextParagraphFormat;
+    GetMath(value: string): void;
+    GetRange(startPosition: number, endPosition: number): Windows.UI.Text.ITextRange;
+    GetRangeFromPoint(point: Windows.Foundation.Point, options: number): Windows.UI.Text.ITextRange;
+    GetText(options: number, value: string): void;
+    LoadFromStream(options: number, value: Windows.Storage.Streams.IRandomAccessStream): void;
+    Redo(): void;
+    SaveToStream(options: number, value: Windows.Storage.Streams.IRandomAccessStream): void;
+    SetDefaultCharacterFormat(value: Windows.UI.Text.ITextCharacterFormat): void;
+    SetDefaultParagraphFormat(value: Windows.UI.Text.ITextParagraphFormat): void;
+    SetMath(value: string): void;
+    SetMathMode(mode: number): void;
+    SetText(options: number, value: string): void;
+    Undo(): void;
+    AlignmentIncludesTrailingWhitespace: boolean;
+    CaretType: number;
+    DefaultTabStop: number;
+    IgnoreTrailingCharacterSpacing: boolean;
+    readonly Selection: Windows.UI.Text.ITextSelection;
+    UndoLimit: number;
+  }
+
+  class RichEditTextRange implements Windows.UI.Text.IRichEditTextRange, Windows.UI.Text.ITextRange {
+    CanPaste(format: number): boolean;
+    ChangeCase(value: number): void;
+    Collapse(value: boolean): void;
+    Copy(): void;
+    Cut(): void;
+    Delete(unit: number, count: number): number;
+    EndOf(unit: number, extend: boolean): number;
+    Expand(unit: number): number;
+    FindText(value: string, scanLength: number, options: number): number;
+    GetCharacterUtf32(value: number, offset: number): void;
+    GetClone(): Windows.UI.Text.ITextRange;
+    GetIndex(unit: number): number;
+    GetPoint(horizontalAlign: number, verticalAlign: number, options: number, point: Windows.Foundation.Point): void;
+    GetRect(options: number, rect: Windows.Foundation.Rect, hit: number): void;
+    GetText(options: number, value: string): void;
+    GetTextViaStream(options: number, value: Windows.Storage.Streams.IRandomAccessStream): void;
+    InRange(range: Windows.UI.Text.ITextRange): boolean;
+    InStory(range: Windows.UI.Text.ITextRange): boolean;
+    InsertImage(width: number, height: number, ascent: number, verticalAlign: number, alternateText: string, value: Windows.Storage.Streams.IRandomAccessStream): void;
+    IsEqual(range: Windows.UI.Text.ITextRange): boolean;
+    MatchSelection(): void;
+    Move(unit: number, count: number): number;
+    MoveEnd(unit: number, count: number): number;
+    MoveStart(unit: number, count: number): number;
+    Paste(format: number): void;
+    ScrollIntoView(value: number): void;
+    SetIndex(unit: number, index: number, extend: boolean): void;
+    SetPoint(point: Windows.Foundation.Point, options: number, extend: boolean): void;
+    SetRange(startPosition: number, endPosition: number): void;
+    SetText(options: number, value: string): void;
+    SetTextViaStream(options: number, value: Windows.Storage.Streams.IRandomAccessStream): void;
+    StartOf(unit: number, extend: boolean): number;
+    Character: string;
+    CharacterFormat: Windows.UI.Text.ITextCharacterFormat;
+    ContentLinkInfo: Windows.UI.Text.ContentLinkInfo;
+    EndPosition: number;
+    FormattedText: Windows.UI.Text.ITextRange;
+    Gravity: number;
+    readonly Length: number;
+    Link: string;
+    ParagraphFormat: Windows.UI.Text.ITextParagraphFormat;
+    StartPosition: number;
+    readonly StoryLength: number;
+    Text: string;
+  }
+
+  class TextConstants {
+    static readonly AutoColor: Windows.UI.Color;
+    static readonly MaxUnitCount: number;
+    static readonly MinUnitCount: number;
+    static readonly UndefinedColor: Windows.UI.Color;
+    static readonly UndefinedFloatValue: number;
+    static readonly UndefinedFontStretch: number;
+    static readonly UndefinedFontStyle: number;
+    static readonly UndefinedInt32Value: number;
+  }
+
+  enum CaretType {
+    Normal = 0,
+    Null = 1,
+  }
+
+  enum FindOptions {
+    None = 0,
+    Word = 2,
+    Case = 4,
+  }
+
+  enum FontStretch {
+    Undefined = 0,
+    UltraCondensed = 1,
+    ExtraCondensed = 2,
+    Condensed = 3,
+    SemiCondensed = 4,
+    Normal = 5,
+    SemiExpanded = 6,
+    Expanded = 7,
+    ExtraExpanded = 8,
+    UltraExpanded = 9,
+  }
+
+  enum FontStyle {
+    Normal = 0,
+    Oblique = 1,
+    Italic = 2,
+  }
+
+  enum FormatEffect {
+    Off = 0,
+    On = 1,
+    Toggle = 2,
+    Undefined = 3,
+  }
+
+  enum HorizontalCharacterAlignment {
+    Left = 0,
+    Right = 1,
+    Center = 2,
+  }
+
+  enum LetterCase {
+    Lower = 0,
+    Upper = 1,
+  }
+
+  enum LineSpacingRule {
+    Undefined = 0,
+    Single = 1,
+    OneAndHalf = 2,
+    Double = 3,
+    AtLeast = 4,
+    Exactly = 5,
+    Multiple = 6,
+    Percent = 7,
+  }
+
+  enum LinkType {
+    Undefined = 0,
+    NotALink = 1,
+    ClientLink = 2,
+    FriendlyLinkName = 3,
+    FriendlyLinkAddress = 4,
+    AutoLink = 5,
+    AutoLinkEmail = 6,
+    AutoLinkPhone = 7,
+    AutoLinkPath = 8,
+  }
+
+  enum MarkerAlignment {
+    Undefined = 0,
+    Left = 1,
+    Center = 2,
+    Right = 3,
+  }
+
+  enum MarkerStyle {
+    Undefined = 0,
+    Parenthesis = 1,
+    Parentheses = 2,
+    Period = 3,
+    Plain = 4,
+    Minus = 5,
+    NoNumber = 6,
+  }
+
+  enum MarkerType {
+    Undefined = 0,
+    None = 1,
+    Bullet = 2,
+    Arabic = 3,
+    LowercaseEnglishLetter = 4,
+    UppercaseEnglishLetter = 5,
+    LowercaseRoman = 6,
+    UppercaseRoman = 7,
+    UnicodeSequence = 8,
+    CircledNumber = 9,
+    BlackCircleWingding = 10,
+    WhiteCircleWingding = 11,
+    ArabicWide = 12,
+    SimplifiedChinese = 13,
+    TraditionalChinese = 14,
+    JapanSimplifiedChinese = 15,
+    JapanKorea = 16,
+    ArabicDictionary = 17,
+    ArabicAbjad = 18,
+    Hebrew = 19,
+    ThaiAlphabetic = 20,
+    ThaiNumeric = 21,
+    DevanagariVowel = 22,
+    DevanagariConsonant = 23,
+    DevanagariNumeric = 24,
+  }
+
+  enum ParagraphAlignment {
+    Undefined = 0,
+    Left = 1,
+    Center = 2,
+    Right = 3,
+    Justify = 4,
+  }
+
+  enum ParagraphStyle {
+    Undefined = 0,
+    None = 1,
+    Normal = 2,
+    Heading1 = 3,
+    Heading2 = 4,
+    Heading3 = 5,
+    Heading4 = 6,
+    Heading5 = 7,
+    Heading6 = 8,
+    Heading7 = 9,
+    Heading8 = 10,
+    Heading9 = 11,
+  }
+
+  enum PointOptions {
+    None = 0,
+    IncludeInset = 1,
+    Start = 32,
+    ClientCoordinates = 256,
+    AllowOffClient = 512,
+    Transform = 1024,
+    NoHorizontalScroll = 65536,
+    NoVerticalScroll = 262144,
+  }
+
+  enum RangeGravity {
+    UIBehavior = 0,
+    Backward = 1,
+    Forward = 2,
+    Inward = 3,
+    Outward = 4,
+  }
+
+  enum RichEditMathMode {
+    NoMath = 0,
+    MathOnly = 1,
+  }
+
+  enum SelectionOptions {
+    StartActive = 1,
+    AtEndOfLine = 2,
+    Overtype = 4,
+    Active = 8,
+    Replace = 16,
+  }
+
+  enum SelectionType {
+    None = 0,
+    InsertionPoint = 1,
+    Normal = 2,
+    InlineShape = 7,
+    Shape = 8,
+  }
+
+  enum TabAlignment {
+    Left = 0,
+    Center = 1,
+    Right = 2,
+    Decimal = 3,
+    Bar = 4,
+  }
+
+  enum TabLeader {
+    Spaces = 0,
+    Dots = 1,
+    Dashes = 2,
+    Lines = 3,
+    ThickLines = 4,
+    Equals = 5,
+  }
+
+  enum TextDecorations {
+    None = 0,
+    Underline = 1,
+    Strikethrough = 2,
+  }
+
+  enum TextGetOptions {
+    None = 0,
+    AdjustCrlf = 1,
+    UseCrlf = 2,
+    UseObjectText = 4,
+    AllowFinalEop = 8,
+    NoHidden = 32,
+    IncludeNumbering = 64,
+    FormatRtf = 8192,
+    UseLf = 16777216,
+  }
+
+  enum TextRangeUnit {
+    Character = 0,
+    Word = 1,
+    Sentence = 2,
+    Paragraph = 3,
+    Line = 4,
+    Story = 5,
+    Screen = 6,
+    Section = 7,
+    Window = 8,
+    CharacterFormat = 9,
+    ParagraphFormat = 10,
+    Object = 11,
+    HardParagraph = 12,
+    Cluster = 13,
+    Bold = 14,
+    Italic = 15,
+    Underline = 16,
+    Strikethrough = 17,
+    ProtectedText = 18,
+    Link = 19,
+    SmallCaps = 20,
+    AllCaps = 21,
+    Hidden = 22,
+    Outline = 23,
+    Shadow = 24,
+    Imprint = 25,
+    Disabled = 26,
+    Revised = 27,
+    Subscript = 28,
+    Superscript = 29,
+    FontBound = 30,
+    LinkProtected = 31,
+    ContentLink = 32,
+  }
+
+  enum TextScript {
+    Undefined = 0,
+    Ansi = 1,
+    EastEurope = 2,
+    Cyrillic = 3,
+    Greek = 4,
+    Turkish = 5,
+    Hebrew = 6,
+    Arabic = 7,
+    Baltic = 8,
+    Vietnamese = 9,
+    Default = 10,
+    Symbol = 11,
+    Thai = 12,
+    ShiftJis = 13,
+    GB2312 = 14,
+    Hangul = 15,
+    Big5 = 16,
+    PC437 = 17,
+    Oem = 18,
+    Mac = 19,
+    Armenian = 20,
+    Syriac = 21,
+    Thaana = 22,
+    Devanagari = 23,
+    Bengali = 24,
+    Gurmukhi = 25,
+    Gujarati = 26,
+    Oriya = 27,
+    Tamil = 28,
+    Telugu = 29,
+    Kannada = 30,
+    Malayalam = 31,
+    Sinhala = 32,
+    Lao = 33,
+    Tibetan = 34,
+    Myanmar = 35,
+    Georgian = 36,
+    Jamo = 37,
+    Ethiopic = 38,
+    Cherokee = 39,
+    Aboriginal = 40,
+    Ogham = 41,
+    Runic = 42,
+    Khmer = 43,
+    Mongolian = 44,
+    Braille = 45,
+    Yi = 46,
+    Limbu = 47,
+    TaiLe = 48,
+    NewTaiLue = 49,
+    SylotiNagri = 50,
+    Kharoshthi = 51,
+    Kayahli = 52,
+    UnicodeSymbol = 53,
+    Emoji = 54,
+    Glagolitic = 55,
+    Lisu = 56,
+    Vai = 57,
+    NKo = 58,
+    Osmanya = 59,
+    PhagsPa = 60,
+    Gothic = 61,
+    Deseret = 62,
+    Tifinagh = 63,
+  }
+
+  enum TextSetOptions {
+    None = 0,
+    UnicodeBidi = 1,
+    Unlink = 8,
+    Unhide = 16,
+    CheckTextLimit = 32,
+    FormatRtf = 8192,
+    ApplyRtfDocumentDefaults = 16384,
+  }
+
+  enum UnderlineType {
+    Undefined = 0,
+    None = 1,
+    Single = 2,
+    Words = 3,
+    Double = 4,
+    Dotted = 5,
+    Dash = 6,
+    DashDot = 7,
+    DashDotDot = 8,
+    Wave = 9,
+    Thick = 10,
+    Thin = 11,
+    DoubleWave = 12,
+    HeavyWave = 13,
+    LongDash = 14,
+    ThickDash = 15,
+    ThickDashDot = 16,
+    ThickDashDotDot = 17,
+    ThickDotted = 18,
+    ThickLongDash = 19,
+  }
+
+  enum VerticalCharacterAlignment {
+    Top = 0,
+    Baseline = 1,
+    Bottom = 2,
+  }
+
+  interface FontWeight {
+    Weight: number;
+  }
+  var FontWeight: {
+    new(weight: number): FontWeight;
+    new(fields: { Weight?: number }): FontWeight;
+  };
+
+  interface IContentLinkInfo {
+    DisplayText: string;
+    Id: number;
+    LinkContentKind: string;
+    SecondaryText: string;
+    Uri: Windows.Foundation.Uri;
+  }
+  var IContentLinkInfo: abstract new (...args: any[]) => IContentLinkInfo;
+
+  interface IFontWeights {
+  }
+  var IFontWeights: abstract new (...args: any[]) => IFontWeights;
+
+  interface IFontWeightsStatics {
+    readonly Black: Windows.UI.Text.FontWeight;
+    readonly Bold: Windows.UI.Text.FontWeight;
+    readonly ExtraBlack: Windows.UI.Text.FontWeight;
+    readonly ExtraBold: Windows.UI.Text.FontWeight;
+    readonly ExtraLight: Windows.UI.Text.FontWeight;
+    readonly Light: Windows.UI.Text.FontWeight;
+    readonly Medium: Windows.UI.Text.FontWeight;
+    readonly Normal: Windows.UI.Text.FontWeight;
+    readonly SemiBold: Windows.UI.Text.FontWeight;
+    readonly SemiLight: Windows.UI.Text.FontWeight;
+    readonly Thin: Windows.UI.Text.FontWeight;
+  }
+  var IFontWeightsStatics: abstract new (...args: any[]) => IFontWeightsStatics;
+
+  interface IRichEditTextRange {
+    ContentLinkInfo: Windows.UI.Text.ContentLinkInfo;
+  }
+  var IRichEditTextRange: abstract new (...args: any[]) => IRichEditTextRange;
+
+  interface ITextCharacterFormat {
+    GetClone(): Windows.UI.Text.ITextCharacterFormat;
+    IsEqual(format: Windows.UI.Text.ITextCharacterFormat): boolean;
+    SetClone(value: Windows.UI.Text.ITextCharacterFormat): void;
+    AllCaps: number;
+    BackgroundColor: Windows.UI.Color;
+    Bold: number;
+    FontStretch: number;
+    FontStyle: number;
+    ForegroundColor: Windows.UI.Color;
+    Hidden: number;
+    Italic: number;
+    Kerning: number;
+    LanguageTag: string;
+    readonly LinkType: number;
+    Name: string;
+    Outline: number;
+    Position: number;
+    ProtectedText: number;
+    Size: number;
+    SmallCaps: number;
+    Spacing: number;
+    Strikethrough: number;
+    Subscript: number;
+    Superscript: number;
+    TextScript: number;
+    Underline: number;
+    Weight: number;
+  }
+  var ITextCharacterFormat: abstract new (...args: any[]) => ITextCharacterFormat;
+
+  interface ITextConstantsStatics {
+    readonly AutoColor: Windows.UI.Color;
+    readonly MaxUnitCount: number;
+    readonly MinUnitCount: number;
+    readonly UndefinedColor: Windows.UI.Color;
+    readonly UndefinedFloatValue: number;
+    readonly UndefinedFontStretch: number;
+    readonly UndefinedFontStyle: number;
+    readonly UndefinedInt32Value: number;
+  }
+  var ITextConstantsStatics: abstract new (...args: any[]) => ITextConstantsStatics;
+
+  interface ITextDocument {
+    ApplyDisplayUpdates(): number;
+    BatchDisplayUpdates(): number;
+    BeginUndoGroup(): void;
+    CanCopy(): boolean;
+    CanPaste(): boolean;
+    CanRedo(): boolean;
+    CanUndo(): boolean;
+    EndUndoGroup(): void;
+    GetDefaultCharacterFormat(): Windows.UI.Text.ITextCharacterFormat;
+    GetDefaultParagraphFormat(): Windows.UI.Text.ITextParagraphFormat;
+    GetRange(startPosition: number, endPosition: number): Windows.UI.Text.ITextRange;
+    GetRangeFromPoint(point: Windows.Foundation.Point, options: number): Windows.UI.Text.ITextRange;
+    GetText(options: number, value: string): void;
+    LoadFromStream(options: number, value: Windows.Storage.Streams.IRandomAccessStream): void;
+    Redo(): void;
+    SaveToStream(options: number, value: Windows.Storage.Streams.IRandomAccessStream): void;
+    SetDefaultCharacterFormat(value: Windows.UI.Text.ITextCharacterFormat): void;
+    SetDefaultParagraphFormat(value: Windows.UI.Text.ITextParagraphFormat): void;
+    SetText(options: number, value: string): void;
+    Undo(): void;
+    CaretType: number;
+    DefaultTabStop: number;
+    readonly Selection: Windows.UI.Text.ITextSelection;
+    UndoLimit: number;
+  }
+  var ITextDocument: abstract new (...args: any[]) => ITextDocument;
+
+  interface ITextDocument2 {
+    AlignmentIncludesTrailingWhitespace: boolean;
+    IgnoreTrailingCharacterSpacing: boolean;
+  }
+  var ITextDocument2: abstract new (...args: any[]) => ITextDocument2;
+
+  interface ITextDocument3 {
+    ClearUndoRedoHistory(): void;
+  }
+  var ITextDocument3: abstract new (...args: any[]) => ITextDocument3;
+
+  interface ITextDocument4 {
+    GetMath(value: string): void;
+    SetMath(value: string): void;
+    SetMathMode(mode: number): void;
+  }
+  var ITextDocument4: abstract new (...args: any[]) => ITextDocument4;
+
+  interface ITextParagraphFormat {
+    AddTab(position: number, align: number, leader: number): void;
+    ClearAllTabs(): void;
+    DeleteTab(position: number): void;
+    GetClone(): Windows.UI.Text.ITextParagraphFormat;
+    GetTab(index: number, position: number, align: number, leader: number): void;
+    IsEqual(format: Windows.UI.Text.ITextParagraphFormat): boolean;
+    SetClone(format: Windows.UI.Text.ITextParagraphFormat): void;
+    SetIndents(start: number, left: number, right: number): void;
+    SetLineSpacing(rule: number, spacing: number): void;
+    Alignment: number;
+    readonly FirstLineIndent: number;
+    KeepTogether: number;
+    KeepWithNext: number;
+    readonly LeftIndent: number;
+    readonly LineSpacing: number;
+    readonly LineSpacingRule: number;
+    ListAlignment: number;
+    ListLevelIndex: number;
+    ListStart: number;
+    ListStyle: number;
+    ListTab: number;
+    ListType: number;
+    NoLineNumber: number;
+    PageBreakBefore: number;
+    RightIndent: number;
+    RightToLeft: number;
+    SpaceAfter: number;
+    SpaceBefore: number;
+    Style: number;
+    readonly TabCount: number;
+    WidowControl: number;
+  }
+  var ITextParagraphFormat: abstract new (...args: any[]) => ITextParagraphFormat;
+
+  interface ITextRange {
+    CanPaste(format: number): boolean;
+    ChangeCase(value: number): void;
+    Collapse(value: boolean): void;
+    Copy(): void;
+    Cut(): void;
+    Delete(unit: number, count: number): number;
+    EndOf(unit: number, extend: boolean): number;
+    Expand(unit: number): number;
+    FindText(value: string, scanLength: number, options: number): number;
+    GetCharacterUtf32(value: number, offset: number): void;
+    GetClone(): Windows.UI.Text.ITextRange;
+    GetIndex(unit: number): number;
+    GetPoint(horizontalAlign: number, verticalAlign: number, options: number, point: Windows.Foundation.Point): void;
+    GetRect(options: number, rect: Windows.Foundation.Rect, hit: number): void;
+    GetText(options: number, value: string): void;
+    GetTextViaStream(options: number, value: Windows.Storage.Streams.IRandomAccessStream): void;
+    InRange(range: Windows.UI.Text.ITextRange): boolean;
+    InStory(range: Windows.UI.Text.ITextRange): boolean;
+    InsertImage(width: number, height: number, ascent: number, verticalAlign: number, alternateText: string, value: Windows.Storage.Streams.IRandomAccessStream): void;
+    IsEqual(range: Windows.UI.Text.ITextRange): boolean;
+    MatchSelection(): void;
+    Move(unit: number, count: number): number;
+    MoveEnd(unit: number, count: number): number;
+    MoveStart(unit: number, count: number): number;
+    Paste(format: number): void;
+    ScrollIntoView(value: number): void;
+    SetIndex(unit: number, index: number, extend: boolean): void;
+    SetPoint(point: Windows.Foundation.Point, options: number, extend: boolean): void;
+    SetRange(startPosition: number, endPosition: number): void;
+    SetText(options: number, value: string): void;
+    SetTextViaStream(options: number, value: Windows.Storage.Streams.IRandomAccessStream): void;
+    StartOf(unit: number, extend: boolean): number;
+    Character: string;
+    CharacterFormat: Windows.UI.Text.ITextCharacterFormat;
+    EndPosition: number;
+    FormattedText: Windows.UI.Text.ITextRange;
+    Gravity: number;
+    readonly Length: number;
+    Link: string;
+    ParagraphFormat: Windows.UI.Text.ITextParagraphFormat;
+    StartPosition: number;
+    readonly StoryLength: number;
+    Text: string;
+  }
+  var ITextRange: abstract new (...args: any[]) => ITextRange;
+
+  interface ITextSelection extends Windows.UI.Text.ITextRange {
+    CanPaste(format: number): boolean;
+    ChangeCase(value: number): void;
+    Collapse(value: boolean): void;
+    Copy(): void;
+    Cut(): void;
+    Delete(unit: number, count: number): number;
+    EndKey(unit: number, extend: boolean): number;
+    EndOf(unit: number, extend: boolean): number;
+    Expand(unit: number): number;
+    FindText(value: string, scanLength: number, options: number): number;
+    GetCharacterUtf32(value: number, offset: number): void;
+    GetClone(): Windows.UI.Text.ITextRange;
+    GetIndex(unit: number): number;
+    GetPoint(horizontalAlign: number, verticalAlign: number, options: number, point: Windows.Foundation.Point): void;
+    GetRect(options: number, rect: Windows.Foundation.Rect, hit: number): void;
+    GetText(options: number, value: string): void;
+    GetTextViaStream(options: number, value: Windows.Storage.Streams.IRandomAccessStream): void;
+    HomeKey(unit: number, extend: boolean): number;
+    InRange(range: Windows.UI.Text.ITextRange): boolean;
+    InStory(range: Windows.UI.Text.ITextRange): boolean;
+    InsertImage(width: number, height: number, ascent: number, verticalAlign: number, alternateText: string, value: Windows.Storage.Streams.IRandomAccessStream): void;
+    IsEqual(range: Windows.UI.Text.ITextRange): boolean;
+    MatchSelection(): void;
+    Move(unit: number, count: number): number;
+    MoveDown(unit: number, count: number, extend: boolean): number;
+    MoveEnd(unit: number, count: number): number;
+    MoveLeft(unit: number, count: number, extend: boolean): number;
+    MoveRight(unit: number, count: number, extend: boolean): number;
+    MoveStart(unit: number, count: number): number;
+    MoveUp(unit: number, count: number, extend: boolean): number;
+    Paste(format: number): void;
+    ScrollIntoView(value: number): void;
+    SetIndex(unit: number, index: number, extend: boolean): void;
+    SetPoint(point: Windows.Foundation.Point, options: number, extend: boolean): void;
+    SetRange(startPosition: number, endPosition: number): void;
+    SetText(options: number, value: string): void;
+    SetTextViaStream(options: number, value: Windows.Storage.Streams.IRandomAccessStream): void;
+    StartOf(unit: number, extend: boolean): number;
+    TypeText(value: string): void;
+    Options: number;
+    readonly Type: number;
+  }
+  var ITextSelection: abstract new (...args: any[]) => ITextSelection;
+
+}
+
+declare namespace Windows.UI.Text.Core {
+  class CoreTextCompositionCompletedEventArgs implements Windows.UI.Text.Core.ICoreTextCompositionCompletedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly CompositionSegments: Windows.Foundation.Collections.IVectorView<Windows.UI.Text.Core.CoreTextCompositionSegment> | Windows.UI.Text.Core.CoreTextCompositionSegment[];
+    readonly IsCanceled: boolean;
+  }
+
+  class CoreTextCompositionSegment implements Windows.UI.Text.Core.ICoreTextCompositionSegment {
+    readonly PreconversionString: string;
+    readonly Range: Windows.UI.Text.Core.CoreTextRange;
+  }
+
+  class CoreTextCompositionStartedEventArgs implements Windows.UI.Text.Core.ICoreTextCompositionStartedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly IsCanceled: boolean;
+  }
+
+  class CoreTextEditContext implements Windows.UI.Text.Core.ICoreTextEditContext, Windows.UI.Text.Core.ICoreTextEditContext2 {
+    NotifyFocusEnter(): void;
+    NotifyFocusLeave(): void;
+    NotifyLayoutChanged(): void;
+    NotifySelectionChanged(selection: Windows.UI.Text.Core.CoreTextRange): void;
+    NotifyTextChanged(modifiedRange: Windows.UI.Text.Core.CoreTextRange, newLength: number, newSelection: Windows.UI.Text.Core.CoreTextRange): void;
+    InputPaneDisplayPolicy: number;
+    InputScope: number;
+    IsReadOnly: boolean;
+    Name: string;
+    CompositionCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Windows.UI.Text.Core.CoreTextCompositionCompletedEventArgs> | null;
+    CompositionStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Windows.UI.Text.Core.CoreTextCompositionStartedEventArgs> | null;
+    FocusRemoved: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Object> | null;
+    FormatUpdating: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Windows.UI.Text.Core.CoreTextFormatUpdatingEventArgs> | null;
+    LayoutRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Windows.UI.Text.Core.CoreTextLayoutRequestedEventArgs> | null;
+    SelectionRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Windows.UI.Text.Core.CoreTextSelectionRequestedEventArgs> | null;
+    SelectionUpdating: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Windows.UI.Text.Core.CoreTextSelectionUpdatingEventArgs> | null;
+    TextRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Windows.UI.Text.Core.CoreTextTextRequestedEventArgs> | null;
+    TextUpdating: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Windows.UI.Text.Core.CoreTextTextUpdatingEventArgs> | null;
+    NotifyFocusLeaveCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Object> | null;
+  }
+
+  class CoreTextFormatUpdatingEventArgs implements Windows.UI.Text.Core.ICoreTextFormatUpdatingEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly BackgroundColor: number | null;
+    readonly IsCanceled: boolean;
+    readonly Range: Windows.UI.Text.Core.CoreTextRange;
+    readonly Reason: number;
+    Result: number;
+    readonly TextColor: number | null;
+    readonly UnderlineColor: number | null;
+    readonly UnderlineType: number | null;
+  }
+
+  class CoreTextLayoutBounds implements Windows.UI.Text.Core.ICoreTextLayoutBounds {
+    ControlBounds: Windows.Foundation.Rect;
+    TextBounds: Windows.Foundation.Rect;
+  }
+
+  class CoreTextLayoutRequest implements Windows.UI.Text.Core.ICoreTextLayoutRequest, Windows.UI.Text.Core.ICoreTextLayoutRequest2 {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly IsCanceled: boolean;
+    readonly LayoutBounds: Windows.UI.Text.Core.CoreTextLayoutBounds;
+    readonly LayoutBoundsVisualPixels: Windows.UI.Text.Core.CoreTextLayoutBounds;
+    readonly Range: Windows.UI.Text.Core.CoreTextRange;
+  }
+
+  class CoreTextLayoutRequestedEventArgs implements Windows.UI.Text.Core.ICoreTextLayoutRequestedEventArgs {
+    readonly Request: Windows.UI.Text.Core.CoreTextLayoutRequest;
+  }
+
+  class CoreTextSelectionRequest implements Windows.UI.Text.Core.ICoreTextSelectionRequest {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly IsCanceled: boolean;
+    Selection: Windows.UI.Text.Core.CoreTextRange;
+  }
+
+  class CoreTextSelectionRequestedEventArgs implements Windows.UI.Text.Core.ICoreTextSelectionRequestedEventArgs {
+    readonly Request: Windows.UI.Text.Core.CoreTextSelectionRequest;
+  }
+
+  class CoreTextSelectionUpdatingEventArgs implements Windows.UI.Text.Core.ICoreTextSelectionUpdatingEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly IsCanceled: boolean;
+    Result: number;
+    readonly Selection: Windows.UI.Text.Core.CoreTextRange;
+  }
+
+  class CoreTextServicesConstants {
+    static readonly HiddenCharacter: string;
+  }
+
+  class CoreTextServicesManager implements Windows.UI.Text.Core.ICoreTextServicesManager {
+    CreateEditContext(): Windows.UI.Text.Core.CoreTextEditContext;
+    static GetForCurrentView(): Windows.UI.Text.Core.CoreTextServicesManager;
+    readonly InputLanguage: Windows.Globalization.Language;
+    InputLanguageChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextServicesManager, Object> | null;
+  }
+
+  class CoreTextTextRequest implements Windows.UI.Text.Core.ICoreTextTextRequest {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly IsCanceled: boolean;
+    readonly Range: Windows.UI.Text.Core.CoreTextRange;
+    Text: string;
+  }
+
+  class CoreTextTextRequestedEventArgs implements Windows.UI.Text.Core.ICoreTextTextRequestedEventArgs {
+    readonly Request: Windows.UI.Text.Core.CoreTextTextRequest;
+  }
+
+  class CoreTextTextUpdatingEventArgs implements Windows.UI.Text.Core.ICoreTextTextUpdatingEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly InputLanguage: Windows.Globalization.Language;
+    readonly IsCanceled: boolean;
+    readonly NewSelection: Windows.UI.Text.Core.CoreTextRange;
+    readonly Range: Windows.UI.Text.Core.CoreTextRange;
+    Result: number;
+    readonly Text: string;
+  }
+
+  enum CoreTextFormatUpdatingReason {
+    None = 0,
+    CompositionUnconverted = 1,
+    CompositionConverted = 2,
+    CompositionTargetUnconverted = 3,
+    CompositionTargetConverted = 4,
+  }
+
+  enum CoreTextFormatUpdatingResult {
+    Succeeded = 0,
+    Failed = 1,
+  }
+
+  enum CoreTextInputPaneDisplayPolicy {
+    Automatic = 0,
+    Manual = 1,
+  }
+
+  enum CoreTextInputScope {
+    Default = 0,
+    Url = 1,
+    FilePath = 2,
+    FileName = 3,
+    EmailUserName = 4,
+    EmailAddress = 5,
+    UserName = 6,
+    PersonalFullName = 7,
+    PersonalNamePrefix = 8,
+    PersonalGivenName = 9,
+    PersonalMiddleName = 10,
+    PersonalSurname = 11,
+    PersonalNameSuffix = 12,
+    Address = 13,
+    AddressPostalCode = 14,
+    AddressStreet = 15,
+    AddressStateOrProvince = 16,
+    AddressCity = 17,
+    AddressCountryName = 18,
+    AddressCountryShortName = 19,
+    CurrencyAmountAndSymbol = 20,
+    CurrencyAmount = 21,
+    Date = 22,
+    DateMonth = 23,
+    DateDay = 24,
+    DateYear = 25,
+    DateMonthName = 26,
+    DateDayName = 27,
+    Number = 29,
+    SingleCharacter = 30,
+    Password = 31,
+    TelephoneNumber = 32,
+    TelephoneCountryCode = 33,
+    TelephoneAreaCode = 34,
+    TelephoneLocalNumber = 35,
+    Time = 36,
+    TimeHour = 37,
+    TimeMinuteOrSecond = 38,
+    NumberFullWidth = 39,
+    AlphanumericHalfWidth = 40,
+    AlphanumericFullWidth = 41,
+    CurrencyChinese = 42,
+    Bopomofo = 43,
+    Hiragana = 44,
+    KatakanaHalfWidth = 45,
+    KatakanaFullWidth = 46,
+    Hanja = 47,
+    HangulHalfWidth = 48,
+    HangulFullWidth = 49,
+    Search = 50,
+    Formula = 51,
+    SearchIncremental = 52,
+    ChineseHalfWidth = 53,
+    ChineseFullWidth = 54,
+    NativeScript = 55,
+    Text = 57,
+    Chat = 58,
+    NameOrPhoneNumber = 59,
+    EmailUserNameOrAddress = 60,
+    Private = 61,
+    Maps = 62,
+    PasswordNumeric = 63,
+    FormulaNumber = 67,
+    ChatWithoutEmoji = 68,
+    Digits = 28,
+    PinNumeric = 64,
+    PinAlphanumeric = 65,
+  }
+
+  enum CoreTextSelectionUpdatingResult {
+    Succeeded = 0,
+    Failed = 1,
+  }
+
+  enum CoreTextTextUpdatingResult {
+    Succeeded = 0,
+    Failed = 1,
+  }
+
+  interface CoreTextRange {
+    StartCaretPosition: number;
+    EndCaretPosition: number;
+  }
+  var CoreTextRange: {
+    new(startCaretPosition: number, endCaretPosition: number): CoreTextRange;
+    new(fields: { StartCaretPosition?: number; EndCaretPosition?: number }): CoreTextRange;
+  };
+
+  interface ICoreTextCompositionCompletedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly CompositionSegments: Windows.Foundation.Collections.IVectorView<Windows.UI.Text.Core.CoreTextCompositionSegment> | Windows.UI.Text.Core.CoreTextCompositionSegment[];
+    readonly IsCanceled: boolean;
+  }
+  var ICoreTextCompositionCompletedEventArgs: abstract new (...args: any[]) => ICoreTextCompositionCompletedEventArgs;
+
+  interface ICoreTextCompositionSegment {
+    readonly PreconversionString: string;
+    readonly Range: Windows.UI.Text.Core.CoreTextRange;
+  }
+  var ICoreTextCompositionSegment: abstract new (...args: any[]) => ICoreTextCompositionSegment;
+
+  interface ICoreTextCompositionStartedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly IsCanceled: boolean;
+  }
+  var ICoreTextCompositionStartedEventArgs: abstract new (...args: any[]) => ICoreTextCompositionStartedEventArgs;
+
+  interface ICoreTextEditContext {
+    NotifyFocusEnter(): void;
+    NotifyFocusLeave(): void;
+    NotifyLayoutChanged(): void;
+    NotifySelectionChanged(selection: Windows.UI.Text.Core.CoreTextRange): void;
+    NotifyTextChanged(modifiedRange: Windows.UI.Text.Core.CoreTextRange, newLength: number, newSelection: Windows.UI.Text.Core.CoreTextRange): void;
+    InputPaneDisplayPolicy: number;
+    InputScope: number;
+    IsReadOnly: boolean;
+    Name: string;
+    CompositionCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Windows.UI.Text.Core.CoreTextCompositionCompletedEventArgs> | null;
+    CompositionStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Windows.UI.Text.Core.CoreTextCompositionStartedEventArgs> | null;
+    FocusRemoved: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Object> | null;
+    FormatUpdating: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Windows.UI.Text.Core.CoreTextFormatUpdatingEventArgs> | null;
+    LayoutRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Windows.UI.Text.Core.CoreTextLayoutRequestedEventArgs> | null;
+    SelectionRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Windows.UI.Text.Core.CoreTextSelectionRequestedEventArgs> | null;
+    SelectionUpdating: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Windows.UI.Text.Core.CoreTextSelectionUpdatingEventArgs> | null;
+    TextRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Windows.UI.Text.Core.CoreTextTextRequestedEventArgs> | null;
+    TextUpdating: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Windows.UI.Text.Core.CoreTextTextUpdatingEventArgs> | null;
+  }
+  var ICoreTextEditContext: abstract new (...args: any[]) => ICoreTextEditContext;
+
+  interface ICoreTextEditContext2 {
+    NotifyFocusLeaveCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextEditContext, Object> | null;
+  }
+  var ICoreTextEditContext2: abstract new (...args: any[]) => ICoreTextEditContext2;
+
+  interface ICoreTextFormatUpdatingEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly BackgroundColor: number | null;
+    readonly IsCanceled: boolean;
+    readonly Range: Windows.UI.Text.Core.CoreTextRange;
+    readonly Reason: number;
+    Result: number;
+    readonly TextColor: number | null;
+    readonly UnderlineColor: number | null;
+    readonly UnderlineType: number | null;
+  }
+  var ICoreTextFormatUpdatingEventArgs: abstract new (...args: any[]) => ICoreTextFormatUpdatingEventArgs;
+
+  interface ICoreTextLayoutBounds {
+    ControlBounds: Windows.Foundation.Rect;
+    TextBounds: Windows.Foundation.Rect;
+  }
+  var ICoreTextLayoutBounds: abstract new (...args: any[]) => ICoreTextLayoutBounds;
+
+  interface ICoreTextLayoutRequest {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly IsCanceled: boolean;
+    readonly LayoutBounds: Windows.UI.Text.Core.CoreTextLayoutBounds;
+    readonly Range: Windows.UI.Text.Core.CoreTextRange;
+  }
+  var ICoreTextLayoutRequest: abstract new (...args: any[]) => ICoreTextLayoutRequest;
+
+  interface ICoreTextLayoutRequest2 {
+    readonly LayoutBoundsVisualPixels: Windows.UI.Text.Core.CoreTextLayoutBounds;
+  }
+  var ICoreTextLayoutRequest2: abstract new (...args: any[]) => ICoreTextLayoutRequest2;
+
+  interface ICoreTextLayoutRequestedEventArgs {
+    readonly Request: Windows.UI.Text.Core.CoreTextLayoutRequest;
+  }
+  var ICoreTextLayoutRequestedEventArgs: abstract new (...args: any[]) => ICoreTextLayoutRequestedEventArgs;
+
+  interface ICoreTextSelectionRequest {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly IsCanceled: boolean;
+    Selection: Windows.UI.Text.Core.CoreTextRange;
+  }
+  var ICoreTextSelectionRequest: abstract new (...args: any[]) => ICoreTextSelectionRequest;
+
+  interface ICoreTextSelectionRequestedEventArgs {
+    readonly Request: Windows.UI.Text.Core.CoreTextSelectionRequest;
+  }
+  var ICoreTextSelectionRequestedEventArgs: abstract new (...args: any[]) => ICoreTextSelectionRequestedEventArgs;
+
+  interface ICoreTextSelectionUpdatingEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly IsCanceled: boolean;
+    Result: number;
+    readonly Selection: Windows.UI.Text.Core.CoreTextRange;
+  }
+  var ICoreTextSelectionUpdatingEventArgs: abstract new (...args: any[]) => ICoreTextSelectionUpdatingEventArgs;
+
+  interface ICoreTextServicesManager {
+    CreateEditContext(): Windows.UI.Text.Core.CoreTextEditContext;
+    readonly InputLanguage: Windows.Globalization.Language;
+    InputLanguageChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Text.Core.CoreTextServicesManager, Object> | null;
+  }
+  var ICoreTextServicesManager: abstract new (...args: any[]) => ICoreTextServicesManager;
+
+  interface ICoreTextServicesManagerStatics {
+    GetForCurrentView(): Windows.UI.Text.Core.CoreTextServicesManager;
+  }
+  var ICoreTextServicesManagerStatics: abstract new (...args: any[]) => ICoreTextServicesManagerStatics;
+
+  interface ICoreTextServicesStatics {
+    readonly HiddenCharacter: string;
+  }
+  var ICoreTextServicesStatics: abstract new (...args: any[]) => ICoreTextServicesStatics;
+
+  interface ICoreTextTextRequest {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly IsCanceled: boolean;
+    readonly Range: Windows.UI.Text.Core.CoreTextRange;
+    Text: string;
+  }
+  var ICoreTextTextRequest: abstract new (...args: any[]) => ICoreTextTextRequest;
+
+  interface ICoreTextTextRequestedEventArgs {
+    readonly Request: Windows.UI.Text.Core.CoreTextTextRequest;
+  }
+  var ICoreTextTextRequestedEventArgs: abstract new (...args: any[]) => ICoreTextTextRequestedEventArgs;
+
+  interface ICoreTextTextUpdatingEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly InputLanguage: Windows.Globalization.Language;
+    readonly IsCanceled: boolean;
+    readonly NewSelection: Windows.UI.Text.Core.CoreTextRange;
+    readonly Range: Windows.UI.Text.Core.CoreTextRange;
+    Result: number;
+    readonly Text: string;
+  }
+  var ICoreTextTextUpdatingEventArgs: abstract new (...args: any[]) => ICoreTextTextUpdatingEventArgs;
+
+}
+
+declare namespace Windows.UI.UIAutomation {
+  class AutomationConnection implements Windows.UI.UIAutomation.IAutomationConnection {
+    readonly AppUserModelId: string;
+    readonly ExecutableFileName: string;
+    readonly IsRemoteSystem: boolean;
+  }
+
+  class AutomationConnectionBoundObject implements Windows.UI.UIAutomation.IAutomationConnectionBoundObject {
+    readonly Connection: Windows.UI.UIAutomation.AutomationConnection;
+  }
+
+  class AutomationElement implements Windows.UI.UIAutomation.IAutomationElement {
+    readonly AppUserModelId: string;
+    readonly ExecutableFileName: string;
+    readonly IsRemoteSystem: boolean;
+  }
+
+  class AutomationTextRange implements Windows.UI.UIAutomation.IAutomationTextRange {
+  }
+
+  interface IAutomationConnection {
+    readonly AppUserModelId: string;
+    readonly ExecutableFileName: string;
+    readonly IsRemoteSystem: boolean;
+  }
+  var IAutomationConnection: abstract new (...args: any[]) => IAutomationConnection;
+
+  interface IAutomationConnectionBoundObject {
+    readonly Connection: Windows.UI.UIAutomation.AutomationConnection;
+  }
+  var IAutomationConnectionBoundObject: abstract new (...args: any[]) => IAutomationConnectionBoundObject;
+
+  interface IAutomationElement {
+    readonly AppUserModelId: string;
+    readonly ExecutableFileName: string;
+    readonly IsRemoteSystem: boolean;
+  }
+  var IAutomationElement: abstract new (...args: any[]) => IAutomationElement;
+
+  interface IAutomationTextRange {
+  }
+  var IAutomationTextRange: abstract new (...args: any[]) => IAutomationTextRange;
+
+  interface UIAutomationContract {
+  }
+  var UIAutomationContract: {
+    new(fields: {  }): UIAutomationContract;
+  };
+
+}
+
+declare namespace Windows.UI.UIAutomation.Core {
+  class AutomationRemoteOperationResult implements Windows.UI.UIAutomation.Core.IAutomationRemoteOperationResult {
+    GetOperand(operandId: Windows.UI.UIAutomation.Core.AutomationRemoteOperationOperandId): Object;
+    HasOperand(operandId: Windows.UI.UIAutomation.Core.AutomationRemoteOperationOperandId): boolean;
+    readonly ErrorLocation: number;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+
+  class CoreAutomationRegistrar {
+    static RegisterAnnotationType(guid: Guid): Windows.UI.UIAutomation.Core.AutomationAnnotationTypeRegistration;
+    static UnregisterAnnotationType(registration: Windows.UI.UIAutomation.Core.AutomationAnnotationTypeRegistration): void;
+  }
+
+  class CoreAutomationRemoteOperation implements Windows.UI.UIAutomation.Core.ICoreAutomationRemoteOperation, Windows.UI.UIAutomation.Core.ICoreAutomationRemoteOperation2 {
+    constructor();
+    AddToResults(operandId: Windows.UI.UIAutomation.Core.AutomationRemoteOperationOperandId): void;
+    Execute(bytecodeBuffer: number[]): Windows.UI.UIAutomation.Core.AutomationRemoteOperationResult;
+    ImportConnectionBoundObject(operandId: Windows.UI.UIAutomation.Core.AutomationRemoteOperationOperandId, connectionBoundObject: Windows.UI.UIAutomation.AutomationConnectionBoundObject): void;
+    ImportElement(operandId: Windows.UI.UIAutomation.Core.AutomationRemoteOperationOperandId, element: Windows.UI.UIAutomation.AutomationElement): void;
+    ImportTextRange(operandId: Windows.UI.UIAutomation.Core.AutomationRemoteOperationOperandId, textRange: Windows.UI.UIAutomation.AutomationTextRange): void;
+    IsOpcodeSupported(opcode: number): boolean;
+  }
+
+  class CoreAutomationRemoteOperationContext implements Windows.UI.UIAutomation.Core.ICoreAutomationRemoteOperationContext {
+    GetOperand(id: Windows.UI.UIAutomation.Core.AutomationRemoteOperationOperandId): Object;
+    SetOperand(id: Windows.UI.UIAutomation.Core.AutomationRemoteOperationOperandId, operand: Object): void;
+    SetOperand(id: Windows.UI.UIAutomation.Core.AutomationRemoteOperationOperandId, operand: Object, operandInterfaceId: Guid): void;
+  }
+
+  class RemoteAutomationClientSession implements Windows.UI.UIAutomation.Core.IRemoteAutomationClientSession {
+    constructor(name: string);
+    constructor(name: string, sessionId: Guid);
+    CreateWindowAsync(remoteWindowId: number | bigint, remoteProcessId: number, parentAutomationElement: Object): Windows.Foundation.IAsyncOperation<Windows.UI.UIAutomation.Core.RemoteAutomationWindow>;
+    Start(): void;
+    Stop(): void;
+    readonly SessionId: Guid;
+    ConnectionRequested: Windows.Foundation.TypedEventHandler<Windows.UI.UIAutomation.Core.RemoteAutomationClientSession, Windows.UI.UIAutomation.Core.RemoteAutomationConnectionRequestedEventArgs> | null;
+    Disconnected: Windows.Foundation.TypedEventHandler<Windows.UI.UIAutomation.Core.RemoteAutomationClientSession, Windows.UI.UIAutomation.Core.RemoteAutomationDisconnectedEventArgs> | null;
+  }
+
+  class RemoteAutomationConnectionRequestedEventArgs implements Windows.UI.UIAutomation.Core.IRemoteAutomationConnectionRequestedEventArgs {
+    readonly LocalPipeName: string;
+    readonly RemoteProcessId: number;
+  }
+
+  class RemoteAutomationDisconnectedEventArgs implements Windows.UI.UIAutomation.Core.IRemoteAutomationDisconnectedEventArgs {
+    readonly LocalPipeName: string;
+  }
+
+  class RemoteAutomationServer {
+    static ReportSession(sessionId: Guid): void;
+  }
+
+  class RemoteAutomationWindow implements Windows.UI.UIAutomation.Core.IRemoteAutomationWindow {
+    UnregisterAsync(): Windows.Foundation.IAsyncAction;
+    readonly AutomationProvider: Object;
+  }
+
+  enum AutomationRemoteOperationStatus {
+    Success = 0,
+    MalformedBytecode = 1,
+    InstructionLimitExceeded = 2,
+    UnhandledException = 3,
+    ExecutionFailure = 4,
+  }
+
+  interface AutomationAnnotationTypeRegistration {
+    LocalId: number;
+  }
+  var AutomationAnnotationTypeRegistration: {
+    new(localId: number): AutomationAnnotationTypeRegistration;
+    new(fields: { LocalId?: number }): AutomationAnnotationTypeRegistration;
+  };
+
+  interface AutomationRemoteOperationOperandId {
+    Value: number;
+  }
+  var AutomationRemoteOperationOperandId: {
+    new(value: number): AutomationRemoteOperationOperandId;
+    new(fields: { Value?: number }): AutomationRemoteOperationOperandId;
+  };
+
+  interface IAutomationRemoteOperationResult {
+    GetOperand(operandId: Windows.UI.UIAutomation.Core.AutomationRemoteOperationOperandId): Object;
+    HasOperand(operandId: Windows.UI.UIAutomation.Core.AutomationRemoteOperationOperandId): boolean;
+    readonly ErrorLocation: number;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly Status: number;
+  }
+  var IAutomationRemoteOperationResult: abstract new (...args: any[]) => IAutomationRemoteOperationResult;
+
+  interface ICoreAutomationConnectionBoundObjectProvider {
+    readonly IsComThreadingRequired: boolean;
+  }
+  var ICoreAutomationConnectionBoundObjectProvider: abstract new (...args: any[]) => ICoreAutomationConnectionBoundObjectProvider;
+
+  interface ICoreAutomationRegistrarStatics {
+    RegisterAnnotationType(guid: Guid): Windows.UI.UIAutomation.Core.AutomationAnnotationTypeRegistration;
+    UnregisterAnnotationType(registration: Windows.UI.UIAutomation.Core.AutomationAnnotationTypeRegistration): void;
+  }
+  var ICoreAutomationRegistrarStatics: abstract new (...args: any[]) => ICoreAutomationRegistrarStatics;
+
+  interface ICoreAutomationRemoteOperation {
+    AddToResults(operandId: Windows.UI.UIAutomation.Core.AutomationRemoteOperationOperandId): void;
+    Execute(bytecodeBuffer: number[]): Windows.UI.UIAutomation.Core.AutomationRemoteOperationResult;
+    ImportElement(operandId: Windows.UI.UIAutomation.Core.AutomationRemoteOperationOperandId, element: Windows.UI.UIAutomation.AutomationElement): void;
+    ImportTextRange(operandId: Windows.UI.UIAutomation.Core.AutomationRemoteOperationOperandId, textRange: Windows.UI.UIAutomation.AutomationTextRange): void;
+    IsOpcodeSupported(opcode: number): boolean;
+  }
+  var ICoreAutomationRemoteOperation: abstract new (...args: any[]) => ICoreAutomationRemoteOperation;
+
+  interface ICoreAutomationRemoteOperation2 {
+    ImportConnectionBoundObject(operandId: Windows.UI.UIAutomation.Core.AutomationRemoteOperationOperandId, connectionBoundObject: Windows.UI.UIAutomation.AutomationConnectionBoundObject): void;
+  }
+  var ICoreAutomationRemoteOperation2: abstract new (...args: any[]) => ICoreAutomationRemoteOperation2;
+
+  interface ICoreAutomationRemoteOperationContext {
+    GetOperand(id: Windows.UI.UIAutomation.Core.AutomationRemoteOperationOperandId): Object;
+    SetOperand(id: Windows.UI.UIAutomation.Core.AutomationRemoteOperationOperandId, operand: Object): void;
+    SetOperand(id: Windows.UI.UIAutomation.Core.AutomationRemoteOperationOperandId, operand: Object, operandInterfaceId: Guid): void;
+  }
+  var ICoreAutomationRemoteOperationContext: abstract new (...args: any[]) => ICoreAutomationRemoteOperationContext;
+
+  interface ICoreAutomationRemoteOperationExtensionProvider {
+    CallExtension(extensionId: Guid, context: Windows.UI.UIAutomation.Core.CoreAutomationRemoteOperationContext, operandIds: Windows.UI.UIAutomation.Core.AutomationRemoteOperationOperandId[]): void;
+    IsExtensionSupported(extensionId: Guid): boolean;
+  }
+  var ICoreAutomationRemoteOperationExtensionProvider: abstract new (...args: any[]) => ICoreAutomationRemoteOperationExtensionProvider;
+
+  interface IRemoteAutomationClientSession {
+    CreateWindowAsync(remoteWindowId: number | bigint, remoteProcessId: number, parentAutomationElement: Object): Windows.Foundation.IAsyncOperation<Windows.UI.UIAutomation.Core.RemoteAutomationWindow>;
+    Start(): void;
+    Stop(): void;
+    readonly SessionId: Guid;
+    ConnectionRequested: Windows.Foundation.TypedEventHandler<Windows.UI.UIAutomation.Core.RemoteAutomationClientSession, Windows.UI.UIAutomation.Core.RemoteAutomationConnectionRequestedEventArgs> | null;
+    Disconnected: Windows.Foundation.TypedEventHandler<Windows.UI.UIAutomation.Core.RemoteAutomationClientSession, Windows.UI.UIAutomation.Core.RemoteAutomationDisconnectedEventArgs> | null;
+  }
+  var IRemoteAutomationClientSession: abstract new (...args: any[]) => IRemoteAutomationClientSession;
+
+  interface IRemoteAutomationClientSessionFactory {
+    CreateInstance(name: string): Windows.UI.UIAutomation.Core.RemoteAutomationClientSession;
+    CreateInstance2(name: string, sessionId: Guid): Windows.UI.UIAutomation.Core.RemoteAutomationClientSession;
+  }
+  var IRemoteAutomationClientSessionFactory: abstract new (...args: any[]) => IRemoteAutomationClientSessionFactory;
+
+  interface IRemoteAutomationConnectionRequestedEventArgs {
+    readonly LocalPipeName: string;
+    readonly RemoteProcessId: number;
+  }
+  var IRemoteAutomationConnectionRequestedEventArgs: abstract new (...args: any[]) => IRemoteAutomationConnectionRequestedEventArgs;
+
+  interface IRemoteAutomationDisconnectedEventArgs {
+    readonly LocalPipeName: string;
+  }
+  var IRemoteAutomationDisconnectedEventArgs: abstract new (...args: any[]) => IRemoteAutomationDisconnectedEventArgs;
+
+  interface IRemoteAutomationServerStatics {
+    ReportSession(sessionId: Guid): void;
+  }
+  var IRemoteAutomationServerStatics: abstract new (...args: any[]) => IRemoteAutomationServerStatics;
+
+  interface IRemoteAutomationWindow {
+    UnregisterAsync(): Windows.Foundation.IAsyncAction;
+    readonly AutomationProvider: Object;
+  }
+  var IRemoteAutomationWindow: abstract new (...args: any[]) => IRemoteAutomationWindow;
+
+}
+
+declare namespace Windows.UI.ViewManagement {
+  class AccessibilitySettings implements Windows.UI.ViewManagement.IAccessibilitySettings {
+    constructor();
+    readonly HighContrast: boolean;
+    readonly HighContrastScheme: string;
+    HighContrastChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.AccessibilitySettings, Object> | null;
+  }
+
+  class ActivationViewSwitcher implements Windows.UI.ViewManagement.IActivationViewSwitcher {
+    IsViewPresentedOnActivationVirtualDesktop(viewId: number): boolean;
+    ShowAsStandaloneAsync(viewId: number): Windows.Foundation.IAsyncAction;
+    ShowAsStandaloneAsync(viewId: number, sizePreference: number): Windows.Foundation.IAsyncAction;
+  }
+
+  class ApplicationView implements Windows.UI.ViewManagement.IApplicationView, Windows.UI.ViewManagement.IApplicationView2, Windows.UI.ViewManagement.IApplicationView3, Windows.UI.ViewManagement.IApplicationView4, Windows.UI.ViewManagement.IApplicationView7, Windows.UI.ViewManagement.IApplicationView9, Windows.UI.ViewManagement.IApplicationViewWithContext {
+    static ClearAllPersistedState(): void;
+    static ClearPersistedState(key: string): void;
+    ExitFullScreenMode(): void;
+    static GetApplicationViewIdForWindow(window: Windows.UI.Core.ICoreWindow): number;
+    GetDisplayRegions(): Windows.Foundation.Collections.IVectorView<Windows.UI.WindowManagement.DisplayRegion> | Windows.UI.WindowManagement.DisplayRegion[];
+    static GetForCurrentView(): Windows.UI.ViewManagement.ApplicationView;
+    IsViewModeSupported(viewMode: number): boolean;
+    SetDesiredBoundsMode(boundsMode: number): boolean;
+    SetPreferredMinSize(minSize: Windows.Foundation.Size): void;
+    ShowStandardSystemOverlays(): void;
+    TryConsolidateAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryEnterFullScreenMode(): boolean;
+    TryEnterViewModeAsync(viewMode: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryEnterViewModeAsync(viewMode: number, viewModePreferences: Windows.UI.ViewManagement.ViewModePreferences): Windows.Foundation.IAsyncOperation<boolean>;
+    TryResizeView(value: Windows.Foundation.Size): boolean;
+    static TryUnsnap(): boolean;
+    static TryUnsnapToFullscreen(): boolean;
+    readonly AdjacentToLeftDisplayEdge: boolean;
+    readonly AdjacentToRightDisplayEdge: boolean;
+    readonly DesiredBoundsMode: number;
+    FullScreenSystemOverlayMode: number;
+    readonly Id: number;
+    readonly IsFullScreen: boolean;
+    readonly IsFullScreenMode: boolean;
+    readonly IsOnLockScreen: boolean;
+    IsScreenCaptureEnabled: boolean;
+    readonly Orientation: number;
+    PersistedStateId: string;
+    static PreferredLaunchViewSize: Windows.Foundation.Size;
+    static PreferredLaunchWindowingMode: number;
+    SuppressSystemOverlays: boolean;
+    static TerminateAppOnFinalViewClose: boolean;
+    Title: string;
+    readonly TitleBar: Windows.UI.ViewManagement.ApplicationViewTitleBar;
+    readonly UIContext: Windows.UI.UIContext;
+    static readonly Value: number;
+    readonly ViewMode: number;
+    readonly VisibleBounds: Windows.Foundation.Rect;
+    readonly WindowingEnvironment: Windows.UI.WindowManagement.WindowingEnvironment;
+    Consolidated: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.ApplicationView, Windows.UI.ViewManagement.ApplicationViewConsolidatedEventArgs> | null;
+    VisibleBoundsChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.ApplicationView, Object> | null;
+  }
+
+  class ApplicationViewConsolidatedEventArgs implements Windows.UI.ViewManagement.IApplicationViewConsolidatedEventArgs, Windows.UI.ViewManagement.IApplicationViewConsolidatedEventArgs2 {
+    readonly IsAppInitiated: boolean;
+    readonly IsUserInitiated: boolean;
+  }
+
+  class ApplicationViewScaling implements Windows.UI.ViewManagement.IApplicationViewScaling {
+    static TrySetDisableLayoutScaling(disableLayoutScaling: boolean): boolean;
+    static readonly DisableLayoutScaling: boolean;
+  }
+
+  class ApplicationViewSwitcher {
+    static DisableShowingMainViewOnActivation(): void;
+    static DisableSystemViewActivationPolicy(): void;
+    static PrepareForCustomAnimatedSwitchAsync(toViewId: number, fromViewId: number, options: number): Windows.Foundation.IAsyncOperation<boolean>;
+    static SwitchAsync(viewId: number): Windows.Foundation.IAsyncAction;
+    static SwitchAsync(toViewId: number, fromViewId: number): Windows.Foundation.IAsyncAction;
+    static SwitchAsync(toViewId: number, fromViewId: number, options: number): Windows.Foundation.IAsyncAction;
+    static TryShowAsStandaloneAsync(viewId: number): Windows.Foundation.IAsyncOperation<boolean>;
+    static TryShowAsStandaloneAsync(viewId: number, sizePreference: number): Windows.Foundation.IAsyncOperation<boolean>;
+    static TryShowAsStandaloneAsync(viewId: number, sizePreference: number, anchorViewId: number, anchorSizePreference: number): Windows.Foundation.IAsyncOperation<boolean>;
+    static TryShowAsViewModeAsync(viewId: number, viewMode: number): Windows.Foundation.IAsyncOperation<boolean>;
+    static TryShowAsViewModeAsync(viewId: number, viewMode: number, viewModePreferences: Windows.UI.ViewManagement.ViewModePreferences): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+
+  class ApplicationViewTitleBar implements Windows.UI.ViewManagement.IApplicationViewTitleBar {
+    BackgroundColor: Windows.UI.Color | null;
+    ButtonBackgroundColor: Windows.UI.Color | null;
+    ButtonForegroundColor: Windows.UI.Color | null;
+    ButtonHoverBackgroundColor: Windows.UI.Color | null;
+    ButtonHoverForegroundColor: Windows.UI.Color | null;
+    ButtonInactiveBackgroundColor: Windows.UI.Color | null;
+    ButtonInactiveForegroundColor: Windows.UI.Color | null;
+    ButtonPressedBackgroundColor: Windows.UI.Color | null;
+    ButtonPressedForegroundColor: Windows.UI.Color | null;
+    ForegroundColor: Windows.UI.Color | null;
+    InactiveBackgroundColor: Windows.UI.Color | null;
+    InactiveForegroundColor: Windows.UI.Color | null;
+  }
+
+  class ApplicationViewTransferContext implements Windows.UI.ViewManagement.IApplicationViewTransferContext {
+    constructor();
+    static readonly DataPackageFormatId: string;
+    ViewId: number;
+  }
+
+  class InputPane implements Windows.UI.ViewManagement.IInputPane, Windows.UI.ViewManagement.IInputPane2, Windows.UI.ViewManagement.IInputPaneControl {
+    static GetForCurrentView(): Windows.UI.ViewManagement.InputPane;
+    static GetForUIContext(context: Windows.UI.UIContext): Windows.UI.ViewManagement.InputPane;
+    TryHide(): boolean;
+    TryShow(): boolean;
+    readonly OccludedRect: Windows.Foundation.Rect;
+    Visible: boolean;
+    Hiding: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.InputPane, Windows.UI.ViewManagement.InputPaneVisibilityEventArgs> | null;
+    Showing: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.InputPane, Windows.UI.ViewManagement.InputPaneVisibilityEventArgs> | null;
+  }
+
+  class InputPaneVisibilityEventArgs implements Windows.UI.ViewManagement.IInputPaneVisibilityEventArgs {
+    EnsuredFocusedElementInView: boolean;
+    readonly OccludedRect: Windows.Foundation.Rect;
+  }
+
+  class ProjectionManager {
+    static GetDeviceSelector(): string;
+    static RequestStartProjectingAsync(projectionViewId: number, anchorViewId: number, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<boolean>;
+    static RequestStartProjectingAsync(projectionViewId: number, anchorViewId: number, selection: Windows.Foundation.Rect, prefferedPlacement: number): Windows.Foundation.IAsyncOperation<boolean>;
+    static StartProjectingAsync(projectionViewId: number, anchorViewId: number, displayDeviceInfo: Windows.Devices.Enumeration.DeviceInformation): Windows.Foundation.IAsyncAction;
+    static StartProjectingAsync(projectionViewId: number, anchorViewId: number): Windows.Foundation.IAsyncAction;
+    static StopProjectingAsync(projectionViewId: number, anchorViewId: number): Windows.Foundation.IAsyncAction;
+    static SwapDisplaysForViewsAsync(projectionViewId: number, anchorViewId: number): Windows.Foundation.IAsyncAction;
+    static readonly ProjectionDisplayAvailable: boolean;
+    static ProjectionDisplayAvailableChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class UISettings implements Windows.UI.ViewManagement.IUISettings, Windows.UI.ViewManagement.IUISettings2, Windows.UI.ViewManagement.IUISettings3, Windows.UI.ViewManagement.IUISettings4, Windows.UI.ViewManagement.IUISettings5, Windows.UI.ViewManagement.IUISettings6 {
+    constructor();
+    GetColorValue(desiredColor: number): Windows.UI.Color;
+    UIElementColor(desiredElement: number): Windows.UI.Color;
+    readonly AdvancedEffectsEnabled: boolean;
+    readonly AnimationsEnabled: boolean;
+    readonly AutoHideScrollBars: boolean;
+    readonly CaretBlinkRate: number;
+    readonly CaretBrowsingEnabled: boolean;
+    readonly CaretWidth: number;
+    readonly CursorSize: Windows.Foundation.Size;
+    readonly DoubleClickTime: number;
+    readonly HandPreference: number;
+    readonly MessageDuration: number;
+    readonly MouseHoverTime: number;
+    readonly ScrollBarArrowSize: Windows.Foundation.Size;
+    readonly ScrollBarSize: Windows.Foundation.Size;
+    readonly ScrollBarThumbBoxSize: Windows.Foundation.Size;
+    readonly TextScaleFactor: number;
+    TextScaleFactorChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.UISettings, Object> | null;
+    ColorValuesChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.UISettings, Object> | null;
+    AdvancedEffectsEnabledChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.UISettings, Object> | null;
+    AutoHideScrollBarsChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.UISettings, Windows.UI.ViewManagement.UISettingsAutoHideScrollBarsChangedEventArgs> | null;
+    AnimationsEnabledChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.UISettings, Windows.UI.ViewManagement.UISettingsAnimationsEnabledChangedEventArgs> | null;
+    MessageDurationChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.UISettings, Windows.UI.ViewManagement.UISettingsMessageDurationChangedEventArgs> | null;
+  }
+
+  class UISettingsAnimationsEnabledChangedEventArgs implements Windows.UI.ViewManagement.IUISettingsAnimationsEnabledChangedEventArgs {
+  }
+
+  class UISettingsAutoHideScrollBarsChangedEventArgs implements Windows.UI.ViewManagement.IUISettingsAutoHideScrollBarsChangedEventArgs {
+  }
+
+  class UISettingsMessageDurationChangedEventArgs implements Windows.UI.ViewManagement.IUISettingsMessageDurationChangedEventArgs {
+  }
+
+  class UIViewSettings implements Windows.UI.ViewManagement.IUIViewSettings, Windows.UI.ViewManagement.IUIViewSettingsPreferredInteractionMode {
+    static GetForCurrentView(): Windows.UI.ViewManagement.UIViewSettings;
+    GetPreferredInteractionMode(supportedModes: number[]): number;
+    readonly UserInteractionMode: number;
+    PreferredInteractionModeChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.UIViewSettings, Object> | null;
+  }
+
+  class ViewModePreferences implements Windows.UI.ViewManagement.IViewModePreferences {
+    static CreateDefault(mode: number): Windows.UI.ViewManagement.ViewModePreferences;
+    CustomSize: Windows.Foundation.Size;
+    ViewSizePreference: number;
+  }
+
+  enum ApplicationViewBoundsMode {
+    UseVisible = 0,
+    UseCoreWindow = 1,
+  }
+
+  enum ApplicationViewMode {
+    Default = 0,
+    CompactOverlay = 1,
+  }
+
+  enum ApplicationViewOrientation {
+    Landscape = 0,
+    Portrait = 1,
+  }
+
+  enum ApplicationViewState {
+    FullScreenLandscape = 0,
+    Filled = 1,
+    Snapped = 2,
+    FullScreenPortrait = 3,
+  }
+
+  enum ApplicationViewSwitchingOptions {
+    Default = 0,
+    SkipAnimation = 1,
+    ConsolidateViews = 2,
+  }
+
+  enum ApplicationViewWindowingMode {
+    Auto = 0,
+    PreferredLaunchViewSize = 1,
+    FullScreen = 2,
+    CompactOverlay = 3,
+    Maximized = 4,
+  }
+
+  enum FullScreenSystemOverlayMode {
+    Standard = 0,
+    Minimal = 1,
+  }
+
+  enum HandPreference {
+    LeftHanded = 0,
+    RightHanded = 1,
+  }
+
+  enum ScreenCaptureDisabledBehavior {
+    DrawAsBlack = 0,
+    ExcludeFromCapture = 1,
+  }
+
+  enum UIColorType {
+    Background = 0,
+    Foreground = 1,
+    AccentDark3 = 2,
+    AccentDark2 = 3,
+    AccentDark1 = 4,
+    Accent = 5,
+    AccentLight1 = 6,
+    AccentLight2 = 7,
+    AccentLight3 = 8,
+    Complement = 9,
+  }
+
+  enum UIElementType {
+    ActiveCaption = 0,
+    Background = 1,
+    ButtonFace = 2,
+    ButtonText = 3,
+    CaptionText = 4,
+    GrayText = 5,
+    Highlight = 6,
+    HighlightText = 7,
+    Hotlight = 8,
+    InactiveCaption = 9,
+    InactiveCaptionText = 10,
+    Window = 11,
+    WindowText = 12,
+    AccentColor = 1000,
+    TextHigh = 1001,
+    TextMedium = 1002,
+    TextLow = 1003,
+    TextContrastWithHigh = 1004,
+    NonTextHigh = 1005,
+    NonTextMediumHigh = 1006,
+    NonTextMedium = 1007,
+    NonTextMediumLow = 1008,
+    NonTextLow = 1009,
+    PageBackground = 1010,
+    PopupBackground = 1011,
+    OverlayOutsidePopup = 1012,
+  }
+
+  enum UserInteractionMode {
+    Mouse = 0,
+    Touch = 1,
+  }
+
+  enum ViewSizePreference {
+    Default = 0,
+    UseLess = 1,
+    UseHalf = 2,
+    UseMore = 3,
+    UseMinimum = 4,
+    UseNone = 5,
+    Custom = 6,
+  }
+
+  interface IAccessibilitySettings {
+    readonly HighContrast: boolean;
+    readonly HighContrastScheme: string;
+    HighContrastChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.AccessibilitySettings, Object> | null;
+  }
+  var IAccessibilitySettings: abstract new (...args: any[]) => IAccessibilitySettings;
+
+  interface IActivationViewSwitcher {
+    IsViewPresentedOnActivationVirtualDesktop(viewId: number): boolean;
+    ShowAsStandaloneAsync(viewId: number): Windows.Foundation.IAsyncAction;
+    ShowAsStandaloneAsync(viewId: number, sizePreference: number): Windows.Foundation.IAsyncAction;
+  }
+  var IActivationViewSwitcher: abstract new (...args: any[]) => IActivationViewSwitcher;
+
+  interface IApplicationView {
+    readonly AdjacentToLeftDisplayEdge: boolean;
+    readonly AdjacentToRightDisplayEdge: boolean;
+    readonly Id: number;
+    readonly IsFullScreen: boolean;
+    readonly IsOnLockScreen: boolean;
+    IsScreenCaptureEnabled: boolean;
+    readonly Orientation: number;
+    Title: string;
+    Consolidated: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.ApplicationView, Windows.UI.ViewManagement.ApplicationViewConsolidatedEventArgs> | null;
+  }
+  var IApplicationView: abstract new (...args: any[]) => IApplicationView;
+
+  interface IApplicationView2 {
+    SetDesiredBoundsMode(boundsMode: number): boolean;
+    readonly DesiredBoundsMode: number;
+    SuppressSystemOverlays: boolean;
+    readonly VisibleBounds: Windows.Foundation.Rect;
+    VisibleBoundsChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.ApplicationView, Object> | null;
+  }
+  var IApplicationView2: abstract new (...args: any[]) => IApplicationView2;
+
+  interface IApplicationView3 {
+    ExitFullScreenMode(): void;
+    SetPreferredMinSize(minSize: Windows.Foundation.Size): void;
+    ShowStandardSystemOverlays(): void;
+    TryEnterFullScreenMode(): boolean;
+    TryResizeView(value: Windows.Foundation.Size): boolean;
+    FullScreenSystemOverlayMode: number;
+    readonly IsFullScreenMode: boolean;
+    readonly TitleBar: Windows.UI.ViewManagement.ApplicationViewTitleBar;
+  }
+  var IApplicationView3: abstract new (...args: any[]) => IApplicationView3;
+
+  interface IApplicationView4 {
+    IsViewModeSupported(viewMode: number): boolean;
+    TryConsolidateAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryEnterViewModeAsync(viewMode: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryEnterViewModeAsync(viewMode: number, viewModePreferences: Windows.UI.ViewManagement.ViewModePreferences): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly ViewMode: number;
+  }
+  var IApplicationView4: abstract new (...args: any[]) => IApplicationView4;
+
+  interface IApplicationView7 {
+    PersistedStateId: string;
+  }
+  var IApplicationView7: abstract new (...args: any[]) => IApplicationView7;
+
+  interface IApplicationView9 {
+    GetDisplayRegions(): Windows.Foundation.Collections.IVectorView<Windows.UI.WindowManagement.DisplayRegion> | Windows.UI.WindowManagement.DisplayRegion[];
+    readonly WindowingEnvironment: Windows.UI.WindowManagement.WindowingEnvironment;
+  }
+  var IApplicationView9: abstract new (...args: any[]) => IApplicationView9;
+
+  interface IApplicationViewConsolidatedEventArgs {
+    readonly IsUserInitiated: boolean;
+  }
+  var IApplicationViewConsolidatedEventArgs: abstract new (...args: any[]) => IApplicationViewConsolidatedEventArgs;
+
+  interface IApplicationViewConsolidatedEventArgs2 {
+    readonly IsAppInitiated: boolean;
+  }
+  var IApplicationViewConsolidatedEventArgs2: abstract new (...args: any[]) => IApplicationViewConsolidatedEventArgs2;
+
+  interface IApplicationViewFullscreenStatics {
+    TryUnsnapToFullscreen(): boolean;
+  }
+  var IApplicationViewFullscreenStatics: abstract new (...args: any[]) => IApplicationViewFullscreenStatics;
+
+  interface IApplicationViewInteropStatics {
+    GetApplicationViewIdForWindow(window: Windows.UI.Core.ICoreWindow): number;
+  }
+  var IApplicationViewInteropStatics: abstract new (...args: any[]) => IApplicationViewInteropStatics;
+
+  interface IApplicationViewScaling {
+  }
+  var IApplicationViewScaling: abstract new (...args: any[]) => IApplicationViewScaling;
+
+  interface IApplicationViewScalingStatics {
+    TrySetDisableLayoutScaling(disableLayoutScaling: boolean): boolean;
+    readonly DisableLayoutScaling: boolean;
+  }
+  var IApplicationViewScalingStatics: abstract new (...args: any[]) => IApplicationViewScalingStatics;
+
+  interface IApplicationViewStatics {
+    TryUnsnap(): boolean;
+    readonly Value: number;
+  }
+  var IApplicationViewStatics: abstract new (...args: any[]) => IApplicationViewStatics;
+
+  interface IApplicationViewStatics2 {
+    GetForCurrentView(): Windows.UI.ViewManagement.ApplicationView;
+    TerminateAppOnFinalViewClose: boolean;
+  }
+  var IApplicationViewStatics2: abstract new (...args: any[]) => IApplicationViewStatics2;
+
+  interface IApplicationViewStatics3 {
+    PreferredLaunchViewSize: Windows.Foundation.Size;
+    PreferredLaunchWindowingMode: number;
+  }
+  var IApplicationViewStatics3: abstract new (...args: any[]) => IApplicationViewStatics3;
+
+  interface IApplicationViewStatics4 {
+    ClearAllPersistedState(): void;
+    ClearPersistedState(key: string): void;
+  }
+  var IApplicationViewStatics4: abstract new (...args: any[]) => IApplicationViewStatics4;
+
+  interface IApplicationViewSwitcherStatics {
+    DisableShowingMainViewOnActivation(): void;
+    PrepareForCustomAnimatedSwitchAsync(toViewId: number, fromViewId: number, options: number): Windows.Foundation.IAsyncOperation<boolean>;
+    SwitchAsync(viewId: number): Windows.Foundation.IAsyncAction;
+    SwitchAsync(toViewId: number, fromViewId: number): Windows.Foundation.IAsyncAction;
+    SwitchAsync(toViewId: number, fromViewId: number, options: number): Windows.Foundation.IAsyncAction;
+    TryShowAsStandaloneAsync(viewId: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryShowAsStandaloneAsync(viewId: number, sizePreference: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryShowAsStandaloneAsync(viewId: number, sizePreference: number, anchorViewId: number, anchorSizePreference: number): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IApplicationViewSwitcherStatics: abstract new (...args: any[]) => IApplicationViewSwitcherStatics;
+
+  interface IApplicationViewSwitcherStatics2 {
+    DisableSystemViewActivationPolicy(): void;
+  }
+  var IApplicationViewSwitcherStatics2: abstract new (...args: any[]) => IApplicationViewSwitcherStatics2;
+
+  interface IApplicationViewSwitcherStatics3 {
+    TryShowAsViewModeAsync(viewId: number, viewMode: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryShowAsViewModeAsync(viewId: number, viewMode: number, viewModePreferences: Windows.UI.ViewManagement.ViewModePreferences): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IApplicationViewSwitcherStatics3: abstract new (...args: any[]) => IApplicationViewSwitcherStatics3;
+
+  interface IApplicationViewTitleBar {
+    BackgroundColor: Windows.UI.Color | null;
+    ButtonBackgroundColor: Windows.UI.Color | null;
+    ButtonForegroundColor: Windows.UI.Color | null;
+    ButtonHoverBackgroundColor: Windows.UI.Color | null;
+    ButtonHoverForegroundColor: Windows.UI.Color | null;
+    ButtonInactiveBackgroundColor: Windows.UI.Color | null;
+    ButtonInactiveForegroundColor: Windows.UI.Color | null;
+    ButtonPressedBackgroundColor: Windows.UI.Color | null;
+    ButtonPressedForegroundColor: Windows.UI.Color | null;
+    ForegroundColor: Windows.UI.Color | null;
+    InactiveBackgroundColor: Windows.UI.Color | null;
+    InactiveForegroundColor: Windows.UI.Color | null;
+  }
+  var IApplicationViewTitleBar: abstract new (...args: any[]) => IApplicationViewTitleBar;
+
+  interface IApplicationViewTransferContext {
+    ViewId: number;
+  }
+  var IApplicationViewTransferContext: abstract new (...args: any[]) => IApplicationViewTransferContext;
+
+  interface IApplicationViewTransferContextStatics {
+    readonly DataPackageFormatId: string;
+  }
+  var IApplicationViewTransferContextStatics: abstract new (...args: any[]) => IApplicationViewTransferContextStatics;
+
+  interface IApplicationViewWithContext {
+    readonly UIContext: Windows.UI.UIContext;
+  }
+  var IApplicationViewWithContext: abstract new (...args: any[]) => IApplicationViewWithContext;
+
+  interface IInputPane {
+    readonly OccludedRect: Windows.Foundation.Rect;
+    Hiding: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.InputPane, Windows.UI.ViewManagement.InputPaneVisibilityEventArgs> | null;
+    Showing: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.InputPane, Windows.UI.ViewManagement.InputPaneVisibilityEventArgs> | null;
+  }
+  var IInputPane: abstract new (...args: any[]) => IInputPane;
+
+  interface IInputPane2 {
+    TryHide(): boolean;
+    TryShow(): boolean;
+  }
+  var IInputPane2: abstract new (...args: any[]) => IInputPane2;
+
+  interface IInputPaneControl {
+    Visible: boolean;
+  }
+  var IInputPaneControl: abstract new (...args: any[]) => IInputPaneControl;
+
+  interface IInputPaneStatics {
+    GetForCurrentView(): Windows.UI.ViewManagement.InputPane;
+  }
+  var IInputPaneStatics: abstract new (...args: any[]) => IInputPaneStatics;
+
+  interface IInputPaneStatics2 {
+    GetForUIContext(context: Windows.UI.UIContext): Windows.UI.ViewManagement.InputPane;
+  }
+  var IInputPaneStatics2: abstract new (...args: any[]) => IInputPaneStatics2;
+
+  interface IInputPaneVisibilityEventArgs {
+    EnsuredFocusedElementInView: boolean;
+    readonly OccludedRect: Windows.Foundation.Rect;
+  }
+  var IInputPaneVisibilityEventArgs: abstract new (...args: any[]) => IInputPaneVisibilityEventArgs;
+
+  interface IProjectionManagerStatics {
+    StartProjectingAsync(projectionViewId: number, anchorViewId: number): Windows.Foundation.IAsyncAction;
+    StopProjectingAsync(projectionViewId: number, anchorViewId: number): Windows.Foundation.IAsyncAction;
+    SwapDisplaysForViewsAsync(projectionViewId: number, anchorViewId: number): Windows.Foundation.IAsyncAction;
+    readonly ProjectionDisplayAvailable: boolean;
+    ProjectionDisplayAvailableChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IProjectionManagerStatics: abstract new (...args: any[]) => IProjectionManagerStatics;
+
+  interface IProjectionManagerStatics2 {
+    GetDeviceSelector(): string;
+    RequestStartProjectingAsync(projectionViewId: number, anchorViewId: number, selection: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<boolean>;
+    RequestStartProjectingAsync(projectionViewId: number, anchorViewId: number, selection: Windows.Foundation.Rect, prefferedPlacement: number): Windows.Foundation.IAsyncOperation<boolean>;
+    StartProjectingAsync(projectionViewId: number, anchorViewId: number, displayDeviceInfo: Windows.Devices.Enumeration.DeviceInformation): Windows.Foundation.IAsyncAction;
+  }
+  var IProjectionManagerStatics2: abstract new (...args: any[]) => IProjectionManagerStatics2;
+
+  interface IUISettings {
+    UIElementColor(desiredElement: number): Windows.UI.Color;
+    readonly AnimationsEnabled: boolean;
+    readonly CaretBlinkRate: number;
+    readonly CaretBrowsingEnabled: boolean;
+    readonly CaretWidth: number;
+    readonly CursorSize: Windows.Foundation.Size;
+    readonly DoubleClickTime: number;
+    readonly HandPreference: number;
+    readonly MessageDuration: number;
+    readonly MouseHoverTime: number;
+    readonly ScrollBarArrowSize: Windows.Foundation.Size;
+    readonly ScrollBarSize: Windows.Foundation.Size;
+    readonly ScrollBarThumbBoxSize: Windows.Foundation.Size;
+  }
+  var IUISettings: abstract new (...args: any[]) => IUISettings;
+
+  interface IUISettings2 {
+    readonly TextScaleFactor: number;
+    TextScaleFactorChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.UISettings, Object> | null;
+  }
+  var IUISettings2: abstract new (...args: any[]) => IUISettings2;
+
+  interface IUISettings3 {
+    GetColorValue(desiredColor: number): Windows.UI.Color;
+    ColorValuesChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.UISettings, Object> | null;
+  }
+  var IUISettings3: abstract new (...args: any[]) => IUISettings3;
+
+  interface IUISettings4 {
+    readonly AdvancedEffectsEnabled: boolean;
+    AdvancedEffectsEnabledChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.UISettings, Object> | null;
+  }
+  var IUISettings4: abstract new (...args: any[]) => IUISettings4;
+
+  interface IUISettings5 {
+    readonly AutoHideScrollBars: boolean;
+    AutoHideScrollBarsChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.UISettings, Windows.UI.ViewManagement.UISettingsAutoHideScrollBarsChangedEventArgs> | null;
+  }
+  var IUISettings5: abstract new (...args: any[]) => IUISettings5;
+
+  interface IUISettings6 {
+    AnimationsEnabledChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.UISettings, Windows.UI.ViewManagement.UISettingsAnimationsEnabledChangedEventArgs> | null;
+    MessageDurationChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.UISettings, Windows.UI.ViewManagement.UISettingsMessageDurationChangedEventArgs> | null;
+  }
+  var IUISettings6: abstract new (...args: any[]) => IUISettings6;
+
+  interface IUISettingsAnimationsEnabledChangedEventArgs {
+  }
+  var IUISettingsAnimationsEnabledChangedEventArgs: abstract new (...args: any[]) => IUISettingsAnimationsEnabledChangedEventArgs;
+
+  interface IUISettingsAutoHideScrollBarsChangedEventArgs {
+  }
+  var IUISettingsAutoHideScrollBarsChangedEventArgs: abstract new (...args: any[]) => IUISettingsAutoHideScrollBarsChangedEventArgs;
+
+  interface IUISettingsMessageDurationChangedEventArgs {
+  }
+  var IUISettingsMessageDurationChangedEventArgs: abstract new (...args: any[]) => IUISettingsMessageDurationChangedEventArgs;
+
+  interface IUIViewSettings {
+    readonly UserInteractionMode: number;
+  }
+  var IUIViewSettings: abstract new (...args: any[]) => IUIViewSettings;
+
+  interface IUIViewSettingsPreferredInteractionMode {
+    GetPreferredInteractionMode(supportedModes: number[]): number;
+    PreferredInteractionModeChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.UIViewSettings, Object> | null;
+  }
+  var IUIViewSettingsPreferredInteractionMode: abstract new (...args: any[]) => IUIViewSettingsPreferredInteractionMode;
+
+  interface IUIViewSettingsStatics {
+    GetForCurrentView(): Windows.UI.ViewManagement.UIViewSettings;
+  }
+  var IUIViewSettingsStatics: abstract new (...args: any[]) => IUIViewSettingsStatics;
+
+  interface IViewModePreferences {
+    CustomSize: Windows.Foundation.Size;
+    ViewSizePreference: number;
+  }
+  var IViewModePreferences: abstract new (...args: any[]) => IViewModePreferences;
+
+  interface IViewModePreferencesStatics {
+    CreateDefault(mode: number): Windows.UI.ViewManagement.ViewModePreferences;
+  }
+  var IViewModePreferencesStatics: abstract new (...args: any[]) => IViewModePreferencesStatics;
+
+  interface ViewManagementViewScalingContract {
+  }
+  var ViewManagementViewScalingContract: {
+    new(fields: {  }): ViewManagementViewScalingContract;
+  };
+
+}
+
+declare namespace Windows.UI.ViewManagement.Core {
+  class CoreFrameworkInputView implements Windows.UI.ViewManagement.Core.ICoreFrameworkInputView {
+    static GetForCurrentView(): Windows.UI.ViewManagement.Core.CoreFrameworkInputView;
+    static GetForUIContext(context: Windows.UI.UIContext): Windows.UI.ViewManagement.Core.CoreFrameworkInputView;
+    OcclusionsChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.Core.CoreFrameworkInputView, Windows.UI.ViewManagement.Core.CoreFrameworkInputViewOcclusionsChangedEventArgs> | null;
+    PrimaryViewAnimationStarting: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.Core.CoreFrameworkInputView, Windows.UI.ViewManagement.Core.CoreFrameworkInputViewAnimationStartingEventArgs> | null;
+  }
+
+  class CoreFrameworkInputViewAnimationStartingEventArgs implements Windows.UI.ViewManagement.Core.ICoreFrameworkInputViewAnimationStartingEventArgs {
+    readonly AnimationDuration: Windows.Foundation.TimeSpan;
+    readonly FrameworkAnimationRecommended: boolean;
+    readonly Occlusions: Windows.Foundation.Collections.IVectorView<Windows.UI.ViewManagement.Core.CoreInputViewOcclusion> | Windows.UI.ViewManagement.Core.CoreInputViewOcclusion[];
+  }
+
+  class CoreFrameworkInputViewOcclusionsChangedEventArgs implements Windows.UI.ViewManagement.Core.ICoreFrameworkInputViewOcclusionsChangedEventArgs {
+    readonly Handled: boolean;
+    readonly Occlusions: Windows.Foundation.Collections.IVectorView<Windows.UI.ViewManagement.Core.CoreInputViewOcclusion> | Windows.UI.ViewManagement.Core.CoreInputViewOcclusion[];
+  }
+
+  class CoreInputView implements Windows.UI.ViewManagement.Core.ICoreInputView, Windows.UI.ViewManagement.Core.ICoreInputView2, Windows.UI.ViewManagement.Core.ICoreInputView3, Windows.UI.ViewManagement.Core.ICoreInputView4, Windows.UI.ViewManagement.Core.ICoreInputView5 {
+    GetCoreInputViewOcclusions(): Windows.Foundation.Collections.IVectorView<Windows.UI.ViewManagement.Core.CoreInputViewOcclusion> | Windows.UI.ViewManagement.Core.CoreInputViewOcclusion[];
+    static GetForCurrentView(): Windows.UI.ViewManagement.Core.CoreInputView;
+    static GetForUIContext(context: Windows.UI.UIContext): Windows.UI.ViewManagement.Core.CoreInputView;
+    IsKindSupported(type: number): boolean;
+    TryHide(): boolean;
+    TryHidePrimaryView(): boolean;
+    TryShow(): boolean;
+    TryShow(type: number): boolean;
+    TryShowPrimaryView(): boolean;
+    TryTransferXYFocusToPrimaryView(origin: Windows.Foundation.Rect, direction: number): boolean;
+    OcclusionsChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.Core.CoreInputView, Windows.UI.ViewManagement.Core.CoreInputViewOcclusionsChangedEventArgs> | null;
+    XYFocusTransferredToPrimaryView: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.Core.CoreInputView, Object> | null;
+    XYFocusTransferringFromPrimaryView: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.Core.CoreInputView, Windows.UI.ViewManagement.Core.CoreInputViewTransferringXYFocusEventArgs> | null;
+    PrimaryViewHiding: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.Core.CoreInputView, Windows.UI.ViewManagement.Core.CoreInputViewHidingEventArgs> | null;
+    PrimaryViewShowing: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.Core.CoreInputView, Windows.UI.ViewManagement.Core.CoreInputViewShowingEventArgs> | null;
+    PrimaryViewAnimationStarting: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.Core.CoreInputView, Windows.UI.ViewManagement.Core.CoreInputViewAnimationStartingEventArgs> | null;
+    SupportedKindsChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.Core.CoreInputView, Object> | null;
+  }
+
+  class CoreInputViewAnimationStartingEventArgs implements Windows.UI.ViewManagement.Core.ICoreInputViewAnimationStartingEventArgs {
+    readonly AnimationDuration: Windows.Foundation.TimeSpan;
+    Handled: boolean;
+    readonly Occlusions: Windows.Foundation.Collections.IVectorView<Windows.UI.ViewManagement.Core.CoreInputViewOcclusion> | Windows.UI.ViewManagement.Core.CoreInputViewOcclusion[];
+  }
+
+  class CoreInputViewHidingEventArgs implements Windows.UI.ViewManagement.Core.ICoreInputViewHidingEventArgs {
+    TryCancel(): boolean;
+  }
+
+  class CoreInputViewOcclusion implements Windows.UI.ViewManagement.Core.ICoreInputViewOcclusion {
+    readonly OccludingRect: Windows.Foundation.Rect;
+    readonly OcclusionKind: number;
+  }
+
+  class CoreInputViewOcclusionsChangedEventArgs implements Windows.UI.ViewManagement.Core.ICoreInputViewOcclusionsChangedEventArgs {
+    Handled: boolean;
+    readonly Occlusions: Windows.Foundation.Collections.IVectorView<Windows.UI.ViewManagement.Core.CoreInputViewOcclusion> | Windows.UI.ViewManagement.Core.CoreInputViewOcclusion[];
+  }
+
+  class CoreInputViewShowingEventArgs implements Windows.UI.ViewManagement.Core.ICoreInputViewShowingEventArgs {
+    TryCancel(): boolean;
+  }
+
+  class CoreInputViewTransferringXYFocusEventArgs implements Windows.UI.ViewManagement.Core.ICoreInputViewTransferringXYFocusEventArgs {
+    readonly Direction: number;
+    KeepPrimaryViewVisible: boolean;
+    readonly Origin: Windows.Foundation.Rect;
+    TransferHandled: boolean;
+  }
+
+  class UISettingsController implements Windows.UI.ViewManagement.Core.IUISettingsController {
+    static RequestDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.ViewManagement.Core.UISettingsController>;
+    SetAdvancedEffectsEnabled(value: boolean): void;
+    SetAnimationsEnabled(value: boolean): void;
+    SetAutoHideScrollBars(value: boolean): void;
+    SetMessageDuration(value: number): void;
+    SetTextScaleFactor(value: number): void;
+  }
+
+  enum CoreInputViewKind {
+    Default = 0,
+    Keyboard = 1,
+    Handwriting = 2,
+    Emoji = 3,
+    Symbols = 4,
+    Clipboard = 5,
+    Dictation = 6,
+    Gamepad = 7,
+  }
+
+  enum CoreInputViewOcclusionKind {
+    Docked = 0,
+    Floating = 1,
+    Overlay = 2,
+  }
+
+  enum CoreInputViewXYFocusTransferDirection {
+    Up = 0,
+    Right = 1,
+    Down = 2,
+    Left = 3,
+  }
+
+  interface ICoreFrameworkInputView {
+    OcclusionsChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.Core.CoreFrameworkInputView, Windows.UI.ViewManagement.Core.CoreFrameworkInputViewOcclusionsChangedEventArgs> | null;
+    PrimaryViewAnimationStarting: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.Core.CoreFrameworkInputView, Windows.UI.ViewManagement.Core.CoreFrameworkInputViewAnimationStartingEventArgs> | null;
+  }
+  var ICoreFrameworkInputView: abstract new (...args: any[]) => ICoreFrameworkInputView;
+
+  interface ICoreFrameworkInputViewAnimationStartingEventArgs {
+    readonly AnimationDuration: Windows.Foundation.TimeSpan;
+    readonly FrameworkAnimationRecommended: boolean;
+    readonly Occlusions: Windows.Foundation.Collections.IVectorView<Windows.UI.ViewManagement.Core.CoreInputViewOcclusion> | Windows.UI.ViewManagement.Core.CoreInputViewOcclusion[];
+  }
+  var ICoreFrameworkInputViewAnimationStartingEventArgs: abstract new (...args: any[]) => ICoreFrameworkInputViewAnimationStartingEventArgs;
+
+  interface ICoreFrameworkInputViewOcclusionsChangedEventArgs {
+    readonly Handled: boolean;
+    readonly Occlusions: Windows.Foundation.Collections.IVectorView<Windows.UI.ViewManagement.Core.CoreInputViewOcclusion> | Windows.UI.ViewManagement.Core.CoreInputViewOcclusion[];
+  }
+  var ICoreFrameworkInputViewOcclusionsChangedEventArgs: abstract new (...args: any[]) => ICoreFrameworkInputViewOcclusionsChangedEventArgs;
+
+  interface ICoreFrameworkInputViewStatics {
+    GetForCurrentView(): Windows.UI.ViewManagement.Core.CoreFrameworkInputView;
+    GetForUIContext(context: Windows.UI.UIContext): Windows.UI.ViewManagement.Core.CoreFrameworkInputView;
+  }
+  var ICoreFrameworkInputViewStatics: abstract new (...args: any[]) => ICoreFrameworkInputViewStatics;
+
+  interface ICoreInputView {
+    GetCoreInputViewOcclusions(): Windows.Foundation.Collections.IVectorView<Windows.UI.ViewManagement.Core.CoreInputViewOcclusion> | Windows.UI.ViewManagement.Core.CoreInputViewOcclusion[];
+    TryHidePrimaryView(): boolean;
+    TryShowPrimaryView(): boolean;
+    OcclusionsChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.Core.CoreInputView, Windows.UI.ViewManagement.Core.CoreInputViewOcclusionsChangedEventArgs> | null;
+  }
+  var ICoreInputView: abstract new (...args: any[]) => ICoreInputView;
+
+  interface ICoreInputView2 {
+    TryTransferXYFocusToPrimaryView(origin: Windows.Foundation.Rect, direction: number): boolean;
+    XYFocusTransferredToPrimaryView: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.Core.CoreInputView, Object> | null;
+    XYFocusTransferringFromPrimaryView: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.Core.CoreInputView, Windows.UI.ViewManagement.Core.CoreInputViewTransferringXYFocusEventArgs> | null;
+  }
+  var ICoreInputView2: abstract new (...args: any[]) => ICoreInputView2;
+
+  interface ICoreInputView3 {
+    TryHide(): boolean;
+    TryShow(): boolean;
+    TryShow(type: number): boolean;
+  }
+  var ICoreInputView3: abstract new (...args: any[]) => ICoreInputView3;
+
+  interface ICoreInputView4 {
+    PrimaryViewHiding: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.Core.CoreInputView, Windows.UI.ViewManagement.Core.CoreInputViewHidingEventArgs> | null;
+    PrimaryViewShowing: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.Core.CoreInputView, Windows.UI.ViewManagement.Core.CoreInputViewShowingEventArgs> | null;
+  }
+  var ICoreInputView4: abstract new (...args: any[]) => ICoreInputView4;
+
+  interface ICoreInputView5 {
+    IsKindSupported(type: number): boolean;
+    PrimaryViewAnimationStarting: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.Core.CoreInputView, Windows.UI.ViewManagement.Core.CoreInputViewAnimationStartingEventArgs> | null;
+    SupportedKindsChanged: Windows.Foundation.TypedEventHandler<Windows.UI.ViewManagement.Core.CoreInputView, Object> | null;
+  }
+  var ICoreInputView5: abstract new (...args: any[]) => ICoreInputView5;
+
+  interface ICoreInputViewAnimationStartingEventArgs {
+    readonly AnimationDuration: Windows.Foundation.TimeSpan;
+    Handled: boolean;
+    readonly Occlusions: Windows.Foundation.Collections.IVectorView<Windows.UI.ViewManagement.Core.CoreInputViewOcclusion> | Windows.UI.ViewManagement.Core.CoreInputViewOcclusion[];
+  }
+  var ICoreInputViewAnimationStartingEventArgs: abstract new (...args: any[]) => ICoreInputViewAnimationStartingEventArgs;
+
+  interface ICoreInputViewHidingEventArgs {
+    TryCancel(): boolean;
+  }
+  var ICoreInputViewHidingEventArgs: abstract new (...args: any[]) => ICoreInputViewHidingEventArgs;
+
+  interface ICoreInputViewOcclusion {
+    readonly OccludingRect: Windows.Foundation.Rect;
+    readonly OcclusionKind: number;
+  }
+  var ICoreInputViewOcclusion: abstract new (...args: any[]) => ICoreInputViewOcclusion;
+
+  interface ICoreInputViewOcclusionsChangedEventArgs {
+    Handled: boolean;
+    readonly Occlusions: Windows.Foundation.Collections.IVectorView<Windows.UI.ViewManagement.Core.CoreInputViewOcclusion> | Windows.UI.ViewManagement.Core.CoreInputViewOcclusion[];
+  }
+  var ICoreInputViewOcclusionsChangedEventArgs: abstract new (...args: any[]) => ICoreInputViewOcclusionsChangedEventArgs;
+
+  interface ICoreInputViewShowingEventArgs {
+    TryCancel(): boolean;
+  }
+  var ICoreInputViewShowingEventArgs: abstract new (...args: any[]) => ICoreInputViewShowingEventArgs;
+
+  interface ICoreInputViewStatics {
+    GetForCurrentView(): Windows.UI.ViewManagement.Core.CoreInputView;
+  }
+  var ICoreInputViewStatics: abstract new (...args: any[]) => ICoreInputViewStatics;
+
+  interface ICoreInputViewStatics2 {
+    GetForUIContext(context: Windows.UI.UIContext): Windows.UI.ViewManagement.Core.CoreInputView;
+  }
+  var ICoreInputViewStatics2: abstract new (...args: any[]) => ICoreInputViewStatics2;
+
+  interface ICoreInputViewTransferringXYFocusEventArgs {
+    readonly Direction: number;
+    KeepPrimaryViewVisible: boolean;
+    readonly Origin: Windows.Foundation.Rect;
+    TransferHandled: boolean;
+  }
+  var ICoreInputViewTransferringXYFocusEventArgs: abstract new (...args: any[]) => ICoreInputViewTransferringXYFocusEventArgs;
+
+  interface IUISettingsController {
+    SetAdvancedEffectsEnabled(value: boolean): void;
+    SetAnimationsEnabled(value: boolean): void;
+    SetAutoHideScrollBars(value: boolean): void;
+    SetMessageDuration(value: number): void;
+    SetTextScaleFactor(value: number): void;
+  }
+  var IUISettingsController: abstract new (...args: any[]) => IUISettingsController;
+
+  interface IUISettingsControllerStatics {
+    RequestDefaultAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.ViewManagement.Core.UISettingsController>;
+  }
+  var IUISettingsControllerStatics: abstract new (...args: any[]) => IUISettingsControllerStatics;
+
+}
+
+declare namespace Windows.UI.WebUI {
+  class ActivatedDeferral implements Windows.UI.WebUI.IActivatedDeferral {
+    Complete(): void;
+  }
+
+  class ActivatedOperation implements Windows.UI.WebUI.IActivatedOperation {
+    GetDeferral(): Windows.UI.WebUI.ActivatedDeferral;
+  }
+
+  class BackgroundActivatedEventArgs implements Windows.ApplicationModel.Activation.IBackgroundActivatedEventArgs {
+    readonly TaskInstance: Windows.ApplicationModel.Background.IBackgroundTaskInstance;
+  }
+
+  class EnteredBackgroundEventArgs implements Windows.ApplicationModel.IEnteredBackgroundEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+
+  class HtmlPrintDocumentSource implements Windows.Foundation.IClosable, Windows.Graphics.Printing.IPrintDocumentSource, Windows.UI.WebUI.IHtmlPrintDocumentSource {
+    Close(): void;
+    TrySetPageRange(strPageRange: string): boolean;
+    BottomMargin: number;
+    Content: number;
+    EnableHeaderFooter: boolean;
+    LeftMargin: number;
+    readonly PageRange: string;
+    PercentScale: number;
+    RightMargin: number;
+    ShrinkToFit: boolean;
+    TopMargin: number;
+  }
+
+  class LeavingBackgroundEventArgs implements Windows.ApplicationModel.ILeavingBackgroundEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+
+  class NewWebUIViewCreatedEventArgs implements Windows.UI.WebUI.INewWebUIViewCreatedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly ActivatedEventArgs: Windows.ApplicationModel.Activation.IActivatedEventArgs;
+    readonly HasPendingNavigate: boolean;
+    readonly WebUIView: Windows.UI.WebUI.WebUIView;
+  }
+
+  class SuspendingDeferral implements Windows.ApplicationModel.ISuspendingDeferral {
+    Complete(): void;
+  }
+
+  class SuspendingEventArgs implements Windows.ApplicationModel.ISuspendingEventArgs {
+    readonly SuspendingOperation: Windows.ApplicationModel.SuspendingOperation;
+  }
+
+  class SuspendingOperation implements Windows.ApplicationModel.ISuspendingOperation {
+    GetDeferral(): Windows.ApplicationModel.SuspendingDeferral;
+    readonly Deadline: Windows.Foundation.DateTime;
+  }
+
+  class WebUIApplication {
+    static EnablePrelaunch(value: boolean): void;
+    static RequestRestartAsync(launchArguments: string): Windows.Foundation.IAsyncOperation<number>;
+    static RequestRestartForUserAsync(user: Windows.System.User, launchArguments: string): Windows.Foundation.IAsyncOperation<number>;
+    static BackgroundActivated: Windows.UI.WebUI.BackgroundActivatedEventHandler | null;
+    static NewWebUIViewCreated: Windows.Foundation.EventHandler<Windows.UI.WebUI.NewWebUIViewCreatedEventArgs> | null;
+    static EnteredBackground: Windows.UI.WebUI.EnteredBackgroundEventHandler | null;
+    static LeavingBackground: Windows.UI.WebUI.LeavingBackgroundEventHandler | null;
+    static Activated: Windows.UI.WebUI.ActivatedEventHandler | null;
+    static Navigated: Windows.UI.WebUI.NavigatedEventHandler | null;
+    static Resuming: Windows.UI.WebUI.ResumingEventHandler | null;
+    static Suspending: Windows.UI.WebUI.SuspendingEventHandler | null;
+  }
+
+  class WebUIAppointmentsProviderAddAppointmentActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IAppointmentsProviderActivatedEventArgs, Windows.ApplicationModel.Activation.IAppointmentsProviderAddAppointmentActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly AddAppointmentOperation: Windows.ApplicationModel.Appointments.AppointmentsProvider.AddAppointmentOperation;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+    readonly Verb: string;
+  }
+
+  class WebUIAppointmentsProviderRemoveAppointmentActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IAppointmentsProviderActivatedEventArgs, Windows.ApplicationModel.Activation.IAppointmentsProviderRemoveAppointmentActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly RemoveAppointmentOperation: Windows.ApplicationModel.Appointments.AppointmentsProvider.RemoveAppointmentOperation;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+    readonly Verb: string;
+  }
+
+  class WebUIAppointmentsProviderReplaceAppointmentActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IAppointmentsProviderActivatedEventArgs, Windows.ApplicationModel.Activation.IAppointmentsProviderReplaceAppointmentActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly ReplaceAppointmentOperation: Windows.ApplicationModel.Appointments.AppointmentsProvider.ReplaceAppointmentOperation;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+    readonly Verb: string;
+  }
+
+  class WebUIAppointmentsProviderShowAppointmentDetailsActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IAppointmentsProviderActivatedEventArgs, Windows.ApplicationModel.Activation.IAppointmentsProviderShowAppointmentDetailsActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly InstanceStartDate: Windows.Foundation.DateTime | null;
+    readonly Kind: number;
+    readonly LocalId: string;
+    readonly PreviousExecutionState: number;
+    readonly RoamingId: string;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+    readonly Verb: string;
+  }
+
+  class WebUIAppointmentsProviderShowTimeFrameActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IAppointmentsProviderActivatedEventArgs, Windows.ApplicationModel.Activation.IAppointmentsProviderShowTimeFrameActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Duration: Windows.Foundation.TimeSpan;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly TimeToShow: Windows.Foundation.DateTime;
+    readonly User: Windows.System.User;
+    readonly Verb: string;
+  }
+
+  class WebUIBackgroundTaskInstance {
+    static readonly Current: Windows.UI.WebUI.IWebUIBackgroundTaskInstance;
+  }
+
+  class WebUIBackgroundTaskInstanceRuntimeClass implements Windows.ApplicationModel.Background.IBackgroundTaskInstance, Windows.UI.WebUI.IWebUIBackgroundTaskInstance {
+    GetDeferral(): Windows.ApplicationModel.Background.BackgroundTaskDeferral;
+    readonly InstanceId: Guid;
+    Progress: number;
+    Succeeded: boolean;
+    readonly SuspendedCount: number;
+    readonly Task: Windows.ApplicationModel.Background.BackgroundTaskRegistration;
+    readonly TriggerDetails: Object;
+    Canceled: Windows.ApplicationModel.Background.BackgroundTaskCanceledEventHandler | null;
+  }
+
+  class WebUIBarcodeScannerPreviewActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IBarcodeScannerPreviewActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly ConnectionId: string;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUICachedFileUpdaterActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.ICachedFileUpdaterActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly CachedFileUpdaterUI: Windows.Storage.Provider.CachedFileUpdaterUI;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUICameraSettingsActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.ICameraSettingsActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly VideoDeviceController: Object;
+    readonly VideoDeviceExtension: Object;
+  }
+
+  class WebUICommandLineActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.ICommandLineActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Kind: number;
+    readonly Operation: Windows.ApplicationModel.Activation.CommandLineActivationOperation;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUIContactCallActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContactActivatedEventArgs, Windows.ApplicationModel.Activation.IContactCallActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly ServiceId: string;
+    readonly ServiceUserId: string;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly Verb: string;
+  }
+
+  class WebUIContactMapActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContactActivatedEventArgs, Windows.ApplicationModel.Activation.IContactMapActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Address: Windows.ApplicationModel.Contacts.ContactAddress;
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly Verb: string;
+  }
+
+  class WebUIContactMessageActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContactActivatedEventArgs, Windows.ApplicationModel.Activation.IContactMessageActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly ServiceId: string;
+    readonly ServiceUserId: string;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly Verb: string;
+  }
+
+  class WebUIContactPanelActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IContactPanelActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+    readonly ContactPanel: Windows.ApplicationModel.Contacts.ContactPanel;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUIContactPickerActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContactPickerActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly ContactPickerUI: Windows.ApplicationModel.Contacts.Provider.ContactPickerUI;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+  }
+
+  class WebUIContactPostActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContactActivatedEventArgs, Windows.ApplicationModel.Activation.IContactPostActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly ServiceId: string;
+    readonly ServiceUserId: string;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly Verb: string;
+  }
+
+  class WebUIContactVideoCallActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContactActivatedEventArgs, Windows.ApplicationModel.Activation.IContactVideoCallActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Contact: Windows.ApplicationModel.Contacts.Contact;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly ServiceId: string;
+    readonly ServiceUserId: string;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly Verb: string;
+  }
+
+  class WebUIDeviceActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs, Windows.ApplicationModel.Activation.IDeviceActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly CurrentlyShownApplicationViewId: number;
+    readonly DeviceInformationId: string;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+    readonly Verb: string;
+  }
+
+  class WebUIDevicePairingActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IDevicePairingActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly DeviceInformation: Windows.Devices.Enumeration.DeviceInformation;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUIDialReceiverActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs, Windows.ApplicationModel.Activation.IDialReceiverActivatedEventArgs, Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly AppName: string;
+    readonly Arguments: string;
+    readonly CurrentlyShownApplicationViewId: number;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly TileId: string;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUIFileActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs, Windows.ApplicationModel.Activation.IFileActivatedEventArgs, Windows.ApplicationModel.Activation.IFileActivatedEventArgsWithNeighboringFiles, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly CurrentlyShownApplicationViewId: number;
+    readonly Files: Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem> | Windows.Storage.IStorageItem[];
+    readonly Kind: number;
+    readonly NeighboringFilesQuery: Windows.Storage.Search.StorageFileQueryResult;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+    readonly Verb: string;
+  }
+
+  class WebUIFileOpenPickerActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IFileOpenPickerActivatedEventArgs, Windows.ApplicationModel.Activation.IFileOpenPickerActivatedEventArgs2, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly CallerPackageFamilyName: string;
+    readonly FileOpenPickerUI: Windows.Storage.Pickers.Provider.FileOpenPickerUI;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUIFileOpenPickerContinuationEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IContinuationActivatedEventArgs, Windows.ApplicationModel.Activation.IFileOpenPickerContinuationEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly ContinuationData: Windows.Foundation.Collections.ValueSet;
+    readonly Files: Windows.Foundation.Collections.IVectorView<Windows.Storage.StorageFile> | Windows.Storage.StorageFile[];
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUIFileSavePickerActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IFileSavePickerActivatedEventArgs, Windows.ApplicationModel.Activation.IFileSavePickerActivatedEventArgs2, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly CallerPackageFamilyName: string;
+    readonly EnterpriseId: string;
+    readonly FileSavePickerUI: Windows.Storage.Pickers.Provider.FileSavePickerUI;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUIFileSavePickerContinuationEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IContinuationActivatedEventArgs, Windows.ApplicationModel.Activation.IFileSavePickerContinuationEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly ContinuationData: Windows.Foundation.Collections.ValueSet;
+    readonly File: Windows.Storage.StorageFile;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUIFolderPickerContinuationEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IContinuationActivatedEventArgs, Windows.ApplicationModel.Activation.IFolderPickerContinuationEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly ContinuationData: Windows.Foundation.Collections.ValueSet;
+    readonly Folder: Windows.Storage.StorageFolder;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUILaunchActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs, Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs, Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs2, Windows.ApplicationModel.Activation.IPrelaunchActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Arguments: string;
+    readonly CurrentlyShownApplicationViewId: number;
+    readonly Kind: number;
+    readonly PrelaunchActivated: boolean;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly TileActivatedInfo: Windows.ApplicationModel.Activation.TileActivatedInfo;
+    readonly TileId: string;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUILockScreenActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs, Windows.ApplicationModel.Activation.ILockScreenActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly CurrentlyShownApplicationViewId: number;
+    readonly Info: Object;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUILockScreenCallActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs, Windows.ApplicationModel.Activation.ILaunchActivatedEventArgs, Windows.ApplicationModel.Activation.ILockScreenCallActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Arguments: string;
+    readonly CallUI: Windows.ApplicationModel.Calls.LockScreenCallUI;
+    readonly CurrentlyShownApplicationViewId: number;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly TileId: string;
+  }
+
+  class WebUILockScreenComponentActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+  }
+
+  class WebUINavigatedDeferral implements Windows.UI.WebUI.IWebUINavigatedDeferral {
+    Complete(): void;
+  }
+
+  class WebUINavigatedEventArgs implements Windows.UI.WebUI.IWebUINavigatedEventArgs {
+    readonly NavigatedOperation: Windows.UI.WebUI.WebUINavigatedOperation;
+  }
+
+  class WebUINavigatedOperation implements Windows.UI.WebUI.IWebUINavigatedOperation {
+    GetDeferral(): Windows.UI.WebUI.WebUINavigatedDeferral;
+  }
+
+  class WebUIPhoneCallActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IPhoneCallActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Kind: number;
+    readonly LineId: Guid;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUIPrint3DWorkflowActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IPrint3DWorkflowActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly Workflow: Windows.Devices.Printers.Extensions.Print3DWorkflow;
+  }
+
+  class WebUIPrintTaskSettingsActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IPrintTaskSettingsActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Configuration: Windows.Devices.Printers.Extensions.PrintTaskConfiguration;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+  }
+
+  class WebUIPrintWorkflowForegroundTaskActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+  }
+
+  class WebUIProtocolActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs, Windows.ApplicationModel.Activation.IProtocolActivatedEventArgs, Windows.ApplicationModel.Activation.IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly CallerPackageFamilyName: string;
+    readonly CurrentlyShownApplicationViewId: number;
+    readonly Data: Windows.Foundation.Collections.ValueSet;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly Uri: Windows.Foundation.Uri;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUIProtocolForResultsActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs, Windows.ApplicationModel.Activation.IProtocolActivatedEventArgs, Windows.ApplicationModel.Activation.IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData, Windows.ApplicationModel.Activation.IProtocolForResultsActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly CallerPackageFamilyName: string;
+    readonly CurrentlyShownApplicationViewId: number;
+    readonly Data: Windows.Foundation.Collections.ValueSet;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly ProtocolForResultsOperation: Windows.System.ProtocolForResultsOperation;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly Uri: Windows.Foundation.Uri;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUIRestrictedLaunchActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IRestrictedLaunchActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SharedContext: Object;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUISearchActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IApplicationViewActivatedEventArgs, Windows.ApplicationModel.Activation.ISearchActivatedEventArgs, Windows.ApplicationModel.Activation.ISearchActivatedEventArgsWithLinguisticDetails, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly CurrentlyShownApplicationViewId: number;
+    readonly Kind: number;
+    readonly Language: string;
+    readonly LinguisticDetails: Windows.ApplicationModel.Search.SearchPaneQueryLinguisticDetails;
+    readonly PreviousExecutionState: number;
+    readonly QueryText: string;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+  }
+
+  class WebUIShareTargetActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IShareTargetActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly ShareOperation: Windows.ApplicationModel.DataTransfer.ShareTarget.ShareOperation;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUIStartupTaskActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IStartupTaskActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly TaskId: string;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUIToastNotificationActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IToastNotificationActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Argument: string;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+    readonly UserInput: Windows.Foundation.Collections.ValueSet;
+  }
+
+  class WebUIUserDataAccountProviderActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IUserDataAccountProviderActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Kind: number;
+    readonly Operation: Windows.ApplicationModel.UserDataAccounts.Provider.IUserDataAccountProviderOperation;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+  }
+
+  class WebUIView implements Windows.UI.WebUI.IWebUIView, Windows.Web.UI.IWebViewControl, Windows.Web.UI.IWebViewControl2 {
+    AddInitializeScript(script: string): void;
+    BuildLocalStreamUri(contentIdentifier: string, relativePath: string): Windows.Foundation.Uri;
+    CapturePreviewToStreamAsync(stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    CaptureSelectedContentToDataPackageAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.DataTransfer.DataPackage>;
+    static CreateAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.WebUI.WebUIView>;
+    static CreateAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.UI.WebUI.WebUIView>;
+    GetDeferredPermissionRequestById(id: number, result: Windows.Web.UI.WebViewControlDeferredPermissionRequest): void;
+    GoBack(): void;
+    GoForward(): void;
+    InvokeScriptAsync(scriptName: string, arguments_: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<string>;
+    Navigate(source: Windows.Foundation.Uri): void;
+    NavigateToLocalStreamUri(source: Windows.Foundation.Uri, streamResolver: Windows.Web.IUriToStreamResolver): void;
+    NavigateToString(text: string): void;
+    NavigateWithHttpRequestMessage(requestMessage: Windows.Web.Http.HttpRequestMessage): void;
+    Refresh(): void;
+    Stop(): void;
+    readonly ApplicationViewId: number;
+    readonly CanGoBack: boolean;
+    readonly CanGoForward: boolean;
+    readonly ContainsFullScreenElement: boolean;
+    DefaultBackgroundColor: Windows.UI.Color;
+    readonly DeferredPermissionRequests: Windows.Foundation.Collections.IVectorView<Windows.Web.UI.WebViewControlDeferredPermissionRequest> | Windows.Web.UI.WebViewControlDeferredPermissionRequest[];
+    readonly DocumentTitle: string;
+    IgnoreApplicationContentUriRulesNavigationRestrictions: boolean;
+    readonly Settings: Windows.Web.UI.WebViewControlSettings;
+    Source: Windows.Foundation.Uri;
+    Activated: Windows.Foundation.TypedEventHandler<Windows.UI.WebUI.WebUIView, Windows.ApplicationModel.Activation.IActivatedEventArgs> | null;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.UI.WebUI.WebUIView, Object> | null;
+    ContainsFullScreenElementChanged: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Object> | null;
+    ContentLoading: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlContentLoadingEventArgs> | null;
+    DOMContentLoaded: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs> | null;
+    FrameContentLoading: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlContentLoadingEventArgs> | null;
+    FrameDOMContentLoaded: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs> | null;
+    FrameNavigationCompleted: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlNavigationCompletedEventArgs> | null;
+    FrameNavigationStarting: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlNavigationStartingEventArgs> | null;
+    LongRunningScriptDetected: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs> | null;
+    NavigationCompleted: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlNavigationCompletedEventArgs> | null;
+    NavigationStarting: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlNavigationStartingEventArgs> | null;
+    NewWindowRequested: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs> | null;
+    PermissionRequested: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlPermissionRequestedEventArgs> | null;
+    ScriptNotify: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlScriptNotifyEventArgs> | null;
+    UnsafeContentWarningDisplaying: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Object> | null;
+    UnsupportedUriSchemeIdentified: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs> | null;
+    UnviewableContentIdentified: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs> | null;
+    WebResourceRequested: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs> | null;
+  }
+
+  class WebUIVoiceCommandActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IVoiceCommandActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly Result: Windows.Media.SpeechRecognition.SpeechRecognitionResult;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUIWalletActionActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IWalletActionActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActionId: string;
+    readonly ActionKind: number;
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly ItemId: string;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+  }
+
+  class WebUIWebAccountProviderActivatedEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IActivatedEventArgsWithUser, Windows.ApplicationModel.Activation.IWebAccountProviderActivatedEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly Kind: number;
+    readonly Operation: Windows.Security.Authentication.Web.Provider.IWebAccountProviderOperation;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly User: Windows.System.User;
+  }
+
+  class WebUIWebAuthenticationBrokerContinuationEventArgs implements Windows.ApplicationModel.Activation.IActivatedEventArgs, Windows.ApplicationModel.Activation.IContinuationActivatedEventArgs, Windows.ApplicationModel.Activation.IWebAuthenticationBrokerContinuationEventArgs, Windows.UI.WebUI.IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+    readonly ContinuationData: Windows.Foundation.Collections.ValueSet;
+    readonly Kind: number;
+    readonly PreviousExecutionState: number;
+    readonly SplashScreen: Windows.ApplicationModel.Activation.SplashScreen;
+    readonly WebAuthenticationResult: Windows.Security.Authentication.Web.WebAuthenticationResult;
+  }
+
+  enum PrintContent {
+    AllPages = 0,
+    CurrentPage = 1,
+    CustomPageRange = 2,
+    CurrentSelection = 3,
+  }
+
+  interface ActivatedEventHandler {
+    (sender: Object, eventArgs: Windows.ApplicationModel.Activation.IActivatedEventArgs): void;
+  }
+  var ActivatedEventHandler: {
+    new(callback: (sender: Object, eventArgs: Windows.ApplicationModel.Activation.IActivatedEventArgs) => void): ActivatedEventHandler;
+  };
+
+  interface BackgroundActivatedEventHandler {
+    (sender: Object, eventArgs: Windows.ApplicationModel.Activation.IBackgroundActivatedEventArgs): void;
+  }
+  var BackgroundActivatedEventHandler: {
+    new(callback: (sender: Object, eventArgs: Windows.ApplicationModel.Activation.IBackgroundActivatedEventArgs) => void): BackgroundActivatedEventHandler;
+  };
+
+  interface EnteredBackgroundEventHandler {
+    (sender: Object, e: Windows.ApplicationModel.IEnteredBackgroundEventArgs): void;
+  }
+  var EnteredBackgroundEventHandler: {
+    new(callback: (sender: Object, e: Windows.ApplicationModel.IEnteredBackgroundEventArgs) => void): EnteredBackgroundEventHandler;
+  };
+
+  interface IActivatedDeferral {
+    Complete(): void;
+  }
+  var IActivatedDeferral: abstract new (...args: any[]) => IActivatedDeferral;
+
+  interface IActivatedEventArgsDeferral {
+    readonly ActivatedOperation: Windows.UI.WebUI.ActivatedOperation;
+  }
+  var IActivatedEventArgsDeferral: abstract new (...args: any[]) => IActivatedEventArgsDeferral;
+
+  interface IActivatedOperation {
+    GetDeferral(): Windows.UI.WebUI.ActivatedDeferral;
+  }
+  var IActivatedOperation: abstract new (...args: any[]) => IActivatedOperation;
+
+  interface IHtmlPrintDocumentSource extends Windows.Graphics.Printing.IPrintDocumentSource {
+    TrySetPageRange(strPageRange: string): boolean;
+    BottomMargin: number;
+    Content: number;
+    EnableHeaderFooter: boolean;
+    LeftMargin: number;
+    readonly PageRange: string;
+    PercentScale: number;
+    RightMargin: number;
+    ShrinkToFit: boolean;
+    TopMargin: number;
+  }
+  var IHtmlPrintDocumentSource: abstract new (...args: any[]) => IHtmlPrintDocumentSource;
+
+  interface INewWebUIViewCreatedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly ActivatedEventArgs: Windows.ApplicationModel.Activation.IActivatedEventArgs;
+    readonly HasPendingNavigate: boolean;
+    readonly WebUIView: Windows.UI.WebUI.WebUIView;
+  }
+  var INewWebUIViewCreatedEventArgs: abstract new (...args: any[]) => INewWebUIViewCreatedEventArgs;
+
+  interface IWebUIActivationStatics {
+    Activated: Windows.UI.WebUI.ActivatedEventHandler | null;
+    Navigated: Windows.UI.WebUI.NavigatedEventHandler | null;
+    Resuming: Windows.UI.WebUI.ResumingEventHandler | null;
+    Suspending: Windows.UI.WebUI.SuspendingEventHandler | null;
+  }
+  var IWebUIActivationStatics: abstract new (...args: any[]) => IWebUIActivationStatics;
+
+  interface IWebUIActivationStatics2 {
+    EnablePrelaunch(value: boolean): void;
+    EnteredBackground: Windows.UI.WebUI.EnteredBackgroundEventHandler | null;
+    LeavingBackground: Windows.UI.WebUI.LeavingBackgroundEventHandler | null;
+  }
+  var IWebUIActivationStatics2: abstract new (...args: any[]) => IWebUIActivationStatics2;
+
+  interface IWebUIActivationStatics3 {
+    RequestRestartAsync(launchArguments: string): Windows.Foundation.IAsyncOperation<number>;
+    RequestRestartForUserAsync(user: Windows.System.User, launchArguments: string): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IWebUIActivationStatics3: abstract new (...args: any[]) => IWebUIActivationStatics3;
+
+  interface IWebUIActivationStatics4 {
+    BackgroundActivated: Windows.UI.WebUI.BackgroundActivatedEventHandler | null;
+    NewWebUIViewCreated: Windows.Foundation.EventHandler<Windows.UI.WebUI.NewWebUIViewCreatedEventArgs> | null;
+  }
+  var IWebUIActivationStatics4: abstract new (...args: any[]) => IWebUIActivationStatics4;
+
+  interface IWebUIBackgroundTaskInstance {
+    Succeeded: boolean;
+  }
+  var IWebUIBackgroundTaskInstance: abstract new (...args: any[]) => IWebUIBackgroundTaskInstance;
+
+  interface IWebUIBackgroundTaskInstanceStatics {
+    readonly Current: Windows.UI.WebUI.IWebUIBackgroundTaskInstance;
+  }
+  var IWebUIBackgroundTaskInstanceStatics: abstract new (...args: any[]) => IWebUIBackgroundTaskInstanceStatics;
+
+  interface IWebUINavigatedDeferral {
+    Complete(): void;
+  }
+  var IWebUINavigatedDeferral: abstract new (...args: any[]) => IWebUINavigatedDeferral;
+
+  interface IWebUINavigatedEventArgs {
+    readonly NavigatedOperation: Windows.UI.WebUI.WebUINavigatedOperation;
+  }
+  var IWebUINavigatedEventArgs: abstract new (...args: any[]) => IWebUINavigatedEventArgs;
+
+  interface IWebUINavigatedOperation {
+    GetDeferral(): Windows.UI.WebUI.WebUINavigatedDeferral;
+  }
+  var IWebUINavigatedOperation: abstract new (...args: any[]) => IWebUINavigatedOperation;
+
+  interface IWebUIView {
+    readonly ApplicationViewId: number;
+    IgnoreApplicationContentUriRulesNavigationRestrictions: boolean;
+    Activated: Windows.Foundation.TypedEventHandler<Windows.UI.WebUI.WebUIView, Windows.ApplicationModel.Activation.IActivatedEventArgs> | null;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.UI.WebUI.WebUIView, Object> | null;
+  }
+  var IWebUIView: abstract new (...args: any[]) => IWebUIView;
+
+  interface IWebUIViewStatics {
+    CreateAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.WebUI.WebUIView>;
+    CreateAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.UI.WebUI.WebUIView>;
+  }
+  var IWebUIViewStatics: abstract new (...args: any[]) => IWebUIViewStatics;
+
+  interface LeavingBackgroundEventHandler {
+    (sender: Object, e: Windows.ApplicationModel.ILeavingBackgroundEventArgs): void;
+  }
+  var LeavingBackgroundEventHandler: {
+    new(callback: (sender: Object, e: Windows.ApplicationModel.ILeavingBackgroundEventArgs) => void): LeavingBackgroundEventHandler;
+  };
+
+  interface NavigatedEventHandler {
+    (sender: Object, e: Windows.UI.WebUI.IWebUINavigatedEventArgs): void;
+  }
+  var NavigatedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.WebUI.IWebUINavigatedEventArgs) => void): NavigatedEventHandler;
+  };
+
+  interface ResumingEventHandler {
+    (sender: Object): void;
+  }
+  var ResumingEventHandler: {
+    new(callback: (sender: Object) => void): ResumingEventHandler;
+  };
+
+  interface SuspendingEventHandler {
+    (sender: Object, e: Windows.ApplicationModel.ISuspendingEventArgs): void;
+  }
+  var SuspendingEventHandler: {
+    new(callback: (sender: Object, e: Windows.ApplicationModel.ISuspendingEventArgs) => void): SuspendingEventHandler;
+  };
+
+}
+
+declare namespace Windows.UI.WindowManagement {
+  class AppWindow implements Windows.UI.WindowManagement.IAppWindow {
+    static ClearAllPersistedState(): void;
+    static ClearPersistedState(key: string): void;
+    CloseAsync(): Windows.Foundation.IAsyncAction;
+    GetDisplayRegions(): Windows.Foundation.Collections.IVectorView<Windows.UI.WindowManagement.DisplayRegion> | Windows.UI.WindowManagement.DisplayRegion[];
+    GetPlacement(): Windows.UI.WindowManagement.AppWindowPlacement;
+    RequestMoveAdjacentToCurrentView(): void;
+    RequestMoveAdjacentToWindow(anchorWindow: Windows.UI.WindowManagement.AppWindow): void;
+    RequestMoveRelativeToCurrentViewContent(contentOffset: Windows.Foundation.Point): void;
+    RequestMoveRelativeToDisplayRegion(displayRegion: Windows.UI.WindowManagement.DisplayRegion, displayRegionOffset: Windows.Foundation.Point): void;
+    RequestMoveRelativeToWindowContent(anchorWindow: Windows.UI.WindowManagement.AppWindow, contentOffset: Windows.Foundation.Point): void;
+    RequestMoveToDisplayRegion(displayRegion: Windows.UI.WindowManagement.DisplayRegion): void;
+    RequestSize(frameSize: Windows.Foundation.Size): void;
+    static TryCreateAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.WindowManagement.AppWindow>;
+    TryShowAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Content: Windows.UI.UIContentRoot;
+    readonly DispatcherQueue: Windows.System.DispatcherQueue;
+    readonly Frame: Windows.UI.WindowManagement.AppWindowFrame;
+    readonly IsVisible: boolean;
+    PersistedStateId: string;
+    readonly Presenter: Windows.UI.WindowManagement.AppWindowPresenter;
+    Title: string;
+    readonly TitleBar: Windows.UI.WindowManagement.AppWindowTitleBar;
+    readonly UIContext: Windows.UI.UIContext;
+    readonly WindowingEnvironment: Windows.UI.WindowManagement.WindowingEnvironment;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.UI.WindowManagement.AppWindow, Windows.UI.WindowManagement.AppWindowChangedEventArgs> | null;
+    CloseRequested: Windows.Foundation.TypedEventHandler<Windows.UI.WindowManagement.AppWindow, Windows.UI.WindowManagement.AppWindowCloseRequestedEventArgs> | null;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.UI.WindowManagement.AppWindow, Windows.UI.WindowManagement.AppWindowClosedEventArgs> | null;
+  }
+
+  class AppWindowChangedEventArgs implements Windows.UI.WindowManagement.IAppWindowChangedEventArgs {
+    readonly DidAvailableWindowPresentationsChange: boolean;
+    readonly DidDisplayRegionsChange: boolean;
+    readonly DidFrameChange: boolean;
+    readonly DidSizeChange: boolean;
+    readonly DidTitleBarChange: boolean;
+    readonly DidVisibilityChange: boolean;
+    readonly DidWindowPresentationChange: boolean;
+    readonly DidWindowingEnvironmentChange: boolean;
+  }
+
+  class AppWindowCloseRequestedEventArgs implements Windows.UI.WindowManagement.IAppWindowCloseRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Cancel: boolean;
+  }
+
+  class AppWindowClosedEventArgs implements Windows.UI.WindowManagement.IAppWindowClosedEventArgs {
+    readonly Reason: number;
+  }
+
+  class AppWindowFrame implements Windows.UI.WindowManagement.IAppWindowFrame, Windows.UI.WindowManagement.IAppWindowFrameStyle {
+    GetFrameStyle(): number;
+    SetFrameStyle(frameStyle: number): void;
+    readonly DragRegionVisuals: Windows.Foundation.Collections.IVector<Windows.UI.Composition.IVisualElement> | Windows.UI.Composition.IVisualElement[];
+  }
+
+  class AppWindowPlacement implements Windows.UI.WindowManagement.IAppWindowPlacement {
+    readonly DisplayRegion: Windows.UI.WindowManagement.DisplayRegion;
+    readonly Offset: Windows.Foundation.Point;
+    readonly Size: Windows.Foundation.Size;
+  }
+
+  class AppWindowPresentationConfiguration implements Windows.UI.WindowManagement.IAppWindowPresentationConfiguration {
+    readonly Kind: number;
+  }
+
+  class AppWindowPresenter implements Windows.UI.WindowManagement.IAppWindowPresenter {
+    GetConfiguration(): Windows.UI.WindowManagement.AppWindowPresentationConfiguration;
+    IsPresentationSupported(presentationKind: number): boolean;
+    RequestPresentation(configuration: Windows.UI.WindowManagement.AppWindowPresentationConfiguration): boolean;
+  }
+
+  class AppWindowTitleBar implements Windows.UI.WindowManagement.IAppWindowTitleBar, Windows.UI.WindowManagement.IAppWindowTitleBarVisibility {
+    GetPreferredVisibility(): number;
+    GetTitleBarOcclusions(): Windows.Foundation.Collections.IVectorView<Windows.UI.WindowManagement.AppWindowTitleBarOcclusion> | Windows.UI.WindowManagement.AppWindowTitleBarOcclusion[];
+    SetPreferredVisibility(visibilityMode: number): void;
+    BackgroundColor: Windows.UI.Color | null;
+    ButtonBackgroundColor: Windows.UI.Color | null;
+    ButtonForegroundColor: Windows.UI.Color | null;
+    ButtonHoverBackgroundColor: Windows.UI.Color | null;
+    ButtonHoverForegroundColor: Windows.UI.Color | null;
+    ButtonInactiveBackgroundColor: Windows.UI.Color | null;
+    ButtonInactiveForegroundColor: Windows.UI.Color | null;
+    ButtonPressedBackgroundColor: Windows.UI.Color | null;
+    ButtonPressedForegroundColor: Windows.UI.Color | null;
+    ExtendsContentIntoTitleBar: boolean;
+    ForegroundColor: Windows.UI.Color | null;
+    InactiveBackgroundColor: Windows.UI.Color | null;
+    InactiveForegroundColor: Windows.UI.Color | null;
+    readonly IsVisible: boolean;
+  }
+
+  class AppWindowTitleBarOcclusion implements Windows.UI.WindowManagement.IAppWindowTitleBarOcclusion {
+    readonly OccludingRect: Windows.Foundation.Rect;
+  }
+
+  class CompactOverlayPresentationConfiguration extends Windows.UI.WindowManagement.AppWindowPresentationConfiguration implements Windows.UI.WindowManagement.ICompactOverlayPresentationConfiguration {
+    constructor();
+  }
+
+  class DefaultPresentationConfiguration extends Windows.UI.WindowManagement.AppWindowPresentationConfiguration implements Windows.UI.WindowManagement.IDefaultPresentationConfiguration {
+    constructor();
+  }
+
+  class DisplayRegion implements Windows.UI.WindowManagement.IDisplayRegion {
+    readonly DisplayMonitorDeviceId: string;
+    readonly IsVisible: boolean;
+    readonly WindowingEnvironment: Windows.UI.WindowManagement.WindowingEnvironment;
+    readonly WorkAreaOffset: Windows.Foundation.Point;
+    readonly WorkAreaSize: Windows.Foundation.Size;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.UI.WindowManagement.DisplayRegion, Object> | null;
+  }
+
+  class FullScreenPresentationConfiguration extends Windows.UI.WindowManagement.AppWindowPresentationConfiguration implements Windows.UI.WindowManagement.IFullScreenPresentationConfiguration {
+    constructor();
+    IsExclusive: boolean;
+  }
+
+  class WindowServices {
+    static FindAllTopLevelWindowIds(): Windows.Foundation.Collections.IVectorView<Windows.UI.WindowId> | Windows.UI.WindowId[];
+  }
+
+  class WindowingEnvironment implements Windows.UI.WindowManagement.IWindowingEnvironment {
+    static FindAll(): Windows.Foundation.Collections.IVectorView<Windows.UI.WindowManagement.WindowingEnvironment> | Windows.UI.WindowManagement.WindowingEnvironment[];
+    static FindAll(kind: number): Windows.Foundation.Collections.IVectorView<Windows.UI.WindowManagement.WindowingEnvironment> | Windows.UI.WindowManagement.WindowingEnvironment[];
+    GetDisplayRegions(): Windows.Foundation.Collections.IVectorView<Windows.UI.WindowManagement.DisplayRegion> | Windows.UI.WindowManagement.DisplayRegion[];
+    readonly IsEnabled: boolean;
+    readonly Kind: number;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.UI.WindowManagement.WindowingEnvironment, Windows.UI.WindowManagement.WindowingEnvironmentChangedEventArgs> | null;
+  }
+
+  class WindowingEnvironmentAddedEventArgs implements Windows.UI.WindowManagement.IWindowingEnvironmentAddedEventArgs {
+    readonly WindowingEnvironment: Windows.UI.WindowManagement.WindowingEnvironment;
+  }
+
+  class WindowingEnvironmentChangedEventArgs implements Windows.UI.WindowManagement.IWindowingEnvironmentChangedEventArgs {
+  }
+
+  class WindowingEnvironmentRemovedEventArgs implements Windows.UI.WindowManagement.IWindowingEnvironmentRemovedEventArgs {
+    readonly WindowingEnvironment: Windows.UI.WindowManagement.WindowingEnvironment;
+  }
+
+  enum AppWindowClosedReason {
+    Other = 0,
+    AppInitiated = 1,
+    UserInitiated = 2,
+  }
+
+  enum AppWindowFrameStyle {
+    Default = 0,
+    NoFrame = 1,
+  }
+
+  enum AppWindowPresentationKind {
+    Default = 0,
+    CompactOverlay = 1,
+    FullScreen = 2,
+  }
+
+  enum AppWindowTitleBarVisibility {
+    Default = 0,
+    AlwaysHidden = 1,
+  }
+
+  enum WindowingEnvironmentKind {
+    Unknown = 0,
+    Overlapped = 1,
+    Tiled = 2,
+  }
+
+  interface IAppWindow {
+    CloseAsync(): Windows.Foundation.IAsyncAction;
+    GetDisplayRegions(): Windows.Foundation.Collections.IVectorView<Windows.UI.WindowManagement.DisplayRegion> | Windows.UI.WindowManagement.DisplayRegion[];
+    GetPlacement(): Windows.UI.WindowManagement.AppWindowPlacement;
+    RequestMoveAdjacentToCurrentView(): void;
+    RequestMoveAdjacentToWindow(anchorWindow: Windows.UI.WindowManagement.AppWindow): void;
+    RequestMoveRelativeToCurrentViewContent(contentOffset: Windows.Foundation.Point): void;
+    RequestMoveRelativeToDisplayRegion(displayRegion: Windows.UI.WindowManagement.DisplayRegion, displayRegionOffset: Windows.Foundation.Point): void;
+    RequestMoveRelativeToWindowContent(anchorWindow: Windows.UI.WindowManagement.AppWindow, contentOffset: Windows.Foundation.Point): void;
+    RequestMoveToDisplayRegion(displayRegion: Windows.UI.WindowManagement.DisplayRegion): void;
+    RequestSize(frameSize: Windows.Foundation.Size): void;
+    TryShowAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly Content: Windows.UI.UIContentRoot;
+    readonly DispatcherQueue: Windows.System.DispatcherQueue;
+    readonly Frame: Windows.UI.WindowManagement.AppWindowFrame;
+    readonly IsVisible: boolean;
+    PersistedStateId: string;
+    readonly Presenter: Windows.UI.WindowManagement.AppWindowPresenter;
+    Title: string;
+    readonly TitleBar: Windows.UI.WindowManagement.AppWindowTitleBar;
+    readonly UIContext: Windows.UI.UIContext;
+    readonly WindowingEnvironment: Windows.UI.WindowManagement.WindowingEnvironment;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.UI.WindowManagement.AppWindow, Windows.UI.WindowManagement.AppWindowChangedEventArgs> | null;
+    CloseRequested: Windows.Foundation.TypedEventHandler<Windows.UI.WindowManagement.AppWindow, Windows.UI.WindowManagement.AppWindowCloseRequestedEventArgs> | null;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.UI.WindowManagement.AppWindow, Windows.UI.WindowManagement.AppWindowClosedEventArgs> | null;
+  }
+  var IAppWindow: abstract new (...args: any[]) => IAppWindow;
+
+  interface IAppWindowChangedEventArgs {
+    readonly DidAvailableWindowPresentationsChange: boolean;
+    readonly DidDisplayRegionsChange: boolean;
+    readonly DidFrameChange: boolean;
+    readonly DidSizeChange: boolean;
+    readonly DidTitleBarChange: boolean;
+    readonly DidVisibilityChange: boolean;
+    readonly DidWindowPresentationChange: boolean;
+    readonly DidWindowingEnvironmentChange: boolean;
+  }
+  var IAppWindowChangedEventArgs: abstract new (...args: any[]) => IAppWindowChangedEventArgs;
+
+  interface IAppWindowCloseRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Cancel: boolean;
+  }
+  var IAppWindowCloseRequestedEventArgs: abstract new (...args: any[]) => IAppWindowCloseRequestedEventArgs;
+
+  interface IAppWindowClosedEventArgs {
+    readonly Reason: number;
+  }
+  var IAppWindowClosedEventArgs: abstract new (...args: any[]) => IAppWindowClosedEventArgs;
+
+  interface IAppWindowFrame {
+    readonly DragRegionVisuals: Windows.Foundation.Collections.IVector<Windows.UI.Composition.IVisualElement> | Windows.UI.Composition.IVisualElement[];
+  }
+  var IAppWindowFrame: abstract new (...args: any[]) => IAppWindowFrame;
+
+  interface IAppWindowFrameStyle {
+    GetFrameStyle(): number;
+    SetFrameStyle(frameStyle: number): void;
+  }
+  var IAppWindowFrameStyle: abstract new (...args: any[]) => IAppWindowFrameStyle;
+
+  interface IAppWindowPlacement {
+    readonly DisplayRegion: Windows.UI.WindowManagement.DisplayRegion;
+    readonly Offset: Windows.Foundation.Point;
+    readonly Size: Windows.Foundation.Size;
+  }
+  var IAppWindowPlacement: abstract new (...args: any[]) => IAppWindowPlacement;
+
+  interface IAppWindowPresentationConfiguration {
+    readonly Kind: number;
+  }
+  var IAppWindowPresentationConfiguration: abstract new (...args: any[]) => IAppWindowPresentationConfiguration;
+
+  interface IAppWindowPresentationConfigurationFactory {
+  }
+  var IAppWindowPresentationConfigurationFactory: abstract new (...args: any[]) => IAppWindowPresentationConfigurationFactory;
+
+  interface IAppWindowPresenter {
+    GetConfiguration(): Windows.UI.WindowManagement.AppWindowPresentationConfiguration;
+    IsPresentationSupported(presentationKind: number): boolean;
+    RequestPresentation(configuration: Windows.UI.WindowManagement.AppWindowPresentationConfiguration): boolean;
+  }
+  var IAppWindowPresenter: abstract new (...args: any[]) => IAppWindowPresenter;
+
+  interface IAppWindowStatics {
+    ClearAllPersistedState(): void;
+    ClearPersistedState(key: string): void;
+    TryCreateAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.WindowManagement.AppWindow>;
+  }
+  var IAppWindowStatics: abstract new (...args: any[]) => IAppWindowStatics;
+
+  interface IAppWindowTitleBar {
+    GetTitleBarOcclusions(): Windows.Foundation.Collections.IVectorView<Windows.UI.WindowManagement.AppWindowTitleBarOcclusion> | Windows.UI.WindowManagement.AppWindowTitleBarOcclusion[];
+    BackgroundColor: Windows.UI.Color | null;
+    ButtonBackgroundColor: Windows.UI.Color | null;
+    ButtonForegroundColor: Windows.UI.Color | null;
+    ButtonHoverBackgroundColor: Windows.UI.Color | null;
+    ButtonHoverForegroundColor: Windows.UI.Color | null;
+    ButtonInactiveBackgroundColor: Windows.UI.Color | null;
+    ButtonInactiveForegroundColor: Windows.UI.Color | null;
+    ButtonPressedBackgroundColor: Windows.UI.Color | null;
+    ButtonPressedForegroundColor: Windows.UI.Color | null;
+    ExtendsContentIntoTitleBar: boolean;
+    ForegroundColor: Windows.UI.Color | null;
+    InactiveBackgroundColor: Windows.UI.Color | null;
+    InactiveForegroundColor: Windows.UI.Color | null;
+    readonly IsVisible: boolean;
+  }
+  var IAppWindowTitleBar: abstract new (...args: any[]) => IAppWindowTitleBar;
+
+  interface IAppWindowTitleBarOcclusion {
+    readonly OccludingRect: Windows.Foundation.Rect;
+  }
+  var IAppWindowTitleBarOcclusion: abstract new (...args: any[]) => IAppWindowTitleBarOcclusion;
+
+  interface IAppWindowTitleBarVisibility {
+    GetPreferredVisibility(): number;
+    SetPreferredVisibility(visibilityMode: number): void;
+  }
+  var IAppWindowTitleBarVisibility: abstract new (...args: any[]) => IAppWindowTitleBarVisibility;
+
+  interface ICompactOverlayPresentationConfiguration {
+  }
+  var ICompactOverlayPresentationConfiguration: abstract new (...args: any[]) => ICompactOverlayPresentationConfiguration;
+
+  interface IDefaultPresentationConfiguration {
+  }
+  var IDefaultPresentationConfiguration: abstract new (...args: any[]) => IDefaultPresentationConfiguration;
+
+  interface IDisplayRegion {
+    readonly DisplayMonitorDeviceId: string;
+    readonly IsVisible: boolean;
+    readonly WindowingEnvironment: Windows.UI.WindowManagement.WindowingEnvironment;
+    readonly WorkAreaOffset: Windows.Foundation.Point;
+    readonly WorkAreaSize: Windows.Foundation.Size;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.UI.WindowManagement.DisplayRegion, Object> | null;
+  }
+  var IDisplayRegion: abstract new (...args: any[]) => IDisplayRegion;
+
+  interface IFullScreenPresentationConfiguration {
+    IsExclusive: boolean;
+  }
+  var IFullScreenPresentationConfiguration: abstract new (...args: any[]) => IFullScreenPresentationConfiguration;
+
+  interface IWindowServicesStatics {
+    FindAllTopLevelWindowIds(): Windows.Foundation.Collections.IVectorView<Windows.UI.WindowId> | Windows.UI.WindowId[];
+  }
+  var IWindowServicesStatics: abstract new (...args: any[]) => IWindowServicesStatics;
+
+  interface IWindowingEnvironment {
+    GetDisplayRegions(): Windows.Foundation.Collections.IVectorView<Windows.UI.WindowManagement.DisplayRegion> | Windows.UI.WindowManagement.DisplayRegion[];
+    readonly IsEnabled: boolean;
+    readonly Kind: number;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.UI.WindowManagement.WindowingEnvironment, Windows.UI.WindowManagement.WindowingEnvironmentChangedEventArgs> | null;
+  }
+  var IWindowingEnvironment: abstract new (...args: any[]) => IWindowingEnvironment;
+
+  interface IWindowingEnvironmentAddedEventArgs {
+    readonly WindowingEnvironment: Windows.UI.WindowManagement.WindowingEnvironment;
+  }
+  var IWindowingEnvironmentAddedEventArgs: abstract new (...args: any[]) => IWindowingEnvironmentAddedEventArgs;
+
+  interface IWindowingEnvironmentChangedEventArgs {
+  }
+  var IWindowingEnvironmentChangedEventArgs: abstract new (...args: any[]) => IWindowingEnvironmentChangedEventArgs;
+
+  interface IWindowingEnvironmentRemovedEventArgs {
+    readonly WindowingEnvironment: Windows.UI.WindowManagement.WindowingEnvironment;
+  }
+  var IWindowingEnvironmentRemovedEventArgs: abstract new (...args: any[]) => IWindowingEnvironmentRemovedEventArgs;
+
+  interface IWindowingEnvironmentStatics {
+    FindAll(): Windows.Foundation.Collections.IVectorView<Windows.UI.WindowManagement.WindowingEnvironment> | Windows.UI.WindowManagement.WindowingEnvironment[];
+    FindAll(kind: number): Windows.Foundation.Collections.IVectorView<Windows.UI.WindowManagement.WindowingEnvironment> | Windows.UI.WindowManagement.WindowingEnvironment[];
+  }
+  var IWindowingEnvironmentStatics: abstract new (...args: any[]) => IWindowingEnvironmentStatics;
+
+}
+
+declare namespace Windows.UI.WindowManagement.Preview {
+  class WindowManagementPreview implements Windows.UI.WindowManagement.Preview.IWindowManagementPreview {
+    static SetPreferredMinSize(window: Windows.UI.WindowManagement.AppWindow, preferredFrameMinSize: Windows.Foundation.Size): void;
+  }
+
+  interface IWindowManagementPreview {
+  }
+  var IWindowManagementPreview: abstract new (...args: any[]) => IWindowManagementPreview;
+
+  interface IWindowManagementPreviewStatics {
+    SetPreferredMinSize(window: Windows.UI.WindowManagement.AppWindow, preferredFrameMinSize: Windows.Foundation.Size): void;
+  }
+  var IWindowManagementPreviewStatics: abstract new (...args: any[]) => IWindowManagementPreviewStatics;
+
+}
+
+declare namespace Windows.UI.Xaml {
+  class AdaptiveTrigger extends Windows.UI.Xaml.StateTriggerBase implements Windows.UI.Xaml.IAdaptiveTrigger {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetActive(IsActive: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    MinWindowHeight: number;
+    static readonly MinWindowHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    MinWindowWidth: number;
+    static readonly MinWindowWidthProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Application implements Windows.UI.Xaml.IApplication, Windows.UI.Xaml.IApplication2, Windows.UI.Xaml.IApplication3, Windows.UI.Xaml.IApplicationOverrides, Windows.UI.Xaml.IApplicationOverrides2 {
+    constructor();
+    Exit(): void;
+    static LoadComponent(component: Object, resourceLocator: Windows.Foundation.Uri): void;
+    static LoadComponent(component: Object, resourceLocator: Windows.Foundation.Uri, componentResourceLocation: number): void;
+    OnActivated(args: Windows.ApplicationModel.Activation.IActivatedEventArgs): void;
+    OnBackgroundActivated(args: Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs): void;
+    OnCachedFileUpdaterActivated(args: Windows.ApplicationModel.Activation.CachedFileUpdaterActivatedEventArgs): void;
+    OnFileActivated(args: Windows.ApplicationModel.Activation.FileActivatedEventArgs): void;
+    OnFileOpenPickerActivated(args: Windows.ApplicationModel.Activation.FileOpenPickerActivatedEventArgs): void;
+    OnFileSavePickerActivated(args: Windows.ApplicationModel.Activation.FileSavePickerActivatedEventArgs): void;
+    OnLaunched(args: Windows.ApplicationModel.Activation.LaunchActivatedEventArgs): void;
+    OnSearchActivated(args: Windows.ApplicationModel.Activation.SearchActivatedEventArgs): void;
+    OnShareTargetActivated(args: Windows.ApplicationModel.Activation.ShareTargetActivatedEventArgs): void;
+    OnWindowCreated(args: Windows.UI.Xaml.WindowCreatedEventArgs): void;
+    static Start(callback: Windows.UI.Xaml.ApplicationInitializationCallback): void;
+    static readonly Current: Windows.UI.Xaml.Application;
+    readonly DebugSettings: Windows.UI.Xaml.DebugSettings;
+    FocusVisualKind: number;
+    HighContrastAdjustment: number;
+    RequestedTheme: number;
+    RequiresPointerMode: number;
+    Resources: Windows.UI.Xaml.ResourceDictionary;
+    Resuming: Windows.Foundation.EventHandler<Object> | null;
+    Suspending: Windows.UI.Xaml.SuspendingEventHandler | null;
+    UnhandledException: Windows.UI.Xaml.UnhandledExceptionEventHandler | null;
+    EnteredBackground: Windows.UI.Xaml.EnteredBackgroundEventHandler | null;
+    LeavingBackground: Windows.UI.Xaml.LeavingBackgroundEventHandler | null;
+  }
+
+  class ApplicationInitializationCallbackParams implements Windows.UI.Xaml.IApplicationInitializationCallbackParams {
+  }
+
+  class BindingFailedEventArgs implements Windows.UI.Xaml.IBindingFailedEventArgs {
+    readonly Message: string;
+  }
+
+  class BringIntoViewOptions implements Windows.UI.Xaml.IBringIntoViewOptions, Windows.UI.Xaml.IBringIntoViewOptions2 {
+    constructor();
+    AnimationDesired: boolean;
+    HorizontalAlignmentRatio: number;
+    HorizontalOffset: number;
+    TargetRect: Windows.Foundation.Rect | null;
+    VerticalAlignmentRatio: number;
+    VerticalOffset: number;
+  }
+
+  class BringIntoViewRequestedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.IBringIntoViewRequestedEventArgs {
+    AnimationDesired: boolean;
+    Handled: boolean;
+    readonly HorizontalAlignmentRatio: number;
+    HorizontalOffset: number;
+    TargetElement: Windows.UI.Xaml.UIElement;
+    TargetRect: Windows.Foundation.Rect;
+    readonly VerticalAlignmentRatio: number;
+    VerticalOffset: number;
+  }
+
+  class BrushTransition implements Windows.UI.Xaml.IBrushTransition {
+    constructor();
+    Duration: Windows.Foundation.TimeSpan;
+  }
+
+  class ColorPaletteResources extends Windows.UI.Xaml.ResourceDictionary implements Windows.UI.Xaml.IColorPaletteResources {
+    constructor();
+    Clear(): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<Object, Object>>;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetView(): Windows.Foundation.Collections.IMapView<Object, Object>;
+    HasKey(key: Object): boolean;
+    Insert(key: Object, value: Object): boolean;
+    Lookup(key: Object): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    Remove(key: Object): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Accent: Windows.UI.Color | null;
+    AltHigh: Windows.UI.Color | null;
+    AltLow: Windows.UI.Color | null;
+    AltMedium: Windows.UI.Color | null;
+    AltMediumHigh: Windows.UI.Color | null;
+    AltMediumLow: Windows.UI.Color | null;
+    BaseHigh: Windows.UI.Color | null;
+    BaseLow: Windows.UI.Color | null;
+    BaseMedium: Windows.UI.Color | null;
+    BaseMediumHigh: Windows.UI.Color | null;
+    BaseMediumLow: Windows.UI.Color | null;
+    ChromeAltLow: Windows.UI.Color | null;
+    ChromeBlackHigh: Windows.UI.Color | null;
+    ChromeBlackLow: Windows.UI.Color | null;
+    ChromeBlackMedium: Windows.UI.Color | null;
+    ChromeBlackMediumLow: Windows.UI.Color | null;
+    ChromeDisabledHigh: Windows.UI.Color | null;
+    ChromeDisabledLow: Windows.UI.Color | null;
+    ChromeGray: Windows.UI.Color | null;
+    ChromeHigh: Windows.UI.Color | null;
+    ChromeLow: Windows.UI.Color | null;
+    ChromeMedium: Windows.UI.Color | null;
+    ChromeMediumLow: Windows.UI.Color | null;
+    ChromeWhite: Windows.UI.Color | null;
+    ErrorText: Windows.UI.Color | null;
+    ListLow: Windows.UI.Color | null;
+    ListMedium: Windows.UI.Color | null;
+  }
+
+  class CornerRadiusHelper implements Windows.UI.Xaml.ICornerRadiusHelper {
+    static FromRadii(topLeft: number, topRight: number, bottomRight: number, bottomLeft: number): Windows.UI.Xaml.CornerRadius;
+    static FromUniformRadius(uniformRadius: number): Windows.UI.Xaml.CornerRadius;
+  }
+
+  class DataContextChangedEventArgs implements Windows.UI.Xaml.IDataContextChangedEventArgs {
+    Handled: boolean;
+    readonly NewValue: Object;
+  }
+
+  class DataTemplate extends Windows.UI.Xaml.FrameworkTemplate implements Windows.UI.Xaml.IDataTemplate, Windows.UI.Xaml.IElementFactory {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetElement(args: Windows.UI.Xaml.ElementFactoryGetArgs): Windows.UI.Xaml.UIElement;
+    static GetExtensionInstance(element: Windows.UI.Xaml.FrameworkElement): Windows.UI.Xaml.IDataTemplateExtension;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    LoadContent(): Windows.UI.Xaml.DependencyObject;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RecycleElement(args: Windows.UI.Xaml.ElementFactoryRecycleArgs): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static SetExtensionInstance(element: Windows.UI.Xaml.FrameworkElement, value: Windows.UI.Xaml.IDataTemplateExtension): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    static readonly ExtensionInstanceProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class DataTemplateKey implements Windows.UI.Xaml.IDataTemplateKey {
+    constructor();
+    constructor(dataType: Object);
+    DataType: Object;
+  }
+
+  class DebugSettings implements Windows.UI.Xaml.IDebugSettings, Windows.UI.Xaml.IDebugSettings2, Windows.UI.Xaml.IDebugSettings3, Windows.UI.Xaml.IDebugSettings4 {
+    EnableFrameRateCounter: boolean;
+    EnableRedrawRegions: boolean;
+    FailFastOnErrors: boolean;
+    IsBindingTracingEnabled: boolean;
+    IsOverdrawHeatMapEnabled: boolean;
+    IsTextPerformanceVisualizationEnabled: boolean;
+    BindingFailed: Windows.UI.Xaml.BindingFailedEventHandler | null;
+  }
+
+  class DependencyObject implements Windows.UI.Xaml.IDependencyObject, Windows.UI.Xaml.IDependencyObject2 {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly Dispatcher: Windows.UI.Core.CoreDispatcher;
+  }
+
+  class DependencyObjectCollection extends Windows.UI.Xaml.DependencyObject {
+    constructor();
+    Append(value: Windows.UI.Xaml.DependencyObject): void;
+    Clear(): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.DependencyObject>;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAt(index: number): Windows.UI.Xaml.DependencyObject;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.DependencyObject[]): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    IndexOf(value: Windows.UI.Xaml.DependencyObject, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.DependencyObject): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.DependencyObject[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.DependencyObject): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly Size: number;
+    VectorChanged: Windows.Foundation.Collections.VectorChangedEventHandler<Windows.UI.Xaml.DependencyObject> | null;
+  }
+
+  class DependencyProperty implements Windows.UI.Xaml.IDependencyProperty {
+    GetMetadata(forType: Windows.UI.Xaml.Interop.TypeName): Windows.UI.Xaml.PropertyMetadata;
+    static Register(name: string, propertyType: Windows.UI.Xaml.Interop.TypeName, ownerType: Windows.UI.Xaml.Interop.TypeName, typeMetadata: Windows.UI.Xaml.PropertyMetadata): Windows.UI.Xaml.DependencyProperty;
+    static RegisterAttached(name: string, propertyType: Windows.UI.Xaml.Interop.TypeName, ownerType: Windows.UI.Xaml.Interop.TypeName, defaultMetadata: Windows.UI.Xaml.PropertyMetadata): Windows.UI.Xaml.DependencyProperty;
+    static readonly UnsetValue: Object;
+  }
+
+  class DependencyPropertyChangedEventArgs implements Windows.UI.Xaml.IDependencyPropertyChangedEventArgs {
+    readonly NewValue: Object;
+    readonly OldValue: Object;
+    readonly Property: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class DispatcherTimer implements Windows.UI.Xaml.IDispatcherTimer {
+    constructor();
+    Start(): void;
+    Stop(): void;
+    Interval: Windows.Foundation.TimeSpan;
+    readonly IsEnabled: boolean;
+    Tick: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class DragEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.IDragEventArgs, Windows.UI.Xaml.IDragEventArgs2, Windows.UI.Xaml.IDragEventArgs3 {
+    GetDeferral(): Windows.UI.Xaml.DragOperationDeferral;
+    GetPosition(relativeTo: Windows.UI.Xaml.UIElement): Windows.Foundation.Point;
+    AcceptedOperation: number;
+    readonly AllowedOperations: number;
+    Data: Windows.ApplicationModel.DataTransfer.DataPackage;
+    readonly DataView: Windows.ApplicationModel.DataTransfer.DataPackageView;
+    readonly DragUIOverride: Windows.UI.Xaml.DragUIOverride;
+    Handled: boolean;
+    readonly Modifiers: number;
+  }
+
+  class DragOperationDeferral implements Windows.UI.Xaml.IDragOperationDeferral {
+    Complete(): void;
+  }
+
+  class DragStartingEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.IDragStartingEventArgs, Windows.UI.Xaml.IDragStartingEventArgs2 {
+    GetDeferral(): Windows.UI.Xaml.DragOperationDeferral;
+    GetPosition(relativeTo: Windows.UI.Xaml.UIElement): Windows.Foundation.Point;
+    AllowedOperations: number;
+    Cancel: boolean;
+    readonly Data: Windows.ApplicationModel.DataTransfer.DataPackage;
+    readonly DragUI: Windows.UI.Xaml.DragUI;
+  }
+
+  class DragUI implements Windows.UI.Xaml.IDragUI {
+    SetContentFromBitmapImage(bitmapImage: Windows.UI.Xaml.Media.Imaging.BitmapImage): void;
+    SetContentFromBitmapImage(bitmapImage: Windows.UI.Xaml.Media.Imaging.BitmapImage, anchorPoint: Windows.Foundation.Point): void;
+    SetContentFromDataPackage(): void;
+    SetContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap): void;
+    SetContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap, anchorPoint: Windows.Foundation.Point): void;
+  }
+
+  class DragUIOverride implements Windows.UI.Xaml.IDragUIOverride {
+    Clear(): void;
+    SetContentFromBitmapImage(bitmapImage: Windows.UI.Xaml.Media.Imaging.BitmapImage): void;
+    SetContentFromBitmapImage(bitmapImage: Windows.UI.Xaml.Media.Imaging.BitmapImage, anchorPoint: Windows.Foundation.Point): void;
+    SetContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap): void;
+    SetContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap, anchorPoint: Windows.Foundation.Point): void;
+    Caption: string;
+    IsCaptionVisible: boolean;
+    IsContentVisible: boolean;
+    IsGlyphVisible: boolean;
+  }
+
+  class DropCompletedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.IDropCompletedEventArgs {
+    readonly DropResult: number;
+  }
+
+  class DurationHelper implements Windows.UI.Xaml.IDurationHelper {
+    static Add(target: Windows.UI.Xaml.Duration, duration: Windows.UI.Xaml.Duration): Windows.UI.Xaml.Duration;
+    static Compare(duration1: Windows.UI.Xaml.Duration, duration2: Windows.UI.Xaml.Duration): number;
+    static Equals(target: Windows.UI.Xaml.Duration, value: Windows.UI.Xaml.Duration): boolean;
+    static FromTimeSpan(timeSpan: Windows.Foundation.TimeSpan): Windows.UI.Xaml.Duration;
+    static GetHasTimeSpan(target: Windows.UI.Xaml.Duration): boolean;
+    static Subtract(target: Windows.UI.Xaml.Duration, duration: Windows.UI.Xaml.Duration): Windows.UI.Xaml.Duration;
+    static readonly Automatic: Windows.UI.Xaml.Duration;
+    static readonly Forever: Windows.UI.Xaml.Duration;
+  }
+
+  class EffectiveViewportChangedEventArgs implements Windows.UI.Xaml.IEffectiveViewportChangedEventArgs {
+    readonly BringIntoViewDistanceX: number;
+    readonly BringIntoViewDistanceY: number;
+    readonly EffectiveViewport: Windows.Foundation.Rect;
+    readonly MaxViewport: Windows.Foundation.Rect;
+  }
+
+  class ElementFactoryGetArgs implements Windows.UI.Xaml.IElementFactoryGetArgs {
+    constructor();
+    Data: Object;
+    Parent: Windows.UI.Xaml.UIElement;
+  }
+
+  class ElementFactoryRecycleArgs implements Windows.UI.Xaml.IElementFactoryRecycleArgs {
+    constructor();
+    Element: Windows.UI.Xaml.UIElement;
+    Parent: Windows.UI.Xaml.UIElement;
+  }
+
+  class ElementSoundPlayer implements Windows.UI.Xaml.IElementSoundPlayer {
+    static Play(sound: number): void;
+    static SpatialAudioMode: number;
+    static State: number;
+    static Volume: number;
+  }
+
+  class EventTrigger extends Windows.UI.Xaml.TriggerBase implements Windows.UI.Xaml.IEventTrigger {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly Actions: Windows.UI.Xaml.TriggerActionCollection;
+    RoutedEvent: Windows.UI.Xaml.RoutedEvent;
+  }
+
+  class ExceptionRoutedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.IExceptionRoutedEventArgs {
+    readonly ErrorMessage: string;
+  }
+
+  class FrameworkElement extends Windows.UI.Xaml.UIElement implements Windows.UI.Xaml.IFrameworkElement, Windows.UI.Xaml.IFrameworkElement2, Windows.UI.Xaml.IFrameworkElement3, Windows.UI.Xaml.IFrameworkElement4, Windows.UI.Xaml.IFrameworkElement6, Windows.UI.Xaml.IFrameworkElement7, Windows.UI.Xaml.IFrameworkElementOverrides, Windows.UI.Xaml.IFrameworkElementOverrides2, Windows.UI.Xaml.IFrameworkElementProtected7 {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly ActualHeight: number;
+    static readonly ActualHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ActualTheme: number;
+    static readonly ActualThemeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ActualWidth: number;
+    static readonly ActualWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    AllowFocusOnInteraction: boolean;
+    static readonly AllowFocusOnInteractionProperty: Windows.UI.Xaml.DependencyProperty;
+    AllowFocusWhenDisabled: boolean;
+    static readonly AllowFocusWhenDisabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BaseUri: Windows.Foundation.Uri;
+    DataContext: Object;
+    static readonly DataContextProperty: Windows.UI.Xaml.DependencyProperty;
+    FlowDirection: number;
+    static readonly FlowDirectionProperty: Windows.UI.Xaml.DependencyProperty;
+    FocusVisualMargin: Windows.UI.Xaml.Thickness;
+    static readonly FocusVisualMarginProperty: Windows.UI.Xaml.DependencyProperty;
+    FocusVisualPrimaryBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly FocusVisualPrimaryBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    FocusVisualPrimaryThickness: Windows.UI.Xaml.Thickness;
+    static readonly FocusVisualPrimaryThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    FocusVisualSecondaryBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly FocusVisualSecondaryBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    FocusVisualSecondaryThickness: Windows.UI.Xaml.Thickness;
+    static readonly FocusVisualSecondaryThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    Height: number;
+    static readonly HeightProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalAlignment: number;
+    static readonly HorizontalAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsLoaded: boolean;
+    Language: string;
+    static readonly LanguageProperty: Windows.UI.Xaml.DependencyProperty;
+    Margin: Windows.UI.Xaml.Thickness;
+    static readonly MarginProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxHeight: number;
+    static readonly MaxHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxWidth: number;
+    static readonly MaxWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    MinHeight: number;
+    static readonly MinHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    MinWidth: number;
+    static readonly MinWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    Name: string;
+    static readonly NameProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Parent: Windows.UI.Xaml.DependencyObject;
+    RequestedTheme: number;
+    static readonly RequestedThemeProperty: Windows.UI.Xaml.DependencyProperty;
+    Resources: Windows.UI.Xaml.ResourceDictionary;
+    Style: Windows.UI.Xaml.Style;
+    static readonly StyleProperty: Windows.UI.Xaml.DependencyProperty;
+    Tag: Object;
+    static readonly TagProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Triggers: Windows.UI.Xaml.TriggerCollection;
+    VerticalAlignment: number;
+    static readonly VerticalAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    Width: number;
+    static readonly WidthProperty: Windows.UI.Xaml.DependencyProperty;
+    LayoutUpdated: Windows.Foundation.EventHandler<Object> | null;
+    Loaded: Windows.UI.Xaml.RoutedEventHandler | null;
+    SizeChanged: Windows.UI.Xaml.SizeChangedEventHandler | null;
+    Unloaded: Windows.UI.Xaml.RoutedEventHandler | null;
+    DataContextChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.FrameworkElement, Windows.UI.Xaml.DataContextChangedEventArgs> | null;
+    Loading: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.FrameworkElement, Object> | null;
+    ActualThemeChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.FrameworkElement, Object> | null;
+    EffectiveViewportChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.FrameworkElement, Windows.UI.Xaml.EffectiveViewportChangedEventArgs> | null;
+  }
+
+  class FrameworkTemplate extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.IFrameworkTemplate {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class FrameworkView implements Windows.ApplicationModel.Core.IFrameworkView, Windows.UI.Xaml.IFrameworkView {
+    constructor();
+    Initialize(applicationView: Windows.ApplicationModel.Core.CoreApplicationView): void;
+    Load(entryPoint: string): void;
+    Run(): void;
+    SetWindow(window: Windows.UI.Core.CoreWindow): void;
+    Uninitialize(): void;
+  }
+
+  class FrameworkViewSource implements Windows.ApplicationModel.Core.IFrameworkViewSource, Windows.UI.Xaml.IFrameworkViewSource {
+    constructor();
+    CreateView(): Windows.ApplicationModel.Core.IFrameworkView;
+  }
+
+  class GridLengthHelper implements Windows.UI.Xaml.IGridLengthHelper {
+    static Equals(target: Windows.UI.Xaml.GridLength, value: Windows.UI.Xaml.GridLength): boolean;
+    static FromPixels(pixels: number): Windows.UI.Xaml.GridLength;
+    static FromValueAndType(value: number, type: number): Windows.UI.Xaml.GridLength;
+    static GetIsAbsolute(target: Windows.UI.Xaml.GridLength): boolean;
+    static GetIsAuto(target: Windows.UI.Xaml.GridLength): boolean;
+    static GetIsStar(target: Windows.UI.Xaml.GridLength): boolean;
+    static readonly Auto: Windows.UI.Xaml.GridLength;
+  }
+
+  class MediaFailedRoutedEventArgs extends Windows.UI.Xaml.ExceptionRoutedEventArgs implements Windows.UI.Xaml.IMediaFailedRoutedEventArgs {
+    readonly ErrorTrace: string;
+  }
+
+  class PointHelper implements Windows.UI.Xaml.IPointHelper {
+    static FromCoordinates(x: number, y: number): Windows.Foundation.Point;
+  }
+
+  class PropertyMetadata implements Windows.UI.Xaml.IPropertyMetadata {
+    constructor(defaultValue: Object);
+    constructor(defaultValue: Object, propertyChangedCallback: Windows.UI.Xaml.PropertyChangedCallback);
+    static Create(defaultValue: Object): Windows.UI.Xaml.PropertyMetadata;
+    static Create(defaultValue: Object, propertyChangedCallback: Windows.UI.Xaml.PropertyChangedCallback): Windows.UI.Xaml.PropertyMetadata;
+    readonly CreateDefaultValueCallback: Windows.UI.Xaml.CreateDefaultValueCallback;
+    readonly DefaultValue: Object;
+  }
+
+  class PropertyPath extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.IPropertyPath {
+    constructor(path: string);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly Path: string;
+  }
+
+  class RectHelper implements Windows.UI.Xaml.IRectHelper {
+    static Contains(target: Windows.Foundation.Rect, point: Windows.Foundation.Point): boolean;
+    static Equals(target: Windows.Foundation.Rect, value: Windows.Foundation.Rect): boolean;
+    static FromCoordinatesAndDimensions(x: number, y: number, width: number, height: number): Windows.Foundation.Rect;
+    static FromLocationAndSize(location: Windows.Foundation.Point, size: Windows.Foundation.Size): Windows.Foundation.Rect;
+    static FromPoints(point1: Windows.Foundation.Point, point2: Windows.Foundation.Point): Windows.Foundation.Rect;
+    static GetBottom(target: Windows.Foundation.Rect): number;
+    static GetIsEmpty(target: Windows.Foundation.Rect): boolean;
+    static GetLeft(target: Windows.Foundation.Rect): number;
+    static GetRight(target: Windows.Foundation.Rect): number;
+    static GetTop(target: Windows.Foundation.Rect): number;
+    static Intersect(target: Windows.Foundation.Rect, rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    static Union(target: Windows.Foundation.Rect, point: Windows.Foundation.Point): Windows.Foundation.Rect;
+    static readonly Empty: Windows.Foundation.Rect;
+  }
+
+  class ResourceDictionary extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.IResourceDictionary {
+    constructor();
+    Clear(): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<Object, Object>>;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetView(): Windows.Foundation.Collections.IMapView<Object, Object>;
+    HasKey(key: Object): boolean;
+    Insert(key: Object, value: Object): boolean;
+    Lookup(key: Object): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    Remove(key: Object): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly MergedDictionaries: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.ResourceDictionary> | Windows.UI.Xaml.ResourceDictionary[];
+    readonly Size: number;
+    Source: Windows.Foundation.Uri;
+    readonly ThemeDictionaries: Windows.Foundation.Collections.IMap<Object, Object>;
+  }
+
+  class RoutedEvent implements Windows.UI.Xaml.IRoutedEvent {
+  }
+
+  class RoutedEventArgs implements Windows.UI.Xaml.IRoutedEventArgs {
+    constructor();
+    readonly OriginalSource: Object;
+  }
+
+  class ScalarTransition implements Windows.UI.Xaml.IScalarTransition {
+    constructor();
+    Duration: Windows.Foundation.TimeSpan;
+  }
+
+  class Setter extends Windows.UI.Xaml.SetterBase implements Windows.UI.Xaml.ISetter, Windows.UI.Xaml.ISetter2 {
+    constructor(targetProperty: Windows.UI.Xaml.DependencyProperty, value: Object);
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Property: Windows.UI.Xaml.DependencyProperty;
+    Target: Windows.UI.Xaml.TargetPropertyPath;
+    Value: Object;
+  }
+
+  class SetterBase extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.ISetterBase {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly IsSealed: boolean;
+  }
+
+  class SetterBaseCollection implements Windows.UI.Xaml.ISetterBaseCollection {
+    constructor();
+    Append(value: Windows.UI.Xaml.SetterBase): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.SetterBase>;
+    GetAt(index: number): Windows.UI.Xaml.SetterBase;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.SetterBase[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.SetterBase> | Windows.UI.Xaml.SetterBase[];
+    IndexOf(value: Windows.UI.Xaml.SetterBase, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.SetterBase): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.SetterBase[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.SetterBase): void;
+    readonly IsSealed: boolean;
+    readonly Size: number;
+  }
+
+  class SizeChangedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.ISizeChangedEventArgs {
+    readonly NewSize: Windows.Foundation.Size;
+    readonly PreviousSize: Windows.Foundation.Size;
+  }
+
+  class SizeHelper implements Windows.UI.Xaml.ISizeHelper {
+    static Equals(target: Windows.Foundation.Size, value: Windows.Foundation.Size): boolean;
+    static FromDimensions(width: number, height: number): Windows.Foundation.Size;
+    static GetIsEmpty(target: Windows.Foundation.Size): boolean;
+    static readonly Empty: Windows.Foundation.Size;
+  }
+
+  class StateTrigger extends Windows.UI.Xaml.StateTriggerBase implements Windows.UI.Xaml.IStateTrigger {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetActive(IsActive: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    IsActive: boolean;
+    static readonly IsActiveProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class StateTriggerBase extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.IStateTriggerBase, Windows.UI.Xaml.IStateTriggerBaseProtected {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetActive(IsActive: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class Style extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.IStyle {
+    constructor(targetType: Windows.UI.Xaml.Interop.TypeName);
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    Seal(): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    BasedOn: Windows.UI.Xaml.Style;
+    readonly IsSealed: boolean;
+    readonly Setters: Windows.UI.Xaml.SetterBaseCollection;
+    TargetType: Windows.UI.Xaml.Interop.TypeName;
+  }
+
+  class StyleTypedPropertyAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class TargetPropertyPath implements Windows.UI.Xaml.ITargetPropertyPath {
+    constructor(targetProperty: Windows.UI.Xaml.DependencyProperty);
+    constructor();
+    Path: Windows.UI.Xaml.PropertyPath;
+    Target: Object;
+  }
+
+  class TemplatePartAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class TemplateVisualStateAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class ThicknessHelper implements Windows.UI.Xaml.IThicknessHelper {
+    static FromLengths(left: number, top: number, right: number, bottom: number): Windows.UI.Xaml.Thickness;
+    static FromUniformLength(uniformLength: number): Windows.UI.Xaml.Thickness;
+  }
+
+  class TriggerAction extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.ITriggerAction {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class TriggerActionCollection {
+    constructor();
+    Append(value: Windows.UI.Xaml.TriggerAction): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.TriggerAction>;
+    GetAt(index: number): Windows.UI.Xaml.TriggerAction;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.TriggerAction[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.TriggerAction> | Windows.UI.Xaml.TriggerAction[];
+    IndexOf(value: Windows.UI.Xaml.TriggerAction, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.TriggerAction): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.TriggerAction[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.TriggerAction): void;
+    readonly Size: number;
+  }
+
+  class TriggerBase extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.ITriggerBase {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class TriggerCollection {
+    Append(value: Windows.UI.Xaml.TriggerBase): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.TriggerBase>;
+    GetAt(index: number): Windows.UI.Xaml.TriggerBase;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.TriggerBase[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.TriggerBase> | Windows.UI.Xaml.TriggerBase[];
+    IndexOf(value: Windows.UI.Xaml.TriggerBase, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.TriggerBase): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.TriggerBase[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.TriggerBase): void;
+    readonly Size: number;
+  }
+
+  class UIElement extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Composition.IAnimationObject, Windows.UI.Composition.IVisualElement, Windows.UI.Xaml.IUIElement, Windows.UI.Xaml.IUIElement10, Windows.UI.Xaml.IUIElement2, Windows.UI.Xaml.IUIElement3, Windows.UI.Xaml.IUIElement4, Windows.UI.Xaml.IUIElement5, Windows.UI.Xaml.IUIElement7, Windows.UI.Xaml.IUIElement8, Windows.UI.Xaml.IUIElement9, Windows.UI.Xaml.IUIElementOverrides, Windows.UI.Xaml.IUIElementOverrides7, Windows.UI.Xaml.IUIElementOverrides8, Windows.UI.Xaml.IUIElementOverrides9 {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    AccessKey: string;
+    static readonly AccessKeyProperty: Windows.UI.Xaml.DependencyProperty;
+    AccessKeyScopeOwner: Windows.UI.Xaml.DependencyObject;
+    static readonly AccessKeyScopeOwnerProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ActualOffset: Windows.Foundation.Numerics.Vector3;
+    readonly ActualSize: Windows.Foundation.Numerics.Vector2;
+    AllowDrop: boolean;
+    static readonly AllowDropProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly BringIntoViewRequestedEvent: Windows.UI.Xaml.RoutedEvent;
+    CacheMode: Windows.UI.Xaml.Media.CacheMode;
+    static readonly CacheModeProperty: Windows.UI.Xaml.DependencyProperty;
+    CanBeScrollAnchor: boolean;
+    static readonly CanBeScrollAnchorProperty: Windows.UI.Xaml.DependencyProperty;
+    CanDrag: boolean;
+    static readonly CanDragProperty: Windows.UI.Xaml.DependencyProperty;
+    CenterPoint: Windows.Foundation.Numerics.Vector3;
+    static readonly CharacterReceivedEvent: Windows.UI.Xaml.RoutedEvent;
+    Clip: Windows.UI.Xaml.Media.RectangleGeometry;
+    static readonly ClipProperty: Windows.UI.Xaml.DependencyProperty;
+    CompositeMode: number;
+    static readonly CompositeModeProperty: Windows.UI.Xaml.DependencyProperty;
+    ContextFlyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    static readonly ContextFlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly ContextRequestedEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly DesiredSize: Windows.Foundation.Size;
+    static readonly DoubleTappedEvent: Windows.UI.Xaml.RoutedEvent;
+    static readonly DragEnterEvent: Windows.UI.Xaml.RoutedEvent;
+    static readonly DragLeaveEvent: Windows.UI.Xaml.RoutedEvent;
+    static readonly DragOverEvent: Windows.UI.Xaml.RoutedEvent;
+    static readonly DropEvent: Windows.UI.Xaml.RoutedEvent;
+    ExitDisplayModeOnAccessKeyInvoked: boolean;
+    static readonly ExitDisplayModeOnAccessKeyInvokedProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly GettingFocusEvent: Windows.UI.Xaml.RoutedEvent;
+    HighContrastAdjustment: number;
+    static readonly HighContrastAdjustmentProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly HoldingEvent: Windows.UI.Xaml.RoutedEvent;
+    IsAccessKeyScope: boolean;
+    static readonly IsAccessKeyScopeProperty: Windows.UI.Xaml.DependencyProperty;
+    IsDoubleTapEnabled: boolean;
+    static readonly IsDoubleTapEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsHitTestVisible: boolean;
+    static readonly IsHitTestVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsHoldingEnabled: boolean;
+    static readonly IsHoldingEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsRightTapEnabled: boolean;
+    static readonly IsRightTapEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsTapEnabled: boolean;
+    static readonly IsTapEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly KeyDownEvent: Windows.UI.Xaml.RoutedEvent;
+    KeyTipHorizontalOffset: number;
+    static readonly KeyTipHorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    KeyTipPlacementMode: number;
+    static readonly KeyTipPlacementModeProperty: Windows.UI.Xaml.DependencyProperty;
+    KeyTipTarget: Windows.UI.Xaml.DependencyObject;
+    static readonly KeyTipTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    KeyTipVerticalOffset: number;
+    static readonly KeyTipVerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly KeyUpEvent: Windows.UI.Xaml.RoutedEvent;
+    KeyboardAcceleratorPlacementMode: number;
+    static readonly KeyboardAcceleratorPlacementModeProperty: Windows.UI.Xaml.DependencyProperty;
+    KeyboardAcceleratorPlacementTarget: Windows.UI.Xaml.DependencyObject;
+    static readonly KeyboardAcceleratorPlacementTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly KeyboardAccelerators: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Input.KeyboardAccelerator> | Windows.UI.Xaml.Input.KeyboardAccelerator[];
+    readonly Lights: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Media.XamlLight> | Windows.UI.Xaml.Media.XamlLight[];
+    static readonly LightsProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly LosingFocusEvent: Windows.UI.Xaml.RoutedEvent;
+    static readonly ManipulationCompletedEvent: Windows.UI.Xaml.RoutedEvent;
+    static readonly ManipulationDeltaEvent: Windows.UI.Xaml.RoutedEvent;
+    static readonly ManipulationInertiaStartingEvent: Windows.UI.Xaml.RoutedEvent;
+    ManipulationMode: number;
+    static readonly ManipulationModeProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly ManipulationStartedEvent: Windows.UI.Xaml.RoutedEvent;
+    static readonly ManipulationStartingEvent: Windows.UI.Xaml.RoutedEvent;
+    static readonly NoFocusCandidateFoundEvent: Windows.UI.Xaml.RoutedEvent;
+    Opacity: number;
+    static readonly OpacityProperty: Windows.UI.Xaml.DependencyProperty;
+    OpacityTransition: Windows.UI.Xaml.ScalarTransition;
+    static readonly PointerCanceledEvent: Windows.UI.Xaml.RoutedEvent;
+    static readonly PointerCaptureLostEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly PointerCaptures: Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Input.Pointer> | Windows.UI.Xaml.Input.Pointer[];
+    static readonly PointerCapturesProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly PointerEnteredEvent: Windows.UI.Xaml.RoutedEvent;
+    static readonly PointerExitedEvent: Windows.UI.Xaml.RoutedEvent;
+    static readonly PointerMovedEvent: Windows.UI.Xaml.RoutedEvent;
+    static readonly PointerPressedEvent: Windows.UI.Xaml.RoutedEvent;
+    static readonly PointerReleasedEvent: Windows.UI.Xaml.RoutedEvent;
+    static readonly PointerWheelChangedEvent: Windows.UI.Xaml.RoutedEvent;
+    static readonly PreviewKeyDownEvent: Windows.UI.Xaml.RoutedEvent;
+    static readonly PreviewKeyUpEvent: Windows.UI.Xaml.RoutedEvent;
+    Projection: Windows.UI.Xaml.Media.Projection;
+    static readonly ProjectionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RenderSize: Windows.Foundation.Size;
+    RenderTransform: Windows.UI.Xaml.Media.Transform;
+    RenderTransformOrigin: Windows.Foundation.Point;
+    static readonly RenderTransformOriginProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly RenderTransformProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly RightTappedEvent: Windows.UI.Xaml.RoutedEvent;
+    Rotation: number;
+    RotationAxis: Windows.Foundation.Numerics.Vector3;
+    RotationTransition: Windows.UI.Xaml.ScalarTransition;
+    Scale: Windows.Foundation.Numerics.Vector3;
+    ScaleTransition: Windows.UI.Xaml.Vector3Transition;
+    Shadow: Windows.UI.Xaml.Media.Shadow;
+    static readonly ShadowProperty: Windows.UI.Xaml.DependencyProperty;
+    TabFocusNavigation: number;
+    static readonly TabFocusNavigationProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly TappedEvent: Windows.UI.Xaml.RoutedEvent;
+    Transform3D: Windows.UI.Xaml.Media.Media3D.Transform3D;
+    static readonly Transform3DProperty: Windows.UI.Xaml.DependencyProperty;
+    TransformMatrix: Windows.Foundation.Numerics.Matrix4x4;
+    Transitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    static readonly TransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    Translation: Windows.Foundation.Numerics.Vector3;
+    TranslationTransition: Windows.UI.Xaml.Vector3Transition;
+    readonly UIContext: Windows.UI.UIContext;
+    UseLayoutRounding: boolean;
+    static readonly UseLayoutRoundingProperty: Windows.UI.Xaml.DependencyProperty;
+    Visibility: number;
+    static readonly VisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusDownNavigationStrategy: number;
+    static readonly XYFocusDownNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusKeyboardNavigation: number;
+    static readonly XYFocusKeyboardNavigationProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusLeftNavigationStrategy: number;
+    static readonly XYFocusLeftNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusRightNavigationStrategy: number;
+    static readonly XYFocusRightNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusUpNavigationStrategy: number;
+    static readonly XYFocusUpNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    XamlRoot: Windows.UI.Xaml.XamlRoot;
+    DoubleTapped: Windows.UI.Xaml.Input.DoubleTappedEventHandler | null;
+    DragEnter: Windows.UI.Xaml.DragEventHandler | null;
+    DragLeave: Windows.UI.Xaml.DragEventHandler | null;
+    DragOver: Windows.UI.Xaml.DragEventHandler | null;
+    Drop: Windows.UI.Xaml.DragEventHandler | null;
+    GotFocus: Windows.UI.Xaml.RoutedEventHandler | null;
+    Holding: Windows.UI.Xaml.Input.HoldingEventHandler | null;
+    KeyDown: Windows.UI.Xaml.Input.KeyEventHandler | null;
+    KeyUp: Windows.UI.Xaml.Input.KeyEventHandler | null;
+    LostFocus: Windows.UI.Xaml.RoutedEventHandler | null;
+    ManipulationCompleted: Windows.UI.Xaml.Input.ManipulationCompletedEventHandler | null;
+    ManipulationDelta: Windows.UI.Xaml.Input.ManipulationDeltaEventHandler | null;
+    ManipulationInertiaStarting: Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler | null;
+    ManipulationStarted: Windows.UI.Xaml.Input.ManipulationStartedEventHandler | null;
+    ManipulationStarting: Windows.UI.Xaml.Input.ManipulationStartingEventHandler | null;
+    PointerCanceled: Windows.UI.Xaml.Input.PointerEventHandler | null;
+    PointerCaptureLost: Windows.UI.Xaml.Input.PointerEventHandler | null;
+    PointerEntered: Windows.UI.Xaml.Input.PointerEventHandler | null;
+    PointerExited: Windows.UI.Xaml.Input.PointerEventHandler | null;
+    PointerMoved: Windows.UI.Xaml.Input.PointerEventHandler | null;
+    PointerPressed: Windows.UI.Xaml.Input.PointerEventHandler | null;
+    PointerReleased: Windows.UI.Xaml.Input.PointerEventHandler | null;
+    PointerWheelChanged: Windows.UI.Xaml.Input.PointerEventHandler | null;
+    RightTapped: Windows.UI.Xaml.Input.RightTappedEventHandler | null;
+    Tapped: Windows.UI.Xaml.Input.TappedEventHandler | null;
+    DragStarting: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.DragStartingEventArgs> | null;
+    DropCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.DropCompletedEventArgs> | null;
+    AccessKeyDisplayDismissed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs> | null;
+    AccessKeyDisplayRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs> | null;
+    AccessKeyInvoked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs> | null;
+    ContextCanceled: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.RoutedEventArgs> | null;
+    ContextRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.Input.ContextRequestedEventArgs> | null;
+    GettingFocus: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.Input.GettingFocusEventArgs> | null;
+    LosingFocus: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.Input.LosingFocusEventArgs> | null;
+    NoFocusCandidateFound: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.Input.NoFocusCandidateFoundEventArgs> | null;
+    CharacterReceived: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs> | null;
+    PreviewKeyDown: Windows.UI.Xaml.Input.KeyEventHandler | null;
+    PreviewKeyUp: Windows.UI.Xaml.Input.KeyEventHandler | null;
+    ProcessKeyboardAccelerators: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs> | null;
+    BringIntoViewRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.BringIntoViewRequestedEventArgs> | null;
+  }
+
+  class UIElementWeakCollection implements Windows.UI.Xaml.IUIElementWeakCollection {
+    constructor();
+    Append(value: Windows.UI.Xaml.UIElement): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.UIElement>;
+    GetAt(index: number): Windows.UI.Xaml.UIElement;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.UIElement[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.UIElement> | Windows.UI.Xaml.UIElement[];
+    IndexOf(value: Windows.UI.Xaml.UIElement, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.UIElement): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.UIElement[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.UIElement): void;
+    readonly Size: number;
+  }
+
+  class UnhandledExceptionEventArgs implements Windows.UI.Xaml.IUnhandledExceptionEventArgs {
+    readonly Exception: Windows.Foundation.HResult;
+    Handled: boolean;
+    readonly Message: string;
+  }
+
+  class Vector3Transition implements Windows.UI.Xaml.IVector3Transition {
+    constructor();
+    Components: number;
+    Duration: Windows.Foundation.TimeSpan;
+  }
+
+  class VisualState extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.IVisualState, Windows.UI.Xaml.IVisualState2 {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly Name: string;
+    readonly Setters: Windows.UI.Xaml.SetterBaseCollection;
+    readonly StateTriggers: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.StateTriggerBase> | Windows.UI.Xaml.StateTriggerBase[];
+    Storyboard: Windows.UI.Xaml.Media.Animation.Storyboard;
+  }
+
+  class VisualStateChangedEventArgs implements Windows.UI.Xaml.IVisualStateChangedEventArgs {
+    constructor();
+    Control: Windows.UI.Xaml.Controls.Control;
+    NewState: Windows.UI.Xaml.VisualState;
+    OldState: Windows.UI.Xaml.VisualState;
+  }
+
+  class VisualStateGroup extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.IVisualStateGroup {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly CurrentState: Windows.UI.Xaml.VisualState;
+    readonly Name: string;
+    readonly States: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.VisualState> | Windows.UI.Xaml.VisualState[];
+    readonly Transitions: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.VisualTransition> | Windows.UI.Xaml.VisualTransition[];
+    CurrentStateChanged: Windows.UI.Xaml.VisualStateChangedEventHandler | null;
+    CurrentStateChanging: Windows.UI.Xaml.VisualStateChangedEventHandler | null;
+  }
+
+  class VisualStateManager extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.IVisualStateManager, Windows.UI.Xaml.IVisualStateManagerOverrides, Windows.UI.Xaml.IVisualStateManagerProtected {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetCustomVisualStateManager(obj: Windows.UI.Xaml.FrameworkElement): Windows.UI.Xaml.VisualStateManager;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetVisualStateGroups(obj: Windows.UI.Xaml.FrameworkElement): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.VisualStateGroup> | Windows.UI.Xaml.VisualStateGroup[];
+    static GoToState(control: Windows.UI.Xaml.Controls.Control, stateName: string, useTransitions: boolean): boolean;
+    GoToStateCore(control: Windows.UI.Xaml.Controls.Control, templateRoot: Windows.UI.Xaml.FrameworkElement, stateName: string, group: Windows.UI.Xaml.VisualStateGroup, state: Windows.UI.Xaml.VisualState, useTransitions: boolean): boolean;
+    RaiseCurrentStateChanged(stateGroup: Windows.UI.Xaml.VisualStateGroup, oldState: Windows.UI.Xaml.VisualState, newState: Windows.UI.Xaml.VisualState, control: Windows.UI.Xaml.Controls.Control): void;
+    RaiseCurrentStateChanging(stateGroup: Windows.UI.Xaml.VisualStateGroup, oldState: Windows.UI.Xaml.VisualState, newState: Windows.UI.Xaml.VisualState, control: Windows.UI.Xaml.Controls.Control): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static SetCustomVisualStateManager(obj: Windows.UI.Xaml.FrameworkElement, value: Windows.UI.Xaml.VisualStateManager): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    static readonly CustomVisualStateManagerProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class VisualTransition extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.IVisualTransition {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    From: string;
+    GeneratedDuration: Windows.UI.Xaml.Duration;
+    GeneratedEasingFunction: Windows.UI.Xaml.Media.Animation.EasingFunctionBase;
+    Storyboard: Windows.UI.Xaml.Media.Animation.Storyboard;
+    To: string;
+  }
+
+  class Window implements Windows.UI.Xaml.IWindow, Windows.UI.Xaml.IWindow2, Windows.UI.Xaml.IWindow3, Windows.UI.Xaml.IWindow4 {
+    Activate(): void;
+    Close(): void;
+    SetTitleBar(value: Windows.UI.Xaml.UIElement): void;
+    readonly Bounds: Windows.Foundation.Rect;
+    readonly Compositor: Windows.UI.Composition.Compositor;
+    Content: Windows.UI.Xaml.UIElement;
+    readonly CoreWindow: Windows.UI.Core.CoreWindow;
+    static readonly Current: Windows.UI.Xaml.Window;
+    readonly Dispatcher: Windows.UI.Core.CoreDispatcher;
+    readonly UIContext: Windows.UI.UIContext;
+    readonly Visible: boolean;
+    Activated: Windows.UI.Xaml.WindowActivatedEventHandler | null;
+    Closed: Windows.UI.Xaml.WindowClosedEventHandler | null;
+    SizeChanged: Windows.UI.Xaml.WindowSizeChangedEventHandler | null;
+    VisibilityChanged: Windows.UI.Xaml.WindowVisibilityChangedEventHandler | null;
+  }
+
+  class WindowCreatedEventArgs implements Windows.UI.Xaml.IWindowCreatedEventArgs {
+    readonly Window: Windows.UI.Xaml.Window;
+  }
+
+  class XamlRoot implements Windows.UI.Xaml.IXamlRoot {
+    readonly Content: Windows.UI.Xaml.UIElement;
+    readonly IsHostVisible: boolean;
+    readonly RasterizationScale: number;
+    readonly Size: Windows.Foundation.Size;
+    readonly UIContext: Windows.UI.UIContext;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.XamlRoot, Windows.UI.Xaml.XamlRootChangedEventArgs> | null;
+  }
+
+  class XamlRootChangedEventArgs implements Windows.UI.Xaml.IXamlRootChangedEventArgs {
+  }
+
+  enum ApplicationHighContrastAdjustment {
+    None = 0,
+    Auto = 4294967295,
+  }
+
+  enum ApplicationRequiresPointerMode {
+    Auto = 0,
+    WhenRequested = 1,
+  }
+
+  enum ApplicationTheme {
+    Light = 0,
+    Dark = 1,
+  }
+
+  enum AutomationTextAttributesEnum {
+    AnimationStyleAttribute = 40000,
+    BackgroundColorAttribute = 40001,
+    BulletStyleAttribute = 40002,
+    CapStyleAttribute = 40003,
+    CultureAttribute = 40004,
+    FontNameAttribute = 40005,
+    FontSizeAttribute = 40006,
+    FontWeightAttribute = 40007,
+    ForegroundColorAttribute = 40008,
+    HorizontalTextAlignmentAttribute = 40009,
+    IndentationFirstLineAttribute = 40010,
+    IndentationLeadingAttribute = 40011,
+    IndentationTrailingAttribute = 40012,
+    IsHiddenAttribute = 40013,
+    IsItalicAttribute = 40014,
+    IsReadOnlyAttribute = 40015,
+    IsSubscriptAttribute = 40016,
+    IsSuperscriptAttribute = 40017,
+    MarginBottomAttribute = 40018,
+    MarginLeadingAttribute = 40019,
+    MarginTopAttribute = 40020,
+    MarginTrailingAttribute = 40021,
+    OutlineStylesAttribute = 40022,
+    OverlineColorAttribute = 40023,
+    OverlineStyleAttribute = 40024,
+    StrikethroughColorAttribute = 40025,
+    StrikethroughStyleAttribute = 40026,
+    TabsAttribute = 40027,
+    TextFlowDirectionsAttribute = 40028,
+    UnderlineColorAttribute = 40029,
+    UnderlineStyleAttribute = 40030,
+    AnnotationTypesAttribute = 40031,
+    AnnotationObjectsAttribute = 40032,
+    StyleNameAttribute = 40033,
+    StyleIdAttribute = 40034,
+    LinkAttribute = 40035,
+    IsActiveAttribute = 40036,
+    SelectionActiveEndAttribute = 40037,
+    CaretPositionAttribute = 40038,
+    CaretBidiModeAttribute = 40039,
+  }
+
+  enum DurationType {
+    Automatic = 0,
+    TimeSpan = 1,
+    Forever = 2,
+  }
+
+  enum ElementHighContrastAdjustment {
+    None = 0,
+    Application = 2147483648,
+    Auto = 4294967295,
+  }
+
+  enum ElementSoundKind {
+    Focus = 0,
+    Invoke = 1,
+    Show = 2,
+    Hide = 3,
+    MovePrevious = 4,
+    MoveNext = 5,
+    GoBack = 6,
+  }
+
+  enum ElementSoundMode {
+    Default = 0,
+    FocusOnly = 1,
+    Off = 2,
+  }
+
+  enum ElementSoundPlayerState {
+    Auto = 0,
+    Off = 1,
+    On = 2,
+  }
+
+  enum ElementSpatialAudioMode {
+    Auto = 0,
+    Off = 1,
+    On = 2,
+  }
+
+  enum ElementTheme {
+    Default = 0,
+    Light = 1,
+    Dark = 2,
+  }
+
+  enum FlowDirection {
+    LeftToRight = 0,
+    RightToLeft = 1,
+  }
+
+  enum FocusState {
+    Unfocused = 0,
+    Pointer = 1,
+    Keyboard = 2,
+    Programmatic = 3,
+  }
+
+  enum FocusVisualKind {
+    DottedLine = 0,
+    HighVisibility = 1,
+    Reveal = 2,
+  }
+
+  enum FontCapitals {
+    Normal = 0,
+    AllSmallCaps = 1,
+    SmallCaps = 2,
+    AllPetiteCaps = 3,
+    PetiteCaps = 4,
+    Unicase = 5,
+    Titling = 6,
+  }
+
+  enum FontEastAsianLanguage {
+    Normal = 0,
+    HojoKanji = 1,
+    Jis04 = 2,
+    Jis78 = 3,
+    Jis83 = 4,
+    Jis90 = 5,
+    NlcKanji = 6,
+    Simplified = 7,
+    Traditional = 8,
+    TraditionalNames = 9,
+  }
+
+  enum FontEastAsianWidths {
+    Normal = 0,
+    Full = 1,
+    Half = 2,
+    Proportional = 3,
+    Quarter = 4,
+    Third = 5,
+  }
+
+  enum FontFraction {
+    Normal = 0,
+    Stacked = 1,
+    Slashed = 2,
+  }
+
+  enum FontNumeralAlignment {
+    Normal = 0,
+    Proportional = 1,
+    Tabular = 2,
+  }
+
+  enum FontNumeralStyle {
+    Normal = 0,
+    Lining = 1,
+    OldStyle = 2,
+  }
+
+  enum FontVariants {
+    Normal = 0,
+    Superscript = 1,
+    Subscript = 2,
+    Ordinal = 3,
+    Inferior = 4,
+    Ruby = 5,
+  }
+
+  enum GridUnitType {
+    Auto = 0,
+    Pixel = 1,
+    Star = 2,
+  }
+
+  enum HorizontalAlignment {
+    Left = 0,
+    Center = 1,
+    Right = 2,
+    Stretch = 3,
+  }
+
+  enum LineStackingStrategy {
+    MaxHeight = 0,
+    BlockLineHeight = 1,
+    BaselineToBaseline = 2,
+  }
+
+  enum OpticalMarginAlignment {
+    None = 0,
+    TrimSideBearings = 1,
+  }
+
+  enum TextAlignment {
+    Center = 0,
+    Left = 1,
+    Start = 1,
+    Right = 2,
+    End = 2,
+    Justify = 3,
+    DetectFromContent = 4,
+  }
+
+  enum TextLineBounds {
+    Full = 0,
+    TrimToCapHeight = 1,
+    TrimToBaseline = 2,
+    Tight = 3,
+  }
+
+  enum TextReadingOrder {
+    Default = 0,
+    UseFlowDirection = 0,
+    DetectFromContent = 1,
+  }
+
+  enum TextTrimming {
+    None = 0,
+    CharacterEllipsis = 1,
+    WordEllipsis = 2,
+    Clip = 3,
+  }
+
+  enum TextWrapping {
+    NoWrap = 1,
+    Wrap = 2,
+    WrapWholeWords = 3,
+  }
+
+  enum Vector3TransitionComponents {
+    X = 1,
+    Y = 2,
+    Z = 4,
+  }
+
+  enum VerticalAlignment {
+    Top = 0,
+    Center = 1,
+    Bottom = 2,
+    Stretch = 3,
+  }
+
+  enum Visibility {
+    Visible = 0,
+    Collapsed = 1,
+  }
+
+  interface ApplicationInitializationCallback {
+    (p: Windows.UI.Xaml.ApplicationInitializationCallbackParams): void;
+  }
+  var ApplicationInitializationCallback: {
+    new(callback: (p: Windows.UI.Xaml.ApplicationInitializationCallbackParams) => void): ApplicationInitializationCallback;
+  };
+
+  interface BindingFailedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.BindingFailedEventArgs): void;
+  }
+  var BindingFailedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.BindingFailedEventArgs) => void): BindingFailedEventHandler;
+  };
+
+  interface CornerRadius {
+    TopLeft: number;
+    TopRight: number;
+    BottomRight: number;
+    BottomLeft: number;
+  }
+  var CornerRadius: {
+    new(topLeft: number, topRight: number, bottomRight: number, bottomLeft: number): CornerRadius;
+    new(fields: { TopLeft?: number; TopRight?: number; BottomRight?: number; BottomLeft?: number }): CornerRadius;
+  };
+
+  interface CreateDefaultValueCallback {
+    (): Object;
+  }
+  var CreateDefaultValueCallback: {
+    new(callback: () => Object): CreateDefaultValueCallback;
+  };
+
+  interface DependencyPropertyChangedCallback {
+    (sender: Windows.UI.Xaml.DependencyObject, dp: Windows.UI.Xaml.DependencyProperty): void;
+  }
+  var DependencyPropertyChangedCallback: {
+    new(callback: (sender: Windows.UI.Xaml.DependencyObject, dp: Windows.UI.Xaml.DependencyProperty) => void): DependencyPropertyChangedCallback;
+  };
+
+  interface DependencyPropertyChangedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.DependencyPropertyChangedEventArgs): void;
+  }
+  var DependencyPropertyChangedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.DependencyPropertyChangedEventArgs) => void): DependencyPropertyChangedEventHandler;
+  };
+
+  interface DragEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.DragEventArgs): void;
+  }
+  var DragEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.DragEventArgs) => void): DragEventHandler;
+  };
+
+  interface Duration {
+    TimeSpan: Windows.Foundation.TimeSpan;
+    Type: number;
+  }
+  var Duration: {
+    new(timeSpan: Windows.Foundation.TimeSpan, type: number): Duration;
+    new(fields: { TimeSpan?: Windows.Foundation.TimeSpan; Type?: number }): Duration;
+  };
+
+  interface EnteredBackgroundEventHandler {
+    (sender: Object, e: Windows.ApplicationModel.EnteredBackgroundEventArgs): void;
+  }
+  var EnteredBackgroundEventHandler: {
+    new(callback: (sender: Object, e: Windows.ApplicationModel.EnteredBackgroundEventArgs) => void): EnteredBackgroundEventHandler;
+  };
+
+  interface ExceptionRoutedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.ExceptionRoutedEventArgs): void;
+  }
+  var ExceptionRoutedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.ExceptionRoutedEventArgs) => void): ExceptionRoutedEventHandler;
+  };
+
+  interface GridLength {
+    Value: number;
+    GridUnitType: number;
+  }
+  var GridLength: {
+    new(value: number, gridUnitType: number): GridLength;
+    new(fields: { Value?: number; GridUnitType?: number }): GridLength;
+  };
+
+  interface IAdaptiveTrigger {
+    MinWindowHeight: number;
+    MinWindowWidth: number;
+  }
+  var IAdaptiveTrigger: abstract new (...args: any[]) => IAdaptiveTrigger;
+
+  interface IAdaptiveTriggerFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.AdaptiveTrigger;
+  }
+  var IAdaptiveTriggerFactory: abstract new (...args: any[]) => IAdaptiveTriggerFactory;
+
+  interface IAdaptiveTriggerStatics {
+    readonly MinWindowHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinWindowWidthProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAdaptiveTriggerStatics: abstract new (...args: any[]) => IAdaptiveTriggerStatics;
+
+  interface IApplication {
+    Exit(): void;
+    readonly DebugSettings: Windows.UI.Xaml.DebugSettings;
+    RequestedTheme: number;
+    Resources: Windows.UI.Xaml.ResourceDictionary;
+    Resuming: Windows.Foundation.EventHandler<Object> | null;
+    Suspending: Windows.UI.Xaml.SuspendingEventHandler | null;
+    UnhandledException: Windows.UI.Xaml.UnhandledExceptionEventHandler | null;
+  }
+  var IApplication: abstract new (...args: any[]) => IApplication;
+
+  interface IApplication2 {
+    FocusVisualKind: number;
+    RequiresPointerMode: number;
+    EnteredBackground: Windows.UI.Xaml.EnteredBackgroundEventHandler | null;
+    LeavingBackground: Windows.UI.Xaml.LeavingBackgroundEventHandler | null;
+  }
+  var IApplication2: abstract new (...args: any[]) => IApplication2;
+
+  interface IApplication3 {
+    HighContrastAdjustment: number;
+  }
+  var IApplication3: abstract new (...args: any[]) => IApplication3;
+
+  interface IApplicationFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Application;
+  }
+  var IApplicationFactory: abstract new (...args: any[]) => IApplicationFactory;
+
+  interface IApplicationInitializationCallbackParams {
+  }
+  var IApplicationInitializationCallbackParams: abstract new (...args: any[]) => IApplicationInitializationCallbackParams;
+
+  interface IApplicationOverrides {
+    OnActivated(args: Windows.ApplicationModel.Activation.IActivatedEventArgs): void;
+    OnCachedFileUpdaterActivated(args: Windows.ApplicationModel.Activation.CachedFileUpdaterActivatedEventArgs): void;
+    OnFileActivated(args: Windows.ApplicationModel.Activation.FileActivatedEventArgs): void;
+    OnFileOpenPickerActivated(args: Windows.ApplicationModel.Activation.FileOpenPickerActivatedEventArgs): void;
+    OnFileSavePickerActivated(args: Windows.ApplicationModel.Activation.FileSavePickerActivatedEventArgs): void;
+    OnLaunched(args: Windows.ApplicationModel.Activation.LaunchActivatedEventArgs): void;
+    OnSearchActivated(args: Windows.ApplicationModel.Activation.SearchActivatedEventArgs): void;
+    OnShareTargetActivated(args: Windows.ApplicationModel.Activation.ShareTargetActivatedEventArgs): void;
+    OnWindowCreated(args: Windows.UI.Xaml.WindowCreatedEventArgs): void;
+  }
+  var IApplicationOverrides: abstract new (...args: any[]) => IApplicationOverrides;
+
+  interface IApplicationOverrides2 {
+    OnBackgroundActivated(args: Windows.ApplicationModel.Activation.BackgroundActivatedEventArgs): void;
+  }
+  var IApplicationOverrides2: abstract new (...args: any[]) => IApplicationOverrides2;
+
+  interface IApplicationStatics {
+    LoadComponent(component: Object, resourceLocator: Windows.Foundation.Uri): void;
+    LoadComponent(component: Object, resourceLocator: Windows.Foundation.Uri, componentResourceLocation: number): void;
+    Start(callback: Windows.UI.Xaml.ApplicationInitializationCallback): void;
+    readonly Current: Windows.UI.Xaml.Application;
+  }
+  var IApplicationStatics: abstract new (...args: any[]) => IApplicationStatics;
+
+  interface IBindingFailedEventArgs {
+    readonly Message: string;
+  }
+  var IBindingFailedEventArgs: abstract new (...args: any[]) => IBindingFailedEventArgs;
+
+  interface IBringIntoViewOptions {
+    AnimationDesired: boolean;
+    TargetRect: Windows.Foundation.Rect | null;
+  }
+  var IBringIntoViewOptions: abstract new (...args: any[]) => IBringIntoViewOptions;
+
+  interface IBringIntoViewOptions2 {
+    HorizontalAlignmentRatio: number;
+    HorizontalOffset: number;
+    VerticalAlignmentRatio: number;
+    VerticalOffset: number;
+  }
+  var IBringIntoViewOptions2: abstract new (...args: any[]) => IBringIntoViewOptions2;
+
+  interface IBringIntoViewRequestedEventArgs {
+    AnimationDesired: boolean;
+    Handled: boolean;
+    readonly HorizontalAlignmentRatio: number;
+    HorizontalOffset: number;
+    TargetElement: Windows.UI.Xaml.UIElement;
+    TargetRect: Windows.Foundation.Rect;
+    readonly VerticalAlignmentRatio: number;
+    VerticalOffset: number;
+  }
+  var IBringIntoViewRequestedEventArgs: abstract new (...args: any[]) => IBringIntoViewRequestedEventArgs;
+
+  interface IBrushTransition {
+    Duration: Windows.Foundation.TimeSpan;
+  }
+  var IBrushTransition: abstract new (...args: any[]) => IBrushTransition;
+
+  interface IBrushTransitionFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.BrushTransition;
+  }
+  var IBrushTransitionFactory: abstract new (...args: any[]) => IBrushTransitionFactory;
+
+  interface IColorPaletteResources {
+    Accent: Windows.UI.Color | null;
+    AltHigh: Windows.UI.Color | null;
+    AltLow: Windows.UI.Color | null;
+    AltMedium: Windows.UI.Color | null;
+    AltMediumHigh: Windows.UI.Color | null;
+    AltMediumLow: Windows.UI.Color | null;
+    BaseHigh: Windows.UI.Color | null;
+    BaseLow: Windows.UI.Color | null;
+    BaseMedium: Windows.UI.Color | null;
+    BaseMediumHigh: Windows.UI.Color | null;
+    BaseMediumLow: Windows.UI.Color | null;
+    ChromeAltLow: Windows.UI.Color | null;
+    ChromeBlackHigh: Windows.UI.Color | null;
+    ChromeBlackLow: Windows.UI.Color | null;
+    ChromeBlackMedium: Windows.UI.Color | null;
+    ChromeBlackMediumLow: Windows.UI.Color | null;
+    ChromeDisabledHigh: Windows.UI.Color | null;
+    ChromeDisabledLow: Windows.UI.Color | null;
+    ChromeGray: Windows.UI.Color | null;
+    ChromeHigh: Windows.UI.Color | null;
+    ChromeLow: Windows.UI.Color | null;
+    ChromeMedium: Windows.UI.Color | null;
+    ChromeMediumLow: Windows.UI.Color | null;
+    ChromeWhite: Windows.UI.Color | null;
+    ErrorText: Windows.UI.Color | null;
+    ListLow: Windows.UI.Color | null;
+    ListMedium: Windows.UI.Color | null;
+  }
+  var IColorPaletteResources: abstract new (...args: any[]) => IColorPaletteResources;
+
+  interface IColorPaletteResourcesFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.ColorPaletteResources;
+  }
+  var IColorPaletteResourcesFactory: abstract new (...args: any[]) => IColorPaletteResourcesFactory;
+
+  interface ICornerRadiusHelper {
+  }
+  var ICornerRadiusHelper: abstract new (...args: any[]) => ICornerRadiusHelper;
+
+  interface ICornerRadiusHelperStatics {
+    FromRadii(topLeft: number, topRight: number, bottomRight: number, bottomLeft: number): Windows.UI.Xaml.CornerRadius;
+    FromUniformRadius(uniformRadius: number): Windows.UI.Xaml.CornerRadius;
+  }
+  var ICornerRadiusHelperStatics: abstract new (...args: any[]) => ICornerRadiusHelperStatics;
+
+  interface IDataContextChangedEventArgs {
+    Handled: boolean;
+    readonly NewValue: Object;
+  }
+  var IDataContextChangedEventArgs: abstract new (...args: any[]) => IDataContextChangedEventArgs;
+
+  interface IDataTemplate {
+    LoadContent(): Windows.UI.Xaml.DependencyObject;
+  }
+  var IDataTemplate: abstract new (...args: any[]) => IDataTemplate;
+
+  interface IDataTemplateExtension {
+    ProcessBinding(phase: number): boolean;
+    ProcessBindings(arg: Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs): number;
+    ResetTemplate(): void;
+  }
+  var IDataTemplateExtension: abstract new (...args: any[]) => IDataTemplateExtension;
+
+  interface IDataTemplateFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.DataTemplate;
+  }
+  var IDataTemplateFactory: abstract new (...args: any[]) => IDataTemplateFactory;
+
+  interface IDataTemplateKey {
+    DataType: Object;
+  }
+  var IDataTemplateKey: abstract new (...args: any[]) => IDataTemplateKey;
+
+  interface IDataTemplateKeyFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.DataTemplateKey;
+    CreateInstanceWithType(dataType: Object, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.DataTemplateKey;
+  }
+  var IDataTemplateKeyFactory: abstract new (...args: any[]) => IDataTemplateKeyFactory;
+
+  interface IDataTemplateStatics2 {
+    GetExtensionInstance(element: Windows.UI.Xaml.FrameworkElement): Windows.UI.Xaml.IDataTemplateExtension;
+    SetExtensionInstance(element: Windows.UI.Xaml.FrameworkElement, value: Windows.UI.Xaml.IDataTemplateExtension): void;
+    readonly ExtensionInstanceProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IDataTemplateStatics2: abstract new (...args: any[]) => IDataTemplateStatics2;
+
+  interface IDebugSettings {
+    EnableFrameRateCounter: boolean;
+    IsBindingTracingEnabled: boolean;
+    IsOverdrawHeatMapEnabled: boolean;
+    BindingFailed: Windows.UI.Xaml.BindingFailedEventHandler | null;
+  }
+  var IDebugSettings: abstract new (...args: any[]) => IDebugSettings;
+
+  interface IDebugSettings2 {
+    EnableRedrawRegions: boolean;
+  }
+  var IDebugSettings2: abstract new (...args: any[]) => IDebugSettings2;
+
+  interface IDebugSettings3 {
+    IsTextPerformanceVisualizationEnabled: boolean;
+  }
+  var IDebugSettings3: abstract new (...args: any[]) => IDebugSettings3;
+
+  interface IDebugSettings4 {
+    FailFastOnErrors: boolean;
+  }
+  var IDebugSettings4: abstract new (...args: any[]) => IDebugSettings4;
+
+  interface IDependencyObject {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    readonly Dispatcher: Windows.UI.Core.CoreDispatcher;
+  }
+  var IDependencyObject: abstract new (...args: any[]) => IDependencyObject;
+
+  interface IDependencyObject2 {
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+  var IDependencyObject2: abstract new (...args: any[]) => IDependencyObject2;
+
+  interface IDependencyObjectCollectionFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.DependencyObjectCollection;
+  }
+  var IDependencyObjectCollectionFactory: abstract new (...args: any[]) => IDependencyObjectCollectionFactory;
+
+  interface IDependencyObjectFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.DependencyObject;
+  }
+  var IDependencyObjectFactory: abstract new (...args: any[]) => IDependencyObjectFactory;
+
+  interface IDependencyProperty {
+    GetMetadata(forType: Windows.UI.Xaml.Interop.TypeName): Windows.UI.Xaml.PropertyMetadata;
+  }
+  var IDependencyProperty: abstract new (...args: any[]) => IDependencyProperty;
+
+  interface IDependencyPropertyChangedEventArgs {
+    readonly NewValue: Object;
+    readonly OldValue: Object;
+    readonly Property: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IDependencyPropertyChangedEventArgs: abstract new (...args: any[]) => IDependencyPropertyChangedEventArgs;
+
+  interface IDependencyPropertyStatics {
+    Register(name: string, propertyType: Windows.UI.Xaml.Interop.TypeName, ownerType: Windows.UI.Xaml.Interop.TypeName, typeMetadata: Windows.UI.Xaml.PropertyMetadata): Windows.UI.Xaml.DependencyProperty;
+    RegisterAttached(name: string, propertyType: Windows.UI.Xaml.Interop.TypeName, ownerType: Windows.UI.Xaml.Interop.TypeName, defaultMetadata: Windows.UI.Xaml.PropertyMetadata): Windows.UI.Xaml.DependencyProperty;
+    readonly UnsetValue: Object;
+  }
+  var IDependencyPropertyStatics: abstract new (...args: any[]) => IDependencyPropertyStatics;
+
+  interface IDispatcherTimer {
+    Start(): void;
+    Stop(): void;
+    Interval: Windows.Foundation.TimeSpan;
+    readonly IsEnabled: boolean;
+    Tick: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IDispatcherTimer: abstract new (...args: any[]) => IDispatcherTimer;
+
+  interface IDispatcherTimerFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.DispatcherTimer;
+  }
+  var IDispatcherTimerFactory: abstract new (...args: any[]) => IDispatcherTimerFactory;
+
+  interface IDragEventArgs {
+    GetPosition(relativeTo: Windows.UI.Xaml.UIElement): Windows.Foundation.Point;
+    Data: Windows.ApplicationModel.DataTransfer.DataPackage;
+    Handled: boolean;
+  }
+  var IDragEventArgs: abstract new (...args: any[]) => IDragEventArgs;
+
+  interface IDragEventArgs2 {
+    GetDeferral(): Windows.UI.Xaml.DragOperationDeferral;
+    AcceptedOperation: number;
+    readonly DataView: Windows.ApplicationModel.DataTransfer.DataPackageView;
+    readonly DragUIOverride: Windows.UI.Xaml.DragUIOverride;
+    readonly Modifiers: number;
+  }
+  var IDragEventArgs2: abstract new (...args: any[]) => IDragEventArgs2;
+
+  interface IDragEventArgs3 {
+    readonly AllowedOperations: number;
+  }
+  var IDragEventArgs3: abstract new (...args: any[]) => IDragEventArgs3;
+
+  interface IDragOperationDeferral {
+    Complete(): void;
+  }
+  var IDragOperationDeferral: abstract new (...args: any[]) => IDragOperationDeferral;
+
+  interface IDragStartingEventArgs {
+    GetDeferral(): Windows.UI.Xaml.DragOperationDeferral;
+    GetPosition(relativeTo: Windows.UI.Xaml.UIElement): Windows.Foundation.Point;
+    Cancel: boolean;
+    readonly Data: Windows.ApplicationModel.DataTransfer.DataPackage;
+    readonly DragUI: Windows.UI.Xaml.DragUI;
+  }
+  var IDragStartingEventArgs: abstract new (...args: any[]) => IDragStartingEventArgs;
+
+  interface IDragStartingEventArgs2 {
+    AllowedOperations: number;
+  }
+  var IDragStartingEventArgs2: abstract new (...args: any[]) => IDragStartingEventArgs2;
+
+  interface IDragUI {
+    SetContentFromBitmapImage(bitmapImage: Windows.UI.Xaml.Media.Imaging.BitmapImage): void;
+    SetContentFromBitmapImage(bitmapImage: Windows.UI.Xaml.Media.Imaging.BitmapImage, anchorPoint: Windows.Foundation.Point): void;
+    SetContentFromDataPackage(): void;
+    SetContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap): void;
+    SetContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap, anchorPoint: Windows.Foundation.Point): void;
+  }
+  var IDragUI: abstract new (...args: any[]) => IDragUI;
+
+  interface IDragUIOverride {
+    Clear(): void;
+    SetContentFromBitmapImage(bitmapImage: Windows.UI.Xaml.Media.Imaging.BitmapImage): void;
+    SetContentFromBitmapImage(bitmapImage: Windows.UI.Xaml.Media.Imaging.BitmapImage, anchorPoint: Windows.Foundation.Point): void;
+    SetContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap): void;
+    SetContentFromSoftwareBitmap(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap, anchorPoint: Windows.Foundation.Point): void;
+    Caption: string;
+    IsCaptionVisible: boolean;
+    IsContentVisible: boolean;
+    IsGlyphVisible: boolean;
+  }
+  var IDragUIOverride: abstract new (...args: any[]) => IDragUIOverride;
+
+  interface IDropCompletedEventArgs {
+    readonly DropResult: number;
+  }
+  var IDropCompletedEventArgs: abstract new (...args: any[]) => IDropCompletedEventArgs;
+
+  interface IDurationHelper {
+  }
+  var IDurationHelper: abstract new (...args: any[]) => IDurationHelper;
+
+  interface IDurationHelperStatics {
+    Add(target: Windows.UI.Xaml.Duration, duration: Windows.UI.Xaml.Duration): Windows.UI.Xaml.Duration;
+    Compare(duration1: Windows.UI.Xaml.Duration, duration2: Windows.UI.Xaml.Duration): number;
+    Equals(target: Windows.UI.Xaml.Duration, value: Windows.UI.Xaml.Duration): boolean;
+    FromTimeSpan(timeSpan: Windows.Foundation.TimeSpan): Windows.UI.Xaml.Duration;
+    GetHasTimeSpan(target: Windows.UI.Xaml.Duration): boolean;
+    Subtract(target: Windows.UI.Xaml.Duration, duration: Windows.UI.Xaml.Duration): Windows.UI.Xaml.Duration;
+    readonly Automatic: Windows.UI.Xaml.Duration;
+    readonly Forever: Windows.UI.Xaml.Duration;
+  }
+  var IDurationHelperStatics: abstract new (...args: any[]) => IDurationHelperStatics;
+
+  interface IEffectiveViewportChangedEventArgs {
+    readonly BringIntoViewDistanceX: number;
+    readonly BringIntoViewDistanceY: number;
+    readonly EffectiveViewport: Windows.Foundation.Rect;
+    readonly MaxViewport: Windows.Foundation.Rect;
+  }
+  var IEffectiveViewportChangedEventArgs: abstract new (...args: any[]) => IEffectiveViewportChangedEventArgs;
+
+  interface IElementFactory {
+    GetElement(args: Windows.UI.Xaml.ElementFactoryGetArgs): Windows.UI.Xaml.UIElement;
+    RecycleElement(args: Windows.UI.Xaml.ElementFactoryRecycleArgs): void;
+  }
+  var IElementFactory: abstract new (...args: any[]) => IElementFactory;
+
+  interface IElementFactoryGetArgs {
+    Data: Object;
+    Parent: Windows.UI.Xaml.UIElement;
+  }
+  var IElementFactoryGetArgs: abstract new (...args: any[]) => IElementFactoryGetArgs;
+
+  interface IElementFactoryGetArgsFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.ElementFactoryGetArgs;
+  }
+  var IElementFactoryGetArgsFactory: abstract new (...args: any[]) => IElementFactoryGetArgsFactory;
+
+  interface IElementFactoryRecycleArgs {
+    Element: Windows.UI.Xaml.UIElement;
+    Parent: Windows.UI.Xaml.UIElement;
+  }
+  var IElementFactoryRecycleArgs: abstract new (...args: any[]) => IElementFactoryRecycleArgs;
+
+  interface IElementFactoryRecycleArgsFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.ElementFactoryRecycleArgs;
+  }
+  var IElementFactoryRecycleArgsFactory: abstract new (...args: any[]) => IElementFactoryRecycleArgsFactory;
+
+  interface IElementSoundPlayer {
+  }
+  var IElementSoundPlayer: abstract new (...args: any[]) => IElementSoundPlayer;
+
+  interface IElementSoundPlayerStatics {
+    Play(sound: number): void;
+    State: number;
+    Volume: number;
+  }
+  var IElementSoundPlayerStatics: abstract new (...args: any[]) => IElementSoundPlayerStatics;
+
+  interface IElementSoundPlayerStatics2 {
+    SpatialAudioMode: number;
+  }
+  var IElementSoundPlayerStatics2: abstract new (...args: any[]) => IElementSoundPlayerStatics2;
+
+  interface IEventTrigger {
+    readonly Actions: Windows.UI.Xaml.TriggerActionCollection;
+    RoutedEvent: Windows.UI.Xaml.RoutedEvent;
+  }
+  var IEventTrigger: abstract new (...args: any[]) => IEventTrigger;
+
+  interface IExceptionRoutedEventArgs {
+    readonly ErrorMessage: string;
+  }
+  var IExceptionRoutedEventArgs: abstract new (...args: any[]) => IExceptionRoutedEventArgs;
+
+  interface IExceptionRoutedEventArgsFactory {
+  }
+  var IExceptionRoutedEventArgsFactory: abstract new (...args: any[]) => IExceptionRoutedEventArgsFactory;
+
+  interface IFrameworkElement {
+    FindName(name: string): Object;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    readonly ActualHeight: number;
+    readonly ActualWidth: number;
+    readonly BaseUri: Windows.Foundation.Uri;
+    DataContext: Object;
+    FlowDirection: number;
+    Height: number;
+    HorizontalAlignment: number;
+    Language: string;
+    Margin: Windows.UI.Xaml.Thickness;
+    MaxHeight: number;
+    MaxWidth: number;
+    MinHeight: number;
+    MinWidth: number;
+    Name: string;
+    readonly Parent: Windows.UI.Xaml.DependencyObject;
+    Resources: Windows.UI.Xaml.ResourceDictionary;
+    Style: Windows.UI.Xaml.Style;
+    Tag: Object;
+    readonly Triggers: Windows.UI.Xaml.TriggerCollection;
+    VerticalAlignment: number;
+    Width: number;
+    LayoutUpdated: Windows.Foundation.EventHandler<Object> | null;
+    Loaded: Windows.UI.Xaml.RoutedEventHandler | null;
+    SizeChanged: Windows.UI.Xaml.SizeChangedEventHandler | null;
+    Unloaded: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+  var IFrameworkElement: abstract new (...args: any[]) => IFrameworkElement;
+
+  interface IFrameworkElement2 {
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    RequestedTheme: number;
+    DataContextChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.FrameworkElement, Windows.UI.Xaml.DataContextChangedEventArgs> | null;
+  }
+  var IFrameworkElement2: abstract new (...args: any[]) => IFrameworkElement2;
+
+  interface IFrameworkElement3 {
+    Loading: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.FrameworkElement, Object> | null;
+  }
+  var IFrameworkElement3: abstract new (...args: any[]) => IFrameworkElement3;
+
+  interface IFrameworkElement4 {
+    AllowFocusOnInteraction: boolean;
+    AllowFocusWhenDisabled: boolean;
+    FocusVisualMargin: Windows.UI.Xaml.Thickness;
+    FocusVisualPrimaryBrush: Windows.UI.Xaml.Media.Brush;
+    FocusVisualPrimaryThickness: Windows.UI.Xaml.Thickness;
+    FocusVisualSecondaryBrush: Windows.UI.Xaml.Media.Brush;
+    FocusVisualSecondaryThickness: Windows.UI.Xaml.Thickness;
+  }
+  var IFrameworkElement4: abstract new (...args: any[]) => IFrameworkElement4;
+
+  interface IFrameworkElement6 {
+    readonly ActualTheme: number;
+    ActualThemeChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.FrameworkElement, Object> | null;
+  }
+  var IFrameworkElement6: abstract new (...args: any[]) => IFrameworkElement6;
+
+  interface IFrameworkElement7 {
+    readonly IsLoaded: boolean;
+    EffectiveViewportChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.FrameworkElement, Windows.UI.Xaml.EffectiveViewportChangedEventArgs> | null;
+  }
+  var IFrameworkElement7: abstract new (...args: any[]) => IFrameworkElement7;
+
+  interface IFrameworkElementFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.FrameworkElement;
+  }
+  var IFrameworkElementFactory: abstract new (...args: any[]) => IFrameworkElementFactory;
+
+  interface IFrameworkElementOverrides {
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+  }
+  var IFrameworkElementOverrides: abstract new (...args: any[]) => IFrameworkElementOverrides;
+
+  interface IFrameworkElementOverrides2 {
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+  }
+  var IFrameworkElementOverrides2: abstract new (...args: any[]) => IFrameworkElementOverrides2;
+
+  interface IFrameworkElementProtected7 {
+    InvalidateViewport(): void;
+  }
+  var IFrameworkElementProtected7: abstract new (...args: any[]) => IFrameworkElementProtected7;
+
+  interface IFrameworkElementStatics {
+    readonly ActualHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ActualWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DataContextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FlowDirectionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LanguageProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MarginProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly NameProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TagProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly WidthProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFrameworkElementStatics: abstract new (...args: any[]) => IFrameworkElementStatics;
+
+  interface IFrameworkElementStatics2 {
+    readonly RequestedThemeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFrameworkElementStatics2: abstract new (...args: any[]) => IFrameworkElementStatics2;
+
+  interface IFrameworkElementStatics4 {
+    readonly AllowFocusOnInteractionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AllowFocusWhenDisabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FocusVisualMarginProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FocusVisualPrimaryBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FocusVisualPrimaryThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FocusVisualSecondaryBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FocusVisualSecondaryThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFrameworkElementStatics4: abstract new (...args: any[]) => IFrameworkElementStatics4;
+
+  interface IFrameworkElementStatics5 {
+    DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+  }
+  var IFrameworkElementStatics5: abstract new (...args: any[]) => IFrameworkElementStatics5;
+
+  interface IFrameworkElementStatics6 {
+    readonly ActualThemeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFrameworkElementStatics6: abstract new (...args: any[]) => IFrameworkElementStatics6;
+
+  interface IFrameworkTemplate {
+  }
+  var IFrameworkTemplate: abstract new (...args: any[]) => IFrameworkTemplate;
+
+  interface IFrameworkTemplateFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.FrameworkTemplate;
+  }
+  var IFrameworkTemplateFactory: abstract new (...args: any[]) => IFrameworkTemplateFactory;
+
+  interface IFrameworkView {
+  }
+  var IFrameworkView: abstract new (...args: any[]) => IFrameworkView;
+
+  interface IFrameworkViewSource {
+  }
+  var IFrameworkViewSource: abstract new (...args: any[]) => IFrameworkViewSource;
+
+  interface IGridLengthHelper {
+  }
+  var IGridLengthHelper: abstract new (...args: any[]) => IGridLengthHelper;
+
+  interface IGridLengthHelperStatics {
+    Equals(target: Windows.UI.Xaml.GridLength, value: Windows.UI.Xaml.GridLength): boolean;
+    FromPixels(pixels: number): Windows.UI.Xaml.GridLength;
+    FromValueAndType(value: number, type: number): Windows.UI.Xaml.GridLength;
+    GetIsAbsolute(target: Windows.UI.Xaml.GridLength): boolean;
+    GetIsAuto(target: Windows.UI.Xaml.GridLength): boolean;
+    GetIsStar(target: Windows.UI.Xaml.GridLength): boolean;
+    readonly Auto: Windows.UI.Xaml.GridLength;
+  }
+  var IGridLengthHelperStatics: abstract new (...args: any[]) => IGridLengthHelperStatics;
+
+  interface IMediaFailedRoutedEventArgs {
+    readonly ErrorTrace: string;
+  }
+  var IMediaFailedRoutedEventArgs: abstract new (...args: any[]) => IMediaFailedRoutedEventArgs;
+
+  interface IPointHelper {
+  }
+  var IPointHelper: abstract new (...args: any[]) => IPointHelper;
+
+  interface IPointHelperStatics {
+    FromCoordinates(x: number, y: number): Windows.Foundation.Point;
+  }
+  var IPointHelperStatics: abstract new (...args: any[]) => IPointHelperStatics;
+
+  interface IPropertyMetadata {
+    readonly CreateDefaultValueCallback: Windows.UI.Xaml.CreateDefaultValueCallback;
+    readonly DefaultValue: Object;
+  }
+  var IPropertyMetadata: abstract new (...args: any[]) => IPropertyMetadata;
+
+  interface IPropertyMetadataFactory {
+    CreateInstanceWithDefaultValue(defaultValue: Object, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.PropertyMetadata;
+    CreateInstanceWithDefaultValueAndCallback(defaultValue: Object, propertyChangedCallback: Windows.UI.Xaml.PropertyChangedCallback, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.PropertyMetadata;
+  }
+  var IPropertyMetadataFactory: abstract new (...args: any[]) => IPropertyMetadataFactory;
+
+  interface IPropertyMetadataStatics {
+    Create(defaultValue: Object): Windows.UI.Xaml.PropertyMetadata;
+    Create(defaultValue: Object, propertyChangedCallback: Windows.UI.Xaml.PropertyChangedCallback): Windows.UI.Xaml.PropertyMetadata;
+  }
+  var IPropertyMetadataStatics: abstract new (...args: any[]) => IPropertyMetadataStatics;
+
+  interface IPropertyPath {
+    readonly Path: string;
+  }
+  var IPropertyPath: abstract new (...args: any[]) => IPropertyPath;
+
+  interface IPropertyPathFactory {
+    CreateInstance(path: string): Windows.UI.Xaml.PropertyPath;
+  }
+  var IPropertyPathFactory: abstract new (...args: any[]) => IPropertyPathFactory;
+
+  interface IRectHelper {
+  }
+  var IRectHelper: abstract new (...args: any[]) => IRectHelper;
+
+  interface IRectHelperStatics {
+    Contains(target: Windows.Foundation.Rect, point: Windows.Foundation.Point): boolean;
+    Equals(target: Windows.Foundation.Rect, value: Windows.Foundation.Rect): boolean;
+    FromCoordinatesAndDimensions(x: number, y: number, width: number, height: number): Windows.Foundation.Rect;
+    FromLocationAndSize(location: Windows.Foundation.Point, size: Windows.Foundation.Size): Windows.Foundation.Rect;
+    FromPoints(point1: Windows.Foundation.Point, point2: Windows.Foundation.Point): Windows.Foundation.Rect;
+    GetBottom(target: Windows.Foundation.Rect): number;
+    GetIsEmpty(target: Windows.Foundation.Rect): boolean;
+    GetLeft(target: Windows.Foundation.Rect): number;
+    GetRight(target: Windows.Foundation.Rect): number;
+    GetTop(target: Windows.Foundation.Rect): number;
+    Intersect(target: Windows.Foundation.Rect, rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    Union(target: Windows.Foundation.Rect, point: Windows.Foundation.Point): Windows.Foundation.Rect;
+    readonly Empty: Windows.Foundation.Rect;
+  }
+  var IRectHelperStatics: abstract new (...args: any[]) => IRectHelperStatics;
+
+  interface IResourceDictionary {
+    readonly MergedDictionaries: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.ResourceDictionary> | Windows.UI.Xaml.ResourceDictionary[];
+    Source: Windows.Foundation.Uri;
+    readonly ThemeDictionaries: Windows.Foundation.Collections.IMap<Object, Object>;
+  }
+  var IResourceDictionary: abstract new (...args: any[]) => IResourceDictionary;
+
+  interface IResourceDictionaryFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.ResourceDictionary;
+  }
+  var IResourceDictionaryFactory: abstract new (...args: any[]) => IResourceDictionaryFactory;
+
+  interface IRoutedEvent {
+  }
+  var IRoutedEvent: abstract new (...args: any[]) => IRoutedEvent;
+
+  interface IRoutedEventArgs {
+    readonly OriginalSource: Object;
+  }
+  var IRoutedEventArgs: abstract new (...args: any[]) => IRoutedEventArgs;
+
+  interface IRoutedEventArgsFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.RoutedEventArgs;
+  }
+  var IRoutedEventArgsFactory: abstract new (...args: any[]) => IRoutedEventArgsFactory;
+
+  interface IScalarTransition {
+    Duration: Windows.Foundation.TimeSpan;
+  }
+  var IScalarTransition: abstract new (...args: any[]) => IScalarTransition;
+
+  interface IScalarTransitionFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.ScalarTransition;
+  }
+  var IScalarTransitionFactory: abstract new (...args: any[]) => IScalarTransitionFactory;
+
+  interface ISetter {
+    Property: Windows.UI.Xaml.DependencyProperty;
+    Value: Object;
+  }
+  var ISetter: abstract new (...args: any[]) => ISetter;
+
+  interface ISetter2 {
+    Target: Windows.UI.Xaml.TargetPropertyPath;
+  }
+  var ISetter2: abstract new (...args: any[]) => ISetter2;
+
+  interface ISetterBase {
+    readonly IsSealed: boolean;
+  }
+  var ISetterBase: abstract new (...args: any[]) => ISetterBase;
+
+  interface ISetterBaseCollection {
+    readonly IsSealed: boolean;
+  }
+  var ISetterBaseCollection: abstract new (...args: any[]) => ISetterBaseCollection;
+
+  interface ISetterBaseFactory {
+  }
+  var ISetterBaseFactory: abstract new (...args: any[]) => ISetterBaseFactory;
+
+  interface ISetterFactory {
+    CreateInstance(targetProperty: Windows.UI.Xaml.DependencyProperty, value: Object): Windows.UI.Xaml.Setter;
+  }
+  var ISetterFactory: abstract new (...args: any[]) => ISetterFactory;
+
+  interface ISizeChangedEventArgs {
+    readonly NewSize: Windows.Foundation.Size;
+    readonly PreviousSize: Windows.Foundation.Size;
+  }
+  var ISizeChangedEventArgs: abstract new (...args: any[]) => ISizeChangedEventArgs;
+
+  interface ISizeHelper {
+  }
+  var ISizeHelper: abstract new (...args: any[]) => ISizeHelper;
+
+  interface ISizeHelperStatics {
+    Equals(target: Windows.Foundation.Size, value: Windows.Foundation.Size): boolean;
+    FromDimensions(width: number, height: number): Windows.Foundation.Size;
+    GetIsEmpty(target: Windows.Foundation.Size): boolean;
+    readonly Empty: Windows.Foundation.Size;
+  }
+  var ISizeHelperStatics: abstract new (...args: any[]) => ISizeHelperStatics;
+
+  interface IStateTrigger {
+    IsActive: boolean;
+  }
+  var IStateTrigger: abstract new (...args: any[]) => IStateTrigger;
+
+  interface IStateTriggerBase {
+  }
+  var IStateTriggerBase: abstract new (...args: any[]) => IStateTriggerBase;
+
+  interface IStateTriggerBaseFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.StateTriggerBase;
+  }
+  var IStateTriggerBaseFactory: abstract new (...args: any[]) => IStateTriggerBaseFactory;
+
+  interface IStateTriggerBaseProtected {
+    SetActive(IsActive: boolean): void;
+  }
+  var IStateTriggerBaseProtected: abstract new (...args: any[]) => IStateTriggerBaseProtected;
+
+  interface IStateTriggerStatics {
+    readonly IsActiveProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IStateTriggerStatics: abstract new (...args: any[]) => IStateTriggerStatics;
+
+  interface IStyle {
+    Seal(): void;
+    BasedOn: Windows.UI.Xaml.Style;
+    readonly IsSealed: boolean;
+    readonly Setters: Windows.UI.Xaml.SetterBaseCollection;
+    TargetType: Windows.UI.Xaml.Interop.TypeName;
+  }
+  var IStyle: abstract new (...args: any[]) => IStyle;
+
+  interface IStyleFactory {
+    CreateInstance(targetType: Windows.UI.Xaml.Interop.TypeName): Windows.UI.Xaml.Style;
+  }
+  var IStyleFactory: abstract new (...args: any[]) => IStyleFactory;
+
+  interface ITargetPropertyPath {
+    Path: Windows.UI.Xaml.PropertyPath;
+    Target: Object;
+  }
+  var ITargetPropertyPath: abstract new (...args: any[]) => ITargetPropertyPath;
+
+  interface ITargetPropertyPathFactory {
+    CreateInstance(targetProperty: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.TargetPropertyPath;
+  }
+  var ITargetPropertyPathFactory: abstract new (...args: any[]) => ITargetPropertyPathFactory;
+
+  interface IThicknessHelper {
+  }
+  var IThicknessHelper: abstract new (...args: any[]) => IThicknessHelper;
+
+  interface IThicknessHelperStatics {
+    FromLengths(left: number, top: number, right: number, bottom: number): Windows.UI.Xaml.Thickness;
+    FromUniformLength(uniformLength: number): Windows.UI.Xaml.Thickness;
+  }
+  var IThicknessHelperStatics: abstract new (...args: any[]) => IThicknessHelperStatics;
+
+  interface ITriggerAction {
+  }
+  var ITriggerAction: abstract new (...args: any[]) => ITriggerAction;
+
+  interface ITriggerActionFactory {
+  }
+  var ITriggerActionFactory: abstract new (...args: any[]) => ITriggerActionFactory;
+
+  interface ITriggerBase {
+  }
+  var ITriggerBase: abstract new (...args: any[]) => ITriggerBase;
+
+  interface ITriggerBaseFactory {
+  }
+  var ITriggerBaseFactory: abstract new (...args: any[]) => ITriggerBaseFactory;
+
+  interface IUIElement {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    UpdateLayout(): void;
+    AllowDrop: boolean;
+    CacheMode: Windows.UI.Xaml.Media.CacheMode;
+    Clip: Windows.UI.Xaml.Media.RectangleGeometry;
+    readonly DesiredSize: Windows.Foundation.Size;
+    IsDoubleTapEnabled: boolean;
+    IsHitTestVisible: boolean;
+    IsHoldingEnabled: boolean;
+    IsRightTapEnabled: boolean;
+    IsTapEnabled: boolean;
+    ManipulationMode: number;
+    Opacity: number;
+    readonly PointerCaptures: Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Input.Pointer> | Windows.UI.Xaml.Input.Pointer[];
+    Projection: Windows.UI.Xaml.Media.Projection;
+    readonly RenderSize: Windows.Foundation.Size;
+    RenderTransform: Windows.UI.Xaml.Media.Transform;
+    RenderTransformOrigin: Windows.Foundation.Point;
+    Transitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    UseLayoutRounding: boolean;
+    Visibility: number;
+    DoubleTapped: Windows.UI.Xaml.Input.DoubleTappedEventHandler | null;
+    DragEnter: Windows.UI.Xaml.DragEventHandler | null;
+    DragLeave: Windows.UI.Xaml.DragEventHandler | null;
+    DragOver: Windows.UI.Xaml.DragEventHandler | null;
+    Drop: Windows.UI.Xaml.DragEventHandler | null;
+    GotFocus: Windows.UI.Xaml.RoutedEventHandler | null;
+    Holding: Windows.UI.Xaml.Input.HoldingEventHandler | null;
+    KeyDown: Windows.UI.Xaml.Input.KeyEventHandler | null;
+    KeyUp: Windows.UI.Xaml.Input.KeyEventHandler | null;
+    LostFocus: Windows.UI.Xaml.RoutedEventHandler | null;
+    ManipulationCompleted: Windows.UI.Xaml.Input.ManipulationCompletedEventHandler | null;
+    ManipulationDelta: Windows.UI.Xaml.Input.ManipulationDeltaEventHandler | null;
+    ManipulationInertiaStarting: Windows.UI.Xaml.Input.ManipulationInertiaStartingEventHandler | null;
+    ManipulationStarted: Windows.UI.Xaml.Input.ManipulationStartedEventHandler | null;
+    ManipulationStarting: Windows.UI.Xaml.Input.ManipulationStartingEventHandler | null;
+    PointerCanceled: Windows.UI.Xaml.Input.PointerEventHandler | null;
+    PointerCaptureLost: Windows.UI.Xaml.Input.PointerEventHandler | null;
+    PointerEntered: Windows.UI.Xaml.Input.PointerEventHandler | null;
+    PointerExited: Windows.UI.Xaml.Input.PointerEventHandler | null;
+    PointerMoved: Windows.UI.Xaml.Input.PointerEventHandler | null;
+    PointerPressed: Windows.UI.Xaml.Input.PointerEventHandler | null;
+    PointerReleased: Windows.UI.Xaml.Input.PointerEventHandler | null;
+    PointerWheelChanged: Windows.UI.Xaml.Input.PointerEventHandler | null;
+    RightTapped: Windows.UI.Xaml.Input.RightTappedEventHandler | null;
+    Tapped: Windows.UI.Xaml.Input.TappedEventHandler | null;
+  }
+  var IUIElement: abstract new (...args: any[]) => IUIElement;
+
+  interface IUIElement10 {
+    readonly ActualOffset: Windows.Foundation.Numerics.Vector3;
+    readonly ActualSize: Windows.Foundation.Numerics.Vector2;
+    Shadow: Windows.UI.Xaml.Media.Shadow;
+    readonly UIContext: Windows.UI.UIContext;
+    XamlRoot: Windows.UI.Xaml.XamlRoot;
+  }
+  var IUIElement10: abstract new (...args: any[]) => IUIElement10;
+
+  interface IUIElement2 {
+    CancelDirectManipulations(): boolean;
+    CompositeMode: number;
+  }
+  var IUIElement2: abstract new (...args: any[]) => IUIElement2;
+
+  interface IUIElement3 {
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    CanDrag: boolean;
+    Transform3D: Windows.UI.Xaml.Media.Media3D.Transform3D;
+    DragStarting: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.DragStartingEventArgs> | null;
+    DropCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.DropCompletedEventArgs> | null;
+  }
+  var IUIElement3: abstract new (...args: any[]) => IUIElement3;
+
+  interface IUIElement4 {
+    AccessKey: string;
+    AccessKeyScopeOwner: Windows.UI.Xaml.DependencyObject;
+    ContextFlyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    ExitDisplayModeOnAccessKeyInvoked: boolean;
+    IsAccessKeyScope: boolean;
+    AccessKeyDisplayDismissed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs> | null;
+    AccessKeyDisplayRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs> | null;
+    AccessKeyInvoked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs> | null;
+    ContextCanceled: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.RoutedEventArgs> | null;
+    ContextRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.Input.ContextRequestedEventArgs> | null;
+  }
+  var IUIElement4: abstract new (...args: any[]) => IUIElement4;
+
+  interface IUIElement5 {
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    HighContrastAdjustment: number;
+    KeyTipHorizontalOffset: number;
+    KeyTipPlacementMode: number;
+    KeyTipVerticalOffset: number;
+    readonly Lights: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Media.XamlLight> | Windows.UI.Xaml.Media.XamlLight[];
+    TabFocusNavigation: number;
+    XYFocusDownNavigationStrategy: number;
+    XYFocusKeyboardNavigation: number;
+    XYFocusLeftNavigationStrategy: number;
+    XYFocusRightNavigationStrategy: number;
+    XYFocusUpNavigationStrategy: number;
+    GettingFocus: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.Input.GettingFocusEventArgs> | null;
+    LosingFocus: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.Input.LosingFocusEventArgs> | null;
+    NoFocusCandidateFound: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.Input.NoFocusCandidateFoundEventArgs> | null;
+  }
+  var IUIElement5: abstract new (...args: any[]) => IUIElement5;
+
+  interface IUIElement7 {
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    readonly KeyboardAccelerators: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Input.KeyboardAccelerator> | Windows.UI.Xaml.Input.KeyboardAccelerator[];
+    CharacterReceived: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs> | null;
+    PreviewKeyDown: Windows.UI.Xaml.Input.KeyEventHandler | null;
+    PreviewKeyUp: Windows.UI.Xaml.Input.KeyEventHandler | null;
+    ProcessKeyboardAccelerators: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs> | null;
+  }
+  var IUIElement7: abstract new (...args: any[]) => IUIElement7;
+
+  interface IUIElement8 {
+    KeyTipTarget: Windows.UI.Xaml.DependencyObject;
+    KeyboardAcceleratorPlacementMode: number;
+    KeyboardAcceleratorPlacementTarget: Windows.UI.Xaml.DependencyObject;
+    BringIntoViewRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.UIElement, Windows.UI.Xaml.BringIntoViewRequestedEventArgs> | null;
+  }
+  var IUIElement8: abstract new (...args: any[]) => IUIElement8;
+
+  interface IUIElement9 {
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    CanBeScrollAnchor: boolean;
+    CenterPoint: Windows.Foundation.Numerics.Vector3;
+    OpacityTransition: Windows.UI.Xaml.ScalarTransition;
+    Rotation: number;
+    RotationAxis: Windows.Foundation.Numerics.Vector3;
+    RotationTransition: Windows.UI.Xaml.ScalarTransition;
+    Scale: Windows.Foundation.Numerics.Vector3;
+    ScaleTransition: Windows.UI.Xaml.Vector3Transition;
+    TransformMatrix: Windows.Foundation.Numerics.Matrix4x4;
+    Translation: Windows.Foundation.Numerics.Vector3;
+    TranslationTransition: Windows.UI.Xaml.Vector3Transition;
+  }
+  var IUIElement9: abstract new (...args: any[]) => IUIElement9;
+
+  interface IUIElementFactory {
+  }
+  var IUIElementFactory: abstract new (...args: any[]) => IUIElementFactory;
+
+  interface IUIElementOverrides {
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+  }
+  var IUIElementOverrides: abstract new (...args: any[]) => IUIElementOverrides;
+
+  interface IUIElementOverrides7 {
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+  }
+  var IUIElementOverrides7: abstract new (...args: any[]) => IUIElementOverrides7;
+
+  interface IUIElementOverrides8 {
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+  }
+  var IUIElementOverrides8: abstract new (...args: any[]) => IUIElementOverrides8;
+
+  interface IUIElementOverrides9 {
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+  }
+  var IUIElementOverrides9: abstract new (...args: any[]) => IUIElementOverrides9;
+
+  interface IUIElementStatics {
+    readonly AllowDropProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CacheModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ClipProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DoubleTappedEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly DragEnterEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly DragLeaveEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly DragOverEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly DropEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly HoldingEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly IsDoubleTapEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsHitTestVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsHoldingEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsRightTapEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsTapEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly KeyDownEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly KeyUpEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly ManipulationCompletedEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly ManipulationDeltaEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly ManipulationInertiaStartingEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly ManipulationModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ManipulationStartedEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly ManipulationStartingEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly OpacityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PointerCanceledEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly PointerCaptureLostEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly PointerCapturesProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PointerEnteredEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly PointerExitedEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly PointerMovedEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly PointerPressedEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly PointerReleasedEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly PointerWheelChangedEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly ProjectionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RenderTransformOriginProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RenderTransformProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RightTappedEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly TappedEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly TransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly UseLayoutRoundingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IUIElementStatics: abstract new (...args: any[]) => IUIElementStatics;
+
+  interface IUIElementStatics10 {
+    readonly ShadowProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IUIElementStatics10: abstract new (...args: any[]) => IUIElementStatics10;
+
+  interface IUIElementStatics2 {
+    readonly CompositeModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IUIElementStatics2: abstract new (...args: any[]) => IUIElementStatics2;
+
+  interface IUIElementStatics3 {
+    TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    readonly CanDragProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Transform3DProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IUIElementStatics3: abstract new (...args: any[]) => IUIElementStatics3;
+
+  interface IUIElementStatics4 {
+    readonly AccessKeyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AccessKeyScopeOwnerProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContextFlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ExitDisplayModeOnAccessKeyInvokedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsAccessKeyScopeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IUIElementStatics4: abstract new (...args: any[]) => IUIElementStatics4;
+
+  interface IUIElementStatics5 {
+    readonly HighContrastAdjustmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly KeyTipHorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly KeyTipPlacementModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly KeyTipVerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LightsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TabFocusNavigationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusDownNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusKeyboardNavigationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusLeftNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusRightNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusUpNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IUIElementStatics5: abstract new (...args: any[]) => IUIElementStatics5;
+
+  interface IUIElementStatics6 {
+    readonly GettingFocusEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly LosingFocusEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly NoFocusCandidateFoundEvent: Windows.UI.Xaml.RoutedEvent;
+  }
+  var IUIElementStatics6: abstract new (...args: any[]) => IUIElementStatics6;
+
+  interface IUIElementStatics7 {
+    readonly CharacterReceivedEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly PreviewKeyDownEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly PreviewKeyUpEvent: Windows.UI.Xaml.RoutedEvent;
+  }
+  var IUIElementStatics7: abstract new (...args: any[]) => IUIElementStatics7;
+
+  interface IUIElementStatics8 {
+    RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    readonly BringIntoViewRequestedEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly ContextRequestedEvent: Windows.UI.Xaml.RoutedEvent;
+    readonly KeyTipTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly KeyboardAcceleratorPlacementModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly KeyboardAcceleratorPlacementTargetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IUIElementStatics8: abstract new (...args: any[]) => IUIElementStatics8;
+
+  interface IUIElementStatics9 {
+    readonly CanBeScrollAnchorProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IUIElementStatics9: abstract new (...args: any[]) => IUIElementStatics9;
+
+  interface IUIElementWeakCollection {
+  }
+  var IUIElementWeakCollection: abstract new (...args: any[]) => IUIElementWeakCollection;
+
+  interface IUIElementWeakCollectionFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.UIElementWeakCollection;
+  }
+  var IUIElementWeakCollectionFactory: abstract new (...args: any[]) => IUIElementWeakCollectionFactory;
+
+  interface IUnhandledExceptionEventArgs {
+    readonly Exception: Windows.Foundation.HResult;
+    Handled: boolean;
+    readonly Message: string;
+  }
+  var IUnhandledExceptionEventArgs: abstract new (...args: any[]) => IUnhandledExceptionEventArgs;
+
+  interface IVector3Transition {
+    Components: number;
+    Duration: Windows.Foundation.TimeSpan;
+  }
+  var IVector3Transition: abstract new (...args: any[]) => IVector3Transition;
+
+  interface IVector3TransitionFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Vector3Transition;
+  }
+  var IVector3TransitionFactory: abstract new (...args: any[]) => IVector3TransitionFactory;
+
+  interface IVisualState {
+    readonly Name: string;
+    Storyboard: Windows.UI.Xaml.Media.Animation.Storyboard;
+  }
+  var IVisualState: abstract new (...args: any[]) => IVisualState;
+
+  interface IVisualState2 {
+    readonly Setters: Windows.UI.Xaml.SetterBaseCollection;
+    readonly StateTriggers: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.StateTriggerBase> | Windows.UI.Xaml.StateTriggerBase[];
+  }
+  var IVisualState2: abstract new (...args: any[]) => IVisualState2;
+
+  interface IVisualStateChangedEventArgs {
+    Control: Windows.UI.Xaml.Controls.Control;
+    NewState: Windows.UI.Xaml.VisualState;
+    OldState: Windows.UI.Xaml.VisualState;
+  }
+  var IVisualStateChangedEventArgs: abstract new (...args: any[]) => IVisualStateChangedEventArgs;
+
+  interface IVisualStateGroup {
+    readonly CurrentState: Windows.UI.Xaml.VisualState;
+    readonly Name: string;
+    readonly States: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.VisualState> | Windows.UI.Xaml.VisualState[];
+    readonly Transitions: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.VisualTransition> | Windows.UI.Xaml.VisualTransition[];
+    CurrentStateChanged: Windows.UI.Xaml.VisualStateChangedEventHandler | null;
+    CurrentStateChanging: Windows.UI.Xaml.VisualStateChangedEventHandler | null;
+  }
+  var IVisualStateGroup: abstract new (...args: any[]) => IVisualStateGroup;
+
+  interface IVisualStateManager {
+  }
+  var IVisualStateManager: abstract new (...args: any[]) => IVisualStateManager;
+
+  interface IVisualStateManagerFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.VisualStateManager;
+  }
+  var IVisualStateManagerFactory: abstract new (...args: any[]) => IVisualStateManagerFactory;
+
+  interface IVisualStateManagerOverrides {
+    GoToStateCore(control: Windows.UI.Xaml.Controls.Control, templateRoot: Windows.UI.Xaml.FrameworkElement, stateName: string, group: Windows.UI.Xaml.VisualStateGroup, state: Windows.UI.Xaml.VisualState, useTransitions: boolean): boolean;
+  }
+  var IVisualStateManagerOverrides: abstract new (...args: any[]) => IVisualStateManagerOverrides;
+
+  interface IVisualStateManagerProtected {
+    RaiseCurrentStateChanged(stateGroup: Windows.UI.Xaml.VisualStateGroup, oldState: Windows.UI.Xaml.VisualState, newState: Windows.UI.Xaml.VisualState, control: Windows.UI.Xaml.Controls.Control): void;
+    RaiseCurrentStateChanging(stateGroup: Windows.UI.Xaml.VisualStateGroup, oldState: Windows.UI.Xaml.VisualState, newState: Windows.UI.Xaml.VisualState, control: Windows.UI.Xaml.Controls.Control): void;
+  }
+  var IVisualStateManagerProtected: abstract new (...args: any[]) => IVisualStateManagerProtected;
+
+  interface IVisualStateManagerStatics {
+    GetCustomVisualStateManager(obj: Windows.UI.Xaml.FrameworkElement): Windows.UI.Xaml.VisualStateManager;
+    GetVisualStateGroups(obj: Windows.UI.Xaml.FrameworkElement): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.VisualStateGroup> | Windows.UI.Xaml.VisualStateGroup[];
+    GoToState(control: Windows.UI.Xaml.Controls.Control, stateName: string, useTransitions: boolean): boolean;
+    SetCustomVisualStateManager(obj: Windows.UI.Xaml.FrameworkElement, value: Windows.UI.Xaml.VisualStateManager): void;
+    readonly CustomVisualStateManagerProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IVisualStateManagerStatics: abstract new (...args: any[]) => IVisualStateManagerStatics;
+
+  interface IVisualTransition {
+    From: string;
+    GeneratedDuration: Windows.UI.Xaml.Duration;
+    GeneratedEasingFunction: Windows.UI.Xaml.Media.Animation.EasingFunctionBase;
+    Storyboard: Windows.UI.Xaml.Media.Animation.Storyboard;
+    To: string;
+  }
+  var IVisualTransition: abstract new (...args: any[]) => IVisualTransition;
+
+  interface IVisualTransitionFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.VisualTransition;
+  }
+  var IVisualTransitionFactory: abstract new (...args: any[]) => IVisualTransitionFactory;
+
+  interface IWindow {
+    Activate(): void;
+    Close(): void;
+    readonly Bounds: Windows.Foundation.Rect;
+    Content: Windows.UI.Xaml.UIElement;
+    readonly CoreWindow: Windows.UI.Core.CoreWindow;
+    readonly Dispatcher: Windows.UI.Core.CoreDispatcher;
+    readonly Visible: boolean;
+    Activated: Windows.UI.Xaml.WindowActivatedEventHandler | null;
+    Closed: Windows.UI.Xaml.WindowClosedEventHandler | null;
+    SizeChanged: Windows.UI.Xaml.WindowSizeChangedEventHandler | null;
+    VisibilityChanged: Windows.UI.Xaml.WindowVisibilityChangedEventHandler | null;
+  }
+  var IWindow: abstract new (...args: any[]) => IWindow;
+
+  interface IWindow2 {
+    SetTitleBar(value: Windows.UI.Xaml.UIElement): void;
+  }
+  var IWindow2: abstract new (...args: any[]) => IWindow2;
+
+  interface IWindow3 {
+    readonly Compositor: Windows.UI.Composition.Compositor;
+  }
+  var IWindow3: abstract new (...args: any[]) => IWindow3;
+
+  interface IWindow4 {
+    readonly UIContext: Windows.UI.UIContext;
+  }
+  var IWindow4: abstract new (...args: any[]) => IWindow4;
+
+  interface IWindowCreatedEventArgs {
+    readonly Window: Windows.UI.Xaml.Window;
+  }
+  var IWindowCreatedEventArgs: abstract new (...args: any[]) => IWindowCreatedEventArgs;
+
+  interface IWindowStatics {
+    readonly Current: Windows.UI.Xaml.Window;
+  }
+  var IWindowStatics: abstract new (...args: any[]) => IWindowStatics;
+
+  interface IXamlRoot {
+    readonly Content: Windows.UI.Xaml.UIElement;
+    readonly IsHostVisible: boolean;
+    readonly RasterizationScale: number;
+    readonly Size: Windows.Foundation.Size;
+    readonly UIContext: Windows.UI.UIContext;
+    Changed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.XamlRoot, Windows.UI.Xaml.XamlRootChangedEventArgs> | null;
+  }
+  var IXamlRoot: abstract new (...args: any[]) => IXamlRoot;
+
+  interface IXamlRootChangedEventArgs {
+  }
+  var IXamlRootChangedEventArgs: abstract new (...args: any[]) => IXamlRootChangedEventArgs;
+
+  interface LeavingBackgroundEventHandler {
+    (sender: Object, e: Windows.ApplicationModel.LeavingBackgroundEventArgs): void;
+  }
+  var LeavingBackgroundEventHandler: {
+    new(callback: (sender: Object, e: Windows.ApplicationModel.LeavingBackgroundEventArgs) => void): LeavingBackgroundEventHandler;
+  };
+
+  interface PropertyChangedCallback {
+    (d: Windows.UI.Xaml.DependencyObject, e: Windows.UI.Xaml.DependencyPropertyChangedEventArgs): void;
+  }
+  var PropertyChangedCallback: {
+    new(callback: (d: Windows.UI.Xaml.DependencyObject, e: Windows.UI.Xaml.DependencyPropertyChangedEventArgs) => void): PropertyChangedCallback;
+  };
+
+  interface RoutedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.RoutedEventArgs): void;
+  }
+  var RoutedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.RoutedEventArgs) => void): RoutedEventHandler;
+  };
+
+  interface SizeChangedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.SizeChangedEventArgs): void;
+  }
+  var SizeChangedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.SizeChangedEventArgs) => void): SizeChangedEventHandler;
+  };
+
+  interface SuspendingEventHandler {
+    (sender: Object, e: Windows.ApplicationModel.SuspendingEventArgs): void;
+  }
+  var SuspendingEventHandler: {
+    new(callback: (sender: Object, e: Windows.ApplicationModel.SuspendingEventArgs) => void): SuspendingEventHandler;
+  };
+
+  interface Thickness {
+    Left: number;
+    Top: number;
+    Right: number;
+    Bottom: number;
+  }
+  var Thickness: {
+    new(left: number, top: number, right: number, bottom: number): Thickness;
+    new(fields: { Left?: number; Top?: number; Right?: number; Bottom?: number }): Thickness;
+  };
+
+  interface UnhandledExceptionEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.UnhandledExceptionEventArgs): void;
+  }
+  var UnhandledExceptionEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.UnhandledExceptionEventArgs) => void): UnhandledExceptionEventHandler;
+  };
+
+  interface VisualStateChangedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.VisualStateChangedEventArgs): void;
+  }
+  var VisualStateChangedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.VisualStateChangedEventArgs) => void): VisualStateChangedEventHandler;
+  };
+
+  interface WindowActivatedEventHandler {
+    (sender: Object, e: Windows.UI.Core.WindowActivatedEventArgs): void;
+  }
+  var WindowActivatedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Core.WindowActivatedEventArgs) => void): WindowActivatedEventHandler;
+  };
+
+  interface WindowClosedEventHandler {
+    (sender: Object, e: Windows.UI.Core.CoreWindowEventArgs): void;
+  }
+  var WindowClosedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Core.CoreWindowEventArgs) => void): WindowClosedEventHandler;
+  };
+
+  interface WindowSizeChangedEventHandler {
+    (sender: Object, e: Windows.UI.Core.WindowSizeChangedEventArgs): void;
+  }
+  var WindowSizeChangedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Core.WindowSizeChangedEventArgs) => void): WindowSizeChangedEventHandler;
+  };
+
+  interface WindowVisibilityChangedEventHandler {
+    (sender: Object, e: Windows.UI.Core.VisibilityChangedEventArgs): void;
+  }
+  var WindowVisibilityChangedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Core.VisibilityChangedEventArgs) => void): WindowVisibilityChangedEventHandler;
+  };
+
+}
+
+declare namespace Windows.UI.Xaml.Automation {
+  class AnnotationPatternIdentifiers implements Windows.UI.Xaml.Automation.IAnnotationPatternIdentifiers {
+    static readonly AnnotationTypeIdProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly AnnotationTypeNameProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly AuthorProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly DateTimeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly TargetProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class AutomationAnnotation extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Automation.IAutomationAnnotation {
+    constructor(type: number);
+    constructor(type: number, element: Windows.UI.Xaml.UIElement);
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Element: Windows.UI.Xaml.UIElement;
+    static readonly ElementProperty: Windows.UI.Xaml.DependencyProperty;
+    Type: number;
+    static readonly TypeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class AutomationElementIdentifiers implements Windows.UI.Xaml.Automation.IAutomationElementIdentifiers {
+    static readonly AcceleratorKeyProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly AccessKeyProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly AnnotationsProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly AutomationIdProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly BoundingRectangleProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly ClassNameProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly ClickablePointProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly ControlTypeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly ControlledPeersProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly CultureProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly DescribedByProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly FlowsFromProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly FlowsToProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly FullDescriptionProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly HasKeyboardFocusProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly HeadingLevelProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly HelpTextProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly IsContentElementProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly IsControlElementProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly IsDataValidForFormProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly IsDialogProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly IsEnabledProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly IsKeyboardFocusableProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly IsOffscreenProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly IsPasswordProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly IsPeripheralProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly IsRequiredForFormProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly ItemStatusProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly ItemTypeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly LabeledByProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly LandmarkTypeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly LevelProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly LiveSettingProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly LocalizedControlTypeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly LocalizedLandmarkTypeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly NameProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly OrientationProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly PositionInSetProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly SizeOfSetProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class AutomationProperties implements Windows.UI.Xaml.Automation.IAutomationProperties {
+    static GetAcceleratorKey(element: Windows.UI.Xaml.DependencyObject): string;
+    static GetAccessKey(element: Windows.UI.Xaml.DependencyObject): string;
+    static GetAccessibilityView(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetAnnotations(element: Windows.UI.Xaml.DependencyObject): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.AutomationAnnotation> | Windows.UI.Xaml.Automation.AutomationAnnotation[];
+    static GetAutomationControlType(element: Windows.UI.Xaml.UIElement): number;
+    static GetAutomationId(element: Windows.UI.Xaml.DependencyObject): string;
+    static GetControlledPeers(element: Windows.UI.Xaml.DependencyObject): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.UIElement> | Windows.UI.Xaml.UIElement[];
+    static GetCulture(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetDescribedBy(element: Windows.UI.Xaml.DependencyObject): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetFlowsFrom(element: Windows.UI.Xaml.DependencyObject): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetFlowsTo(element: Windows.UI.Xaml.DependencyObject): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetFullDescription(element: Windows.UI.Xaml.DependencyObject): string;
+    static GetHeadingLevel(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetHelpText(element: Windows.UI.Xaml.DependencyObject): string;
+    static GetIsDataValidForForm(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsDialog(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsPeripheral(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsRequiredForForm(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetItemStatus(element: Windows.UI.Xaml.DependencyObject): string;
+    static GetItemType(element: Windows.UI.Xaml.DependencyObject): string;
+    static GetLabeledBy(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.UIElement;
+    static GetLandmarkType(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetLevel(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetLiveSetting(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetLocalizedControlType(element: Windows.UI.Xaml.DependencyObject): string;
+    static GetLocalizedLandmarkType(element: Windows.UI.Xaml.DependencyObject): string;
+    static GetName(element: Windows.UI.Xaml.DependencyObject): string;
+    static GetPositionInSet(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetSizeOfSet(element: Windows.UI.Xaml.DependencyObject): number;
+    static SetAcceleratorKey(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    static SetAccessKey(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    static SetAccessibilityView(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static SetAutomationControlType(element: Windows.UI.Xaml.UIElement, value: number): void;
+    static SetAutomationId(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    static SetCulture(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static SetFullDescription(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    static SetHeadingLevel(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static SetHelpText(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    static SetIsDataValidForForm(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetIsDialog(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetIsPeripheral(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetIsRequiredForForm(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetItemStatus(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    static SetItemType(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    static SetLabeledBy(element: Windows.UI.Xaml.DependencyObject, value: Windows.UI.Xaml.UIElement): void;
+    static SetLandmarkType(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static SetLevel(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static SetLiveSetting(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static SetLocalizedControlType(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    static SetLocalizedLandmarkType(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    static SetName(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    static SetPositionInSet(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static SetSizeOfSet(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static readonly AcceleratorKeyProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly AccessKeyProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly AccessibilityViewProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly AnnotationsProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly AutomationControlTypeProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly AutomationIdProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly ControlledPeersProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly CultureProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly DescribedByProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly FlowsFromProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly FlowsToProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly FullDescriptionProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly HeadingLevelProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly HelpTextProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly IsDataValidForFormProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly IsDialogProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly IsPeripheralProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly IsRequiredForFormProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly ItemStatusProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly ItemTypeProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly LabeledByProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly LandmarkTypeProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly LevelProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly LiveSettingProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly LocalizedControlTypeProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly LocalizedLandmarkTypeProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly NameProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly PositionInSetProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly SizeOfSetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class AutomationProperty implements Windows.UI.Xaml.Automation.IAutomationProperty {
+  }
+
+  class DockPatternIdentifiers implements Windows.UI.Xaml.Automation.IDockPatternIdentifiers {
+    static readonly DockPositionProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class DragPatternIdentifiers implements Windows.UI.Xaml.Automation.IDragPatternIdentifiers {
+    static readonly DropEffectProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly DropEffectsProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly GrabbedItemsProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly IsGrabbedProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class DropTargetPatternIdentifiers implements Windows.UI.Xaml.Automation.IDropTargetPatternIdentifiers {
+    static readonly DropTargetEffectProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly DropTargetEffectsProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class ExpandCollapsePatternIdentifiers implements Windows.UI.Xaml.Automation.IExpandCollapsePatternIdentifiers {
+    static readonly ExpandCollapseStateProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class GridItemPatternIdentifiers implements Windows.UI.Xaml.Automation.IGridItemPatternIdentifiers {
+    static readonly ColumnProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly ColumnSpanProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly ContainingGridProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly RowProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly RowSpanProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class GridPatternIdentifiers implements Windows.UI.Xaml.Automation.IGridPatternIdentifiers {
+    static readonly ColumnCountProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly RowCountProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class MultipleViewPatternIdentifiers implements Windows.UI.Xaml.Automation.IMultipleViewPatternIdentifiers {
+    static readonly CurrentViewProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly SupportedViewsProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class RangeValuePatternIdentifiers implements Windows.UI.Xaml.Automation.IRangeValuePatternIdentifiers {
+    static readonly IsReadOnlyProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly LargeChangeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly MaximumProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly MinimumProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly SmallChangeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly ValueProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class ScrollPatternIdentifiers implements Windows.UI.Xaml.Automation.IScrollPatternIdentifiers {
+    static readonly HorizontalScrollPercentProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly HorizontalViewSizeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly HorizontallyScrollableProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly NoScroll: number;
+    static readonly VerticalScrollPercentProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly VerticalViewSizeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly VerticallyScrollableProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class SelectionItemPatternIdentifiers implements Windows.UI.Xaml.Automation.ISelectionItemPatternIdentifiers {
+    static readonly IsSelectedProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly SelectionContainerProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class SelectionPatternIdentifiers implements Windows.UI.Xaml.Automation.ISelectionPatternIdentifiers {
+    static readonly CanSelectMultipleProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly IsSelectionRequiredProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly SelectionProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class SpreadsheetItemPatternIdentifiers implements Windows.UI.Xaml.Automation.ISpreadsheetItemPatternIdentifiers {
+    static readonly FormulaProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class StylesPatternIdentifiers implements Windows.UI.Xaml.Automation.IStylesPatternIdentifiers {
+    static readonly ExtendedPropertiesProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly FillColorProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly FillPatternColorProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly FillPatternStyleProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly ShapeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly StyleIdProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly StyleNameProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class TableItemPatternIdentifiers implements Windows.UI.Xaml.Automation.ITableItemPatternIdentifiers {
+    static readonly ColumnHeaderItemsProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly RowHeaderItemsProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class TablePatternIdentifiers implements Windows.UI.Xaml.Automation.ITablePatternIdentifiers {
+    static readonly ColumnHeadersProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly RowHeadersProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly RowOrColumnMajorProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class TogglePatternIdentifiers implements Windows.UI.Xaml.Automation.ITogglePatternIdentifiers {
+    static readonly ToggleStateProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class TransformPattern2Identifiers implements Windows.UI.Xaml.Automation.ITransformPattern2Identifiers {
+    static readonly CanZoomProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly MaxZoomProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly MinZoomProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly ZoomLevelProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class TransformPatternIdentifiers implements Windows.UI.Xaml.Automation.ITransformPatternIdentifiers {
+    static readonly CanMoveProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly CanResizeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly CanRotateProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class ValuePatternIdentifiers implements Windows.UI.Xaml.Automation.IValuePatternIdentifiers {
+    static readonly IsReadOnlyProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly ValueProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  class WindowPatternIdentifiers implements Windows.UI.Xaml.Automation.IWindowPatternIdentifiers {
+    static readonly CanMaximizeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly CanMinimizeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly IsModalProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly IsTopmostProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly WindowInteractionStateProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    static readonly WindowVisualStateProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+
+  enum AnnotationType {
+    Unknown = 60000,
+    SpellingError = 60001,
+    GrammarError = 60002,
+    Comment = 60003,
+    FormulaError = 60004,
+    TrackChanges = 60005,
+    Header = 60006,
+    Footer = 60007,
+    Highlighted = 60008,
+    Endnote = 60009,
+    Footnote = 60010,
+    InsertionChange = 60011,
+    DeletionChange = 60012,
+    MoveChange = 60013,
+    FormatChange = 60014,
+    UnsyncedChange = 60015,
+    EditingLockedChange = 60016,
+    ExternalChange = 60017,
+    ConflictingChange = 60018,
+    Author = 60019,
+    AdvancedProofingIssue = 60020,
+    DataValidationError = 60021,
+    CircularReferenceError = 60022,
+  }
+
+  enum AutomationActiveEnd {
+    None = 0,
+    Start = 1,
+    End = 2,
+  }
+
+  enum AutomationAnimationStyle {
+    None = 0,
+    LasVegasLights = 1,
+    BlinkingBackground = 2,
+    SparkleText = 3,
+    MarchingBlackAnts = 4,
+    MarchingRedAnts = 5,
+    Shimmer = 6,
+    Other = 7,
+  }
+
+  enum AutomationBulletStyle {
+    None = 0,
+    HollowRoundBullet = 1,
+    FilledRoundBullet = 2,
+    HollowSquareBullet = 3,
+    FilledSquareBullet = 4,
+    DashBullet = 5,
+    Other = 6,
+  }
+
+  enum AutomationCaretBidiMode {
+    LTR = 0,
+    RTL = 1,
+  }
+
+  enum AutomationCaretPosition {
+    Unknown = 0,
+    EndOfLine = 1,
+    BeginningOfLine = 2,
+  }
+
+  enum AutomationFlowDirections {
+    Default = 0,
+    RightToLeft = 1,
+    BottomToTop = 2,
+    Vertical = 3,
+  }
+
+  enum AutomationOutlineStyles {
+    None = 0,
+    Outline = 1,
+    Shadow = 2,
+    Engraved = 3,
+    Embossed = 4,
+  }
+
+  enum AutomationStyleId {
+    Heading1 = 70001,
+    Heading2 = 70002,
+    Heading3 = 70003,
+    Heading4 = 70004,
+    Heading5 = 70005,
+    Heading6 = 70006,
+    Heading7 = 70007,
+    Heading8 = 70008,
+    Heading9 = 70009,
+    Title = 70010,
+    Subtitle = 70011,
+    Normal = 70012,
+    Emphasis = 70013,
+    Quote = 70014,
+    BulletedList = 70015,
+  }
+
+  enum AutomationTextDecorationLineStyle {
+    None = 0,
+    Single = 1,
+    WordsOnly = 2,
+    Double = 3,
+    Dot = 4,
+    Dash = 5,
+    DashDot = 6,
+    DashDotDot = 7,
+    Wavy = 8,
+    ThickSingle = 9,
+    DoubleWavy = 10,
+    ThickWavy = 11,
+    LongDash = 12,
+    ThickDash = 13,
+    ThickDashDot = 14,
+    ThickDashDotDot = 15,
+    ThickDot = 16,
+    ThickLongDash = 17,
+    Other = 18,
+  }
+
+  enum AutomationTextEditChangeType {
+    None = 0,
+    AutoCorrect = 1,
+    Composition = 2,
+    CompositionFinalized = 3,
+  }
+
+  enum DockPosition {
+    Top = 0,
+    Left = 1,
+    Bottom = 2,
+    Right = 3,
+    Fill = 4,
+    None = 5,
+  }
+
+  enum ExpandCollapseState {
+    Collapsed = 0,
+    Expanded = 1,
+    PartiallyExpanded = 2,
+    LeafNode = 3,
+  }
+
+  enum RowOrColumnMajor {
+    RowMajor = 0,
+    ColumnMajor = 1,
+    Indeterminate = 2,
+  }
+
+  enum ScrollAmount {
+    LargeDecrement = 0,
+    SmallDecrement = 1,
+    NoAmount = 2,
+    LargeIncrement = 3,
+    SmallIncrement = 4,
+  }
+
+  enum SupportedTextSelection {
+    None = 0,
+    Single = 1,
+    Multiple = 2,
+  }
+
+  enum SynchronizedInputType {
+    KeyUp = 1,
+    KeyDown = 2,
+    LeftMouseUp = 4,
+    LeftMouseDown = 8,
+    RightMouseUp = 16,
+    RightMouseDown = 32,
+  }
+
+  enum ToggleState {
+    Off = 0,
+    On = 1,
+    Indeterminate = 2,
+  }
+
+  enum WindowInteractionState {
+    Running = 0,
+    Closing = 1,
+    ReadyForUserInteraction = 2,
+    BlockedByModalWindow = 3,
+    NotResponding = 4,
+  }
+
+  enum WindowVisualState {
+    Normal = 0,
+    Maximized = 1,
+    Minimized = 2,
+  }
+
+  enum ZoomUnit {
+    NoAmount = 0,
+    LargeDecrement = 1,
+    SmallDecrement = 2,
+    LargeIncrement = 3,
+    SmallIncrement = 4,
+  }
+
+  interface IAnnotationPatternIdentifiers {
+  }
+  var IAnnotationPatternIdentifiers: abstract new (...args: any[]) => IAnnotationPatternIdentifiers;
+
+  interface IAnnotationPatternIdentifiersStatics {
+    readonly AnnotationTypeIdProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly AnnotationTypeNameProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly AuthorProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly DateTimeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly TargetProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IAnnotationPatternIdentifiersStatics: abstract new (...args: any[]) => IAnnotationPatternIdentifiersStatics;
+
+  interface IAutomationAnnotation {
+    Element: Windows.UI.Xaml.UIElement;
+    Type: number;
+  }
+  var IAutomationAnnotation: abstract new (...args: any[]) => IAutomationAnnotation;
+
+  interface IAutomationAnnotationFactory {
+    CreateInstance(type: number): Windows.UI.Xaml.Automation.AutomationAnnotation;
+    CreateWithElementParameter(type: number, element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.AutomationAnnotation;
+  }
+  var IAutomationAnnotationFactory: abstract new (...args: any[]) => IAutomationAnnotationFactory;
+
+  interface IAutomationAnnotationStatics {
+    readonly ElementProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TypeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAutomationAnnotationStatics: abstract new (...args: any[]) => IAutomationAnnotationStatics;
+
+  interface IAutomationElementIdentifiers {
+  }
+  var IAutomationElementIdentifiers: abstract new (...args: any[]) => IAutomationElementIdentifiers;
+
+  interface IAutomationElementIdentifiersStatics {
+    readonly AcceleratorKeyProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly AccessKeyProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly AutomationIdProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly BoundingRectangleProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly ClassNameProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly ClickablePointProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly ControlTypeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly HasKeyboardFocusProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly HelpTextProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly IsContentElementProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly IsControlElementProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly IsEnabledProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly IsKeyboardFocusableProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly IsOffscreenProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly IsPasswordProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly IsRequiredForFormProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly ItemStatusProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly ItemTypeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly LabeledByProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly LiveSettingProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly LocalizedControlTypeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly NameProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly OrientationProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IAutomationElementIdentifiersStatics: abstract new (...args: any[]) => IAutomationElementIdentifiersStatics;
+
+  interface IAutomationElementIdentifiersStatics2 {
+    readonly ControlledPeersProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IAutomationElementIdentifiersStatics2: abstract new (...args: any[]) => IAutomationElementIdentifiersStatics2;
+
+  interface IAutomationElementIdentifiersStatics3 {
+    readonly AnnotationsProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly LevelProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly PositionInSetProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly SizeOfSetProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IAutomationElementIdentifiersStatics3: abstract new (...args: any[]) => IAutomationElementIdentifiersStatics3;
+
+  interface IAutomationElementIdentifiersStatics4 {
+    readonly LandmarkTypeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly LocalizedLandmarkTypeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IAutomationElementIdentifiersStatics4: abstract new (...args: any[]) => IAutomationElementIdentifiersStatics4;
+
+  interface IAutomationElementIdentifiersStatics5 {
+    readonly DescribedByProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly FlowsFromProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly FlowsToProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly FullDescriptionProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly IsDataValidForFormProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly IsPeripheralProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IAutomationElementIdentifiersStatics5: abstract new (...args: any[]) => IAutomationElementIdentifiersStatics5;
+
+  interface IAutomationElementIdentifiersStatics6 {
+    readonly CultureProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IAutomationElementIdentifiersStatics6: abstract new (...args: any[]) => IAutomationElementIdentifiersStatics6;
+
+  interface IAutomationElementIdentifiersStatics7 {
+    readonly HeadingLevelProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IAutomationElementIdentifiersStatics7: abstract new (...args: any[]) => IAutomationElementIdentifiersStatics7;
+
+  interface IAutomationElementIdentifiersStatics8 {
+    readonly IsDialogProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IAutomationElementIdentifiersStatics8: abstract new (...args: any[]) => IAutomationElementIdentifiersStatics8;
+
+  interface IAutomationProperties {
+  }
+  var IAutomationProperties: abstract new (...args: any[]) => IAutomationProperties;
+
+  interface IAutomationPropertiesStatics {
+    GetAcceleratorKey(element: Windows.UI.Xaml.DependencyObject): string;
+    GetAccessKey(element: Windows.UI.Xaml.DependencyObject): string;
+    GetAutomationId(element: Windows.UI.Xaml.DependencyObject): string;
+    GetHelpText(element: Windows.UI.Xaml.DependencyObject): string;
+    GetIsRequiredForForm(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetItemStatus(element: Windows.UI.Xaml.DependencyObject): string;
+    GetItemType(element: Windows.UI.Xaml.DependencyObject): string;
+    GetLabeledBy(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.UIElement;
+    GetLiveSetting(element: Windows.UI.Xaml.DependencyObject): number;
+    GetName(element: Windows.UI.Xaml.DependencyObject): string;
+    SetAcceleratorKey(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    SetAccessKey(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    SetAutomationId(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    SetHelpText(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    SetIsRequiredForForm(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetItemStatus(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    SetItemType(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    SetLabeledBy(element: Windows.UI.Xaml.DependencyObject, value: Windows.UI.Xaml.UIElement): void;
+    SetLiveSetting(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    SetName(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    readonly AcceleratorKeyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AccessKeyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AutomationIdProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HelpTextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsRequiredForFormProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemStatusProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemTypeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LabeledByProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LiveSettingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly NameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAutomationPropertiesStatics: abstract new (...args: any[]) => IAutomationPropertiesStatics;
+
+  interface IAutomationPropertiesStatics2 {
+    GetAccessibilityView(element: Windows.UI.Xaml.DependencyObject): number;
+    GetControlledPeers(element: Windows.UI.Xaml.DependencyObject): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.UIElement> | Windows.UI.Xaml.UIElement[];
+    SetAccessibilityView(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    readonly AccessibilityViewProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ControlledPeersProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAutomationPropertiesStatics2: abstract new (...args: any[]) => IAutomationPropertiesStatics2;
+
+  interface IAutomationPropertiesStatics3 {
+    GetAnnotations(element: Windows.UI.Xaml.DependencyObject): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.AutomationAnnotation> | Windows.UI.Xaml.Automation.AutomationAnnotation[];
+    GetLevel(element: Windows.UI.Xaml.DependencyObject): number;
+    GetPositionInSet(element: Windows.UI.Xaml.DependencyObject): number;
+    GetSizeOfSet(element: Windows.UI.Xaml.DependencyObject): number;
+    SetLevel(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    SetPositionInSet(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    SetSizeOfSet(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    readonly AnnotationsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LevelProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PositionInSetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SizeOfSetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAutomationPropertiesStatics3: abstract new (...args: any[]) => IAutomationPropertiesStatics3;
+
+  interface IAutomationPropertiesStatics4 {
+    GetLandmarkType(element: Windows.UI.Xaml.DependencyObject): number;
+    GetLocalizedLandmarkType(element: Windows.UI.Xaml.DependencyObject): string;
+    SetLandmarkType(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    SetLocalizedLandmarkType(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    readonly LandmarkTypeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LocalizedLandmarkTypeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAutomationPropertiesStatics4: abstract new (...args: any[]) => IAutomationPropertiesStatics4;
+
+  interface IAutomationPropertiesStatics5 {
+    GetDescribedBy(element: Windows.UI.Xaml.DependencyObject): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetFlowsFrom(element: Windows.UI.Xaml.DependencyObject): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetFlowsTo(element: Windows.UI.Xaml.DependencyObject): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetFullDescription(element: Windows.UI.Xaml.DependencyObject): string;
+    GetIsDataValidForForm(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetIsPeripheral(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetLocalizedControlType(element: Windows.UI.Xaml.DependencyObject): string;
+    SetFullDescription(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    SetIsDataValidForForm(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetIsPeripheral(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetLocalizedControlType(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    readonly DescribedByProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FlowsFromProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FlowsToProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FullDescriptionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsDataValidForFormProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsPeripheralProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LocalizedControlTypeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAutomationPropertiesStatics5: abstract new (...args: any[]) => IAutomationPropertiesStatics5;
+
+  interface IAutomationPropertiesStatics6 {
+    GetCulture(element: Windows.UI.Xaml.DependencyObject): number;
+    SetCulture(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    readonly CultureProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAutomationPropertiesStatics6: abstract new (...args: any[]) => IAutomationPropertiesStatics6;
+
+  interface IAutomationPropertiesStatics7 {
+    GetHeadingLevel(element: Windows.UI.Xaml.DependencyObject): number;
+    SetHeadingLevel(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    readonly HeadingLevelProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAutomationPropertiesStatics7: abstract new (...args: any[]) => IAutomationPropertiesStatics7;
+
+  interface IAutomationPropertiesStatics8 {
+    GetIsDialog(element: Windows.UI.Xaml.DependencyObject): boolean;
+    SetIsDialog(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    readonly IsDialogProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAutomationPropertiesStatics8: abstract new (...args: any[]) => IAutomationPropertiesStatics8;
+
+  interface IAutomationPropertiesStatics9 {
+    GetAutomationControlType(element: Windows.UI.Xaml.UIElement): number;
+    SetAutomationControlType(element: Windows.UI.Xaml.UIElement, value: number): void;
+    readonly AutomationControlTypeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAutomationPropertiesStatics9: abstract new (...args: any[]) => IAutomationPropertiesStatics9;
+
+  interface IAutomationProperty {
+  }
+  var IAutomationProperty: abstract new (...args: any[]) => IAutomationProperty;
+
+  interface IDockPatternIdentifiers {
+  }
+  var IDockPatternIdentifiers: abstract new (...args: any[]) => IDockPatternIdentifiers;
+
+  interface IDockPatternIdentifiersStatics {
+    readonly DockPositionProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IDockPatternIdentifiersStatics: abstract new (...args: any[]) => IDockPatternIdentifiersStatics;
+
+  interface IDragPatternIdentifiers {
+  }
+  var IDragPatternIdentifiers: abstract new (...args: any[]) => IDragPatternIdentifiers;
+
+  interface IDragPatternIdentifiersStatics {
+    readonly DropEffectProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly DropEffectsProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly GrabbedItemsProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly IsGrabbedProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IDragPatternIdentifiersStatics: abstract new (...args: any[]) => IDragPatternIdentifiersStatics;
+
+  interface IDropTargetPatternIdentifiers {
+  }
+  var IDropTargetPatternIdentifiers: abstract new (...args: any[]) => IDropTargetPatternIdentifiers;
+
+  interface IDropTargetPatternIdentifiersStatics {
+    readonly DropTargetEffectProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly DropTargetEffectsProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IDropTargetPatternIdentifiersStatics: abstract new (...args: any[]) => IDropTargetPatternIdentifiersStatics;
+
+  interface IExpandCollapsePatternIdentifiers {
+  }
+  var IExpandCollapsePatternIdentifiers: abstract new (...args: any[]) => IExpandCollapsePatternIdentifiers;
+
+  interface IExpandCollapsePatternIdentifiersStatics {
+    readonly ExpandCollapseStateProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IExpandCollapsePatternIdentifiersStatics: abstract new (...args: any[]) => IExpandCollapsePatternIdentifiersStatics;
+
+  interface IGridItemPatternIdentifiers {
+  }
+  var IGridItemPatternIdentifiers: abstract new (...args: any[]) => IGridItemPatternIdentifiers;
+
+  interface IGridItemPatternIdentifiersStatics {
+    readonly ColumnProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly ColumnSpanProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly ContainingGridProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly RowProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly RowSpanProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IGridItemPatternIdentifiersStatics: abstract new (...args: any[]) => IGridItemPatternIdentifiersStatics;
+
+  interface IGridPatternIdentifiers {
+  }
+  var IGridPatternIdentifiers: abstract new (...args: any[]) => IGridPatternIdentifiers;
+
+  interface IGridPatternIdentifiersStatics {
+    readonly ColumnCountProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly RowCountProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IGridPatternIdentifiersStatics: abstract new (...args: any[]) => IGridPatternIdentifiersStatics;
+
+  interface IMultipleViewPatternIdentifiers {
+  }
+  var IMultipleViewPatternIdentifiers: abstract new (...args: any[]) => IMultipleViewPatternIdentifiers;
+
+  interface IMultipleViewPatternIdentifiersStatics {
+    readonly CurrentViewProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly SupportedViewsProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IMultipleViewPatternIdentifiersStatics: abstract new (...args: any[]) => IMultipleViewPatternIdentifiersStatics;
+
+  interface IRangeValuePatternIdentifiers {
+  }
+  var IRangeValuePatternIdentifiers: abstract new (...args: any[]) => IRangeValuePatternIdentifiers;
+
+  interface IRangeValuePatternIdentifiersStatics {
+    readonly IsReadOnlyProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly LargeChangeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly MaximumProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly MinimumProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly SmallChangeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly ValueProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IRangeValuePatternIdentifiersStatics: abstract new (...args: any[]) => IRangeValuePatternIdentifiersStatics;
+
+  interface IScrollPatternIdentifiers {
+  }
+  var IScrollPatternIdentifiers: abstract new (...args: any[]) => IScrollPatternIdentifiers;
+
+  interface IScrollPatternIdentifiersStatics {
+    readonly HorizontalScrollPercentProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly HorizontalViewSizeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly HorizontallyScrollableProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly NoScroll: number;
+    readonly VerticalScrollPercentProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly VerticalViewSizeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly VerticallyScrollableProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IScrollPatternIdentifiersStatics: abstract new (...args: any[]) => IScrollPatternIdentifiersStatics;
+
+  interface ISelectionItemPatternIdentifiers {
+  }
+  var ISelectionItemPatternIdentifiers: abstract new (...args: any[]) => ISelectionItemPatternIdentifiers;
+
+  interface ISelectionItemPatternIdentifiersStatics {
+    readonly IsSelectedProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly SelectionContainerProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var ISelectionItemPatternIdentifiersStatics: abstract new (...args: any[]) => ISelectionItemPatternIdentifiersStatics;
+
+  interface ISelectionPatternIdentifiers {
+  }
+  var ISelectionPatternIdentifiers: abstract new (...args: any[]) => ISelectionPatternIdentifiers;
+
+  interface ISelectionPatternIdentifiersStatics {
+    readonly CanSelectMultipleProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly IsSelectionRequiredProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly SelectionProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var ISelectionPatternIdentifiersStatics: abstract new (...args: any[]) => ISelectionPatternIdentifiersStatics;
+
+  interface ISpreadsheetItemPatternIdentifiers {
+  }
+  var ISpreadsheetItemPatternIdentifiers: abstract new (...args: any[]) => ISpreadsheetItemPatternIdentifiers;
+
+  interface ISpreadsheetItemPatternIdentifiersStatics {
+    readonly FormulaProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var ISpreadsheetItemPatternIdentifiersStatics: abstract new (...args: any[]) => ISpreadsheetItemPatternIdentifiersStatics;
+
+  interface IStylesPatternIdentifiers {
+  }
+  var IStylesPatternIdentifiers: abstract new (...args: any[]) => IStylesPatternIdentifiers;
+
+  interface IStylesPatternIdentifiersStatics {
+    readonly ExtendedPropertiesProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly FillColorProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly FillPatternColorProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly FillPatternStyleProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly ShapeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly StyleIdProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly StyleNameProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IStylesPatternIdentifiersStatics: abstract new (...args: any[]) => IStylesPatternIdentifiersStatics;
+
+  interface ITableItemPatternIdentifiers {
+  }
+  var ITableItemPatternIdentifiers: abstract new (...args: any[]) => ITableItemPatternIdentifiers;
+
+  interface ITableItemPatternIdentifiersStatics {
+    readonly ColumnHeaderItemsProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly RowHeaderItemsProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var ITableItemPatternIdentifiersStatics: abstract new (...args: any[]) => ITableItemPatternIdentifiersStatics;
+
+  interface ITablePatternIdentifiers {
+  }
+  var ITablePatternIdentifiers: abstract new (...args: any[]) => ITablePatternIdentifiers;
+
+  interface ITablePatternIdentifiersStatics {
+    readonly ColumnHeadersProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly RowHeadersProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly RowOrColumnMajorProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var ITablePatternIdentifiersStatics: abstract new (...args: any[]) => ITablePatternIdentifiersStatics;
+
+  interface ITogglePatternIdentifiers {
+  }
+  var ITogglePatternIdentifiers: abstract new (...args: any[]) => ITogglePatternIdentifiers;
+
+  interface ITogglePatternIdentifiersStatics {
+    readonly ToggleStateProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var ITogglePatternIdentifiersStatics: abstract new (...args: any[]) => ITogglePatternIdentifiersStatics;
+
+  interface ITransformPattern2Identifiers {
+  }
+  var ITransformPattern2Identifiers: abstract new (...args: any[]) => ITransformPattern2Identifiers;
+
+  interface ITransformPattern2IdentifiersStatics {
+    readonly CanZoomProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly MaxZoomProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly MinZoomProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly ZoomLevelProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var ITransformPattern2IdentifiersStatics: abstract new (...args: any[]) => ITransformPattern2IdentifiersStatics;
+
+  interface ITransformPatternIdentifiers {
+  }
+  var ITransformPatternIdentifiers: abstract new (...args: any[]) => ITransformPatternIdentifiers;
+
+  interface ITransformPatternIdentifiersStatics {
+    readonly CanMoveProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly CanResizeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly CanRotateProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var ITransformPatternIdentifiersStatics: abstract new (...args: any[]) => ITransformPatternIdentifiersStatics;
+
+  interface IValuePatternIdentifiers {
+  }
+  var IValuePatternIdentifiers: abstract new (...args: any[]) => IValuePatternIdentifiers;
+
+  interface IValuePatternIdentifiersStatics {
+    readonly IsReadOnlyProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly ValueProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IValuePatternIdentifiersStatics: abstract new (...args: any[]) => IValuePatternIdentifiersStatics;
+
+  interface IWindowPatternIdentifiers {
+  }
+  var IWindowPatternIdentifiers: abstract new (...args: any[]) => IWindowPatternIdentifiers;
+
+  interface IWindowPatternIdentifiersStatics {
+    readonly CanMaximizeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly CanMinimizeProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly IsModalProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly IsTopmostProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly WindowInteractionStateProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+    readonly WindowVisualStateProperty: Windows.UI.Xaml.Automation.AutomationProperty;
+  }
+  var IWindowPatternIdentifiersStatics: abstract new (...args: any[]) => IWindowPatternIdentifiersStatics;
+
+}
+
+declare namespace Windows.UI.Xaml.Automation.Peers {
+  class AppBarAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IAppBarAutomationPeer, Windows.UI.Xaml.Automation.Provider.IExpandCollapseProvider, Windows.UI.Xaml.Automation.Provider.IToggleProvider, Windows.UI.Xaml.Automation.Provider.IWindowProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.AppBar);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Close(): void;
+    Collapse(): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    Expand(): void;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    SetVisualState(state: number): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    Toggle(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    WaitForInputIdle(milliseconds: number): boolean;
+    readonly ExpandCollapseState: number;
+    readonly InteractionState: number;
+    readonly IsModal: boolean;
+    readonly IsTopmost: boolean;
+    readonly Maximizable: boolean;
+    readonly Minimizable: boolean;
+    readonly ToggleState: number;
+    readonly VisualState: number;
+  }
+
+  class AppBarButtonAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ButtonAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IAppBarButtonAutomationPeer, Windows.UI.Xaml.Automation.Provider.IExpandCollapseProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.AppBarButton);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Collapse(): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    Expand(): void;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    Invoke(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly ExpandCollapseState: number;
+  }
+
+  class AppBarToggleButtonAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ToggleButtonAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IAppBarToggleButtonAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.AppBarToggleButton);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    Toggle(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class AutoSuggestBoxAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IAutoSuggestBoxAutomationPeer, Windows.UI.Xaml.Automation.Provider.IInvokeProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.AutoSuggestBox);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    Invoke(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class AutomationPeer extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Automation.Peers.IAutomationPeer, Windows.UI.Xaml.Automation.Peers.IAutomationPeer2, Windows.UI.Xaml.Automation.Peers.IAutomationPeer3, Windows.UI.Xaml.Automation.Peers.IAutomationPeer4, Windows.UI.Xaml.Automation.Peers.IAutomationPeer5, Windows.UI.Xaml.Automation.Peers.IAutomationPeer6, Windows.UI.Xaml.Automation.Peers.IAutomationPeer7, Windows.UI.Xaml.Automation.Peers.IAutomationPeer8, Windows.UI.Xaml.Automation.Peers.IAutomationPeer9, Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides, Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides2, Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides3, Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides4, Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides5, Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides6, Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides8, Windows.UI.Xaml.Automation.Peers.IAutomationPeerOverrides9, Windows.UI.Xaml.Automation.Peers.IAutomationPeerProtected {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    EventsSource: Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+  }
+
+  class AutomationPeerAnnotation extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Automation.Peers.IAutomationPeerAnnotation {
+    constructor(type: number);
+    constructor(type: number, peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer);
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static readonly PeerProperty: Windows.UI.Xaml.DependencyProperty;
+    Type: number;
+    static readonly TypeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ButtonAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ButtonBaseAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IButtonAutomationPeer, Windows.UI.Xaml.Automation.Provider.IInvokeProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.Button);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    Invoke(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ButtonBaseAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IButtonBaseAutomationPeer {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class CalendarDatePickerAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.ICalendarDatePickerAutomationPeer, Windows.UI.Xaml.Automation.Provider.IInvokeProvider, Windows.UI.Xaml.Automation.Provider.IValueProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.CalendarDatePicker);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    Invoke(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(value: string): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly IsReadOnly: boolean;
+    readonly Value: string;
+  }
+
+  class CaptureElementAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.ICaptureElementAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.CaptureElement);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class CheckBoxAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ToggleButtonAutomationPeer implements Windows.UI.Xaml.Automation.Peers.ICheckBoxAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.CheckBox);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    Toggle(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ColorPickerSliderAutomationPeer extends Windows.UI.Xaml.Automation.Peers.SliderAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IColorPickerSliderAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.Primitives.ColorPickerSlider);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(value: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ColorSpectrumAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IColorSpectrumAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.Primitives.ColorSpectrum);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ComboBoxAutomationPeer extends Windows.UI.Xaml.Automation.Peers.SelectorAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IComboBoxAutomationPeer, Windows.UI.Xaml.Automation.Provider.IExpandCollapseProvider, Windows.UI.Xaml.Automation.Provider.IValueProvider, Windows.UI.Xaml.Automation.Provider.IWindowProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.ComboBox);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Close(): void;
+    Collapse(): void;
+    CreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    Expand(): void;
+    FindItemByProperty(startAfter: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple, automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, value: Object): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSelection(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    OnCreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(value: string): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    SetVisualState(state: number): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    WaitForInputIdle(milliseconds: number): boolean;
+    readonly ExpandCollapseState: number;
+    readonly InteractionState: number;
+    readonly IsModal: boolean;
+    readonly IsReadOnly: boolean;
+    readonly IsTopmost: boolean;
+    readonly Maximizable: boolean;
+    readonly Minimizable: boolean;
+    readonly Value: string;
+    readonly VisualState: number;
+  }
+
+  class ComboBoxItemAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IComboBoxItemAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.ComboBoxItem);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ComboBoxItemDataAutomationPeer extends Windows.UI.Xaml.Automation.Peers.SelectorItemAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IComboBoxItemDataAutomationPeer, Windows.UI.Xaml.Automation.Provider.IScrollItemProvider {
+    constructor(item: Object, parent: Windows.UI.Xaml.Automation.Peers.ComboBoxAutomationPeer);
+    AddToSelection(): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Realize(): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    RemoveFromSelection(): void;
+    ScrollIntoView(): void;
+    Select(): void;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class DatePickerAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IDatePickerAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.DatePicker);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class DatePickerFlyoutPresenterAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IDatePickerFlyoutPresenterAutomationPeer {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class FlipViewAutomationPeer extends Windows.UI.Xaml.Automation.Peers.SelectorAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IFlipViewAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.FlipView);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    FindItemByProperty(startAfter: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple, automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, value: Object): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSelection(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    OnCreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class FlipViewItemAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IFlipViewItemAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.FlipViewItem);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class FlipViewItemDataAutomationPeer extends Windows.UI.Xaml.Automation.Peers.SelectorItemAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IFlipViewItemDataAutomationPeer, Windows.UI.Xaml.Automation.Provider.IScrollItemProvider {
+    constructor(item: Object, parent: Windows.UI.Xaml.Automation.Peers.FlipViewAutomationPeer);
+    AddToSelection(): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Realize(): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    RemoveFromSelection(): void;
+    ScrollIntoView(): void;
+    Select(): void;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class FlyoutPresenterAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IFlyoutPresenterAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.FlyoutPresenter);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class FrameworkElementAutomationPeer extends Windows.UI.Xaml.Automation.Peers.AutomationPeer implements Windows.UI.Xaml.Automation.Peers.IFrameworkElementAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.FrameworkElement);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly Owner: Windows.UI.Xaml.UIElement;
+  }
+
+  class GridViewAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ListViewBaseAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IGridViewAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.GridView);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    FindItemByProperty(startAfter: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple, automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, value: Object): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSelection(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    OnCreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class GridViewHeaderItemAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ListViewBaseHeaderItemAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IGridViewHeaderItemAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.GridViewHeaderItem);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class GridViewItemAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IGridViewItemAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.GridViewItem);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class GridViewItemDataAutomationPeer extends Windows.UI.Xaml.Automation.Peers.SelectorItemAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IGridViewItemDataAutomationPeer, Windows.UI.Xaml.Automation.Provider.IScrollItemProvider {
+    constructor(item: Object, parent: Windows.UI.Xaml.Automation.Peers.GridViewAutomationPeer);
+    AddToSelection(): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Realize(): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    RemoveFromSelection(): void;
+    ScrollIntoView(): void;
+    Select(): void;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class GroupItemAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IGroupItemAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.GroupItem);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class HubAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IHubAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.Hub);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class HubSectionAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IHubSectionAutomationPeer, Windows.UI.Xaml.Automation.Provider.IScrollItemProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.HubSection);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ScrollIntoView(): void;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class HyperlinkButtonAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ButtonBaseAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IHyperlinkButtonAutomationPeer, Windows.UI.Xaml.Automation.Provider.IInvokeProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.HyperlinkButton);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    Invoke(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ImageAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IImageAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.Image);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class InkToolbarAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IInkToolbarAutomationPeer {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ItemAutomationPeer extends Windows.UI.Xaml.Automation.Peers.AutomationPeer implements Windows.UI.Xaml.Automation.Peers.IItemAutomationPeer, Windows.UI.Xaml.Automation.Provider.IVirtualizedItemProvider {
+    constructor(item: Object, parent: Windows.UI.Xaml.Automation.Peers.ItemsControlAutomationPeer);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Realize(): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly Item: Object;
+    readonly ItemsControlAutomationPeer: Windows.UI.Xaml.Automation.Peers.ItemsControlAutomationPeer;
+  }
+
+  class ItemsControlAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IItemsControlAutomationPeer, Windows.UI.Xaml.Automation.Peers.IItemsControlAutomationPeer2, Windows.UI.Xaml.Automation.Peers.IItemsControlAutomationPeerOverrides2, Windows.UI.Xaml.Automation.Provider.IItemContainerProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.ItemsControl);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    FindItemByProperty(startAfter: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple, automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, value: Object): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    OnCreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ListBoxAutomationPeer extends Windows.UI.Xaml.Automation.Peers.SelectorAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IListBoxAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.ListBox);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    FindItemByProperty(startAfter: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple, automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, value: Object): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSelection(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    OnCreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ListBoxItemAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IListBoxItemAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.ListBoxItem);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ListBoxItemDataAutomationPeer extends Windows.UI.Xaml.Automation.Peers.SelectorItemAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IListBoxItemDataAutomationPeer, Windows.UI.Xaml.Automation.Provider.IScrollItemProvider {
+    constructor(item: Object, parent: Windows.UI.Xaml.Automation.Peers.ListBoxAutomationPeer);
+    AddToSelection(): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Realize(): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    RemoveFromSelection(): void;
+    ScrollIntoView(): void;
+    Select(): void;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ListPickerFlyoutPresenterAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IListPickerFlyoutPresenterAutomationPeer {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ListViewAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ListViewBaseAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IListViewAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.ListView);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    FindItemByProperty(startAfter: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple, automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, value: Object): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSelection(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    OnCreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ListViewBaseAutomationPeer extends Windows.UI.Xaml.Automation.Peers.SelectorAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IListViewBaseAutomationPeer, Windows.UI.Xaml.Automation.Provider.IDropTargetProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.ListViewBase);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    FindItemByProperty(startAfter: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple, automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, value: Object): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSelection(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    OnCreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly DropEffect: string;
+    readonly DropEffects: string[];
+  }
+
+  class ListViewBaseHeaderItemAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IListViewBaseHeaderItemAutomationPeer {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ListViewHeaderItemAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ListViewBaseHeaderItemAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IListViewHeaderItemAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.ListViewHeaderItem);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ListViewItemAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IListViewItemAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.ListViewItem);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ListViewItemDataAutomationPeer extends Windows.UI.Xaml.Automation.Peers.SelectorItemAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IListViewItemDataAutomationPeer, Windows.UI.Xaml.Automation.Provider.IScrollItemProvider {
+    constructor(item: Object, parent: Windows.UI.Xaml.Automation.Peers.ListViewBaseAutomationPeer);
+    AddToSelection(): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Realize(): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    RemoveFromSelection(): void;
+    ScrollIntoView(): void;
+    Select(): void;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class LoopingSelectorAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.ILoopingSelectorAutomationPeer, Windows.UI.Xaml.Automation.Provider.IExpandCollapseProvider, Windows.UI.Xaml.Automation.Provider.IItemContainerProvider, Windows.UI.Xaml.Automation.Provider.IScrollProvider, Windows.UI.Xaml.Automation.Provider.ISelectionProvider {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Collapse(): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    Expand(): void;
+    FindItemByProperty(startAfter: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple, automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, value: Object): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSelection(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    Scroll(horizontalAmount: number, verticalAmount: number): void;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetScrollPercent(horizontalPercent: number, verticalPercent: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly CanSelectMultiple: boolean;
+    readonly ExpandCollapseState: number;
+    readonly HorizontalScrollPercent: number;
+    readonly HorizontalViewSize: number;
+    readonly HorizontallyScrollable: boolean;
+    readonly IsSelectionRequired: boolean;
+    readonly VerticalScrollPercent: number;
+    readonly VerticalViewSize: number;
+    readonly VerticallyScrollable: boolean;
+  }
+
+  class LoopingSelectorItemAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.ILoopingSelectorItemAutomationPeer, Windows.UI.Xaml.Automation.Provider.IScrollItemProvider, Windows.UI.Xaml.Automation.Provider.ISelectionItemProvider {
+    AddToSelection(): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    RemoveFromSelection(): void;
+    ScrollIntoView(): void;
+    Select(): void;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly IsSelected: boolean;
+    readonly SelectionContainer: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+  }
+
+  class LoopingSelectorItemDataAutomationPeer extends Windows.UI.Xaml.Automation.Peers.AutomationPeer implements Windows.UI.Xaml.Automation.Peers.ILoopingSelectorItemDataAutomationPeer, Windows.UI.Xaml.Automation.Provider.IVirtualizedItemProvider {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Realize(): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class MapControlAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IMapControlAutomationPeer, Windows.UI.Xaml.Automation.Provider.IScrollProvider, Windows.UI.Xaml.Automation.Provider.ITransformProvider, Windows.UI.Xaml.Automation.Provider.ITransformProvider2 {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Move(x: number, y: number): void;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    Resize(width: number, height: number): void;
+    Rotate(degrees: number): void;
+    Scroll(horizontalAmount: number, verticalAmount: number): void;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetScrollPercent(horizontalPercent: number, verticalPercent: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Zoom(zoom: number): void;
+    ZoomByUnit(zoomUnit: number): void;
+    readonly CanMove: boolean;
+    readonly CanResize: boolean;
+    readonly CanRotate: boolean;
+    readonly CanZoom: boolean;
+    readonly HorizontalScrollPercent: number;
+    readonly HorizontalViewSize: number;
+    readonly HorizontallyScrollable: boolean;
+    readonly MaxZoom: number;
+    readonly MinZoom: number;
+    readonly VerticalScrollPercent: number;
+    readonly VerticalViewSize: number;
+    readonly VerticallyScrollable: boolean;
+    readonly ZoomLevel: number;
+  }
+
+  class MediaElementAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IMediaElementAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.MediaElement);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class MediaPlayerElementAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IMediaPlayerElementAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.MediaPlayerElement);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class MediaTransportControlsAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IMediaTransportControlsAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.MediaTransportControls);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class MenuBarAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IMenuBarAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.MenuBar);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class MenuBarItemAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IMenuBarItemAutomationPeer, Windows.UI.Xaml.Automation.Provider.IExpandCollapseProvider, Windows.UI.Xaml.Automation.Provider.IInvokeProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.MenuBarItem);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Collapse(): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    Expand(): void;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    Invoke(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly ExpandCollapseState: number;
+  }
+
+  class MenuFlyoutItemAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IMenuFlyoutItemAutomationPeer, Windows.UI.Xaml.Automation.Provider.IInvokeProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.MenuFlyoutItem);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    Invoke(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class MenuFlyoutPresenterAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ItemsControlAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IMenuFlyoutPresenterAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.MenuFlyoutPresenter);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    FindItemByProperty(startAfter: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple, automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, value: Object): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    OnCreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class NavigationViewItemAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ListViewItemAutomationPeer implements Windows.UI.Xaml.Automation.Peers.INavigationViewItemAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.NavigationViewItem);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class PasswordBoxAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IPasswordBoxAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.PasswordBox);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class PersonPictureAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IPersonPictureAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.PersonPicture);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class PickerFlyoutPresenterAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IPickerFlyoutPresenterAutomationPeer {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class PivotAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ItemsControlAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IPivotAutomationPeer, Windows.UI.Xaml.Automation.Provider.IScrollProvider, Windows.UI.Xaml.Automation.Provider.ISelectionProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.Pivot);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    FindItemByProperty(startAfter: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple, automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, value: Object): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSelection(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    OnCreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    Scroll(horizontalAmount: number, verticalAmount: number): void;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetScrollPercent(horizontalPercent: number, verticalPercent: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly CanSelectMultiple: boolean;
+    readonly HorizontalScrollPercent: number;
+    readonly HorizontalViewSize: number;
+    readonly HorizontallyScrollable: boolean;
+    readonly IsSelectionRequired: boolean;
+    readonly VerticalScrollPercent: number;
+    readonly VerticalViewSize: number;
+    readonly VerticallyScrollable: boolean;
+  }
+
+  class PivotItemAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IPivotItemAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.PivotItem);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class PivotItemDataAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IPivotItemDataAutomationPeer, Windows.UI.Xaml.Automation.Provider.IScrollItemProvider, Windows.UI.Xaml.Automation.Provider.ISelectionItemProvider, Windows.UI.Xaml.Automation.Provider.IVirtualizedItemProvider {
+    constructor(item: Object, parent: Windows.UI.Xaml.Automation.Peers.PivotAutomationPeer);
+    AddToSelection(): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Realize(): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    RemoveFromSelection(): void;
+    ScrollIntoView(): void;
+    Select(): void;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly IsSelected: boolean;
+    readonly SelectionContainer: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+  }
+
+  class ProgressBarAutomationPeer extends Windows.UI.Xaml.Automation.Peers.RangeBaseAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IProgressBarAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.ProgressBar);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(value: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ProgressRingAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IProgressRingAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.ProgressRing);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class RadioButtonAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ToggleButtonAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IRadioButtonAutomationPeer, Windows.UI.Xaml.Automation.Provider.ISelectionItemProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.RadioButton);
+    AddToSelection(): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    RemoveFromSelection(): void;
+    Select(): void;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    Toggle(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly IsSelected: boolean;
+    readonly SelectionContainer: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+  }
+
+  class RangeBaseAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IRangeBaseAutomationPeer, Windows.UI.Xaml.Automation.Provider.IRangeValueProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.Primitives.RangeBase);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(value: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly IsReadOnly: boolean;
+    readonly LargeChange: number;
+    readonly Maximum: number;
+    readonly Minimum: number;
+    readonly SmallChange: number;
+    readonly Value: number;
+  }
+
+  class RatingControlAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IRatingControlAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.RatingControl);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class RepeatButtonAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ButtonBaseAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IRepeatButtonAutomationPeer, Windows.UI.Xaml.Automation.Provider.IInvokeProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.Primitives.RepeatButton);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    Invoke(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class RichEditBoxAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IRichEditBoxAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.RichEditBox);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class RichTextBlockAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IRichTextBlockAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.RichTextBlock);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class RichTextBlockOverflowAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IRichTextBlockOverflowAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.RichTextBlockOverflow);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ScrollBarAutomationPeer extends Windows.UI.Xaml.Automation.Peers.RangeBaseAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IScrollBarAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.Primitives.ScrollBar);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(value: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ScrollViewerAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IScrollViewerAutomationPeer, Windows.UI.Xaml.Automation.Provider.IScrollProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.ScrollViewer);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    Scroll(horizontalAmount: number, verticalAmount: number): void;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetScrollPercent(horizontalPercent: number, verticalPercent: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly HorizontalScrollPercent: number;
+    readonly HorizontalViewSize: number;
+    readonly HorizontallyScrollable: boolean;
+    readonly VerticalScrollPercent: number;
+    readonly VerticalViewSize: number;
+    readonly VerticallyScrollable: boolean;
+  }
+
+  class SearchBoxAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.ISearchBoxAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.SearchBox);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class SelectorAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ItemsControlAutomationPeer implements Windows.UI.Xaml.Automation.Peers.ISelectorAutomationPeer, Windows.UI.Xaml.Automation.Provider.ISelectionProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.Primitives.Selector);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    FindItemByProperty(startAfter: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple, automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, value: Object): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSelection(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    OnCreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly CanSelectMultiple: boolean;
+    readonly IsSelectionRequired: boolean;
+  }
+
+  class SelectorItemAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer implements Windows.UI.Xaml.Automation.Peers.ISelectorItemAutomationPeer, Windows.UI.Xaml.Automation.Provider.ISelectionItemProvider {
+    constructor(item: Object, parent: Windows.UI.Xaml.Automation.Peers.SelectorAutomationPeer);
+    AddToSelection(): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Realize(): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    RemoveFromSelection(): void;
+    Select(): void;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly IsSelected: boolean;
+    readonly SelectionContainer: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+  }
+
+  class SemanticZoomAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.ISemanticZoomAutomationPeer, Windows.UI.Xaml.Automation.Provider.IToggleProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.SemanticZoom);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    Toggle(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly ToggleState: number;
+  }
+
+  class SettingsFlyoutAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.ISettingsFlyoutAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.SettingsFlyout);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class SliderAutomationPeer extends Windows.UI.Xaml.Automation.Peers.RangeBaseAutomationPeer implements Windows.UI.Xaml.Automation.Peers.ISliderAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.Slider);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(value: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class TextBlockAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.ITextBlockAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.TextBlock);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class TextBoxAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.ITextBoxAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.TextBox);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ThumbAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IThumbAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.Primitives.Thumb);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class TimePickerAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.ITimePickerAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.TimePicker);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class TimePickerFlyoutPresenterAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.ITimePickerFlyoutPresenterAutomationPeer {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ToggleButtonAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ButtonBaseAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IToggleButtonAutomationPeer, Windows.UI.Xaml.Automation.Provider.IToggleProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.Primitives.ToggleButton);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    Toggle(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly ToggleState: number;
+  }
+
+  class ToggleMenuFlyoutItemAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IToggleMenuFlyoutItemAutomationPeer, Windows.UI.Xaml.Automation.Provider.IToggleProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.ToggleMenuFlyoutItem);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    Toggle(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly ToggleState: number;
+  }
+
+  class ToggleSwitchAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Peers.IToggleSwitchAutomationPeer, Windows.UI.Xaml.Automation.Provider.IToggleProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.ToggleSwitch);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    Toggle(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly ToggleState: number;
+  }
+
+  class TreeViewItemAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ListViewItemAutomationPeer implements Windows.UI.Xaml.Automation.Peers.ITreeViewItemAutomationPeer, Windows.UI.Xaml.Automation.Provider.IExpandCollapseProvider {
+    constructor(owner: Windows.UI.Xaml.Controls.TreeViewItem);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Collapse(): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    Expand(): void;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly ExpandCollapseState: number;
+  }
+
+  class TreeViewListAutomationPeer extends Windows.UI.Xaml.Automation.Peers.SelectorAutomationPeer implements Windows.UI.Xaml.Automation.Peers.ITreeViewListAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.TreeViewList);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    FindItemByProperty(startAfter: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple, automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, value: Object): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSelection(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    OnCreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  enum AccessibilityView {
+    Raw = 0,
+    Control = 1,
+    Content = 2,
+  }
+
+  enum AutomationControlType {
+    Button = 0,
+    Calendar = 1,
+    CheckBox = 2,
+    ComboBox = 3,
+    Edit = 4,
+    Hyperlink = 5,
+    Image = 6,
+    ListItem = 7,
+    List = 8,
+    Menu = 9,
+    MenuBar = 10,
+    MenuItem = 11,
+    ProgressBar = 12,
+    RadioButton = 13,
+    ScrollBar = 14,
+    Slider = 15,
+    Spinner = 16,
+    StatusBar = 17,
+    Tab = 18,
+    TabItem = 19,
+    Text = 20,
+    ToolBar = 21,
+    ToolTip = 22,
+    Tree = 23,
+    TreeItem = 24,
+    Custom = 25,
+    Group = 26,
+    Thumb = 27,
+    DataGrid = 28,
+    DataItem = 29,
+    Document = 30,
+    SplitButton = 31,
+    Window = 32,
+    Pane = 33,
+    Header = 34,
+    HeaderItem = 35,
+    Table = 36,
+    TitleBar = 37,
+    Separator = 38,
+    SemanticZoom = 39,
+    AppBar = 40,
+  }
+
+  enum AutomationEvents {
+    ToolTipOpened = 0,
+    ToolTipClosed = 1,
+    MenuOpened = 2,
+    MenuClosed = 3,
+    AutomationFocusChanged = 4,
+    InvokePatternOnInvoked = 5,
+    SelectionItemPatternOnElementAddedToSelection = 6,
+    SelectionItemPatternOnElementRemovedFromSelection = 7,
+    SelectionItemPatternOnElementSelected = 8,
+    SelectionPatternOnInvalidated = 9,
+    TextPatternOnTextSelectionChanged = 10,
+    TextPatternOnTextChanged = 11,
+    AsyncContentLoaded = 12,
+    PropertyChanged = 13,
+    StructureChanged = 14,
+    DragStart = 15,
+    DragCancel = 16,
+    DragComplete = 17,
+    DragEnter = 18,
+    DragLeave = 19,
+    Dropped = 20,
+    LiveRegionChanged = 21,
+    InputReachedTarget = 22,
+    InputReachedOtherElement = 23,
+    InputDiscarded = 24,
+    WindowClosed = 25,
+    WindowOpened = 26,
+    ConversionTargetChanged = 27,
+    TextEditTextChanged = 28,
+    LayoutInvalidated = 29,
+  }
+
+  enum AutomationHeadingLevel {
+    None = 0,
+    Level1 = 1,
+    Level2 = 2,
+    Level3 = 3,
+    Level4 = 4,
+    Level5 = 5,
+    Level6 = 6,
+    Level7 = 7,
+    Level8 = 8,
+    Level9 = 9,
+  }
+
+  enum AutomationLandmarkType {
+    None = 0,
+    Custom = 1,
+    Form = 2,
+    Main = 3,
+    Navigation = 4,
+    Search = 5,
+  }
+
+  enum AutomationLiveSetting {
+    Off = 0,
+    Polite = 1,
+    Assertive = 2,
+  }
+
+  enum AutomationNavigationDirection {
+    Parent = 0,
+    NextSibling = 1,
+    PreviousSibling = 2,
+    FirstChild = 3,
+    LastChild = 4,
+  }
+
+  enum AutomationNotificationKind {
+    ItemAdded = 0,
+    ItemRemoved = 1,
+    ActionCompleted = 2,
+    ActionAborted = 3,
+    Other = 4,
+  }
+
+  enum AutomationNotificationProcessing {
+    ImportantAll = 0,
+    ImportantMostRecent = 1,
+    All = 2,
+    MostRecent = 3,
+    CurrentThenMostRecent = 4,
+  }
+
+  enum AutomationOrientation {
+    None = 0,
+    Horizontal = 1,
+    Vertical = 2,
+  }
+
+  enum AutomationStructureChangeType {
+    ChildAdded = 0,
+    ChildRemoved = 1,
+    ChildrenInvalidated = 2,
+    ChildrenBulkAdded = 3,
+    ChildrenBulkRemoved = 4,
+    ChildrenReordered = 5,
+  }
+
+  enum PatternInterface {
+    Invoke = 0,
+    Selection = 1,
+    Value = 2,
+    RangeValue = 3,
+    Scroll = 4,
+    ScrollItem = 5,
+    ExpandCollapse = 6,
+    Grid = 7,
+    GridItem = 8,
+    MultipleView = 9,
+    Window = 10,
+    SelectionItem = 11,
+    Dock = 12,
+    Table = 13,
+    TableItem = 14,
+    Toggle = 15,
+    Transform = 16,
+    Text = 17,
+    ItemContainer = 18,
+    VirtualizedItem = 19,
+    Text2 = 20,
+    TextChild = 21,
+    TextRange = 22,
+    Annotation = 23,
+    Drag = 24,
+    DropTarget = 25,
+    ObjectModel = 26,
+    Spreadsheet = 27,
+    SpreadsheetItem = 28,
+    Styles = 29,
+    Transform2 = 30,
+    SynchronizedInput = 31,
+    TextEdit = 32,
+    CustomNavigation = 33,
+  }
+
+  interface IAppBarAutomationPeer {
+  }
+  var IAppBarAutomationPeer: abstract new (...args: any[]) => IAppBarAutomationPeer;
+
+  interface IAppBarAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.AppBar, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.AppBarAutomationPeer;
+  }
+  var IAppBarAutomationPeerFactory: abstract new (...args: any[]) => IAppBarAutomationPeerFactory;
+
+  interface IAppBarButtonAutomationPeer {
+  }
+  var IAppBarButtonAutomationPeer: abstract new (...args: any[]) => IAppBarButtonAutomationPeer;
+
+  interface IAppBarButtonAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.AppBarButton, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.AppBarButtonAutomationPeer;
+  }
+  var IAppBarButtonAutomationPeerFactory: abstract new (...args: any[]) => IAppBarButtonAutomationPeerFactory;
+
+  interface IAppBarToggleButtonAutomationPeer {
+  }
+  var IAppBarToggleButtonAutomationPeer: abstract new (...args: any[]) => IAppBarToggleButtonAutomationPeer;
+
+  interface IAppBarToggleButtonAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.AppBarToggleButton, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.AppBarToggleButtonAutomationPeer;
+  }
+  var IAppBarToggleButtonAutomationPeerFactory: abstract new (...args: any[]) => IAppBarToggleButtonAutomationPeerFactory;
+
+  interface IAutoSuggestBoxAutomationPeer {
+  }
+  var IAutoSuggestBoxAutomationPeer: abstract new (...args: any[]) => IAutoSuggestBoxAutomationPeer;
+
+  interface IAutoSuggestBoxAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.AutoSuggestBox): Windows.UI.Xaml.Automation.Peers.AutoSuggestBoxAutomationPeer;
+  }
+  var IAutoSuggestBoxAutomationPeerFactory: abstract new (...args: any[]) => IAutoSuggestBoxAutomationPeerFactory;
+
+  interface IAutomationPeer {
+    GetAcceleratorKey(): string;
+    GetAccessKey(): string;
+    GetAutomationControlType(): number;
+    GetAutomationId(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetHelpText(): string;
+    GetItemStatus(): string;
+    GetItemType(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLiveSetting(): number;
+    GetLocalizedControlType(): string;
+    GetName(): string;
+    GetOrientation(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    HasKeyboardFocus(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsControlElement(): boolean;
+    IsEnabled(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsOffscreen(): boolean;
+    IsPassword(): boolean;
+    IsRequiredForForm(): boolean;
+    RaiseAutomationEvent(eventId: number): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    SetFocus(): void;
+    EventsSource: Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+  }
+  var IAutomationPeer: abstract new (...args: any[]) => IAutomationPeer;
+
+  interface IAutomationPeer2 {
+  }
+  var IAutomationPeer2: abstract new (...args: any[]) => IAutomationPeer2;
+
+  interface IAutomationPeer3 {
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFocusedElement(): Object;
+    GetLevel(): number;
+    GetPositionInSet(): number;
+    GetSizeOfSet(): number;
+    Navigate(direction: number): Object;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    ShowContextMenu(): void;
+  }
+  var IAutomationPeer3: abstract new (...args: any[]) => IAutomationPeer3;
+
+  interface IAutomationPeer4 {
+    GetLandmarkType(): number;
+    GetLocalizedLandmarkType(): string;
+  }
+  var IAutomationPeer4: abstract new (...args: any[]) => IAutomationPeer4;
+
+  interface IAutomationPeer5 {
+    GetFullDescription(): string;
+    IsDataValidForForm(): boolean;
+    IsPeripheral(): boolean;
+  }
+  var IAutomationPeer5: abstract new (...args: any[]) => IAutomationPeer5;
+
+  interface IAutomationPeer6 {
+    GetCulture(): number;
+  }
+  var IAutomationPeer6: abstract new (...args: any[]) => IAutomationPeer6;
+
+  interface IAutomationPeer7 {
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+  }
+  var IAutomationPeer7: abstract new (...args: any[]) => IAutomationPeer7;
+
+  interface IAutomationPeer8 {
+    GetHeadingLevel(): number;
+  }
+  var IAutomationPeer8: abstract new (...args: any[]) => IAutomationPeer8;
+
+  interface IAutomationPeer9 {
+    IsDialog(): boolean;
+  }
+  var IAutomationPeer9: abstract new (...args: any[]) => IAutomationPeer9;
+
+  interface IAutomationPeerAnnotation {
+    Peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    Type: number;
+  }
+  var IAutomationPeerAnnotation: abstract new (...args: any[]) => IAutomationPeerAnnotation;
+
+  interface IAutomationPeerAnnotationFactory {
+    CreateInstance(type: number): Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation;
+    CreateWithPeerParameter(type: number, peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation;
+  }
+  var IAutomationPeerAnnotationFactory: abstract new (...args: any[]) => IAutomationPeerAnnotationFactory;
+
+  interface IAutomationPeerAnnotationStatics {
+    readonly PeerProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TypeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAutomationPeerAnnotationStatics: abstract new (...args: any[]) => IAutomationPeerAnnotationStatics;
+
+  interface IAutomationPeerFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+  }
+  var IAutomationPeerFactory: abstract new (...args: any[]) => IAutomationPeerFactory;
+
+  interface IAutomationPeerOverrides {
+    GetAcceleratorKeyCore(): string;
+    GetAccessKeyCore(): string;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassNameCore(): string;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetHelpTextCore(): string;
+    GetItemStatusCore(): string;
+    GetItemTypeCore(): string;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlTypeCore(): string;
+    GetNameCore(): string;
+    GetOrientationCore(): number;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    HasKeyboardFocusCore(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElementCore(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPasswordCore(): boolean;
+    IsRequiredForFormCore(): boolean;
+    SetFocusCore(): void;
+  }
+  var IAutomationPeerOverrides: abstract new (...args: any[]) => IAutomationPeerOverrides;
+
+  interface IAutomationPeerOverrides2 {
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    ShowContextMenuCore(): void;
+  }
+  var IAutomationPeerOverrides2: abstract new (...args: any[]) => IAutomationPeerOverrides2;
+
+  interface IAutomationPeerOverrides3 {
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFocusedElementCore(): Object;
+    GetLevelCore(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSetCore(): number;
+    NavigateCore(direction: number): Object;
+  }
+  var IAutomationPeerOverrides3: abstract new (...args: any[]) => IAutomationPeerOverrides3;
+
+  interface IAutomationPeerOverrides4 {
+    GetLandmarkTypeCore(): number;
+    GetLocalizedLandmarkTypeCore(): string;
+  }
+  var IAutomationPeerOverrides4: abstract new (...args: any[]) => IAutomationPeerOverrides4;
+
+  interface IAutomationPeerOverrides5 {
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFullDescriptionCore(): string;
+    IsDataValidForFormCore(): boolean;
+    IsPeripheralCore(): boolean;
+  }
+  var IAutomationPeerOverrides5: abstract new (...args: any[]) => IAutomationPeerOverrides5;
+
+  interface IAutomationPeerOverrides6 {
+    GetCultureCore(): number;
+  }
+  var IAutomationPeerOverrides6: abstract new (...args: any[]) => IAutomationPeerOverrides6;
+
+  interface IAutomationPeerOverrides8 {
+    GetHeadingLevelCore(): number;
+  }
+  var IAutomationPeerOverrides8: abstract new (...args: any[]) => IAutomationPeerOverrides8;
+
+  interface IAutomationPeerOverrides9 {
+    IsDialogCore(): boolean;
+  }
+  var IAutomationPeerOverrides9: abstract new (...args: any[]) => IAutomationPeerOverrides9;
+
+  interface IAutomationPeerProtected {
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+  }
+  var IAutomationPeerProtected: abstract new (...args: any[]) => IAutomationPeerProtected;
+
+  interface IAutomationPeerStatics {
+    ListenerExists(eventId: number): boolean;
+  }
+  var IAutomationPeerStatics: abstract new (...args: any[]) => IAutomationPeerStatics;
+
+  interface IAutomationPeerStatics3 {
+    GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+  }
+  var IAutomationPeerStatics3: abstract new (...args: any[]) => IAutomationPeerStatics3;
+
+  interface IButtonAutomationPeer {
+  }
+  var IButtonAutomationPeer: abstract new (...args: any[]) => IButtonAutomationPeer;
+
+  interface IButtonAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.Button, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ButtonAutomationPeer;
+  }
+  var IButtonAutomationPeerFactory: abstract new (...args: any[]) => IButtonAutomationPeerFactory;
+
+  interface IButtonBaseAutomationPeer {
+  }
+  var IButtonBaseAutomationPeer: abstract new (...args: any[]) => IButtonBaseAutomationPeer;
+
+  interface IButtonBaseAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.Primitives.ButtonBase, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ButtonBaseAutomationPeer;
+  }
+  var IButtonBaseAutomationPeerFactory: abstract new (...args: any[]) => IButtonBaseAutomationPeerFactory;
+
+  interface ICalendarDatePickerAutomationPeer {
+  }
+  var ICalendarDatePickerAutomationPeer: abstract new (...args: any[]) => ICalendarDatePickerAutomationPeer;
+
+  interface ICalendarDatePickerAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.CalendarDatePicker, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.CalendarDatePickerAutomationPeer;
+  }
+  var ICalendarDatePickerAutomationPeerFactory: abstract new (...args: any[]) => ICalendarDatePickerAutomationPeerFactory;
+
+  interface ICaptureElementAutomationPeer {
+  }
+  var ICaptureElementAutomationPeer: abstract new (...args: any[]) => ICaptureElementAutomationPeer;
+
+  interface ICaptureElementAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.CaptureElement, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.CaptureElementAutomationPeer;
+  }
+  var ICaptureElementAutomationPeerFactory: abstract new (...args: any[]) => ICaptureElementAutomationPeerFactory;
+
+  interface ICheckBoxAutomationPeer {
+  }
+  var ICheckBoxAutomationPeer: abstract new (...args: any[]) => ICheckBoxAutomationPeer;
+
+  interface ICheckBoxAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.CheckBox, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.CheckBoxAutomationPeer;
+  }
+  var ICheckBoxAutomationPeerFactory: abstract new (...args: any[]) => ICheckBoxAutomationPeerFactory;
+
+  interface IColorPickerSliderAutomationPeer {
+  }
+  var IColorPickerSliderAutomationPeer: abstract new (...args: any[]) => IColorPickerSliderAutomationPeer;
+
+  interface IColorPickerSliderAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.Primitives.ColorPickerSlider, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ColorPickerSliderAutomationPeer;
+  }
+  var IColorPickerSliderAutomationPeerFactory: abstract new (...args: any[]) => IColorPickerSliderAutomationPeerFactory;
+
+  interface IColorSpectrumAutomationPeer {
+  }
+  var IColorSpectrumAutomationPeer: abstract new (...args: any[]) => IColorSpectrumAutomationPeer;
+
+  interface IColorSpectrumAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.Primitives.ColorSpectrum, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ColorSpectrumAutomationPeer;
+  }
+  var IColorSpectrumAutomationPeerFactory: abstract new (...args: any[]) => IColorSpectrumAutomationPeerFactory;
+
+  interface IComboBoxAutomationPeer {
+  }
+  var IComboBoxAutomationPeer: abstract new (...args: any[]) => IComboBoxAutomationPeer;
+
+  interface IComboBoxAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.ComboBox, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ComboBoxAutomationPeer;
+  }
+  var IComboBoxAutomationPeerFactory: abstract new (...args: any[]) => IComboBoxAutomationPeerFactory;
+
+  interface IComboBoxItemAutomationPeer {
+  }
+  var IComboBoxItemAutomationPeer: abstract new (...args: any[]) => IComboBoxItemAutomationPeer;
+
+  interface IComboBoxItemAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.ComboBoxItem, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ComboBoxItemAutomationPeer;
+  }
+  var IComboBoxItemAutomationPeerFactory: abstract new (...args: any[]) => IComboBoxItemAutomationPeerFactory;
+
+  interface IComboBoxItemDataAutomationPeer {
+  }
+  var IComboBoxItemDataAutomationPeer: abstract new (...args: any[]) => IComboBoxItemDataAutomationPeer;
+
+  interface IComboBoxItemDataAutomationPeerFactory {
+    CreateInstanceWithParentAndItem(item: Object, parent: Windows.UI.Xaml.Automation.Peers.ComboBoxAutomationPeer, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ComboBoxItemDataAutomationPeer;
+  }
+  var IComboBoxItemDataAutomationPeerFactory: abstract new (...args: any[]) => IComboBoxItemDataAutomationPeerFactory;
+
+  interface IDatePickerAutomationPeer {
+  }
+  var IDatePickerAutomationPeer: abstract new (...args: any[]) => IDatePickerAutomationPeer;
+
+  interface IDatePickerAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.DatePicker, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.DatePickerAutomationPeer;
+  }
+  var IDatePickerAutomationPeerFactory: abstract new (...args: any[]) => IDatePickerAutomationPeerFactory;
+
+  interface IDatePickerFlyoutPresenterAutomationPeer {
+  }
+  var IDatePickerFlyoutPresenterAutomationPeer: abstract new (...args: any[]) => IDatePickerFlyoutPresenterAutomationPeer;
+
+  interface IFlipViewAutomationPeer {
+  }
+  var IFlipViewAutomationPeer: abstract new (...args: any[]) => IFlipViewAutomationPeer;
+
+  interface IFlipViewAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.FlipView, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.FlipViewAutomationPeer;
+  }
+  var IFlipViewAutomationPeerFactory: abstract new (...args: any[]) => IFlipViewAutomationPeerFactory;
+
+  interface IFlipViewItemAutomationPeer {
+  }
+  var IFlipViewItemAutomationPeer: abstract new (...args: any[]) => IFlipViewItemAutomationPeer;
+
+  interface IFlipViewItemAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.FlipViewItem, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.FlipViewItemAutomationPeer;
+  }
+  var IFlipViewItemAutomationPeerFactory: abstract new (...args: any[]) => IFlipViewItemAutomationPeerFactory;
+
+  interface IFlipViewItemDataAutomationPeer {
+  }
+  var IFlipViewItemDataAutomationPeer: abstract new (...args: any[]) => IFlipViewItemDataAutomationPeer;
+
+  interface IFlipViewItemDataAutomationPeerFactory {
+    CreateInstanceWithParentAndItem(item: Object, parent: Windows.UI.Xaml.Automation.Peers.FlipViewAutomationPeer, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.FlipViewItemDataAutomationPeer;
+  }
+  var IFlipViewItemDataAutomationPeerFactory: abstract new (...args: any[]) => IFlipViewItemDataAutomationPeerFactory;
+
+  interface IFlyoutPresenterAutomationPeer {
+  }
+  var IFlyoutPresenterAutomationPeer: abstract new (...args: any[]) => IFlyoutPresenterAutomationPeer;
+
+  interface IFlyoutPresenterAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.FlyoutPresenter, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.FlyoutPresenterAutomationPeer;
+  }
+  var IFlyoutPresenterAutomationPeerFactory: abstract new (...args: any[]) => IFlyoutPresenterAutomationPeerFactory;
+
+  interface IFrameworkElementAutomationPeer {
+    readonly Owner: Windows.UI.Xaml.UIElement;
+  }
+  var IFrameworkElementAutomationPeer: abstract new (...args: any[]) => IFrameworkElementAutomationPeer;
+
+  interface IFrameworkElementAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.FrameworkElement, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer;
+  }
+  var IFrameworkElementAutomationPeerFactory: abstract new (...args: any[]) => IFrameworkElementAutomationPeerFactory;
+
+  interface IFrameworkElementAutomationPeerStatics {
+    CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+  }
+  var IFrameworkElementAutomationPeerStatics: abstract new (...args: any[]) => IFrameworkElementAutomationPeerStatics;
+
+  interface IGridViewAutomationPeer {
+  }
+  var IGridViewAutomationPeer: abstract new (...args: any[]) => IGridViewAutomationPeer;
+
+  interface IGridViewAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.GridView, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.GridViewAutomationPeer;
+  }
+  var IGridViewAutomationPeerFactory: abstract new (...args: any[]) => IGridViewAutomationPeerFactory;
+
+  interface IGridViewHeaderItemAutomationPeer {
+  }
+  var IGridViewHeaderItemAutomationPeer: abstract new (...args: any[]) => IGridViewHeaderItemAutomationPeer;
+
+  interface IGridViewHeaderItemAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.GridViewHeaderItem, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.GridViewHeaderItemAutomationPeer;
+  }
+  var IGridViewHeaderItemAutomationPeerFactory: abstract new (...args: any[]) => IGridViewHeaderItemAutomationPeerFactory;
+
+  interface IGridViewItemAutomationPeer {
+  }
+  var IGridViewItemAutomationPeer: abstract new (...args: any[]) => IGridViewItemAutomationPeer;
+
+  interface IGridViewItemAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.GridViewItem, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.GridViewItemAutomationPeer;
+  }
+  var IGridViewItemAutomationPeerFactory: abstract new (...args: any[]) => IGridViewItemAutomationPeerFactory;
+
+  interface IGridViewItemDataAutomationPeer {
+  }
+  var IGridViewItemDataAutomationPeer: abstract new (...args: any[]) => IGridViewItemDataAutomationPeer;
+
+  interface IGridViewItemDataAutomationPeerFactory {
+    CreateInstanceWithParentAndItem(item: Object, parent: Windows.UI.Xaml.Automation.Peers.GridViewAutomationPeer, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.GridViewItemDataAutomationPeer;
+  }
+  var IGridViewItemDataAutomationPeerFactory: abstract new (...args: any[]) => IGridViewItemDataAutomationPeerFactory;
+
+  interface IGroupItemAutomationPeer {
+  }
+  var IGroupItemAutomationPeer: abstract new (...args: any[]) => IGroupItemAutomationPeer;
+
+  interface IGroupItemAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.GroupItem, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.GroupItemAutomationPeer;
+  }
+  var IGroupItemAutomationPeerFactory: abstract new (...args: any[]) => IGroupItemAutomationPeerFactory;
+
+  interface IHubAutomationPeer {
+  }
+  var IHubAutomationPeer: abstract new (...args: any[]) => IHubAutomationPeer;
+
+  interface IHubAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.Hub, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.HubAutomationPeer;
+  }
+  var IHubAutomationPeerFactory: abstract new (...args: any[]) => IHubAutomationPeerFactory;
+
+  interface IHubSectionAutomationPeer {
+  }
+  var IHubSectionAutomationPeer: abstract new (...args: any[]) => IHubSectionAutomationPeer;
+
+  interface IHubSectionAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.HubSection, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.HubSectionAutomationPeer;
+  }
+  var IHubSectionAutomationPeerFactory: abstract new (...args: any[]) => IHubSectionAutomationPeerFactory;
+
+  interface IHyperlinkButtonAutomationPeer {
+  }
+  var IHyperlinkButtonAutomationPeer: abstract new (...args: any[]) => IHyperlinkButtonAutomationPeer;
+
+  interface IHyperlinkButtonAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.HyperlinkButton, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.HyperlinkButtonAutomationPeer;
+  }
+  var IHyperlinkButtonAutomationPeerFactory: abstract new (...args: any[]) => IHyperlinkButtonAutomationPeerFactory;
+
+  interface IImageAutomationPeer {
+  }
+  var IImageAutomationPeer: abstract new (...args: any[]) => IImageAutomationPeer;
+
+  interface IImageAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.Image, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ImageAutomationPeer;
+  }
+  var IImageAutomationPeerFactory: abstract new (...args: any[]) => IImageAutomationPeerFactory;
+
+  interface IInkToolbarAutomationPeer {
+  }
+  var IInkToolbarAutomationPeer: abstract new (...args: any[]) => IInkToolbarAutomationPeer;
+
+  interface IItemAutomationPeer {
+    readonly Item: Object;
+    readonly ItemsControlAutomationPeer: Windows.UI.Xaml.Automation.Peers.ItemsControlAutomationPeer;
+  }
+  var IItemAutomationPeer: abstract new (...args: any[]) => IItemAutomationPeer;
+
+  interface IItemAutomationPeerFactory {
+    CreateInstanceWithParentAndItem(item: Object, parent: Windows.UI.Xaml.Automation.Peers.ItemsControlAutomationPeer, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+  }
+  var IItemAutomationPeerFactory: abstract new (...args: any[]) => IItemAutomationPeerFactory;
+
+  interface IItemsControlAutomationPeer {
+  }
+  var IItemsControlAutomationPeer: abstract new (...args: any[]) => IItemsControlAutomationPeer;
+
+  interface IItemsControlAutomationPeer2 {
+    CreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+  }
+  var IItemsControlAutomationPeer2: abstract new (...args: any[]) => IItemsControlAutomationPeer2;
+
+  interface IItemsControlAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.ItemsControl, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ItemsControlAutomationPeer;
+  }
+  var IItemsControlAutomationPeerFactory: abstract new (...args: any[]) => IItemsControlAutomationPeerFactory;
+
+  interface IItemsControlAutomationPeerOverrides2 {
+    OnCreateItemAutomationPeer(item: Object): Windows.UI.Xaml.Automation.Peers.ItemAutomationPeer;
+  }
+  var IItemsControlAutomationPeerOverrides2: abstract new (...args: any[]) => IItemsControlAutomationPeerOverrides2;
+
+  interface IListBoxAutomationPeer {
+  }
+  var IListBoxAutomationPeer: abstract new (...args: any[]) => IListBoxAutomationPeer;
+
+  interface IListBoxAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.ListBox, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ListBoxAutomationPeer;
+  }
+  var IListBoxAutomationPeerFactory: abstract new (...args: any[]) => IListBoxAutomationPeerFactory;
+
+  interface IListBoxItemAutomationPeer {
+  }
+  var IListBoxItemAutomationPeer: abstract new (...args: any[]) => IListBoxItemAutomationPeer;
+
+  interface IListBoxItemAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.ListBoxItem, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ListBoxItemAutomationPeer;
+  }
+  var IListBoxItemAutomationPeerFactory: abstract new (...args: any[]) => IListBoxItemAutomationPeerFactory;
+
+  interface IListBoxItemDataAutomationPeer {
+  }
+  var IListBoxItemDataAutomationPeer: abstract new (...args: any[]) => IListBoxItemDataAutomationPeer;
+
+  interface IListBoxItemDataAutomationPeerFactory {
+    CreateInstanceWithParentAndItem(item: Object, parent: Windows.UI.Xaml.Automation.Peers.ListBoxAutomationPeer, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ListBoxItemDataAutomationPeer;
+  }
+  var IListBoxItemDataAutomationPeerFactory: abstract new (...args: any[]) => IListBoxItemDataAutomationPeerFactory;
+
+  interface IListPickerFlyoutPresenterAutomationPeer {
+  }
+  var IListPickerFlyoutPresenterAutomationPeer: abstract new (...args: any[]) => IListPickerFlyoutPresenterAutomationPeer;
+
+  interface IListViewAutomationPeer {
+  }
+  var IListViewAutomationPeer: abstract new (...args: any[]) => IListViewAutomationPeer;
+
+  interface IListViewAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.ListView, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ListViewAutomationPeer;
+  }
+  var IListViewAutomationPeerFactory: abstract new (...args: any[]) => IListViewAutomationPeerFactory;
+
+  interface IListViewBaseAutomationPeer {
+  }
+  var IListViewBaseAutomationPeer: abstract new (...args: any[]) => IListViewBaseAutomationPeer;
+
+  interface IListViewBaseAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.ListViewBase, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ListViewBaseAutomationPeer;
+  }
+  var IListViewBaseAutomationPeerFactory: abstract new (...args: any[]) => IListViewBaseAutomationPeerFactory;
+
+  interface IListViewBaseHeaderItemAutomationPeer {
+  }
+  var IListViewBaseHeaderItemAutomationPeer: abstract new (...args: any[]) => IListViewBaseHeaderItemAutomationPeer;
+
+  interface IListViewBaseHeaderItemAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.ListViewBaseHeaderItem, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ListViewBaseHeaderItemAutomationPeer;
+  }
+  var IListViewBaseHeaderItemAutomationPeerFactory: abstract new (...args: any[]) => IListViewBaseHeaderItemAutomationPeerFactory;
+
+  interface IListViewHeaderItemAutomationPeer {
+  }
+  var IListViewHeaderItemAutomationPeer: abstract new (...args: any[]) => IListViewHeaderItemAutomationPeer;
+
+  interface IListViewHeaderItemAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.ListViewHeaderItem, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ListViewHeaderItemAutomationPeer;
+  }
+  var IListViewHeaderItemAutomationPeerFactory: abstract new (...args: any[]) => IListViewHeaderItemAutomationPeerFactory;
+
+  interface IListViewItemAutomationPeer {
+  }
+  var IListViewItemAutomationPeer: abstract new (...args: any[]) => IListViewItemAutomationPeer;
+
+  interface IListViewItemAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.ListViewItem, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ListViewItemAutomationPeer;
+  }
+  var IListViewItemAutomationPeerFactory: abstract new (...args: any[]) => IListViewItemAutomationPeerFactory;
+
+  interface IListViewItemDataAutomationPeer {
+  }
+  var IListViewItemDataAutomationPeer: abstract new (...args: any[]) => IListViewItemDataAutomationPeer;
+
+  interface IListViewItemDataAutomationPeerFactory {
+    CreateInstanceWithParentAndItem(item: Object, parent: Windows.UI.Xaml.Automation.Peers.ListViewBaseAutomationPeer, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ListViewItemDataAutomationPeer;
+  }
+  var IListViewItemDataAutomationPeerFactory: abstract new (...args: any[]) => IListViewItemDataAutomationPeerFactory;
+
+  interface ILoopingSelectorAutomationPeer {
+  }
+  var ILoopingSelectorAutomationPeer: abstract new (...args: any[]) => ILoopingSelectorAutomationPeer;
+
+  interface ILoopingSelectorItemAutomationPeer {
+  }
+  var ILoopingSelectorItemAutomationPeer: abstract new (...args: any[]) => ILoopingSelectorItemAutomationPeer;
+
+  interface ILoopingSelectorItemDataAutomationPeer {
+  }
+  var ILoopingSelectorItemDataAutomationPeer: abstract new (...args: any[]) => ILoopingSelectorItemDataAutomationPeer;
+
+  interface IMapControlAutomationPeer {
+  }
+  var IMapControlAutomationPeer: abstract new (...args: any[]) => IMapControlAutomationPeer;
+
+  interface IMediaElementAutomationPeer {
+  }
+  var IMediaElementAutomationPeer: abstract new (...args: any[]) => IMediaElementAutomationPeer;
+
+  interface IMediaElementAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.MediaElement, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.MediaElementAutomationPeer;
+  }
+  var IMediaElementAutomationPeerFactory: abstract new (...args: any[]) => IMediaElementAutomationPeerFactory;
+
+  interface IMediaPlayerElementAutomationPeer {
+  }
+  var IMediaPlayerElementAutomationPeer: abstract new (...args: any[]) => IMediaPlayerElementAutomationPeer;
+
+  interface IMediaPlayerElementAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.MediaPlayerElement, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.MediaPlayerElementAutomationPeer;
+  }
+  var IMediaPlayerElementAutomationPeerFactory: abstract new (...args: any[]) => IMediaPlayerElementAutomationPeerFactory;
+
+  interface IMediaTransportControlsAutomationPeer {
+  }
+  var IMediaTransportControlsAutomationPeer: abstract new (...args: any[]) => IMediaTransportControlsAutomationPeer;
+
+  interface IMediaTransportControlsAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.MediaTransportControls, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.MediaTransportControlsAutomationPeer;
+  }
+  var IMediaTransportControlsAutomationPeerFactory: abstract new (...args: any[]) => IMediaTransportControlsAutomationPeerFactory;
+
+  interface IMenuBarAutomationPeer {
+  }
+  var IMenuBarAutomationPeer: abstract new (...args: any[]) => IMenuBarAutomationPeer;
+
+  interface IMenuBarAutomationPeerFactory {
+    CreateInstance(owner: Windows.UI.Xaml.Controls.MenuBar, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.MenuBarAutomationPeer;
+  }
+  var IMenuBarAutomationPeerFactory: abstract new (...args: any[]) => IMenuBarAutomationPeerFactory;
+
+  interface IMenuBarItemAutomationPeer {
+  }
+  var IMenuBarItemAutomationPeer: abstract new (...args: any[]) => IMenuBarItemAutomationPeer;
+
+  interface IMenuBarItemAutomationPeerFactory {
+    CreateInstance(owner: Windows.UI.Xaml.Controls.MenuBarItem, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.MenuBarItemAutomationPeer;
+  }
+  var IMenuBarItemAutomationPeerFactory: abstract new (...args: any[]) => IMenuBarItemAutomationPeerFactory;
+
+  interface IMenuFlyoutItemAutomationPeer {
+  }
+  var IMenuFlyoutItemAutomationPeer: abstract new (...args: any[]) => IMenuFlyoutItemAutomationPeer;
+
+  interface IMenuFlyoutItemAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.MenuFlyoutItem, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.MenuFlyoutItemAutomationPeer;
+  }
+  var IMenuFlyoutItemAutomationPeerFactory: abstract new (...args: any[]) => IMenuFlyoutItemAutomationPeerFactory;
+
+  interface IMenuFlyoutPresenterAutomationPeer {
+  }
+  var IMenuFlyoutPresenterAutomationPeer: abstract new (...args: any[]) => IMenuFlyoutPresenterAutomationPeer;
+
+  interface IMenuFlyoutPresenterAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.MenuFlyoutPresenter, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.MenuFlyoutPresenterAutomationPeer;
+  }
+  var IMenuFlyoutPresenterAutomationPeerFactory: abstract new (...args: any[]) => IMenuFlyoutPresenterAutomationPeerFactory;
+
+  interface INavigationViewItemAutomationPeer {
+  }
+  var INavigationViewItemAutomationPeer: abstract new (...args: any[]) => INavigationViewItemAutomationPeer;
+
+  interface INavigationViewItemAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.NavigationViewItem, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.NavigationViewItemAutomationPeer;
+  }
+  var INavigationViewItemAutomationPeerFactory: abstract new (...args: any[]) => INavigationViewItemAutomationPeerFactory;
+
+  interface IPasswordBoxAutomationPeer {
+  }
+  var IPasswordBoxAutomationPeer: abstract new (...args: any[]) => IPasswordBoxAutomationPeer;
+
+  interface IPasswordBoxAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.PasswordBox, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.PasswordBoxAutomationPeer;
+  }
+  var IPasswordBoxAutomationPeerFactory: abstract new (...args: any[]) => IPasswordBoxAutomationPeerFactory;
+
+  interface IPersonPictureAutomationPeer {
+  }
+  var IPersonPictureAutomationPeer: abstract new (...args: any[]) => IPersonPictureAutomationPeer;
+
+  interface IPersonPictureAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.PersonPicture, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.PersonPictureAutomationPeer;
+  }
+  var IPersonPictureAutomationPeerFactory: abstract new (...args: any[]) => IPersonPictureAutomationPeerFactory;
+
+  interface IPickerFlyoutPresenterAutomationPeer {
+  }
+  var IPickerFlyoutPresenterAutomationPeer: abstract new (...args: any[]) => IPickerFlyoutPresenterAutomationPeer;
+
+  interface IPivotAutomationPeer {
+  }
+  var IPivotAutomationPeer: abstract new (...args: any[]) => IPivotAutomationPeer;
+
+  interface IPivotAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.Pivot): Windows.UI.Xaml.Automation.Peers.PivotAutomationPeer;
+  }
+  var IPivotAutomationPeerFactory: abstract new (...args: any[]) => IPivotAutomationPeerFactory;
+
+  interface IPivotItemAutomationPeer {
+  }
+  var IPivotItemAutomationPeer: abstract new (...args: any[]) => IPivotItemAutomationPeer;
+
+  interface IPivotItemAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.PivotItem): Windows.UI.Xaml.Automation.Peers.PivotItemAutomationPeer;
+  }
+  var IPivotItemAutomationPeerFactory: abstract new (...args: any[]) => IPivotItemAutomationPeerFactory;
+
+  interface IPivotItemDataAutomationPeer {
+  }
+  var IPivotItemDataAutomationPeer: abstract new (...args: any[]) => IPivotItemDataAutomationPeer;
+
+  interface IPivotItemDataAutomationPeerFactory {
+    CreateInstanceWithParentAndItem(item: Object, parent: Windows.UI.Xaml.Automation.Peers.PivotAutomationPeer): Windows.UI.Xaml.Automation.Peers.PivotItemDataAutomationPeer;
+  }
+  var IPivotItemDataAutomationPeerFactory: abstract new (...args: any[]) => IPivotItemDataAutomationPeerFactory;
+
+  interface IProgressBarAutomationPeer {
+  }
+  var IProgressBarAutomationPeer: abstract new (...args: any[]) => IProgressBarAutomationPeer;
+
+  interface IProgressBarAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.ProgressBar, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ProgressBarAutomationPeer;
+  }
+  var IProgressBarAutomationPeerFactory: abstract new (...args: any[]) => IProgressBarAutomationPeerFactory;
+
+  interface IProgressRingAutomationPeer {
+  }
+  var IProgressRingAutomationPeer: abstract new (...args: any[]) => IProgressRingAutomationPeer;
+
+  interface IProgressRingAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.ProgressRing, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ProgressRingAutomationPeer;
+  }
+  var IProgressRingAutomationPeerFactory: abstract new (...args: any[]) => IProgressRingAutomationPeerFactory;
+
+  interface IRadioButtonAutomationPeer {
+  }
+  var IRadioButtonAutomationPeer: abstract new (...args: any[]) => IRadioButtonAutomationPeer;
+
+  interface IRadioButtonAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.RadioButton, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.RadioButtonAutomationPeer;
+  }
+  var IRadioButtonAutomationPeerFactory: abstract new (...args: any[]) => IRadioButtonAutomationPeerFactory;
+
+  interface IRangeBaseAutomationPeer {
+  }
+  var IRangeBaseAutomationPeer: abstract new (...args: any[]) => IRangeBaseAutomationPeer;
+
+  interface IRangeBaseAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.Primitives.RangeBase, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.RangeBaseAutomationPeer;
+  }
+  var IRangeBaseAutomationPeerFactory: abstract new (...args: any[]) => IRangeBaseAutomationPeerFactory;
+
+  interface IRatingControlAutomationPeer {
+  }
+  var IRatingControlAutomationPeer: abstract new (...args: any[]) => IRatingControlAutomationPeer;
+
+  interface IRatingControlAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.RatingControl, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.RatingControlAutomationPeer;
+  }
+  var IRatingControlAutomationPeerFactory: abstract new (...args: any[]) => IRatingControlAutomationPeerFactory;
+
+  interface IRepeatButtonAutomationPeer {
+  }
+  var IRepeatButtonAutomationPeer: abstract new (...args: any[]) => IRepeatButtonAutomationPeer;
+
+  interface IRepeatButtonAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.Primitives.RepeatButton, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.RepeatButtonAutomationPeer;
+  }
+  var IRepeatButtonAutomationPeerFactory: abstract new (...args: any[]) => IRepeatButtonAutomationPeerFactory;
+
+  interface IRichEditBoxAutomationPeer {
+  }
+  var IRichEditBoxAutomationPeer: abstract new (...args: any[]) => IRichEditBoxAutomationPeer;
+
+  interface IRichEditBoxAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.RichEditBox, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.RichEditBoxAutomationPeer;
+  }
+  var IRichEditBoxAutomationPeerFactory: abstract new (...args: any[]) => IRichEditBoxAutomationPeerFactory;
+
+  interface IRichTextBlockAutomationPeer {
+  }
+  var IRichTextBlockAutomationPeer: abstract new (...args: any[]) => IRichTextBlockAutomationPeer;
+
+  interface IRichTextBlockAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.RichTextBlock, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.RichTextBlockAutomationPeer;
+  }
+  var IRichTextBlockAutomationPeerFactory: abstract new (...args: any[]) => IRichTextBlockAutomationPeerFactory;
+
+  interface IRichTextBlockOverflowAutomationPeer {
+  }
+  var IRichTextBlockOverflowAutomationPeer: abstract new (...args: any[]) => IRichTextBlockOverflowAutomationPeer;
+
+  interface IRichTextBlockOverflowAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.RichTextBlockOverflow, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.RichTextBlockOverflowAutomationPeer;
+  }
+  var IRichTextBlockOverflowAutomationPeerFactory: abstract new (...args: any[]) => IRichTextBlockOverflowAutomationPeerFactory;
+
+  interface IScrollBarAutomationPeer {
+  }
+  var IScrollBarAutomationPeer: abstract new (...args: any[]) => IScrollBarAutomationPeer;
+
+  interface IScrollBarAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.Primitives.ScrollBar, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ScrollBarAutomationPeer;
+  }
+  var IScrollBarAutomationPeerFactory: abstract new (...args: any[]) => IScrollBarAutomationPeerFactory;
+
+  interface IScrollViewerAutomationPeer {
+  }
+  var IScrollViewerAutomationPeer: abstract new (...args: any[]) => IScrollViewerAutomationPeer;
+
+  interface IScrollViewerAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.ScrollViewer, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ScrollViewerAutomationPeer;
+  }
+  var IScrollViewerAutomationPeerFactory: abstract new (...args: any[]) => IScrollViewerAutomationPeerFactory;
+
+  interface ISearchBoxAutomationPeer {
+  }
+  var ISearchBoxAutomationPeer: abstract new (...args: any[]) => ISearchBoxAutomationPeer;
+
+  interface ISearchBoxAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.SearchBox, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.SearchBoxAutomationPeer;
+  }
+  var ISearchBoxAutomationPeerFactory: abstract new (...args: any[]) => ISearchBoxAutomationPeerFactory;
+
+  interface ISelectorAutomationPeer {
+  }
+  var ISelectorAutomationPeer: abstract new (...args: any[]) => ISelectorAutomationPeer;
+
+  interface ISelectorAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.Primitives.Selector, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.SelectorAutomationPeer;
+  }
+  var ISelectorAutomationPeerFactory: abstract new (...args: any[]) => ISelectorAutomationPeerFactory;
+
+  interface ISelectorItemAutomationPeer {
+  }
+  var ISelectorItemAutomationPeer: abstract new (...args: any[]) => ISelectorItemAutomationPeer;
+
+  interface ISelectorItemAutomationPeerFactory {
+    CreateInstanceWithParentAndItem(item: Object, parent: Windows.UI.Xaml.Automation.Peers.SelectorAutomationPeer, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.SelectorItemAutomationPeer;
+  }
+  var ISelectorItemAutomationPeerFactory: abstract new (...args: any[]) => ISelectorItemAutomationPeerFactory;
+
+  interface ISemanticZoomAutomationPeer {
+  }
+  var ISemanticZoomAutomationPeer: abstract new (...args: any[]) => ISemanticZoomAutomationPeer;
+
+  interface ISemanticZoomAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.SemanticZoom, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.SemanticZoomAutomationPeer;
+  }
+  var ISemanticZoomAutomationPeerFactory: abstract new (...args: any[]) => ISemanticZoomAutomationPeerFactory;
+
+  interface ISettingsFlyoutAutomationPeer {
+  }
+  var ISettingsFlyoutAutomationPeer: abstract new (...args: any[]) => ISettingsFlyoutAutomationPeer;
+
+  interface ISettingsFlyoutAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.SettingsFlyout, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.SettingsFlyoutAutomationPeer;
+  }
+  var ISettingsFlyoutAutomationPeerFactory: abstract new (...args: any[]) => ISettingsFlyoutAutomationPeerFactory;
+
+  interface ISliderAutomationPeer {
+  }
+  var ISliderAutomationPeer: abstract new (...args: any[]) => ISliderAutomationPeer;
+
+  interface ISliderAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.Slider, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.SliderAutomationPeer;
+  }
+  var ISliderAutomationPeerFactory: abstract new (...args: any[]) => ISliderAutomationPeerFactory;
+
+  interface ITextBlockAutomationPeer {
+  }
+  var ITextBlockAutomationPeer: abstract new (...args: any[]) => ITextBlockAutomationPeer;
+
+  interface ITextBlockAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.TextBlock, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.TextBlockAutomationPeer;
+  }
+  var ITextBlockAutomationPeerFactory: abstract new (...args: any[]) => ITextBlockAutomationPeerFactory;
+
+  interface ITextBoxAutomationPeer {
+  }
+  var ITextBoxAutomationPeer: abstract new (...args: any[]) => ITextBoxAutomationPeer;
+
+  interface ITextBoxAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.TextBox, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.TextBoxAutomationPeer;
+  }
+  var ITextBoxAutomationPeerFactory: abstract new (...args: any[]) => ITextBoxAutomationPeerFactory;
+
+  interface IThumbAutomationPeer {
+  }
+  var IThumbAutomationPeer: abstract new (...args: any[]) => IThumbAutomationPeer;
+
+  interface IThumbAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.Primitives.Thumb, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ThumbAutomationPeer;
+  }
+  var IThumbAutomationPeerFactory: abstract new (...args: any[]) => IThumbAutomationPeerFactory;
+
+  interface ITimePickerAutomationPeer {
+  }
+  var ITimePickerAutomationPeer: abstract new (...args: any[]) => ITimePickerAutomationPeer;
+
+  interface ITimePickerAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.TimePicker, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.TimePickerAutomationPeer;
+  }
+  var ITimePickerAutomationPeerFactory: abstract new (...args: any[]) => ITimePickerAutomationPeerFactory;
+
+  interface ITimePickerFlyoutPresenterAutomationPeer {
+  }
+  var ITimePickerFlyoutPresenterAutomationPeer: abstract new (...args: any[]) => ITimePickerFlyoutPresenterAutomationPeer;
+
+  interface IToggleButtonAutomationPeer {
+  }
+  var IToggleButtonAutomationPeer: abstract new (...args: any[]) => IToggleButtonAutomationPeer;
+
+  interface IToggleButtonAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.Primitives.ToggleButton, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ToggleButtonAutomationPeer;
+  }
+  var IToggleButtonAutomationPeerFactory: abstract new (...args: any[]) => IToggleButtonAutomationPeerFactory;
+
+  interface IToggleMenuFlyoutItemAutomationPeer {
+  }
+  var IToggleMenuFlyoutItemAutomationPeer: abstract new (...args: any[]) => IToggleMenuFlyoutItemAutomationPeer;
+
+  interface IToggleMenuFlyoutItemAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.ToggleMenuFlyoutItem, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ToggleMenuFlyoutItemAutomationPeer;
+  }
+  var IToggleMenuFlyoutItemAutomationPeerFactory: abstract new (...args: any[]) => IToggleMenuFlyoutItemAutomationPeerFactory;
+
+  interface IToggleSwitchAutomationPeer {
+  }
+  var IToggleSwitchAutomationPeer: abstract new (...args: any[]) => IToggleSwitchAutomationPeer;
+
+  interface IToggleSwitchAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.ToggleSwitch, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.ToggleSwitchAutomationPeer;
+  }
+  var IToggleSwitchAutomationPeerFactory: abstract new (...args: any[]) => IToggleSwitchAutomationPeerFactory;
+
+  interface ITreeViewItemAutomationPeer {
+  }
+  var ITreeViewItemAutomationPeer: abstract new (...args: any[]) => ITreeViewItemAutomationPeer;
+
+  interface ITreeViewItemAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.TreeViewItem, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.TreeViewItemAutomationPeer;
+  }
+  var ITreeViewItemAutomationPeerFactory: abstract new (...args: any[]) => ITreeViewItemAutomationPeerFactory;
+
+  interface ITreeViewListAutomationPeer {
+  }
+  var ITreeViewListAutomationPeer: abstract new (...args: any[]) => ITreeViewListAutomationPeer;
+
+  interface ITreeViewListAutomationPeerFactory {
+    CreateInstanceWithOwner(owner: Windows.UI.Xaml.Controls.TreeViewList, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Automation.Peers.TreeViewListAutomationPeer;
+  }
+  var ITreeViewListAutomationPeerFactory: abstract new (...args: any[]) => ITreeViewListAutomationPeerFactory;
+
+  interface RawElementProviderRuntimeId {
+    Part1: number;
+    Part2: number;
+  }
+  var RawElementProviderRuntimeId: {
+    new(part1: number, part2: number): RawElementProviderRuntimeId;
+    new(fields: { Part1?: number; Part2?: number }): RawElementProviderRuntimeId;
+  };
+
+}
+
+declare namespace Windows.UI.Xaml.Automation.Provider {
+  class IRawElementProviderSimple extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Automation.Provider.IIRawElementProviderSimple {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  interface IAnnotationProvider {
+    readonly AnnotationTypeId: number;
+    readonly AnnotationTypeName: string;
+    readonly Author: string;
+    readonly DateTime: string;
+    readonly Target: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+  }
+  var IAnnotationProvider: abstract new (...args: any[]) => IAnnotationProvider;
+
+  interface ICustomNavigationProvider {
+    NavigateCustom(direction: number): Object;
+  }
+  var ICustomNavigationProvider: abstract new (...args: any[]) => ICustomNavigationProvider;
+
+  interface IDockProvider {
+    SetDockPosition(dockPosition: number): void;
+    readonly DockPosition: number;
+  }
+  var IDockProvider: abstract new (...args: any[]) => IDockProvider;
+
+  interface IDragProvider {
+    GetGrabbedItems(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    readonly DropEffect: string;
+    readonly DropEffects: string[];
+    readonly IsGrabbed: boolean;
+  }
+  var IDragProvider: abstract new (...args: any[]) => IDragProvider;
+
+  interface IDropTargetProvider {
+    readonly DropEffect: string;
+    readonly DropEffects: string[];
+  }
+  var IDropTargetProvider: abstract new (...args: any[]) => IDropTargetProvider;
+
+  interface IExpandCollapseProvider {
+    Collapse(): void;
+    Expand(): void;
+    readonly ExpandCollapseState: number;
+  }
+  var IExpandCollapseProvider: abstract new (...args: any[]) => IExpandCollapseProvider;
+
+  interface IGridItemProvider {
+    readonly Column: number;
+    readonly ColumnSpan: number;
+    readonly ContainingGrid: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    readonly Row: number;
+    readonly RowSpan: number;
+  }
+  var IGridItemProvider: abstract new (...args: any[]) => IGridItemProvider;
+
+  interface IGridProvider {
+    GetItem(row: number, column: number): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    readonly ColumnCount: number;
+    readonly RowCount: number;
+  }
+  var IGridProvider: abstract new (...args: any[]) => IGridProvider;
+
+  interface IIRawElementProviderSimple {
+  }
+  var IIRawElementProviderSimple: abstract new (...args: any[]) => IIRawElementProviderSimple;
+
+  interface IInvokeProvider {
+    Invoke(): void;
+  }
+  var IInvokeProvider: abstract new (...args: any[]) => IInvokeProvider;
+
+  interface IItemContainerProvider {
+    FindItemByProperty(startAfter: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple, automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, value: Object): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+  }
+  var IItemContainerProvider: abstract new (...args: any[]) => IItemContainerProvider;
+
+  interface IMultipleViewProvider {
+    GetSupportedViews(): number[];
+    GetViewName(viewId: number): string;
+    SetCurrentView(viewId: number): void;
+    readonly CurrentView: number;
+  }
+  var IMultipleViewProvider: abstract new (...args: any[]) => IMultipleViewProvider;
+
+  interface IObjectModelProvider {
+    GetUnderlyingObjectModel(): Object;
+  }
+  var IObjectModelProvider: abstract new (...args: any[]) => IObjectModelProvider;
+
+  interface IRangeValueProvider {
+    SetValue(value: number): void;
+    readonly IsReadOnly: boolean;
+    readonly LargeChange: number;
+    readonly Maximum: number;
+    readonly Minimum: number;
+    readonly SmallChange: number;
+    readonly Value: number;
+  }
+  var IRangeValueProvider: abstract new (...args: any[]) => IRangeValueProvider;
+
+  interface IScrollItemProvider {
+    ScrollIntoView(): void;
+  }
+  var IScrollItemProvider: abstract new (...args: any[]) => IScrollItemProvider;
+
+  interface IScrollProvider {
+    Scroll(horizontalAmount: number, verticalAmount: number): void;
+    SetScrollPercent(horizontalPercent: number, verticalPercent: number): void;
+    readonly HorizontalScrollPercent: number;
+    readonly HorizontalViewSize: number;
+    readonly HorizontallyScrollable: boolean;
+    readonly VerticalScrollPercent: number;
+    readonly VerticalViewSize: number;
+    readonly VerticallyScrollable: boolean;
+  }
+  var IScrollProvider: abstract new (...args: any[]) => IScrollProvider;
+
+  interface ISelectionItemProvider {
+    AddToSelection(): void;
+    RemoveFromSelection(): void;
+    Select(): void;
+    readonly IsSelected: boolean;
+    readonly SelectionContainer: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+  }
+  var ISelectionItemProvider: abstract new (...args: any[]) => ISelectionItemProvider;
+
+  interface ISelectionProvider {
+    GetSelection(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    readonly CanSelectMultiple: boolean;
+    readonly IsSelectionRequired: boolean;
+  }
+  var ISelectionProvider: abstract new (...args: any[]) => ISelectionProvider;
+
+  interface ISpreadsheetItemProvider {
+    GetAnnotationObjects(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    GetAnnotationTypes(): number[];
+    readonly Formula: string;
+  }
+  var ISpreadsheetItemProvider: abstract new (...args: any[]) => ISpreadsheetItemProvider;
+
+  interface ISpreadsheetProvider {
+    GetItemByName(name: string): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+  }
+  var ISpreadsheetProvider: abstract new (...args: any[]) => ISpreadsheetProvider;
+
+  interface IStylesProvider {
+    readonly ExtendedProperties: string;
+    readonly FillColor: Windows.UI.Color;
+    readonly FillPatternColor: Windows.UI.Color;
+    readonly FillPatternStyle: string;
+    readonly Shape: string;
+    readonly StyleId: number;
+    readonly StyleName: string;
+  }
+  var IStylesProvider: abstract new (...args: any[]) => IStylesProvider;
+
+  interface ISynchronizedInputProvider {
+    Cancel(): void;
+    StartListening(inputType: number): void;
+  }
+  var ISynchronizedInputProvider: abstract new (...args: any[]) => ISynchronizedInputProvider;
+
+  interface ITableItemProvider {
+    GetColumnHeaderItems(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    GetRowHeaderItems(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+  }
+  var ITableItemProvider: abstract new (...args: any[]) => ITableItemProvider;
+
+  interface ITableProvider {
+    GetColumnHeaders(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    GetRowHeaders(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    readonly RowOrColumnMajor: number;
+  }
+  var ITableProvider: abstract new (...args: any[]) => ITableProvider;
+
+  interface ITextChildProvider {
+    readonly TextContainer: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    readonly TextRange: Windows.UI.Xaml.Automation.Provider.ITextRangeProvider;
+  }
+  var ITextChildProvider: abstract new (...args: any[]) => ITextChildProvider;
+
+  interface ITextEditProvider extends Windows.UI.Xaml.Automation.Provider.ITextProvider {
+    GetActiveComposition(): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider;
+    GetConversionTarget(): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider;
+    GetSelection(): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider[];
+    GetVisibleRanges(): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider[];
+    RangeFromChild(childElement: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider;
+    RangeFromPoint(screenLocation: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider;
+  }
+  var ITextEditProvider: abstract new (...args: any[]) => ITextEditProvider;
+
+  interface ITextProvider {
+    GetSelection(): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider[];
+    GetVisibleRanges(): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider[];
+    RangeFromChild(childElement: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider;
+    RangeFromPoint(screenLocation: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider;
+    readonly DocumentRange: Windows.UI.Xaml.Automation.Provider.ITextRangeProvider;
+    readonly SupportedTextSelection: number;
+  }
+  var ITextProvider: abstract new (...args: any[]) => ITextProvider;
+
+  interface ITextProvider2 extends Windows.UI.Xaml.Automation.Provider.ITextProvider {
+    GetCaretRange(isActive: boolean): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider;
+    GetSelection(): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider[];
+    GetVisibleRanges(): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider[];
+    RangeFromAnnotation(annotationElement: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider;
+    RangeFromChild(childElement: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider;
+    RangeFromPoint(screenLocation: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider;
+  }
+  var ITextProvider2: abstract new (...args: any[]) => ITextProvider2;
+
+  interface ITextRangeProvider {
+    AddToSelection(): void;
+    Clone(): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider;
+    Compare(textRangeProvider: Windows.UI.Xaml.Automation.Provider.ITextRangeProvider): boolean;
+    CompareEndpoints(endpoint: number, textRangeProvider: Windows.UI.Xaml.Automation.Provider.ITextRangeProvider, targetEndpoint: number): number;
+    ExpandToEnclosingUnit(unit: number): void;
+    FindAttribute(attributeId: number, value: Object, backward: boolean): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider;
+    FindText(text: string, backward: boolean, ignoreCase: boolean): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider;
+    GetAttributeValue(attributeId: number): Object;
+    GetBoundingRectangles(returnValue: number[]): void;
+    GetChildren(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    GetEnclosingElement(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    GetText(maxLength: number): string;
+    Move(unit: number, count: number): number;
+    MoveEndpointByRange(endpoint: number, textRangeProvider: Windows.UI.Xaml.Automation.Provider.ITextRangeProvider, targetEndpoint: number): void;
+    MoveEndpointByUnit(endpoint: number, unit: number, count: number): number;
+    RemoveFromSelection(): void;
+    ScrollIntoView(alignToTop: boolean): void;
+    Select(): void;
+  }
+  var ITextRangeProvider: abstract new (...args: any[]) => ITextRangeProvider;
+
+  interface ITextRangeProvider2 extends Windows.UI.Xaml.Automation.Provider.ITextRangeProvider {
+    AddToSelection(): void;
+    Clone(): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider;
+    Compare(textRangeProvider: Windows.UI.Xaml.Automation.Provider.ITextRangeProvider): boolean;
+    CompareEndpoints(endpoint: number, textRangeProvider: Windows.UI.Xaml.Automation.Provider.ITextRangeProvider, targetEndpoint: number): number;
+    ExpandToEnclosingUnit(unit: number): void;
+    FindAttribute(attributeId: number, value: Object, backward: boolean): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider;
+    FindText(text: string, backward: boolean, ignoreCase: boolean): Windows.UI.Xaml.Automation.Provider.ITextRangeProvider;
+    GetAttributeValue(attributeId: number): Object;
+    GetBoundingRectangles(returnValue: number[]): void;
+    GetChildren(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple[];
+    GetEnclosingElement(): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    GetText(maxLength: number): string;
+    Move(unit: number, count: number): number;
+    MoveEndpointByRange(endpoint: number, textRangeProvider: Windows.UI.Xaml.Automation.Provider.ITextRangeProvider, targetEndpoint: number): void;
+    MoveEndpointByUnit(endpoint: number, unit: number, count: number): number;
+    RemoveFromSelection(): void;
+    ScrollIntoView(alignToTop: boolean): void;
+    Select(): void;
+    ShowContextMenu(): void;
+  }
+  var ITextRangeProvider2: abstract new (...args: any[]) => ITextRangeProvider2;
+
+  interface IToggleProvider {
+    Toggle(): void;
+    readonly ToggleState: number;
+  }
+  var IToggleProvider: abstract new (...args: any[]) => IToggleProvider;
+
+  interface ITransformProvider {
+    Move(x: number, y: number): void;
+    Resize(width: number, height: number): void;
+    Rotate(degrees: number): void;
+    readonly CanMove: boolean;
+    readonly CanResize: boolean;
+    readonly CanRotate: boolean;
+  }
+  var ITransformProvider: abstract new (...args: any[]) => ITransformProvider;
+
+  interface ITransformProvider2 extends Windows.UI.Xaml.Automation.Provider.ITransformProvider {
+    Move(x: number, y: number): void;
+    Resize(width: number, height: number): void;
+    Rotate(degrees: number): void;
+    Zoom(zoom: number): void;
+    ZoomByUnit(zoomUnit: number): void;
+    readonly CanZoom: boolean;
+    readonly MaxZoom: number;
+    readonly MinZoom: number;
+    readonly ZoomLevel: number;
+  }
+  var ITransformProvider2: abstract new (...args: any[]) => ITransformProvider2;
+
+  interface IValueProvider {
+    SetValue(value: string): void;
+    readonly IsReadOnly: boolean;
+    readonly Value: string;
+  }
+  var IValueProvider: abstract new (...args: any[]) => IValueProvider;
+
+  interface IVirtualizedItemProvider {
+    Realize(): void;
+  }
+  var IVirtualizedItemProvider: abstract new (...args: any[]) => IVirtualizedItemProvider;
+
+  interface IWindowProvider {
+    Close(): void;
+    SetVisualState(state: number): void;
+    WaitForInputIdle(milliseconds: number): boolean;
+    readonly InteractionState: number;
+    readonly IsModal: boolean;
+    readonly IsTopmost: boolean;
+    readonly Maximizable: boolean;
+    readonly Minimizable: boolean;
+    readonly VisualState: number;
+  }
+  var IWindowProvider: abstract new (...args: any[]) => IWindowProvider;
+
+}
+
+declare namespace Windows.UI.Xaml.Automation.Text {
+  enum TextPatternRangeEndpoint {
+    Start = 0,
+    End = 1,
+  }
+
+  enum TextUnit {
+    Character = 0,
+    Format = 1,
+    Word = 2,
+    Line = 3,
+    Paragraph = 4,
+    Page = 5,
+    Document = 6,
+  }
+
+}
+
+declare namespace Windows.UI.Xaml.Controls {
+  class AnchorRequestedEventArgs implements Windows.UI.Xaml.Controls.IAnchorRequestedEventArgs {
+    Anchor: Windows.UI.Xaml.UIElement;
+    readonly AnchorCandidates: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.UIElement> | Windows.UI.Xaml.UIElement[];
+  }
+
+  class AppBar extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.IAppBar, Windows.UI.Xaml.Controls.IAppBar2, Windows.UI.Xaml.Controls.IAppBar3, Windows.UI.Xaml.Controls.IAppBar4, Windows.UI.Xaml.Controls.IAppBarOverrides, Windows.UI.Xaml.Controls.IAppBarOverrides3 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnClosed(e: Object): void;
+    OnClosing(e: Object): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnOpened(e: Object): void;
+    OnOpening(e: Object): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    ClosedDisplayMode: number;
+    static readonly ClosedDisplayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    IsOpen: boolean;
+    static readonly IsOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    IsSticky: boolean;
+    static readonly IsStickyProperty: Windows.UI.Xaml.DependencyProperty;
+    LightDismissOverlayMode: number;
+    static readonly LightDismissOverlayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.AppBarTemplateSettings;
+    Closed: Windows.Foundation.EventHandler<Object> | null;
+    Opened: Windows.Foundation.EventHandler<Object> | null;
+    Closing: Windows.Foundation.EventHandler<Object> | null;
+    Opening: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class AppBarButton extends Windows.UI.Xaml.Controls.Button implements Windows.UI.Xaml.Controls.IAppBarButton, Windows.UI.Xaml.Controls.IAppBarButton3, Windows.UI.Xaml.Controls.IAppBarButton4, Windows.UI.Xaml.Controls.IAppBarButton5, Windows.UI.Xaml.Controls.ICommandBarElement, Windows.UI.Xaml.Controls.ICommandBarElement2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    DynamicOverflowOrder: number;
+    static readonly DynamicOverflowOrderProperty: Windows.UI.Xaml.DependencyProperty;
+    Icon: Windows.UI.Xaml.Controls.IconElement;
+    static readonly IconProperty: Windows.UI.Xaml.DependencyProperty;
+    IsCompact: boolean;
+    static readonly IsCompactProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsInOverflow: boolean;
+    static readonly IsInOverflowProperty: Windows.UI.Xaml.DependencyProperty;
+    KeyboardAcceleratorTextOverride: string;
+    static readonly KeyboardAcceleratorTextOverrideProperty: Windows.UI.Xaml.DependencyProperty;
+    Label: string;
+    LabelPosition: number;
+    static readonly LabelPositionProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly LabelProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.AppBarButtonTemplateSettings;
+  }
+
+  class AppBarElementContainer extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.IAppBarElementContainer, Windows.UI.Xaml.Controls.ICommandBarElement, Windows.UI.Xaml.Controls.ICommandBarElement2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    DynamicOverflowOrder: number;
+    static readonly DynamicOverflowOrderProperty: Windows.UI.Xaml.DependencyProperty;
+    IsCompact: boolean;
+    static readonly IsCompactProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsInOverflow: boolean;
+    static readonly IsInOverflowProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class AppBarSeparator extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IAppBarSeparator, Windows.UI.Xaml.Controls.ICommandBarElement, Windows.UI.Xaml.Controls.ICommandBarElement2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    DynamicOverflowOrder: number;
+    static readonly DynamicOverflowOrderProperty: Windows.UI.Xaml.DependencyProperty;
+    IsCompact: boolean;
+    static readonly IsCompactProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsInOverflow: boolean;
+    static readonly IsInOverflowProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class AppBarToggleButton extends Windows.UI.Xaml.Controls.Primitives.ToggleButton implements Windows.UI.Xaml.Controls.IAppBarToggleButton, Windows.UI.Xaml.Controls.IAppBarToggleButton3, Windows.UI.Xaml.Controls.IAppBarToggleButton4, Windows.UI.Xaml.Controls.IAppBarToggleButton5, Windows.UI.Xaml.Controls.ICommandBarElement, Windows.UI.Xaml.Controls.ICommandBarElement2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnToggle(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    DynamicOverflowOrder: number;
+    static readonly DynamicOverflowOrderProperty: Windows.UI.Xaml.DependencyProperty;
+    Icon: Windows.UI.Xaml.Controls.IconElement;
+    static readonly IconProperty: Windows.UI.Xaml.DependencyProperty;
+    IsCompact: boolean;
+    static readonly IsCompactProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsInOverflow: boolean;
+    static readonly IsInOverflowProperty: Windows.UI.Xaml.DependencyProperty;
+    KeyboardAcceleratorTextOverride: string;
+    static readonly KeyboardAcceleratorTextOverrideProperty: Windows.UI.Xaml.DependencyProperty;
+    Label: string;
+    LabelPosition: number;
+    static readonly LabelPositionProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly LabelProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.AppBarToggleButtonTemplateSettings;
+  }
+
+  class AutoSuggestBox extends Windows.UI.Xaml.Controls.ItemsControl implements Windows.UI.Xaml.Controls.IAutoSuggestBox, Windows.UI.Xaml.Controls.IAutoSuggestBox2, Windows.UI.Xaml.Controls.IAutoSuggestBox3, Windows.UI.Xaml.Controls.IAutoSuggestBox4 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    ContainerFromIndex(index: number): Windows.UI.Xaml.DependencyObject;
+    ContainerFromItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetContainerForItemOverride(): Windows.UI.Xaml.DependencyObject;
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetItemsOwner(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    GroupHeaderContainerFromItemContainer(itemContainer: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+    IndexFromContainer(container: Windows.UI.Xaml.DependencyObject): number;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    IsItemItsOwnContainerOverride(item: Object): boolean;
+    ItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    static ItemsControlFromItemContainer(container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnGroupStyleSelectorChanged(oldGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector, newGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnItemContainerStyleChanged(oldItemContainerStyle: Windows.UI.Xaml.Style, newItemContainerStyle: Windows.UI.Xaml.Style): void;
+    OnItemContainerStyleSelectorChanged(oldItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector, newItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector): void;
+    OnItemTemplateChanged(oldItemTemplate: Windows.UI.Xaml.DataTemplate, newItemTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnItemTemplateSelectorChanged(oldItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnItemsChanged(e: Object): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PrepareContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    AutoMaximizeSuggestionArea: boolean;
+    static readonly AutoMaximizeSuggestionAreaProperty: Windows.UI.Xaml.DependencyProperty;
+    Description: Object;
+    static readonly DescriptionProperty: Windows.UI.Xaml.DependencyProperty;
+    Header: Object;
+    static readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    IsSuggestionListOpen: boolean;
+    static readonly IsSuggestionListOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    LightDismissOverlayMode: number;
+    static readonly LightDismissOverlayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxSuggestionListHeight: number;
+    static readonly MaxSuggestionListHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    PlaceholderText: string;
+    static readonly PlaceholderTextProperty: Windows.UI.Xaml.DependencyProperty;
+    QueryIcon: Windows.UI.Xaml.Controls.IconElement;
+    static readonly QueryIconProperty: Windows.UI.Xaml.DependencyProperty;
+    Text: string;
+    TextBoxStyle: Windows.UI.Xaml.Style;
+    static readonly TextBoxStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    TextMemberPath: string;
+    static readonly TextMemberPathProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly TextProperty: Windows.UI.Xaml.DependencyProperty;
+    UpdateTextOnSelect: boolean;
+    static readonly UpdateTextOnSelectProperty: Windows.UI.Xaml.DependencyProperty;
+    SuggestionChosen: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.AutoSuggestBox, Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs> | null;
+    TextChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.AutoSuggestBox, Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs> | null;
+    QuerySubmitted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.AutoSuggestBox, Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs> | null;
+  }
+
+  class AutoSuggestBoxQuerySubmittedEventArgs extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.IAutoSuggestBoxQuerySubmittedEventArgs {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly ChosenSuggestion: Object;
+    readonly QueryText: string;
+  }
+
+  class AutoSuggestBoxSuggestionChosenEventArgs extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.IAutoSuggestBoxSuggestionChosenEventArgs {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly SelectedItem: Object;
+  }
+
+  class AutoSuggestBoxTextChangedEventArgs extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.IAutoSuggestBoxTextChangedEventArgs {
+    constructor();
+    CheckCurrent(): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Reason: number;
+    static readonly ReasonProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class BackClickEventArgs implements Windows.UI.Xaml.Controls.IBackClickEventArgs {
+    constructor();
+    Handled: boolean;
+  }
+
+  class BitmapIcon extends Windows.UI.Xaml.Controls.IconElement implements Windows.UI.Xaml.Controls.IBitmapIcon, Windows.UI.Xaml.Controls.IBitmapIcon2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    ShowAsMonochrome: boolean;
+    static readonly ShowAsMonochromeProperty: Windows.UI.Xaml.DependencyProperty;
+    UriSource: Windows.Foundation.Uri;
+    static readonly UriSourceProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class BitmapIconSource extends Windows.UI.Xaml.Controls.IconSource implements Windows.UI.Xaml.Controls.IBitmapIconSource {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    ShowAsMonochrome: boolean;
+    static readonly ShowAsMonochromeProperty: Windows.UI.Xaml.DependencyProperty;
+    UriSource: Windows.Foundation.Uri;
+    static readonly UriSourceProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Border extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Controls.IBorder, Windows.UI.Xaml.Controls.IBorder2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Background: Windows.UI.Xaml.Media.Brush;
+    static readonly BackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    BackgroundSizing: number;
+    static readonly BackgroundSizingProperty: Windows.UI.Xaml.DependencyProperty;
+    BackgroundTransition: Windows.UI.Xaml.BrushTransition;
+    BorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly BorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    BorderThickness: Windows.UI.Xaml.Thickness;
+    static readonly BorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    Child: Windows.UI.Xaml.UIElement;
+    ChildTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    static readonly ChildTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    CornerRadius: Windows.UI.Xaml.CornerRadius;
+    static readonly CornerRadiusProperty: Windows.UI.Xaml.DependencyProperty;
+    Padding: Windows.UI.Xaml.Thickness;
+    static readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Button extends Windows.UI.Xaml.Controls.Primitives.ButtonBase implements Windows.UI.Xaml.Controls.IButton, Windows.UI.Xaml.Controls.IButtonWithFlyout {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Flyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    static readonly FlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class CalendarDatePicker extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.ICalendarDatePicker, Windows.UI.Xaml.Controls.ICalendarDatePicker2, Windows.UI.Xaml.Controls.ICalendarDatePicker3 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetDisplayDate(date: Windows.Foundation.DateTime): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    SetYearDecadeDisplayDimensions(columns: number, rows: number): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    CalendarIdentifier: string;
+    static readonly CalendarIdentifierProperty: Windows.UI.Xaml.DependencyProperty;
+    CalendarViewStyle: Windows.UI.Xaml.Style;
+    static readonly CalendarViewStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    Date: Windows.Foundation.DateTime | null;
+    DateFormat: string;
+    static readonly DateFormatProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly DateProperty: Windows.UI.Xaml.DependencyProperty;
+    DayOfWeekFormat: string;
+    static readonly DayOfWeekFormatProperty: Windows.UI.Xaml.DependencyProperty;
+    Description: Object;
+    static readonly DescriptionProperty: Windows.UI.Xaml.DependencyProperty;
+    DisplayMode: number;
+    static readonly DisplayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    FirstDayOfWeek: number;
+    static readonly FirstDayOfWeekProperty: Windows.UI.Xaml.DependencyProperty;
+    Header: Object;
+    static readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    IsCalendarOpen: boolean;
+    static readonly IsCalendarOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    IsGroupLabelVisible: boolean;
+    static readonly IsGroupLabelVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsOutOfScopeEnabled: boolean;
+    static readonly IsOutOfScopeEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsTodayHighlighted: boolean;
+    static readonly IsTodayHighlightedProperty: Windows.UI.Xaml.DependencyProperty;
+    LightDismissOverlayMode: number;
+    static readonly LightDismissOverlayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxDate: Windows.Foundation.DateTime;
+    static readonly MaxDateProperty: Windows.UI.Xaml.DependencyProperty;
+    MinDate: Windows.Foundation.DateTime;
+    static readonly MinDateProperty: Windows.UI.Xaml.DependencyProperty;
+    PlaceholderText: string;
+    static readonly PlaceholderTextProperty: Windows.UI.Xaml.DependencyProperty;
+    CalendarViewDayItemChanging: Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventHandler | null;
+    Closed: Windows.Foundation.EventHandler<Object> | null;
+    DateChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.CalendarDatePicker, Windows.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs> | null;
+    Opened: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class CalendarDatePickerDateChangedEventArgs implements Windows.UI.Xaml.Controls.ICalendarDatePickerDateChangedEventArgs {
+    readonly NewDate: Windows.Foundation.DateTime | null;
+    readonly OldDate: Windows.Foundation.DateTime | null;
+  }
+
+  class CalendarView extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.ICalendarView, Windows.UI.Xaml.Controls.ICalendarView2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetDisplayDate(date: Windows.Foundation.DateTime): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    SetYearDecadeDisplayDimensions(columns: number, rows: number): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    BlackoutBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly BlackoutBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    BlackoutForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly BlackoutForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    BlackoutStrikethroughBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly BlackoutStrikethroughBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CalendarIdentifier: string;
+    static readonly CalendarIdentifierProperty: Windows.UI.Xaml.DependencyProperty;
+    CalendarItemBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly CalendarItemBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    CalendarItemBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CalendarItemBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CalendarItemBorderThickness: Windows.UI.Xaml.Thickness;
+    static readonly CalendarItemBorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    CalendarItemCornerRadius: Windows.UI.Xaml.CornerRadius;
+    static readonly CalendarItemCornerRadiusProperty: Windows.UI.Xaml.DependencyProperty;
+    CalendarItemDisabledBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly CalendarItemDisabledBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    CalendarItemForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly CalendarItemForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    CalendarItemHoverBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly CalendarItemHoverBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    CalendarItemPressedBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly CalendarItemPressedBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    CalendarViewDayItemStyle: Windows.UI.Xaml.Style;
+    static readonly CalendarViewDayItemStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    DayItemFontFamily: Windows.UI.Xaml.Media.FontFamily;
+    static readonly DayItemFontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    DayItemFontSize: number;
+    static readonly DayItemFontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    DayItemFontStyle: number;
+    static readonly DayItemFontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    DayItemFontWeight: Windows.UI.Text.FontWeight;
+    static readonly DayItemFontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    DayItemMargin: Windows.UI.Xaml.Thickness;
+    static readonly DayItemMarginProperty: Windows.UI.Xaml.DependencyProperty;
+    DayOfWeekFormat: string;
+    static readonly DayOfWeekFormatProperty: Windows.UI.Xaml.DependencyProperty;
+    DisabledForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly DisabledForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    DisplayMode: number;
+    static readonly DisplayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    FirstDayOfWeek: number;
+    static readonly FirstDayOfWeekProperty: Windows.UI.Xaml.DependencyProperty;
+    FirstOfMonthLabelFontFamily: Windows.UI.Xaml.Media.FontFamily;
+    static readonly FirstOfMonthLabelFontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    FirstOfMonthLabelFontSize: number;
+    static readonly FirstOfMonthLabelFontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    FirstOfMonthLabelFontStyle: number;
+    static readonly FirstOfMonthLabelFontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    FirstOfMonthLabelFontWeight: Windows.UI.Text.FontWeight;
+    static readonly FirstOfMonthLabelFontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    FirstOfMonthLabelMargin: Windows.UI.Xaml.Thickness;
+    static readonly FirstOfMonthLabelMarginProperty: Windows.UI.Xaml.DependencyProperty;
+    FirstOfYearDecadeLabelFontFamily: Windows.UI.Xaml.Media.FontFamily;
+    static readonly FirstOfYearDecadeLabelFontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    FirstOfYearDecadeLabelFontSize: number;
+    static readonly FirstOfYearDecadeLabelFontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    FirstOfYearDecadeLabelFontStyle: number;
+    static readonly FirstOfYearDecadeLabelFontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    FirstOfYearDecadeLabelFontWeight: Windows.UI.Text.FontWeight;
+    static readonly FirstOfYearDecadeLabelFontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    FirstOfYearDecadeLabelMargin: Windows.UI.Xaml.Thickness;
+    static readonly FirstOfYearDecadeLabelMarginProperty: Windows.UI.Xaml.DependencyProperty;
+    FocusBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly FocusBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalDayItemAlignment: number;
+    static readonly HorizontalDayItemAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalFirstOfMonthLabelAlignment: number;
+    static readonly HorizontalFirstOfMonthLabelAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    HoverBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly HoverBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    IsGroupLabelVisible: boolean;
+    static readonly IsGroupLabelVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsOutOfScopeEnabled: boolean;
+    static readonly IsOutOfScopeEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsTodayHighlighted: boolean;
+    static readonly IsTodayHighlightedProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxDate: Windows.Foundation.DateTime;
+    static readonly MaxDateProperty: Windows.UI.Xaml.DependencyProperty;
+    MinDate: Windows.Foundation.DateTime;
+    static readonly MinDateProperty: Windows.UI.Xaml.DependencyProperty;
+    MonthYearItemFontFamily: Windows.UI.Xaml.Media.FontFamily;
+    static readonly MonthYearItemFontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    MonthYearItemFontSize: number;
+    static readonly MonthYearItemFontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    MonthYearItemFontStyle: number;
+    static readonly MonthYearItemFontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    MonthYearItemFontWeight: Windows.UI.Text.FontWeight;
+    static readonly MonthYearItemFontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    MonthYearItemMargin: Windows.UI.Xaml.Thickness;
+    static readonly MonthYearItemMarginProperty: Windows.UI.Xaml.DependencyProperty;
+    NumberOfWeeksInView: number;
+    static readonly NumberOfWeeksInViewProperty: Windows.UI.Xaml.DependencyProperty;
+    OutOfScopeBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly OutOfScopeBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    OutOfScopeForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly OutOfScopeForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    OutOfScopeHoverForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly OutOfScopeHoverForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    OutOfScopePressedForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly OutOfScopePressedForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    PressedBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly PressedBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    PressedForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly PressedForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedDates: Windows.Foundation.Collections.IVector<Windows.Foundation.DateTime> | Windows.Foundation.DateTime[];
+    static readonly SelectedDatesProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedDisabledBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedDisabledBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedDisabledForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedDisabledForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedHoverBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedHoverBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedHoverForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedHoverForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedPressedBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedPressedBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedPressedForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedPressedForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionMode: number;
+    static readonly SelectionModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.CalendarViewTemplateSettings;
+    static readonly TemplateSettingsProperty: Windows.UI.Xaml.DependencyProperty;
+    TodayBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly TodayBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    TodayBlackoutBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly TodayBlackoutBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    TodayBlackoutForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly TodayBlackoutForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    TodayDisabledBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly TodayDisabledBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    TodayFontWeight: Windows.UI.Text.FontWeight;
+    static readonly TodayFontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    TodayForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly TodayForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    TodayHoverBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly TodayHoverBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    TodayPressedBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly TodayPressedBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    TodaySelectedInnerBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly TodaySelectedInnerBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    VerticalDayItemAlignment: number;
+    static readonly VerticalDayItemAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    VerticalFirstOfMonthLabelAlignment: number;
+    static readonly VerticalFirstOfMonthLabelAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    CalendarViewDayItemChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.CalendarView, Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs> | null;
+    SelectedDatesChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.CalendarView, Windows.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs> | null;
+  }
+
+  class CalendarViewDayItem extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.ICalendarViewDayItem {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetDensityColors(colors: Windows.Foundation.Collections.IIterable<Windows.UI.Color> | Windows.UI.Color[]): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly Date: Windows.Foundation.DateTime;
+    static readonly DateProperty: Windows.UI.Xaml.DependencyProperty;
+    IsBlackout: boolean;
+    static readonly IsBlackoutProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class CalendarViewDayItemChangingEventArgs implements Windows.UI.Xaml.Controls.ICalendarViewDayItemChangingEventArgs {
+    RegisterUpdateCallback(callback: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.CalendarView, Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs>): void;
+    RegisterUpdateCallback(callbackPhase: number, callback: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.CalendarView, Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs>): void;
+    readonly InRecycleQueue: boolean;
+    readonly Item: Windows.UI.Xaml.Controls.CalendarViewDayItem;
+    readonly Phase: number;
+  }
+
+  class CalendarViewSelectedDatesChangedEventArgs implements Windows.UI.Xaml.Controls.ICalendarViewSelectedDatesChangedEventArgs {
+    readonly AddedDates: Windows.Foundation.Collections.IVectorView<Windows.Foundation.DateTime> | Windows.Foundation.DateTime[];
+    readonly RemovedDates: Windows.Foundation.Collections.IVectorView<Windows.Foundation.DateTime> | Windows.Foundation.DateTime[];
+  }
+
+  class CandidateWindowBoundsChangedEventArgs implements Windows.UI.Xaml.Controls.ICandidateWindowBoundsChangedEventArgs {
+    readonly Bounds: Windows.Foundation.Rect;
+  }
+
+  class Canvas extends Windows.UI.Xaml.Controls.Panel implements Windows.UI.Xaml.Controls.ICanvas {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetLeft(element: Windows.UI.Xaml.UIElement): number;
+    static GetTop(element: Windows.UI.Xaml.UIElement): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetZIndex(element: Windows.UI.Xaml.UIElement): number;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetLeft(element: Windows.UI.Xaml.UIElement, length: number): void;
+    static SetTop(element: Windows.UI.Xaml.UIElement, length: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    static SetZIndex(element: Windows.UI.Xaml.UIElement, value: number): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    static readonly LeftProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly TopProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly ZIndexProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class CaptureElement extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Controls.ICaptureElement {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Source: Windows.Media.Capture.MediaCapture;
+    static readonly SourceProperty: Windows.UI.Xaml.DependencyProperty;
+    Stretch: number;
+    static readonly StretchProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class CheckBox extends Windows.UI.Xaml.Controls.Primitives.ToggleButton implements Windows.UI.Xaml.Controls.ICheckBox {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnToggle(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class ChoosingGroupHeaderContainerEventArgs implements Windows.UI.Xaml.Controls.IChoosingGroupHeaderContainerEventArgs {
+    constructor();
+    readonly Group: Object;
+    GroupHeaderContainer: Windows.UI.Xaml.Controls.ListViewBaseHeaderItem;
+    readonly GroupIndex: number;
+  }
+
+  class ChoosingItemContainerEventArgs implements Windows.UI.Xaml.Controls.IChoosingItemContainerEventArgs {
+    constructor();
+    IsContainerPrepared: boolean;
+    readonly Item: Object;
+    ItemContainer: Windows.UI.Xaml.Controls.Primitives.SelectorItem;
+    readonly ItemIndex: number;
+  }
+
+  class CleanUpVirtualizedItemEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Controls.ICleanUpVirtualizedItemEventArgs {
+    Cancel: boolean;
+    readonly UIElement: Windows.UI.Xaml.UIElement;
+    readonly Value: Object;
+  }
+
+  class ColorChangedEventArgs implements Windows.UI.Xaml.Controls.IColorChangedEventArgs {
+    readonly NewColor: Windows.UI.Color;
+    readonly OldColor: Windows.UI.Color;
+  }
+
+  class ColorPicker extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IColorPicker {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Color: Windows.UI.Color;
+    static readonly ColorProperty: Windows.UI.Xaml.DependencyProperty;
+    ColorSpectrumComponents: number;
+    static readonly ColorSpectrumComponentsProperty: Windows.UI.Xaml.DependencyProperty;
+    ColorSpectrumShape: number;
+    static readonly ColorSpectrumShapeProperty: Windows.UI.Xaml.DependencyProperty;
+    IsAlphaEnabled: boolean;
+    static readonly IsAlphaEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsAlphaSliderVisible: boolean;
+    static readonly IsAlphaSliderVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsAlphaTextInputVisible: boolean;
+    static readonly IsAlphaTextInputVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsColorChannelTextInputVisible: boolean;
+    static readonly IsColorChannelTextInputVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsColorPreviewVisible: boolean;
+    static readonly IsColorPreviewVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsColorSliderVisible: boolean;
+    static readonly IsColorSliderVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsColorSpectrumVisible: boolean;
+    static readonly IsColorSpectrumVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsHexInputVisible: boolean;
+    static readonly IsHexInputVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsMoreButtonVisible: boolean;
+    static readonly IsMoreButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxHue: number;
+    static readonly MaxHueProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxSaturation: number;
+    static readonly MaxSaturationProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxValue: number;
+    static readonly MaxValueProperty: Windows.UI.Xaml.DependencyProperty;
+    MinHue: number;
+    static readonly MinHueProperty: Windows.UI.Xaml.DependencyProperty;
+    MinSaturation: number;
+    static readonly MinSaturationProperty: Windows.UI.Xaml.DependencyProperty;
+    MinValue: number;
+    static readonly MinValueProperty: Windows.UI.Xaml.DependencyProperty;
+    PreviousColor: Windows.UI.Color | null;
+    static readonly PreviousColorProperty: Windows.UI.Xaml.DependencyProperty;
+    ColorChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ColorPicker, Windows.UI.Xaml.Controls.ColorChangedEventArgs> | null;
+  }
+
+  class ColumnDefinition extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.IColumnDefinition {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly ActualWidth: number;
+    MaxWidth: number;
+    static readonly MaxWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    MinWidth: number;
+    static readonly MinWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    Width: Windows.UI.Xaml.GridLength;
+    static readonly WidthProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ColumnDefinitionCollection {
+    Append(value: Windows.UI.Xaml.Controls.ColumnDefinition): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Controls.ColumnDefinition>;
+    GetAt(index: number): Windows.UI.Xaml.Controls.ColumnDefinition;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Controls.ColumnDefinition[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Controls.ColumnDefinition> | Windows.UI.Xaml.Controls.ColumnDefinition[];
+    IndexOf(value: Windows.UI.Xaml.Controls.ColumnDefinition, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Controls.ColumnDefinition): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Controls.ColumnDefinition[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Controls.ColumnDefinition): void;
+    readonly Size: number;
+  }
+
+  class ComboBox extends Windows.UI.Xaml.Controls.Primitives.Selector implements Windows.UI.Xaml.Controls.IComboBox, Windows.UI.Xaml.Controls.IComboBox2, Windows.UI.Xaml.Controls.IComboBox3, Windows.UI.Xaml.Controls.IComboBox4, Windows.UI.Xaml.Controls.IComboBox5, Windows.UI.Xaml.Controls.IComboBox6, Windows.UI.Xaml.Controls.IComboBoxOverrides {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    ContainerFromIndex(index: number): Windows.UI.Xaml.DependencyObject;
+    ContainerFromItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetContainerForItemOverride(): Windows.UI.Xaml.DependencyObject;
+    static GetIsSelectionActive(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetItemsOwner(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    GroupHeaderContainerFromItemContainer(itemContainer: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+    IndexFromContainer(container: Windows.UI.Xaml.DependencyObject): number;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    IsItemItsOwnContainerOverride(item: Object): boolean;
+    ItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    static ItemsControlFromItemContainer(container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDropDownClosed(e: Object): void;
+    OnDropDownOpened(e: Object): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnGroupStyleSelectorChanged(oldGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector, newGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnItemContainerStyleChanged(oldItemContainerStyle: Windows.UI.Xaml.Style, newItemContainerStyle: Windows.UI.Xaml.Style): void;
+    OnItemContainerStyleSelectorChanged(oldItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector, newItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector): void;
+    OnItemTemplateChanged(oldItemTemplate: Windows.UI.Xaml.DataTemplate, newItemTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnItemTemplateSelectorChanged(oldItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnItemsChanged(e: Object): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PrepareContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Description: Object;
+    static readonly DescriptionProperty: Windows.UI.Xaml.DependencyProperty;
+    Header: Object;
+    static readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    IsDropDownOpen: boolean;
+    static readonly IsDropDownOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    IsEditable: boolean;
+    static readonly IsEditableProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsSelectionBoxHighlighted: boolean;
+    IsTextSearchEnabled: boolean;
+    static readonly IsTextSearchEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    LightDismissOverlayMode: number;
+    static readonly LightDismissOverlayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxDropDownHeight: number;
+    static readonly MaxDropDownHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    PlaceholderForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly PlaceholderForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    PlaceholderText: string;
+    static readonly PlaceholderTextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionBoxItem: Object;
+    readonly SelectionBoxItemTemplate: Windows.UI.Xaml.DataTemplate;
+    SelectionChangedTrigger: number;
+    static readonly SelectionChangedTriggerProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.ComboBoxTemplateSettings;
+    Text: string;
+    TextBoxStyle: Windows.UI.Xaml.Style;
+    static readonly TextBoxStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly TextProperty: Windows.UI.Xaml.DependencyProperty;
+    DropDownClosed: Windows.Foundation.EventHandler<Object> | null;
+    DropDownOpened: Windows.Foundation.EventHandler<Object> | null;
+    TextSubmitted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ComboBox, Windows.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs> | null;
+  }
+
+  class ComboBoxItem extends Windows.UI.Xaml.Controls.Primitives.SelectorItem implements Windows.UI.Xaml.Controls.IComboBoxItem {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class ComboBoxTextSubmittedEventArgs implements Windows.UI.Xaml.Controls.IComboBoxTextSubmittedEventArgs {
+    Handled: boolean;
+    readonly Text: string;
+  }
+
+  class CommandBar extends Windows.UI.Xaml.Controls.AppBar implements Windows.UI.Xaml.Controls.ICommandBar, Windows.UI.Xaml.Controls.ICommandBar2, Windows.UI.Xaml.Controls.ICommandBar3 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnClosed(e: Object): void;
+    OnClosing(e: Object): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnOpened(e: Object): void;
+    OnOpening(e: Object): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    CommandBarOverflowPresenterStyle: Windows.UI.Xaml.Style;
+    static readonly CommandBarOverflowPresenterStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CommandBarTemplateSettings: Windows.UI.Xaml.Controls.Primitives.CommandBarTemplateSettings;
+    DefaultLabelPosition: number;
+    static readonly DefaultLabelPositionProperty: Windows.UI.Xaml.DependencyProperty;
+    IsDynamicOverflowEnabled: boolean;
+    static readonly IsDynamicOverflowEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    OverflowButtonVisibility: number;
+    static readonly OverflowButtonVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PrimaryCommands: Windows.Foundation.Collections.IObservableVector<Windows.UI.Xaml.Controls.ICommandBarElement>;
+    static readonly PrimaryCommandsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SecondaryCommands: Windows.Foundation.Collections.IObservableVector<Windows.UI.Xaml.Controls.ICommandBarElement>;
+    static readonly SecondaryCommandsProperty: Windows.UI.Xaml.DependencyProperty;
+    DynamicOverflowItemsChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.CommandBar, Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs> | null;
+  }
+
+  class CommandBarFlyout extends Windows.UI.Xaml.Controls.Primitives.FlyoutBase implements Windows.UI.Xaml.Controls.ICommandBarFlyout {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreatePresenter(): Windows.UI.Xaml.Controls.Control;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement): Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Hide(): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static SetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement, value: Windows.UI.Xaml.Controls.Primitives.FlyoutBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowAt(placementTarget: Windows.UI.Xaml.FrameworkElement): void;
+    ShowAt(placementTarget: Windows.UI.Xaml.DependencyObject, showOptions: Windows.UI.Xaml.Controls.Primitives.FlyoutShowOptions): void;
+    static ShowAttachedFlyout(flyoutOwner: Windows.UI.Xaml.FrameworkElement): void;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly PrimaryCommands: Windows.Foundation.Collections.IObservableVector<Windows.UI.Xaml.Controls.ICommandBarElement>;
+    readonly SecondaryCommands: Windows.Foundation.Collections.IObservableVector<Windows.UI.Xaml.Controls.ICommandBarElement>;
+  }
+
+  class CommandBarOverflowPresenter extends Windows.UI.Xaml.Controls.ItemsControl implements Windows.UI.Xaml.Controls.ICommandBarOverflowPresenter {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    ContainerFromIndex(index: number): Windows.UI.Xaml.DependencyObject;
+    ContainerFromItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetContainerForItemOverride(): Windows.UI.Xaml.DependencyObject;
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetItemsOwner(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    GroupHeaderContainerFromItemContainer(itemContainer: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+    IndexFromContainer(container: Windows.UI.Xaml.DependencyObject): number;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    IsItemItsOwnContainerOverride(item: Object): boolean;
+    ItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    static ItemsControlFromItemContainer(container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnGroupStyleSelectorChanged(oldGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector, newGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnItemContainerStyleChanged(oldItemContainerStyle: Windows.UI.Xaml.Style, newItemContainerStyle: Windows.UI.Xaml.Style): void;
+    OnItemContainerStyleSelectorChanged(oldItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector, newItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector): void;
+    OnItemTemplateChanged(oldItemTemplate: Windows.UI.Xaml.DataTemplate, newItemTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnItemTemplateSelectorChanged(oldItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnItemsChanged(e: Object): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PrepareContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class ContainerContentChangingEventArgs implements Windows.UI.Xaml.Controls.IContainerContentChangingEventArgs {
+    constructor();
+    RegisterUpdateCallback(callback: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ListViewBase, Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs>): void;
+    RegisterUpdateCallback(callbackPhase: number, callback: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ListViewBase, Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs>): void;
+    Handled: boolean;
+    readonly InRecycleQueue: boolean;
+    readonly Item: Object;
+    readonly ItemContainer: Windows.UI.Xaml.Controls.Primitives.SelectorItem;
+    readonly ItemIndex: number;
+    readonly Phase: number;
+  }
+
+  class ContentControl extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IContentControl, Windows.UI.Xaml.Controls.IContentControl2, Windows.UI.Xaml.Controls.IContentControlOverrides {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Content: Object;
+    static readonly ContentProperty: Windows.UI.Xaml.DependencyProperty;
+    ContentTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly ContentTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentTemplateRoot: Windows.UI.Xaml.UIElement;
+    ContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector;
+    static readonly ContentTemplateSelectorProperty: Windows.UI.Xaml.DependencyProperty;
+    ContentTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    static readonly ContentTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ContentDialog extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.IContentDialog, Windows.UI.Xaml.Controls.IContentDialog2, Windows.UI.Xaml.Controls.IContentDialog3 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    Hide(): void;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowAsync(): Windows.Foundation.IAsyncOperation<number>;
+    ShowAsync(placement: number): Windows.Foundation.IAsyncOperation<number>;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    CloseButtonCommand: Windows.UI.Xaml.Input.ICommand;
+    CloseButtonCommandParameter: Object;
+    static readonly CloseButtonCommandParameterProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly CloseButtonCommandProperty: Windows.UI.Xaml.DependencyProperty;
+    CloseButtonStyle: Windows.UI.Xaml.Style;
+    static readonly CloseButtonStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    CloseButtonText: string;
+    static readonly CloseButtonTextProperty: Windows.UI.Xaml.DependencyProperty;
+    DefaultButton: number;
+    static readonly DefaultButtonProperty: Windows.UI.Xaml.DependencyProperty;
+    FullSizeDesired: boolean;
+    static readonly FullSizeDesiredProperty: Windows.UI.Xaml.DependencyProperty;
+    IsPrimaryButtonEnabled: boolean;
+    static readonly IsPrimaryButtonEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsSecondaryButtonEnabled: boolean;
+    static readonly IsSecondaryButtonEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    PrimaryButtonCommand: Windows.UI.Xaml.Input.ICommand;
+    PrimaryButtonCommandParameter: Object;
+    static readonly PrimaryButtonCommandParameterProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly PrimaryButtonCommandProperty: Windows.UI.Xaml.DependencyProperty;
+    PrimaryButtonStyle: Windows.UI.Xaml.Style;
+    static readonly PrimaryButtonStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    PrimaryButtonText: string;
+    static readonly PrimaryButtonTextProperty: Windows.UI.Xaml.DependencyProperty;
+    SecondaryButtonCommand: Windows.UI.Xaml.Input.ICommand;
+    SecondaryButtonCommandParameter: Object;
+    static readonly SecondaryButtonCommandParameterProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly SecondaryButtonCommandProperty: Windows.UI.Xaml.DependencyProperty;
+    SecondaryButtonStyle: Windows.UI.Xaml.Style;
+    static readonly SecondaryButtonStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    SecondaryButtonText: string;
+    static readonly SecondaryButtonTextProperty: Windows.UI.Xaml.DependencyProperty;
+    Title: Object;
+    static readonly TitleProperty: Windows.UI.Xaml.DependencyProperty;
+    TitleTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly TitleTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ContentDialog, Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs> | null;
+    Closing: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ContentDialog, Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs> | null;
+    Opened: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ContentDialog, Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs> | null;
+    PrimaryButtonClick: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ContentDialog, Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs> | null;
+    SecondaryButtonClick: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ContentDialog, Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs> | null;
+    CloseButtonClick: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ContentDialog, Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs> | null;
+  }
+
+  class ContentDialogButtonClickDeferral implements Windows.UI.Xaml.Controls.IContentDialogButtonClickDeferral {
+    Complete(): void;
+  }
+
+  class ContentDialogButtonClickEventArgs implements Windows.UI.Xaml.Controls.IContentDialogButtonClickEventArgs {
+    GetDeferral(): Windows.UI.Xaml.Controls.ContentDialogButtonClickDeferral;
+    Cancel: boolean;
+  }
+
+  class ContentDialogClosedEventArgs implements Windows.UI.Xaml.Controls.IContentDialogClosedEventArgs {
+    readonly Result: number;
+  }
+
+  class ContentDialogClosingDeferral implements Windows.UI.Xaml.Controls.IContentDialogClosingDeferral {
+    Complete(): void;
+  }
+
+  class ContentDialogClosingEventArgs implements Windows.UI.Xaml.Controls.IContentDialogClosingEventArgs {
+    GetDeferral(): Windows.UI.Xaml.Controls.ContentDialogClosingDeferral;
+    Cancel: boolean;
+    readonly Result: number;
+  }
+
+  class ContentDialogOpenedEventArgs implements Windows.UI.Xaml.Controls.IContentDialogOpenedEventArgs {
+  }
+
+  class ContentLinkChangedEventArgs implements Windows.UI.Xaml.Controls.IContentLinkChangedEventArgs {
+    readonly ChangeKind: number;
+    readonly ContentLinkInfo: Windows.UI.Text.ContentLinkInfo;
+    readonly TextRange: Windows.UI.Xaml.Documents.TextRange;
+  }
+
+  class ContentPresenter extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Controls.IContentPresenter, Windows.UI.Xaml.Controls.IContentPresenter2, Windows.UI.Xaml.Controls.IContentPresenter3, Windows.UI.Xaml.Controls.IContentPresenter4, Windows.UI.Xaml.Controls.IContentPresenter5, Windows.UI.Xaml.Controls.IContentPresenterOverrides {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Background: Windows.UI.Xaml.Media.Brush;
+    static readonly BackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    BackgroundSizing: number;
+    static readonly BackgroundSizingProperty: Windows.UI.Xaml.DependencyProperty;
+    BackgroundTransition: Windows.UI.Xaml.BrushTransition;
+    BorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly BorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    BorderThickness: Windows.UI.Xaml.Thickness;
+    static readonly BorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    CharacterSpacing: number;
+    static readonly CharacterSpacingProperty: Windows.UI.Xaml.DependencyProperty;
+    Content: Object;
+    static readonly ContentProperty: Windows.UI.Xaml.DependencyProperty;
+    ContentTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly ContentTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    ContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector;
+    static readonly ContentTemplateSelectorProperty: Windows.UI.Xaml.DependencyProperty;
+    ContentTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    static readonly ContentTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    CornerRadius: Windows.UI.Xaml.CornerRadius;
+    static readonly CornerRadiusProperty: Windows.UI.Xaml.DependencyProperty;
+    FontFamily: Windows.UI.Xaml.Media.FontFamily;
+    static readonly FontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    FontSize: number;
+    static readonly FontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    FontStretch: number;
+    static readonly FontStretchProperty: Windows.UI.Xaml.DependencyProperty;
+    FontStyle: number;
+    static readonly FontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    FontWeight: Windows.UI.Text.FontWeight;
+    static readonly FontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    Foreground: Windows.UI.Xaml.Media.Brush;
+    static readonly ForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalContentAlignment: number;
+    static readonly HorizontalContentAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    IsTextScaleFactorEnabled: boolean;
+    static readonly IsTextScaleFactorEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    LineHeight: number;
+    static readonly LineHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    LineStackingStrategy: number;
+    static readonly LineStackingStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxLines: number;
+    static readonly MaxLinesProperty: Windows.UI.Xaml.DependencyProperty;
+    OpticalMarginAlignment: number;
+    static readonly OpticalMarginAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    Padding: Windows.UI.Xaml.Thickness;
+    static readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    TextLineBounds: number;
+    static readonly TextLineBoundsProperty: Windows.UI.Xaml.DependencyProperty;
+    TextWrapping: number;
+    static readonly TextWrappingProperty: Windows.UI.Xaml.DependencyProperty;
+    VerticalContentAlignment: number;
+    static readonly VerticalContentAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ContextMenuEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Controls.IContextMenuEventArgs {
+    readonly CursorLeft: number;
+    readonly CursorTop: number;
+    Handled: boolean;
+  }
+
+  class Control extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Controls.IControl, Windows.UI.Xaml.Controls.IControl2, Windows.UI.Xaml.Controls.IControl3, Windows.UI.Xaml.Controls.IControl4, Windows.UI.Xaml.Controls.IControl5, Windows.UI.Xaml.Controls.IControl7, Windows.UI.Xaml.Controls.IControlOverrides, Windows.UI.Xaml.Controls.IControlOverrides6, Windows.UI.Xaml.Controls.IControlProtected {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Background: Windows.UI.Xaml.Media.Brush;
+    static readonly BackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    BackgroundSizing: number;
+    static readonly BackgroundSizingProperty: Windows.UI.Xaml.DependencyProperty;
+    BorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly BorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    BorderThickness: Windows.UI.Xaml.Thickness;
+    static readonly BorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    CharacterSpacing: number;
+    static readonly CharacterSpacingProperty: Windows.UI.Xaml.DependencyProperty;
+    CornerRadius: Windows.UI.Xaml.CornerRadius;
+    static readonly CornerRadiusProperty: Windows.UI.Xaml.DependencyProperty;
+    DefaultStyleKey: Object;
+    static readonly DefaultStyleKeyProperty: Windows.UI.Xaml.DependencyProperty;
+    DefaultStyleResourceUri: Windows.Foundation.Uri;
+    static readonly DefaultStyleResourceUriProperty: Windows.UI.Xaml.DependencyProperty;
+    ElementSoundMode: number;
+    static readonly ElementSoundModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FocusState: number;
+    static readonly FocusStateProperty: Windows.UI.Xaml.DependencyProperty;
+    FontFamily: Windows.UI.Xaml.Media.FontFamily;
+    static readonly FontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    FontSize: number;
+    static readonly FontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    FontStretch: number;
+    static readonly FontStretchProperty: Windows.UI.Xaml.DependencyProperty;
+    FontStyle: number;
+    static readonly FontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    FontWeight: Windows.UI.Text.FontWeight;
+    static readonly FontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    Foreground: Windows.UI.Xaml.Media.Brush;
+    static readonly ForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalContentAlignment: number;
+    static readonly HorizontalContentAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    IsEnabled: boolean;
+    static readonly IsEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsFocusEngaged: boolean;
+    static readonly IsFocusEngagedProperty: Windows.UI.Xaml.DependencyProperty;
+    IsFocusEngagementEnabled: boolean;
+    static readonly IsFocusEngagementEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsTabStop: boolean;
+    static readonly IsTabStopProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly IsTemplateFocusTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly IsTemplateKeyTipTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    IsTextScaleFactorEnabled: boolean;
+    static readonly IsTextScaleFactorEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    Padding: Windows.UI.Xaml.Thickness;
+    static readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    RequiresPointer: number;
+    static readonly RequiresPointerProperty: Windows.UI.Xaml.DependencyProperty;
+    TabIndex: number;
+    static readonly TabIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    TabNavigation: number;
+    static readonly TabNavigationProperty: Windows.UI.Xaml.DependencyProperty;
+    Template: Windows.UI.Xaml.Controls.ControlTemplate;
+    static readonly TemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    UseSystemFocusVisuals: boolean;
+    static readonly UseSystemFocusVisualsProperty: Windows.UI.Xaml.DependencyProperty;
+    VerticalContentAlignment: number;
+    static readonly VerticalContentAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusDown: Windows.UI.Xaml.DependencyObject;
+    static readonly XYFocusDownProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusLeft: Windows.UI.Xaml.DependencyObject;
+    static readonly XYFocusLeftProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusRight: Windows.UI.Xaml.DependencyObject;
+    static readonly XYFocusRightProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusUp: Windows.UI.Xaml.DependencyObject;
+    static readonly XYFocusUpProperty: Windows.UI.Xaml.DependencyProperty;
+    IsEnabledChanged: Windows.UI.Xaml.DependencyPropertyChangedEventHandler | null;
+    FocusDisengaged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Control, Windows.UI.Xaml.Controls.FocusDisengagedEventArgs> | null;
+    FocusEngaged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Control, Windows.UI.Xaml.Controls.FocusEngagedEventArgs> | null;
+  }
+
+  class ControlTemplate extends Windows.UI.Xaml.FrameworkTemplate implements Windows.UI.Xaml.Controls.IControlTemplate {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    TargetType: Windows.UI.Xaml.Interop.TypeName;
+  }
+
+  class DataTemplateSelector implements Windows.UI.Xaml.Controls.IDataTemplateSelector, Windows.UI.Xaml.Controls.IDataTemplateSelector2, Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides, Windows.UI.Xaml.Controls.IDataTemplateSelectorOverrides2, Windows.UI.Xaml.IElementFactory {
+    constructor();
+    GetElement(args: Windows.UI.Xaml.ElementFactoryGetArgs): Windows.UI.Xaml.UIElement;
+    RecycleElement(args: Windows.UI.Xaml.ElementFactoryRecycleArgs): void;
+    SelectTemplate(item: Object, container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DataTemplate;
+    SelectTemplate(item: Object): Windows.UI.Xaml.DataTemplate;
+    SelectTemplateCore(item: Object, container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DataTemplate;
+    SelectTemplateCore(item: Object): Windows.UI.Xaml.DataTemplate;
+  }
+
+  class DatePickedEventArgs extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.IDatePickedEventArgs {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly NewDate: Windows.Foundation.DateTime;
+    readonly OldDate: Windows.Foundation.DateTime;
+  }
+
+  class DatePicker extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IDatePicker, Windows.UI.Xaml.Controls.IDatePicker2, Windows.UI.Xaml.Controls.IDatePicker3 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    CalendarIdentifier: string;
+    static readonly CalendarIdentifierProperty: Windows.UI.Xaml.DependencyProperty;
+    Date: Windows.Foundation.DateTime;
+    static readonly DateProperty: Windows.UI.Xaml.DependencyProperty;
+    DayFormat: string;
+    static readonly DayFormatProperty: Windows.UI.Xaml.DependencyProperty;
+    DayVisible: boolean;
+    static readonly DayVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    Header: Object;
+    static readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    LightDismissOverlayMode: number;
+    static readonly LightDismissOverlayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxYear: Windows.Foundation.DateTime;
+    static readonly MaxYearProperty: Windows.UI.Xaml.DependencyProperty;
+    MinYear: Windows.Foundation.DateTime;
+    static readonly MinYearProperty: Windows.UI.Xaml.DependencyProperty;
+    MonthFormat: string;
+    static readonly MonthFormatProperty: Windows.UI.Xaml.DependencyProperty;
+    MonthVisible: boolean;
+    static readonly MonthVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    Orientation: number;
+    static readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedDate: Windows.Foundation.DateTime | null;
+    static readonly SelectedDateProperty: Windows.UI.Xaml.DependencyProperty;
+    YearFormat: string;
+    static readonly YearFormatProperty: Windows.UI.Xaml.DependencyProperty;
+    YearVisible: boolean;
+    static readonly YearVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    DateChanged: Windows.Foundation.EventHandler<Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs> | null;
+    SelectedDateChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.DatePicker, Windows.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs> | null;
+  }
+
+  class DatePickerFlyout extends Windows.UI.Xaml.Controls.Primitives.PickerFlyoutBase implements Windows.UI.Xaml.Controls.IDatePickerFlyout, Windows.UI.Xaml.Controls.IDatePickerFlyout2 {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreatePresenter(): Windows.UI.Xaml.Controls.Control;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement): Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    static GetTitle(element: Windows.UI.Xaml.DependencyObject): string;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Hide(): void;
+    OnConfirmed(): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static SetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement, value: Windows.UI.Xaml.Controls.Primitives.FlyoutBase): void;
+    static SetTitle(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShouldShowConfirmationButtons(): boolean;
+    ShowAt(placementTarget: Windows.UI.Xaml.FrameworkElement): void;
+    ShowAt(placementTarget: Windows.UI.Xaml.DependencyObject, showOptions: Windows.UI.Xaml.Controls.Primitives.FlyoutShowOptions): void;
+    ShowAtAsync(target: Windows.UI.Xaml.FrameworkElement): Windows.Foundation.IAsyncOperation<Windows.Foundation.DateTime | null>;
+    static ShowAttachedFlyout(flyoutOwner: Windows.UI.Xaml.FrameworkElement): void;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    CalendarIdentifier: string;
+    static readonly CalendarIdentifierProperty: Windows.UI.Xaml.DependencyProperty;
+    Date: Windows.Foundation.DateTime;
+    static readonly DateProperty: Windows.UI.Xaml.DependencyProperty;
+    DayFormat: string;
+    static readonly DayFormatProperty: Windows.UI.Xaml.DependencyProperty;
+    DayVisible: boolean;
+    static readonly DayVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxYear: Windows.Foundation.DateTime;
+    static readonly MaxYearProperty: Windows.UI.Xaml.DependencyProperty;
+    MinYear: Windows.Foundation.DateTime;
+    static readonly MinYearProperty: Windows.UI.Xaml.DependencyProperty;
+    MonthFormat: string;
+    static readonly MonthFormatProperty: Windows.UI.Xaml.DependencyProperty;
+    MonthVisible: boolean;
+    static readonly MonthVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    YearFormat: string;
+    static readonly YearFormatProperty: Windows.UI.Xaml.DependencyProperty;
+    YearVisible: boolean;
+    static readonly YearVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    DatePicked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.DatePickerFlyout, Windows.UI.Xaml.Controls.DatePickedEventArgs> | null;
+  }
+
+  class DatePickerFlyoutItem extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.IDatePickerFlyoutItem, Windows.UI.Xaml.Data.ICustomPropertyProvider {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetCustomProperty(name: string): Windows.UI.Xaml.Data.ICustomProperty;
+    GetIndexedProperty(name: string, type: Windows.UI.Xaml.Interop.TypeName): Windows.UI.Xaml.Data.ICustomProperty;
+    GetStringRepresentation(): string;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    PrimaryText: string;
+    static readonly PrimaryTextProperty: Windows.UI.Xaml.DependencyProperty;
+    SecondaryText: string;
+    static readonly SecondaryTextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Type: Windows.UI.Xaml.Interop.TypeName;
+  }
+
+  class DatePickerFlyoutPresenter extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IDatePickerFlyoutPresenter, Windows.UI.Xaml.Controls.IDatePickerFlyoutPresenter2 {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    IsDefaultShadowEnabled: boolean;
+    static readonly IsDefaultShadowEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class DatePickerSelectedValueChangedEventArgs implements Windows.UI.Xaml.Controls.IDatePickerSelectedValueChangedEventArgs {
+    readonly NewDate: Windows.Foundation.DateTime | null;
+    readonly OldDate: Windows.Foundation.DateTime | null;
+  }
+
+  class DatePickerValueChangedEventArgs implements Windows.UI.Xaml.Controls.IDatePickerValueChangedEventArgs {
+    readonly NewDate: Windows.Foundation.DateTime;
+    readonly OldDate: Windows.Foundation.DateTime;
+  }
+
+  class DragItemsCompletedEventArgs implements Windows.UI.Xaml.Controls.IDragItemsCompletedEventArgs {
+    readonly DropResult: number;
+    readonly Items: Windows.Foundation.Collections.IVectorView<Object> | Object[];
+  }
+
+  class DragItemsStartingEventArgs implements Windows.UI.Xaml.Controls.IDragItemsStartingEventArgs {
+    constructor();
+    Cancel: boolean;
+    readonly Data: Windows.ApplicationModel.DataTransfer.DataPackage;
+    readonly Items: Windows.Foundation.Collections.IVector<Object> | Object[];
+  }
+
+  class DropDownButton extends Windows.UI.Xaml.Controls.Button implements Windows.UI.Xaml.Controls.IDropDownButton {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class DropDownButtonAutomationPeer extends Windows.UI.Xaml.Automation.Peers.ButtonAutomationPeer implements Windows.UI.Xaml.Automation.Provider.IExpandCollapseProvider, Windows.UI.Xaml.Controls.IDropDownButtonAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.DropDownButton);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Collapse(): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    Expand(): void;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    Invoke(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly ExpandCollapseState: number;
+  }
+
+  class DynamicOverflowItemsChangingEventArgs implements Windows.UI.Xaml.Controls.IDynamicOverflowItemsChangingEventArgs {
+    constructor();
+    readonly Action: number;
+  }
+
+  class FlipView extends Windows.UI.Xaml.Controls.Primitives.Selector implements Windows.UI.Xaml.Controls.IFlipView, Windows.UI.Xaml.Controls.IFlipView2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    ContainerFromIndex(index: number): Windows.UI.Xaml.DependencyObject;
+    ContainerFromItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetContainerForItemOverride(): Windows.UI.Xaml.DependencyObject;
+    static GetIsSelectionActive(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetItemsOwner(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    GroupHeaderContainerFromItemContainer(itemContainer: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+    IndexFromContainer(container: Windows.UI.Xaml.DependencyObject): number;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    IsItemItsOwnContainerOverride(item: Object): boolean;
+    ItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    static ItemsControlFromItemContainer(container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnGroupStyleSelectorChanged(oldGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector, newGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnItemContainerStyleChanged(oldItemContainerStyle: Windows.UI.Xaml.Style, newItemContainerStyle: Windows.UI.Xaml.Style): void;
+    OnItemContainerStyleSelectorChanged(oldItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector, newItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector): void;
+    OnItemTemplateChanged(oldItemTemplate: Windows.UI.Xaml.DataTemplate, newItemTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnItemTemplateSelectorChanged(oldItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnItemsChanged(e: Object): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PrepareContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    UseTouchAnimationsForAllNavigation: boolean;
+    static readonly UseTouchAnimationsForAllNavigationProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class FlipViewItem extends Windows.UI.Xaml.Controls.Primitives.SelectorItem implements Windows.UI.Xaml.Controls.IFlipViewItem {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class Flyout extends Windows.UI.Xaml.Controls.Primitives.FlyoutBase implements Windows.UI.Xaml.Controls.IFlyout {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreatePresenter(): Windows.UI.Xaml.Controls.Control;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement): Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Hide(): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static SetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement, value: Windows.UI.Xaml.Controls.Primitives.FlyoutBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowAt(placementTarget: Windows.UI.Xaml.FrameworkElement): void;
+    ShowAt(placementTarget: Windows.UI.Xaml.DependencyObject, showOptions: Windows.UI.Xaml.Controls.Primitives.FlyoutShowOptions): void;
+    static ShowAttachedFlyout(flyoutOwner: Windows.UI.Xaml.FrameworkElement): void;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Content: Windows.UI.Xaml.UIElement;
+    static readonly ContentProperty: Windows.UI.Xaml.DependencyProperty;
+    FlyoutPresenterStyle: Windows.UI.Xaml.Style;
+    static readonly FlyoutPresenterStyleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class FlyoutPresenter extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.IFlyoutPresenter, Windows.UI.Xaml.Controls.IFlyoutPresenter2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    IsDefaultShadowEnabled: boolean;
+    static readonly IsDefaultShadowEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class FocusDisengagedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Controls.IFocusDisengagedEventArgs {
+  }
+
+  class FocusEngagedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Controls.IFocusEngagedEventArgs, Windows.UI.Xaml.Controls.IFocusEngagedEventArgs2 {
+    Handled: boolean;
+  }
+
+  class FontIcon extends Windows.UI.Xaml.Controls.IconElement implements Windows.UI.Xaml.Controls.IFontIcon, Windows.UI.Xaml.Controls.IFontIcon2, Windows.UI.Xaml.Controls.IFontIcon3 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    FontFamily: Windows.UI.Xaml.Media.FontFamily;
+    static readonly FontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    FontSize: number;
+    static readonly FontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    FontStyle: number;
+    static readonly FontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    FontWeight: Windows.UI.Text.FontWeight;
+    static readonly FontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    Glyph: string;
+    static readonly GlyphProperty: Windows.UI.Xaml.DependencyProperty;
+    IsTextScaleFactorEnabled: boolean;
+    static readonly IsTextScaleFactorEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    MirroredWhenRightToLeft: boolean;
+    static readonly MirroredWhenRightToLeftProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class FontIconSource extends Windows.UI.Xaml.Controls.IconSource implements Windows.UI.Xaml.Controls.IFontIconSource {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    FontFamily: Windows.UI.Xaml.Media.FontFamily;
+    static readonly FontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    FontSize: number;
+    static readonly FontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    FontStyle: number;
+    static readonly FontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    FontWeight: Windows.UI.Text.FontWeight;
+    static readonly FontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    Glyph: string;
+    static readonly GlyphProperty: Windows.UI.Xaml.DependencyProperty;
+    IsTextScaleFactorEnabled: boolean;
+    static readonly IsTextScaleFactorEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    MirroredWhenRightToLeft: boolean;
+    static readonly MirroredWhenRightToLeftProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Frame extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.IFrame, Windows.UI.Xaml.Controls.IFrame2, Windows.UI.Xaml.Controls.IFrame3, Windows.UI.Xaml.Controls.IFrame4, Windows.UI.Xaml.Controls.IFrame5, Windows.UI.Xaml.Controls.INavigate {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetNavigationState(): string;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoBack(): void;
+    GoBack(transitionInfoOverride: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo): void;
+    GoForward(): void;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    Navigate(sourcePageType: Windows.UI.Xaml.Interop.TypeName, parameter: Object): boolean;
+    Navigate(sourcePageType: Windows.UI.Xaml.Interop.TypeName, parameter: Object, infoOverride: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo): boolean;
+    Navigate(sourcePageType: Windows.UI.Xaml.Interop.TypeName): boolean;
+    NavigateToType(sourcePageType: Windows.UI.Xaml.Interop.TypeName, parameter: Object, navigationOptions: Windows.UI.Xaml.Navigation.FrameNavigationOptions): boolean;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetNavigationState(navigationState: string): void;
+    SetNavigationState(navigationState: string, suppressNavigate: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly BackStack: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Navigation.PageStackEntry> | Windows.UI.Xaml.Navigation.PageStackEntry[];
+    readonly BackStackDepth: number;
+    static readonly BackStackDepthProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly BackStackProperty: Windows.UI.Xaml.DependencyProperty;
+    CacheSize: number;
+    static readonly CacheSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanGoBack: boolean;
+    static readonly CanGoBackProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanGoForward: boolean;
+    static readonly CanGoForwardProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CurrentSourcePageType: Windows.UI.Xaml.Interop.TypeName;
+    static readonly CurrentSourcePageTypeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ForwardStack: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Navigation.PageStackEntry> | Windows.UI.Xaml.Navigation.PageStackEntry[];
+    static readonly ForwardStackProperty: Windows.UI.Xaml.DependencyProperty;
+    IsNavigationStackEnabled: boolean;
+    static readonly IsNavigationStackEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    SourcePageType: Windows.UI.Xaml.Interop.TypeName;
+    static readonly SourcePageTypeProperty: Windows.UI.Xaml.DependencyProperty;
+    Navigated: Windows.UI.Xaml.Navigation.NavigatedEventHandler | null;
+    Navigating: Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler | null;
+    NavigationFailed: Windows.UI.Xaml.Navigation.NavigationFailedEventHandler | null;
+    NavigationStopped: Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler | null;
+  }
+
+  class Grid extends Windows.UI.Xaml.Controls.Panel implements Windows.UI.Xaml.Controls.IGrid, Windows.UI.Xaml.Controls.IGrid2, Windows.UI.Xaml.Controls.IGrid3, Windows.UI.Xaml.Controls.IGrid4 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetColumn(element: Windows.UI.Xaml.FrameworkElement): number;
+    static GetColumnSpan(element: Windows.UI.Xaml.FrameworkElement): number;
+    static GetRow(element: Windows.UI.Xaml.FrameworkElement): number;
+    static GetRowSpan(element: Windows.UI.Xaml.FrameworkElement): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetColumn(element: Windows.UI.Xaml.FrameworkElement, value: number): void;
+    static SetColumnSpan(element: Windows.UI.Xaml.FrameworkElement, value: number): void;
+    static SetRow(element: Windows.UI.Xaml.FrameworkElement, value: number): void;
+    static SetRowSpan(element: Windows.UI.Xaml.FrameworkElement, value: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    BackgroundSizing: number;
+    static readonly BackgroundSizingProperty: Windows.UI.Xaml.DependencyProperty;
+    BorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly BorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    BorderThickness: Windows.UI.Xaml.Thickness;
+    static readonly BorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ColumnDefinitions: Windows.UI.Xaml.Controls.ColumnDefinitionCollection;
+    static readonly ColumnProperty: Windows.UI.Xaml.DependencyProperty;
+    ColumnSpacing: number;
+    static readonly ColumnSpacingProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly ColumnSpanProperty: Windows.UI.Xaml.DependencyProperty;
+    CornerRadius: Windows.UI.Xaml.CornerRadius;
+    static readonly CornerRadiusProperty: Windows.UI.Xaml.DependencyProperty;
+    Padding: Windows.UI.Xaml.Thickness;
+    static readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RowDefinitions: Windows.UI.Xaml.Controls.RowDefinitionCollection;
+    static readonly RowProperty: Windows.UI.Xaml.DependencyProperty;
+    RowSpacing: number;
+    static readonly RowSpacingProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly RowSpanProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class GridView extends Windows.UI.Xaml.Controls.ListViewBase implements Windows.UI.Xaml.Controls.IGridView {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CompleteViewChange(): void;
+    CompleteViewChangeFrom(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    CompleteViewChangeTo(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    ContainerFromIndex(index: number): Windows.UI.Xaml.DependencyObject;
+    ContainerFromItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    DeselectRange(itemIndexRange: Windows.UI.Xaml.Data.ItemIndexRange): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetContainerForItemOverride(): Windows.UI.Xaml.DependencyObject;
+    static GetIsSelectionActive(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetItemsOwner(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    GroupHeaderContainerFromItemContainer(itemContainer: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+    IndexFromContainer(container: Windows.UI.Xaml.DependencyObject): number;
+    InitializeViewChange(): void;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    IsDragSource(): boolean;
+    IsItemItsOwnContainerOverride(item: Object): boolean;
+    ItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    static ItemsControlFromItemContainer(container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    LoadMoreItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Data.LoadMoreItemsResult>;
+    MakeVisible(item: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnGroupStyleSelectorChanged(oldGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector, newGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnItemContainerStyleChanged(oldItemContainerStyle: Windows.UI.Xaml.Style, newItemContainerStyle: Windows.UI.Xaml.Style): void;
+    OnItemContainerStyleSelectorChanged(oldItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector, newItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector): void;
+    OnItemTemplateChanged(oldItemTemplate: Windows.UI.Xaml.DataTemplate, newItemTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnItemTemplateSelectorChanged(oldItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnItemsChanged(e: Object): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PrepareConnectedAnimation(key: string, item: Object, elementName: string): Windows.UI.Xaml.Media.Animation.ConnectedAnimation;
+    PrepareContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    ScrollIntoView(item: Object): void;
+    ScrollIntoView(item: Object, alignment: number): void;
+    SelectAll(): void;
+    SelectRange(itemIndexRange: Windows.UI.Xaml.Data.ItemIndexRange): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetDesiredContainerUpdateDuration(duration: Windows.Foundation.TimeSpan): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StartViewChangeFrom(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    StartViewChangeTo(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    TryStartConnectedAnimationAsync(animation: Windows.UI.Xaml.Media.Animation.ConnectedAnimation, item: Object, elementName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class GridViewHeaderItem extends Windows.UI.Xaml.Controls.ListViewBaseHeaderItem implements Windows.UI.Xaml.Controls.IGridViewHeaderItem {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class GridViewItem extends Windows.UI.Xaml.Controls.Primitives.SelectorItem implements Windows.UI.Xaml.Controls.IGridViewItem {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.GridViewItemTemplateSettings;
+  }
+
+  class GroupItem extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.IGroupItem {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class GroupStyle implements Windows.UI.Xaml.Controls.IGroupStyle, Windows.UI.Xaml.Controls.IGroupStyle2, Windows.UI.Xaml.Data.INotifyPropertyChanged {
+    constructor();
+    ContainerStyle: Windows.UI.Xaml.Style;
+    ContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector;
+    HeaderContainerStyle: Windows.UI.Xaml.Style;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    HeaderTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector;
+    HidesIfEmpty: boolean;
+    Panel: Windows.UI.Xaml.Controls.ItemsPanelTemplate;
+    PropertyChanged: Windows.UI.Xaml.Data.PropertyChangedEventHandler | null;
+  }
+
+  class GroupStyleSelector implements Windows.UI.Xaml.Controls.IGroupStyleSelector, Windows.UI.Xaml.Controls.IGroupStyleSelectorOverrides {
+    constructor();
+    SelectGroupStyle(group: Object, level: number): Windows.UI.Xaml.Controls.GroupStyle;
+    SelectGroupStyleCore(group: Object, level: number): Windows.UI.Xaml.Controls.GroupStyle;
+  }
+
+  class HandwritingPanelClosedEventArgs implements Windows.UI.Xaml.Controls.IHandwritingPanelClosedEventArgs {
+  }
+
+  class HandwritingPanelOpenedEventArgs implements Windows.UI.Xaml.Controls.IHandwritingPanelOpenedEventArgs {
+  }
+
+  class HandwritingView extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IHandwritingView, Windows.UI.Xaml.Controls.IHandwritingView2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetCandidates(candidatesSessionId: number): Windows.Foundation.Collections.IVectorView<string> | string[];
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SelectCandidate(candidatesSessionId: number, selectedCandidateIndex: number): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryClose(): boolean;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    TryOpen(): boolean;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    AreCandidatesEnabled: boolean;
+    static readonly AreCandidatesEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    InputDeviceTypes: number;
+    IsCommandBarOpen: boolean;
+    static readonly IsCommandBarOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsOpen: boolean;
+    static readonly IsOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    IsSwitchToKeyboardEnabled: boolean;
+    static readonly IsSwitchToKeyboardEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    PlacementAlignment: number;
+    static readonly PlacementAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    PlacementTarget: Windows.UI.Xaml.UIElement;
+    static readonly PlacementTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.HandwritingView, Windows.UI.Xaml.Controls.HandwritingPanelClosedEventArgs> | null;
+    Opened: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.HandwritingView, Windows.UI.Xaml.Controls.HandwritingPanelOpenedEventArgs> | null;
+    CandidatesChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.HandwritingView, Windows.UI.Xaml.Controls.HandwritingViewCandidatesChangedEventArgs> | null;
+    TextSubmitted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.HandwritingView, Windows.UI.Xaml.Controls.HandwritingViewTextSubmittedEventArgs> | null;
+  }
+
+  class HandwritingViewCandidatesChangedEventArgs implements Windows.UI.Xaml.Controls.IHandwritingViewCandidatesChangedEventArgs {
+    readonly CandidatesSessionId: number;
+  }
+
+  class HandwritingViewTextSubmittedEventArgs implements Windows.UI.Xaml.Controls.IHandwritingViewTextSubmittedEventArgs {
+  }
+
+  class Hub extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IHub, Windows.UI.Xaml.Controls.ISemanticZoomInformation {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CompleteViewChange(): void;
+    CompleteViewChangeFrom(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    CompleteViewChangeTo(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InitializeViewChange(): void;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    MakeVisible(item: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    ScrollToSection(section: Windows.UI.Xaml.Controls.HubSection): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StartViewChangeFrom(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    StartViewChangeTo(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    DefaultSectionIndex: number;
+    static readonly DefaultSectionIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    Header: Object;
+    static readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    IsActiveView: boolean;
+    static readonly IsActiveViewProperty: Windows.UI.Xaml.DependencyProperty;
+    IsZoomedInView: boolean;
+    static readonly IsZoomedInViewProperty: Windows.UI.Xaml.DependencyProperty;
+    Orientation: number;
+    static readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SectionHeaders: Windows.Foundation.Collections.IObservableVector<Object>;
+    readonly Sections: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.HubSection> | Windows.UI.Xaml.Controls.HubSection[];
+    readonly SectionsInView: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.HubSection> | Windows.UI.Xaml.Controls.HubSection[];
+    SemanticZoomOwner: Windows.UI.Xaml.Controls.SemanticZoom;
+    static readonly SemanticZoomOwnerProperty: Windows.UI.Xaml.DependencyProperty;
+    SectionHeaderClick: Windows.UI.Xaml.Controls.HubSectionHeaderClickEventHandler | null;
+    SectionsInViewChanged: Windows.UI.Xaml.Controls.SectionsInViewChangedEventHandler | null;
+  }
+
+  class HubSection extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IHubSection {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    ContentTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly ContentTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    Header: Object;
+    static readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    IsHeaderInteractive: boolean;
+    static readonly IsHeaderInteractiveProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class HubSectionCollection {
+    Append(value: Windows.UI.Xaml.Controls.HubSection): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Controls.HubSection>;
+    GetAt(index: number): Windows.UI.Xaml.Controls.HubSection;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Controls.HubSection[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Controls.HubSection> | Windows.UI.Xaml.Controls.HubSection[];
+    IndexOf(value: Windows.UI.Xaml.Controls.HubSection, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Controls.HubSection): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Controls.HubSection[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Controls.HubSection): void;
+    readonly Size: number;
+  }
+
+  class HubSectionHeaderClickEventArgs implements Windows.UI.Xaml.Controls.IHubSectionHeaderClickEventArgs {
+    constructor();
+    readonly Section: Windows.UI.Xaml.Controls.HubSection;
+  }
+
+  class HyperlinkButton extends Windows.UI.Xaml.Controls.Primitives.ButtonBase implements Windows.UI.Xaml.Controls.IHyperlinkButton {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    NavigateUri: Windows.Foundation.Uri;
+    static readonly NavigateUriProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class IconElement extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Controls.IIconElement {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Foreground: Windows.UI.Xaml.Media.Brush;
+    static readonly ForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class IconSource extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.IIconSource {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Foreground: Windows.UI.Xaml.Media.Brush;
+    static readonly ForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class IconSourceElement extends Windows.UI.Xaml.Controls.IconElement implements Windows.UI.Xaml.Controls.IIconSourceElement {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    IconSource: Windows.UI.Xaml.Controls.IconSource;
+    static readonly IconSourceProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Image extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Controls.IImage, Windows.UI.Xaml.Controls.IImage2, Windows.UI.Xaml.Controls.IImage3 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAlphaMask(): Windows.UI.Composition.CompositionBrush;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAsCastingSource(): Windows.Media.Casting.CastingSource;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    NineGrid: Windows.UI.Xaml.Thickness;
+    static readonly NineGridProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlayToSource: Windows.Media.PlayTo.PlayToSource;
+    static readonly PlayToSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    Source: Windows.UI.Xaml.Media.ImageSource;
+    static readonly SourceProperty: Windows.UI.Xaml.DependencyProperty;
+    Stretch: number;
+    static readonly StretchProperty: Windows.UI.Xaml.DependencyProperty;
+    ImageFailed: Windows.UI.Xaml.ExceptionRoutedEventHandler | null;
+    ImageOpened: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+
+  class InkCanvas extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Controls.IInkCanvas {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly InkPresenter: Windows.UI.Input.Inking.InkPresenter;
+  }
+
+  class InkToolbar extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IInkToolbar, Windows.UI.Xaml.Controls.IInkToolbar2, Windows.UI.Xaml.Controls.IInkToolbar3 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetMenuButton(menu: number): Windows.UI.Xaml.Controls.InkToolbarMenuButton;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetToggleButton(tool: number): Windows.UI.Xaml.Controls.InkToolbarToggleButton;
+    GetToolButton(tool: number): Windows.UI.Xaml.Controls.InkToolbarToolButton;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    ActiveTool: Windows.UI.Xaml.Controls.InkToolbarToolButton;
+    static readonly ActiveToolProperty: Windows.UI.Xaml.DependencyProperty;
+    ButtonFlyoutPlacement: number;
+    static readonly ButtonFlyoutPlacementProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Children: Windows.UI.Xaml.DependencyObjectCollection;
+    static readonly ChildrenProperty: Windows.UI.Xaml.DependencyProperty;
+    InitialControls: number;
+    static readonly InitialControlsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly InkDrawingAttributes: Windows.UI.Input.Inking.InkDrawingAttributes;
+    static readonly InkDrawingAttributesProperty: Windows.UI.Xaml.DependencyProperty;
+    IsRulerButtonChecked: boolean;
+    static readonly IsRulerButtonCheckedProperty: Windows.UI.Xaml.DependencyProperty;
+    IsStencilButtonChecked: boolean;
+    static readonly IsStencilButtonCheckedProperty: Windows.UI.Xaml.DependencyProperty;
+    Orientation: number;
+    static readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    TargetInkCanvas: Windows.UI.Xaml.Controls.InkCanvas;
+    static readonly TargetInkCanvasProperty: Windows.UI.Xaml.DependencyProperty;
+    TargetInkPresenter: Windows.UI.Input.Inking.InkPresenter;
+    static readonly TargetInkPresenterProperty: Windows.UI.Xaml.DependencyProperty;
+    ActiveToolChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.InkToolbar, Object> | null;
+    EraseAllClicked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.InkToolbar, Object> | null;
+    InkDrawingAttributesChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.InkToolbar, Object> | null;
+    IsRulerButtonCheckedChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.InkToolbar, Object> | null;
+    IsStencilButtonCheckedChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.InkToolbar, Windows.UI.Xaml.Controls.InkToolbarIsStencilButtonCheckedChangedEventArgs> | null;
+  }
+
+  class InkToolbarBallpointPenButton extends Windows.UI.Xaml.Controls.InkToolbarPenButton implements Windows.UI.Xaml.Controls.IInkToolbarBallpointPenButton {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnToggle(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class InkToolbarCustomPen extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.IInkToolbarCustomPen, Windows.UI.Xaml.Controls.IInkToolbarCustomPenOverrides {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreateInkDrawingAttributes(brush: Windows.UI.Xaml.Media.Brush, strokeWidth: number): Windows.UI.Input.Inking.InkDrawingAttributes;
+    CreateInkDrawingAttributesCore(brush: Windows.UI.Xaml.Media.Brush, strokeWidth: number): Windows.UI.Input.Inking.InkDrawingAttributes;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class InkToolbarCustomPenButton extends Windows.UI.Xaml.Controls.InkToolbarPenButton implements Windows.UI.Xaml.Controls.IInkToolbarCustomPenButton {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnToggle(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    ConfigurationContent: Windows.UI.Xaml.UIElement;
+    static readonly ConfigurationContentProperty: Windows.UI.Xaml.DependencyProperty;
+    CustomPen: Windows.UI.Xaml.Controls.InkToolbarCustomPen;
+    static readonly CustomPenProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class InkToolbarCustomToggleButton extends Windows.UI.Xaml.Controls.InkToolbarToggleButton implements Windows.UI.Xaml.Controls.IInkToolbarCustomToggleButton {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnToggle(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class InkToolbarCustomToolButton extends Windows.UI.Xaml.Controls.InkToolbarToolButton implements Windows.UI.Xaml.Controls.IInkToolbarCustomToolButton {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnToggle(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    ConfigurationContent: Windows.UI.Xaml.UIElement;
+    static readonly ConfigurationContentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class InkToolbarEraserButton extends Windows.UI.Xaml.Controls.InkToolbarToolButton implements Windows.UI.Xaml.Controls.IInkToolbarEraserButton, Windows.UI.Xaml.Controls.IInkToolbarEraserButton2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnToggle(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    IsClearAllVisible: boolean;
+    static readonly IsClearAllVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class InkToolbarFlyoutItem extends Windows.UI.Xaml.Controls.Primitives.ButtonBase implements Windows.UI.Xaml.Controls.IInkToolbarFlyoutItem {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    IsChecked: boolean;
+    static readonly IsCheckedProperty: Windows.UI.Xaml.DependencyProperty;
+    Kind: number;
+    static readonly KindProperty: Windows.UI.Xaml.DependencyProperty;
+    Checked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.InkToolbarFlyoutItem, Object> | null;
+    Unchecked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.InkToolbarFlyoutItem, Object> | null;
+  }
+
+  class InkToolbarHighlighterButton extends Windows.UI.Xaml.Controls.InkToolbarPenButton implements Windows.UI.Xaml.Controls.IInkToolbarHighlighterButton {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnToggle(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class InkToolbarIsStencilButtonCheckedChangedEventArgs implements Windows.UI.Xaml.Controls.IInkToolbarIsStencilButtonCheckedChangedEventArgs {
+    constructor();
+    readonly StencilButton: Windows.UI.Xaml.Controls.InkToolbarStencilButton;
+    readonly StencilKind: number;
+  }
+
+  class InkToolbarMenuButton extends Windows.UI.Xaml.Controls.Primitives.ToggleButton implements Windows.UI.Xaml.Controls.IInkToolbarMenuButton {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnToggle(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    IsExtensionGlyphShown: boolean;
+    static readonly IsExtensionGlyphShownProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MenuKind: number;
+  }
+
+  class InkToolbarPenButton extends Windows.UI.Xaml.Controls.InkToolbarToolButton implements Windows.UI.Xaml.Controls.IInkToolbarPenButton {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnToggle(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    MaxStrokeWidth: number;
+    static readonly MaxStrokeWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    MinStrokeWidth: number;
+    static readonly MinStrokeWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    Palette: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Media.Brush> | Windows.UI.Xaml.Media.Brush[];
+    static readonly PaletteProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedBrush: Windows.UI.Xaml.Media.Brush;
+    SelectedBrushIndex: number;
+    static readonly SelectedBrushIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly SelectedBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedStrokeWidth: number;
+    static readonly SelectedStrokeWidthProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class InkToolbarPenConfigurationControl extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IInkToolbarPenConfigurationControl {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly PenButton: Windows.UI.Xaml.Controls.InkToolbarPenButton;
+    static readonly PenButtonProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class InkToolbarPencilButton extends Windows.UI.Xaml.Controls.InkToolbarPenButton implements Windows.UI.Xaml.Controls.IInkToolbarPencilButton {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnToggle(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class InkToolbarRulerButton extends Windows.UI.Xaml.Controls.InkToolbarToggleButton implements Windows.UI.Xaml.Controls.IInkToolbarRulerButton {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnToggle(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly Ruler: Windows.UI.Input.Inking.InkPresenterRuler;
+    static readonly RulerProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class InkToolbarStencilButton extends Windows.UI.Xaml.Controls.InkToolbarMenuButton implements Windows.UI.Xaml.Controls.IInkToolbarStencilButton {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnToggle(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    IsProtractorItemVisible: boolean;
+    static readonly IsProtractorItemVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsRulerItemVisible: boolean;
+    static readonly IsRulerItemVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Protractor: Windows.UI.Input.Inking.InkPresenterProtractor;
+    static readonly ProtractorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Ruler: Windows.UI.Input.Inking.InkPresenterRuler;
+    static readonly RulerProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedStencil: number;
+    static readonly SelectedStencilProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class InkToolbarToggleButton extends Windows.UI.Xaml.Controls.CheckBox implements Windows.UI.Xaml.Controls.IInkToolbarToggleButton {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnToggle(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly ToggleKind: number;
+  }
+
+  class InkToolbarToolButton extends Windows.UI.Xaml.Controls.RadioButton implements Windows.UI.Xaml.Controls.IInkToolbarToolButton {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnToggle(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    IsExtensionGlyphShown: boolean;
+    static readonly IsExtensionGlyphShownProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ToolKind: number;
+  }
+
+  class IsTextTrimmedChangedEventArgs implements Windows.UI.Xaml.Controls.IIsTextTrimmedChangedEventArgs {
+  }
+
+  class ItemClickEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Controls.IItemClickEventArgs {
+    constructor();
+    readonly ClickedItem: Object;
+  }
+
+  class ItemCollection {
+    Append(value: Object): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Object>;
+    GetAt(index: number): Object;
+    GetMany(startIndex: number, items: Object[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Object> | Object[];
+    IndexOf(value: Object, index: number): boolean;
+    InsertAt(index: number, value: Object): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Object[]): void;
+    SetAt(index: number, value: Object): void;
+    readonly Size: number;
+    VectorChanged: Windows.Foundation.Collections.VectorChangedEventHandler<Object> | null;
+  }
+
+  class ItemContainerGenerator implements Windows.UI.Xaml.Controls.IItemContainerGenerator {
+    ContainerFromIndex(index: number): Windows.UI.Xaml.DependencyObject;
+    ContainerFromItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    GenerateNext(isNewlyRealized: boolean): Windows.UI.Xaml.DependencyObject;
+    GeneratorPositionFromIndex(itemIndex: number): Windows.UI.Xaml.Controls.Primitives.GeneratorPosition;
+    GetItemContainerGeneratorForPanel(panel: Windows.UI.Xaml.Controls.Panel): Windows.UI.Xaml.Controls.ItemContainerGenerator;
+    IndexFromContainer(container: Windows.UI.Xaml.DependencyObject): number;
+    IndexFromGeneratorPosition(position: Windows.UI.Xaml.Controls.Primitives.GeneratorPosition): number;
+    ItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    PrepareItemContainer(container: Windows.UI.Xaml.DependencyObject): void;
+    Recycle(position: Windows.UI.Xaml.Controls.Primitives.GeneratorPosition, count: number): void;
+    Remove(position: Windows.UI.Xaml.Controls.Primitives.GeneratorPosition, count: number): void;
+    RemoveAll(): void;
+    StartAt(position: Windows.UI.Xaml.Controls.Primitives.GeneratorPosition, direction: number, allowStartAtRealizedItem: boolean): void;
+    Stop(): void;
+    ItemsChanged: Windows.UI.Xaml.Controls.Primitives.ItemsChangedEventHandler | null;
+  }
+
+  class ItemsControl extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IItemContainerMapping, Windows.UI.Xaml.Controls.IItemsControl, Windows.UI.Xaml.Controls.IItemsControl2, Windows.UI.Xaml.Controls.IItemsControl3, Windows.UI.Xaml.Controls.IItemsControlOverrides {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    ContainerFromIndex(index: number): Windows.UI.Xaml.DependencyObject;
+    ContainerFromItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetContainerForItemOverride(): Windows.UI.Xaml.DependencyObject;
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetItemsOwner(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    GroupHeaderContainerFromItemContainer(itemContainer: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+    IndexFromContainer(container: Windows.UI.Xaml.DependencyObject): number;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    IsItemItsOwnContainerOverride(item: Object): boolean;
+    ItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    static ItemsControlFromItemContainer(container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnGroupStyleSelectorChanged(oldGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector, newGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnItemContainerStyleChanged(oldItemContainerStyle: Windows.UI.Xaml.Style, newItemContainerStyle: Windows.UI.Xaml.Style): void;
+    OnItemContainerStyleSelectorChanged(oldItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector, newItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector): void;
+    OnItemTemplateChanged(oldItemTemplate: Windows.UI.Xaml.DataTemplate, newItemTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnItemTemplateSelectorChanged(oldItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnItemsChanged(e: Object): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PrepareContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    DisplayMemberPath: string;
+    static readonly DisplayMemberPathProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GroupStyle: Windows.Foundation.Collections.IObservableVector<Windows.UI.Xaml.Controls.GroupStyle>;
+    GroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector;
+    static readonly GroupStyleSelectorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsGrouping: boolean;
+    static readonly IsGroupingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemContainerGenerator: Windows.UI.Xaml.Controls.ItemContainerGenerator;
+    ItemContainerStyle: Windows.UI.Xaml.Style;
+    static readonly ItemContainerStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector;
+    static readonly ItemContainerStyleSelectorProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemContainerTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    static readonly ItemContainerTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly ItemTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector;
+    static readonly ItemTemplateSelectorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Items: Windows.UI.Xaml.Controls.ItemCollection;
+    ItemsPanel: Windows.UI.Xaml.Controls.ItemsPanelTemplate;
+    static readonly ItemsPanelProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemsPanelRoot: Windows.UI.Xaml.Controls.Panel;
+    ItemsSource: Object;
+    static readonly ItemsSourceProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ItemsPanelTemplate extends Windows.UI.Xaml.FrameworkTemplate implements Windows.UI.Xaml.Controls.IItemsPanelTemplate {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ItemsPickedEventArgs extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.IItemsPickedEventArgs {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly AddedItems: Windows.Foundation.Collections.IVector<Object> | Object[];
+    readonly RemovedItems: Windows.Foundation.Collections.IVector<Object> | Object[];
+  }
+
+  class ItemsPresenter extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Controls.IItemsPresenter, Windows.UI.Xaml.Controls.IItemsPresenter2, Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetIrregularSnapPoints(orientation: number, alignment: number): Windows.Foundation.Collections.IVectorView<number> | number[];
+    GetRegularSnapPoints(orientation: number, alignment: number, offset: number): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly AreHorizontalSnapPointsRegular: boolean;
+    readonly AreVerticalSnapPointsRegular: boolean;
+    Footer: Object;
+    static readonly FooterProperty: Windows.UI.Xaml.DependencyProperty;
+    FooterTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly FooterTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    FooterTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    static readonly FooterTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    Header: Object;
+    static readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    HeaderTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    static readonly HeaderTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    Padding: Windows.UI.Xaml.Thickness;
+    static readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalSnapPointsChanged: Windows.Foundation.EventHandler<Object> | null;
+    VerticalSnapPointsChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class ItemsStackPanel extends Windows.UI.Xaml.Controls.Panel implements Windows.UI.Xaml.Controls.IItemsStackPanel, Windows.UI.Xaml.Controls.IItemsStackPanel2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    AreStickyGroupHeadersEnabled: boolean;
+    static readonly AreStickyGroupHeadersEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    CacheLength: number;
+    static readonly CacheLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FirstCacheIndex: number;
+    readonly FirstVisibleIndex: number;
+    GroupHeaderPlacement: number;
+    static readonly GroupHeaderPlacementProperty: Windows.UI.Xaml.DependencyProperty;
+    GroupPadding: Windows.UI.Xaml.Thickness;
+    static readonly GroupPaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemsUpdatingScrollMode: number;
+    readonly LastCacheIndex: number;
+    readonly LastVisibleIndex: number;
+    Orientation: number;
+    static readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ScrollingDirection: number;
+  }
+
+  class ItemsWrapGrid extends Windows.UI.Xaml.Controls.Panel implements Windows.UI.Xaml.Controls.IItemsWrapGrid, Windows.UI.Xaml.Controls.IItemsWrapGrid2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    AreStickyGroupHeadersEnabled: boolean;
+    static readonly AreStickyGroupHeadersEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    CacheLength: number;
+    static readonly CacheLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FirstCacheIndex: number;
+    readonly FirstVisibleIndex: number;
+    GroupHeaderPlacement: number;
+    static readonly GroupHeaderPlacementProperty: Windows.UI.Xaml.DependencyProperty;
+    GroupPadding: Windows.UI.Xaml.Thickness;
+    static readonly GroupPaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemHeight: number;
+    static readonly ItemHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemWidth: number;
+    static readonly ItemWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LastCacheIndex: number;
+    readonly LastVisibleIndex: number;
+    MaximumRowsOrColumns: number;
+    static readonly MaximumRowsOrColumnsProperty: Windows.UI.Xaml.DependencyProperty;
+    Orientation: number;
+    static readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ScrollingDirection: number;
+  }
+
+  class ListBox extends Windows.UI.Xaml.Controls.Primitives.Selector implements Windows.UI.Xaml.Controls.IListBox, Windows.UI.Xaml.Controls.IListBox2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    ContainerFromIndex(index: number): Windows.UI.Xaml.DependencyObject;
+    ContainerFromItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetContainerForItemOverride(): Windows.UI.Xaml.DependencyObject;
+    static GetIsSelectionActive(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetItemsOwner(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    GroupHeaderContainerFromItemContainer(itemContainer: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+    IndexFromContainer(container: Windows.UI.Xaml.DependencyObject): number;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    IsItemItsOwnContainerOverride(item: Object): boolean;
+    ItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    static ItemsControlFromItemContainer(container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnGroupStyleSelectorChanged(oldGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector, newGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnItemContainerStyleChanged(oldItemContainerStyle: Windows.UI.Xaml.Style, newItemContainerStyle: Windows.UI.Xaml.Style): void;
+    OnItemContainerStyleSelectorChanged(oldItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector, newItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector): void;
+    OnItemTemplateChanged(oldItemTemplate: Windows.UI.Xaml.DataTemplate, newItemTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnItemTemplateSelectorChanged(oldItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnItemsChanged(e: Object): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PrepareContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    ScrollIntoView(item: Object): void;
+    SelectAll(): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly SelectedItems: Windows.Foundation.Collections.IVector<Object> | Object[];
+    SelectionMode: number;
+    static readonly SelectionModeProperty: Windows.UI.Xaml.DependencyProperty;
+    SingleSelectionFollowsFocus: boolean;
+    static readonly SingleSelectionFollowsFocusProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ListBoxItem extends Windows.UI.Xaml.Controls.Primitives.SelectorItem implements Windows.UI.Xaml.Controls.IListBoxItem {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class ListPickerFlyout extends Windows.UI.Xaml.Controls.Primitives.PickerFlyoutBase implements Windows.UI.Xaml.Controls.IListPickerFlyout {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreatePresenter(): Windows.UI.Xaml.Controls.Control;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement): Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    static GetTitle(element: Windows.UI.Xaml.DependencyObject): string;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Hide(): void;
+    OnConfirmed(): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static SetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement, value: Windows.UI.Xaml.Controls.Primitives.FlyoutBase): void;
+    static SetTitle(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShouldShowConfirmationButtons(): boolean;
+    ShowAt(placementTarget: Windows.UI.Xaml.FrameworkElement): void;
+    ShowAt(placementTarget: Windows.UI.Xaml.DependencyObject, showOptions: Windows.UI.Xaml.Controls.Primitives.FlyoutShowOptions): void;
+    ShowAtAsync(target: Windows.UI.Xaml.FrameworkElement): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Object> | Object[]>;
+    static ShowAttachedFlyout(flyoutOwner: Windows.UI.Xaml.FrameworkElement): void;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    DisplayMemberPath: string;
+    static readonly DisplayMemberPathProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly ItemTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemsSource: Object;
+    static readonly ItemsSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedIndex: number;
+    static readonly SelectedIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedItem: Object;
+    static readonly SelectedItemProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedItems: Windows.Foundation.Collections.IVector<Object> | Object[];
+    SelectedValue: Object;
+    SelectedValuePath: string;
+    static readonly SelectedValuePathProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly SelectedValueProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionMode: number;
+    static readonly SelectionModeProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemsPicked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ListPickerFlyout, Windows.UI.Xaml.Controls.ItemsPickedEventArgs> | null;
+  }
+
+  class ListPickerFlyoutPresenter extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IListPickerFlyoutPresenter {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class ListView extends Windows.UI.Xaml.Controls.ListViewBase implements Windows.UI.Xaml.Controls.IListView {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CompleteViewChange(): void;
+    CompleteViewChangeFrom(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    CompleteViewChangeTo(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    ContainerFromIndex(index: number): Windows.UI.Xaml.DependencyObject;
+    ContainerFromItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    DeselectRange(itemIndexRange: Windows.UI.Xaml.Data.ItemIndexRange): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetContainerForItemOverride(): Windows.UI.Xaml.DependencyObject;
+    static GetIsSelectionActive(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetItemsOwner(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    GroupHeaderContainerFromItemContainer(itemContainer: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+    IndexFromContainer(container: Windows.UI.Xaml.DependencyObject): number;
+    InitializeViewChange(): void;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    IsDragSource(): boolean;
+    IsItemItsOwnContainerOverride(item: Object): boolean;
+    ItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    static ItemsControlFromItemContainer(container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    LoadMoreItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Data.LoadMoreItemsResult>;
+    MakeVisible(item: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnGroupStyleSelectorChanged(oldGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector, newGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnItemContainerStyleChanged(oldItemContainerStyle: Windows.UI.Xaml.Style, newItemContainerStyle: Windows.UI.Xaml.Style): void;
+    OnItemContainerStyleSelectorChanged(oldItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector, newItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector): void;
+    OnItemTemplateChanged(oldItemTemplate: Windows.UI.Xaml.DataTemplate, newItemTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnItemTemplateSelectorChanged(oldItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnItemsChanged(e: Object): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PrepareConnectedAnimation(key: string, item: Object, elementName: string): Windows.UI.Xaml.Media.Animation.ConnectedAnimation;
+    PrepareContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    ScrollIntoView(item: Object): void;
+    ScrollIntoView(item: Object, alignment: number): void;
+    SelectAll(): void;
+    SelectRange(itemIndexRange: Windows.UI.Xaml.Data.ItemIndexRange): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetDesiredContainerUpdateDuration(duration: Windows.Foundation.TimeSpan): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StartViewChangeFrom(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    StartViewChangeTo(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    TryStartConnectedAnimationAsync(animation: Windows.UI.Xaml.Media.Animation.ConnectedAnimation, item: Object, elementName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class ListViewBase extends Windows.UI.Xaml.Controls.Primitives.Selector implements Windows.UI.Xaml.Controls.IListViewBase, Windows.UI.Xaml.Controls.IListViewBase2, Windows.UI.Xaml.Controls.IListViewBase3, Windows.UI.Xaml.Controls.IListViewBase4, Windows.UI.Xaml.Controls.IListViewBase5, Windows.UI.Xaml.Controls.IListViewBase6, Windows.UI.Xaml.Controls.ISemanticZoomInformation {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CompleteViewChange(): void;
+    CompleteViewChangeFrom(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    CompleteViewChangeTo(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    ContainerFromIndex(index: number): Windows.UI.Xaml.DependencyObject;
+    ContainerFromItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    DeselectRange(itemIndexRange: Windows.UI.Xaml.Data.ItemIndexRange): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetContainerForItemOverride(): Windows.UI.Xaml.DependencyObject;
+    static GetIsSelectionActive(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetItemsOwner(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    GroupHeaderContainerFromItemContainer(itemContainer: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+    IndexFromContainer(container: Windows.UI.Xaml.DependencyObject): number;
+    InitializeViewChange(): void;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    IsDragSource(): boolean;
+    IsItemItsOwnContainerOverride(item: Object): boolean;
+    ItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    static ItemsControlFromItemContainer(container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    LoadMoreItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Data.LoadMoreItemsResult>;
+    MakeVisible(item: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnGroupStyleSelectorChanged(oldGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector, newGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnItemContainerStyleChanged(oldItemContainerStyle: Windows.UI.Xaml.Style, newItemContainerStyle: Windows.UI.Xaml.Style): void;
+    OnItemContainerStyleSelectorChanged(oldItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector, newItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector): void;
+    OnItemTemplateChanged(oldItemTemplate: Windows.UI.Xaml.DataTemplate, newItemTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnItemTemplateSelectorChanged(oldItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnItemsChanged(e: Object): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PrepareConnectedAnimation(key: string, item: Object, elementName: string): Windows.UI.Xaml.Media.Animation.ConnectedAnimation;
+    PrepareContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    ScrollIntoView(item: Object): void;
+    ScrollIntoView(item: Object, alignment: number): void;
+    SelectAll(): void;
+    SelectRange(itemIndexRange: Windows.UI.Xaml.Data.ItemIndexRange): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetDesiredContainerUpdateDuration(duration: Windows.Foundation.TimeSpan): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StartViewChangeFrom(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    StartViewChangeTo(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    TryStartConnectedAnimationAsync(animation: Windows.UI.Xaml.Media.Animation.ConnectedAnimation, item: Object, elementName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    CanDragItems: boolean;
+    static readonly CanDragItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    CanReorderItems: boolean;
+    static readonly CanReorderItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    DataFetchSize: number;
+    static readonly DataFetchSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    Footer: Object;
+    static readonly FooterProperty: Windows.UI.Xaml.DependencyProperty;
+    FooterTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly FooterTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    FooterTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    static readonly FooterTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    Header: Object;
+    static readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    HeaderTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    static readonly HeaderTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    IncrementalLoadingThreshold: number;
+    static readonly IncrementalLoadingThresholdProperty: Windows.UI.Xaml.DependencyProperty;
+    IncrementalLoadingTrigger: number;
+    static readonly IncrementalLoadingTriggerProperty: Windows.UI.Xaml.DependencyProperty;
+    IsActiveView: boolean;
+    static readonly IsActiveViewProperty: Windows.UI.Xaml.DependencyProperty;
+    IsItemClickEnabled: boolean;
+    static readonly IsItemClickEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsMultiSelectCheckBoxEnabled: boolean;
+    static readonly IsMultiSelectCheckBoxEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsSwipeEnabled: boolean;
+    static readonly IsSwipeEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsZoomedInView: boolean;
+    static readonly IsZoomedInViewProperty: Windows.UI.Xaml.DependencyProperty;
+    ReorderMode: number;
+    static readonly ReorderModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedItems: Windows.Foundation.Collections.IVector<Object> | Object[];
+    readonly SelectedRanges: Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Data.ItemIndexRange> | Windows.UI.Xaml.Data.ItemIndexRange[];
+    SelectionMode: number;
+    static readonly SelectionModeProperty: Windows.UI.Xaml.DependencyProperty;
+    SemanticZoomOwner: Windows.UI.Xaml.Controls.SemanticZoom;
+    static readonly SemanticZoomOwnerProperty: Windows.UI.Xaml.DependencyProperty;
+    ShowsScrollingPlaceholders: boolean;
+    static readonly ShowsScrollingPlaceholdersProperty: Windows.UI.Xaml.DependencyProperty;
+    SingleSelectionFollowsFocus: boolean;
+    static readonly SingleSelectionFollowsFocusProperty: Windows.UI.Xaml.DependencyProperty;
+    DragItemsStarting: Windows.UI.Xaml.Controls.DragItemsStartingEventHandler | null;
+    ItemClick: Windows.UI.Xaml.Controls.ItemClickEventHandler | null;
+    ContainerContentChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ListViewBase, Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs> | null;
+    ChoosingGroupHeaderContainer: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ListViewBase, Windows.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs> | null;
+    ChoosingItemContainer: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ListViewBase, Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs> | null;
+    DragItemsCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ListViewBase, Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs> | null;
+  }
+
+  class ListViewBaseHeaderItem extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.IListViewBaseHeaderItem {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class ListViewHeaderItem extends Windows.UI.Xaml.Controls.ListViewBaseHeaderItem implements Windows.UI.Xaml.Controls.IListViewHeaderItem {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class ListViewItem extends Windows.UI.Xaml.Controls.Primitives.SelectorItem implements Windows.UI.Xaml.Controls.IListViewItem {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.ListViewItemTemplateSettings;
+  }
+
+  class ListViewPersistenceHelper implements Windows.UI.Xaml.Controls.IListViewPersistenceHelper {
+    static GetRelativeScrollPosition(listViewBase: Windows.UI.Xaml.Controls.ListViewBase, itemToKeyHandler: Windows.UI.Xaml.Controls.ListViewItemToKeyHandler): string;
+    static SetRelativeScrollPositionAsync(listViewBase: Windows.UI.Xaml.Controls.ListViewBase, relativeScrollPosition: string, keyToItemHandler: Windows.UI.Xaml.Controls.ListViewKeyToItemHandler): Windows.Foundation.IAsyncAction;
+  }
+
+  class MediaElement extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Controls.IMediaElement, Windows.UI.Xaml.Controls.IMediaElement2, Windows.UI.Xaml.Controls.IMediaElement3 {
+    constructor();
+    AddAudioEffect(effectID: string, effectOptional: boolean, effectConfiguration: Windows.Foundation.Collections.IPropertySet): void;
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    AddVideoEffect(effectID: string, effectOptional: boolean, effectConfiguration: Windows.Foundation.Collections.IPropertySet): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CanPlayType(type: string): number;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAsCastingSource(): Windows.Media.Casting.CastingSource;
+    GetAudioStreamLanguage(index: number | null): string;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    Pause(): void;
+    Play(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveAllEffects(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetMediaStreamSource(source: Windows.Media.Core.IMediaSource): void;
+    SetPlaybackSource(source: Windows.Media.Playback.IMediaPlaybackSource): void;
+    SetSource(stream: Windows.Storage.Streams.IRandomAccessStream, mimeType: string): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    Stop(): void;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly ActualStereo3DVideoPackingMode: number;
+    static readonly ActualStereo3DVideoPackingModeProperty: Windows.UI.Xaml.DependencyProperty;
+    AreTransportControlsEnabled: boolean;
+    static readonly AreTransportControlsEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AspectRatioHeight: number;
+    static readonly AspectRatioHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AspectRatioWidth: number;
+    static readonly AspectRatioWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    AudioCategory: number;
+    static readonly AudioCategoryProperty: Windows.UI.Xaml.DependencyProperty;
+    AudioDeviceType: number;
+    static readonly AudioDeviceTypeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AudioStreamCount: number;
+    static readonly AudioStreamCountProperty: Windows.UI.Xaml.DependencyProperty;
+    AudioStreamIndex: number | null;
+    static readonly AudioStreamIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    AutoPlay: boolean;
+    static readonly AutoPlayProperty: Windows.UI.Xaml.DependencyProperty;
+    Balance: number;
+    static readonly BalanceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BufferingProgress: number;
+    static readonly BufferingProgressProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanPause: boolean;
+    static readonly CanPauseProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanSeek: boolean;
+    static readonly CanSeekProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CurrentState: number;
+    static readonly CurrentStateProperty: Windows.UI.Xaml.DependencyProperty;
+    DefaultPlaybackRate: number;
+    static readonly DefaultPlaybackRateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DownloadProgress: number;
+    readonly DownloadProgressOffset: number;
+    static readonly DownloadProgressOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly DownloadProgressProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsAudioOnly: boolean;
+    static readonly IsAudioOnlyProperty: Windows.UI.Xaml.DependencyProperty;
+    IsFullWindow: boolean;
+    static readonly IsFullWindowProperty: Windows.UI.Xaml.DependencyProperty;
+    IsLooping: boolean;
+    static readonly IsLoopingProperty: Windows.UI.Xaml.DependencyProperty;
+    IsMuted: boolean;
+    static readonly IsMutedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsStereo3DVideo: boolean;
+    static readonly IsStereo3DVideoProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Markers: Windows.UI.Xaml.Media.TimelineMarkerCollection;
+    readonly NaturalDuration: Windows.UI.Xaml.Duration;
+    static readonly NaturalDurationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly NaturalVideoHeight: number;
+    static readonly NaturalVideoHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly NaturalVideoWidth: number;
+    static readonly NaturalVideoWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    PlayToPreferredSourceUri: Windows.Foundation.Uri;
+    static readonly PlayToPreferredSourceUriProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlayToSource: Windows.Media.PlayTo.PlayToSource;
+    static readonly PlayToSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    PlaybackRate: number;
+    static readonly PlaybackRateProperty: Windows.UI.Xaml.DependencyProperty;
+    Position: Windows.Foundation.TimeSpan;
+    static readonly PositionProperty: Windows.UI.Xaml.DependencyProperty;
+    PosterSource: Windows.UI.Xaml.Media.ImageSource;
+    static readonly PosterSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    ProtectionManager: Windows.Media.Protection.MediaProtectionManager;
+    static readonly ProtectionManagerProperty: Windows.UI.Xaml.DependencyProperty;
+    RealTimePlayback: boolean;
+    static readonly RealTimePlaybackProperty: Windows.UI.Xaml.DependencyProperty;
+    Source: Windows.Foundation.Uri;
+    static readonly SourceProperty: Windows.UI.Xaml.DependencyProperty;
+    Stereo3DVideoPackingMode: number;
+    static readonly Stereo3DVideoPackingModeProperty: Windows.UI.Xaml.DependencyProperty;
+    Stereo3DVideoRenderMode: number;
+    static readonly Stereo3DVideoRenderModeProperty: Windows.UI.Xaml.DependencyProperty;
+    Stretch: number;
+    static readonly StretchProperty: Windows.UI.Xaml.DependencyProperty;
+    TransportControls: Windows.UI.Xaml.Controls.MediaTransportControls;
+    Volume: number;
+    static readonly VolumeProperty: Windows.UI.Xaml.DependencyProperty;
+    BufferingProgressChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+    CurrentStateChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+    DownloadProgressChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+    MarkerReached: Windows.UI.Xaml.Media.TimelineMarkerRoutedEventHandler | null;
+    MediaEnded: Windows.UI.Xaml.RoutedEventHandler | null;
+    MediaFailed: Windows.UI.Xaml.ExceptionRoutedEventHandler | null;
+    MediaOpened: Windows.UI.Xaml.RoutedEventHandler | null;
+    RateChanged: Windows.UI.Xaml.Media.RateChangedRoutedEventHandler | null;
+    SeekCompleted: Windows.UI.Xaml.RoutedEventHandler | null;
+    VolumeChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+    PartialMediaFailureDetected: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.MediaElement, Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs> | null;
+  }
+
+  class MediaPlayerElement extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IMediaPlayerElement {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetMediaPlayer(mediaPlayer: Windows.Media.Playback.MediaPlayer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    AreTransportControlsEnabled: boolean;
+    static readonly AreTransportControlsEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    AutoPlay: boolean;
+    static readonly AutoPlayProperty: Windows.UI.Xaml.DependencyProperty;
+    IsFullWindow: boolean;
+    static readonly IsFullWindowProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MediaPlayer: Windows.Media.Playback.MediaPlayer;
+    static readonly MediaPlayerProperty: Windows.UI.Xaml.DependencyProperty;
+    PosterSource: Windows.UI.Xaml.Media.ImageSource;
+    static readonly PosterSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    Source: Windows.Media.Playback.IMediaPlaybackSource;
+    static readonly SourceProperty: Windows.UI.Xaml.DependencyProperty;
+    Stretch: number;
+    static readonly StretchProperty: Windows.UI.Xaml.DependencyProperty;
+    TransportControls: Windows.UI.Xaml.Controls.MediaTransportControls;
+  }
+
+  class MediaPlayerPresenter extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Controls.IMediaPlayerPresenter {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    IsFullWindow: boolean;
+    static readonly IsFullWindowProperty: Windows.UI.Xaml.DependencyProperty;
+    MediaPlayer: Windows.Media.Playback.MediaPlayer;
+    static readonly MediaPlayerProperty: Windows.UI.Xaml.DependencyProperty;
+    Stretch: number;
+    static readonly StretchProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class MediaTransportControls extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IMediaTransportControls, Windows.UI.Xaml.Controls.IMediaTransportControls2, Windows.UI.Xaml.Controls.IMediaTransportControls3, Windows.UI.Xaml.Controls.IMediaTransportControls4 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    Hide(): void;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    Show(): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    FastPlayFallbackBehaviour: number;
+    static readonly FastPlayFallbackBehaviourProperty: Windows.UI.Xaml.DependencyProperty;
+    IsCompact: boolean;
+    IsCompactOverlayButtonVisible: boolean;
+    static readonly IsCompactOverlayButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsCompactOverlayEnabled: boolean;
+    static readonly IsCompactOverlayEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly IsCompactProperty: Windows.UI.Xaml.DependencyProperty;
+    IsFastForwardButtonVisible: boolean;
+    static readonly IsFastForwardButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsFastForwardEnabled: boolean;
+    static readonly IsFastForwardEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsFastRewindButtonVisible: boolean;
+    static readonly IsFastRewindButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsFastRewindEnabled: boolean;
+    static readonly IsFastRewindEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsFullWindowButtonVisible: boolean;
+    static readonly IsFullWindowButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsFullWindowEnabled: boolean;
+    static readonly IsFullWindowEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsNextTrackButtonVisible: boolean;
+    static readonly IsNextTrackButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsPlaybackRateButtonVisible: boolean;
+    static readonly IsPlaybackRateButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsPlaybackRateEnabled: boolean;
+    static readonly IsPlaybackRateEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsPreviousTrackButtonVisible: boolean;
+    static readonly IsPreviousTrackButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsRepeatButtonVisible: boolean;
+    static readonly IsRepeatButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsRepeatEnabled: boolean;
+    static readonly IsRepeatEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsSeekBarVisible: boolean;
+    static readonly IsSeekBarVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsSeekEnabled: boolean;
+    static readonly IsSeekEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsSkipBackwardButtonVisible: boolean;
+    static readonly IsSkipBackwardButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsSkipBackwardEnabled: boolean;
+    static readonly IsSkipBackwardEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsSkipForwardButtonVisible: boolean;
+    static readonly IsSkipForwardButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsSkipForwardEnabled: boolean;
+    static readonly IsSkipForwardEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsStopButtonVisible: boolean;
+    static readonly IsStopButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsStopEnabled: boolean;
+    static readonly IsStopEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsVolumeButtonVisible: boolean;
+    static readonly IsVolumeButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsVolumeEnabled: boolean;
+    static readonly IsVolumeEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsZoomButtonVisible: boolean;
+    static readonly IsZoomButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsZoomEnabled: boolean;
+    static readonly IsZoomEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    ShowAndHideAutomatically: boolean;
+    static readonly ShowAndHideAutomaticallyProperty: Windows.UI.Xaml.DependencyProperty;
+    ThumbnailRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.MediaTransportControls, Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs> | null;
+  }
+
+  class MediaTransportControlsHelper implements Windows.UI.Xaml.Controls.IMediaTransportControlsHelper {
+    static GetDropoutOrder(element: Windows.UI.Xaml.UIElement): number | null;
+    static SetDropoutOrder(element: Windows.UI.Xaml.UIElement, value: number | null): void;
+    static readonly DropoutOrderProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class MenuBar extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IMenuBar {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.MenuBarItem> | Windows.UI.Xaml.Controls.MenuBarItem[];
+    static readonly ItemsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class MenuBarItem extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IMenuBarItem {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.MenuFlyoutItemBase> | Windows.UI.Xaml.Controls.MenuFlyoutItemBase[];
+    static readonly ItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    Title: string;
+    static readonly TitleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class MenuBarItemFlyout extends Windows.UI.Xaml.Controls.MenuFlyout implements Windows.UI.Xaml.Controls.IMenuBarItemFlyout {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreatePresenter(): Windows.UI.Xaml.Controls.Control;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement): Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Hide(): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static SetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement, value: Windows.UI.Xaml.Controls.Primitives.FlyoutBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowAt(targetElement: Windows.UI.Xaml.UIElement, point: Windows.Foundation.Point): void;
+    ShowAt(placementTarget: Windows.UI.Xaml.FrameworkElement): void;
+    static ShowAttachedFlyout(flyoutOwner: Windows.UI.Xaml.FrameworkElement): void;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class MenuFlyout extends Windows.UI.Xaml.Controls.Primitives.FlyoutBase implements Windows.UI.Xaml.Controls.IMenuFlyout, Windows.UI.Xaml.Controls.IMenuFlyout2 {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreatePresenter(): Windows.UI.Xaml.Controls.Control;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement): Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Hide(): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static SetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement, value: Windows.UI.Xaml.Controls.Primitives.FlyoutBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowAt(targetElement: Windows.UI.Xaml.UIElement, point: Windows.Foundation.Point): void;
+    ShowAt(placementTarget: Windows.UI.Xaml.FrameworkElement): void;
+    static ShowAttachedFlyout(flyoutOwner: Windows.UI.Xaml.FrameworkElement): void;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.MenuFlyoutItemBase> | Windows.UI.Xaml.Controls.MenuFlyoutItemBase[];
+    MenuFlyoutPresenterStyle: Windows.UI.Xaml.Style;
+    static readonly MenuFlyoutPresenterStyleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class MenuFlyoutItem extends Windows.UI.Xaml.Controls.MenuFlyoutItemBase implements Windows.UI.Xaml.Controls.IMenuFlyoutItem, Windows.UI.Xaml.Controls.IMenuFlyoutItem2, Windows.UI.Xaml.Controls.IMenuFlyoutItem3 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Command: Windows.UI.Xaml.Input.ICommand;
+    CommandParameter: Object;
+    static readonly CommandParameterProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly CommandProperty: Windows.UI.Xaml.DependencyProperty;
+    Icon: Windows.UI.Xaml.Controls.IconElement;
+    static readonly IconProperty: Windows.UI.Xaml.DependencyProperty;
+    KeyboardAcceleratorTextOverride: string;
+    static readonly KeyboardAcceleratorTextOverrideProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.MenuFlyoutItemTemplateSettings;
+    Text: string;
+    static readonly TextProperty: Windows.UI.Xaml.DependencyProperty;
+    Click: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+
+  class MenuFlyoutItemBase extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IMenuFlyoutItemBase {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class MenuFlyoutPresenter extends Windows.UI.Xaml.Controls.ItemsControl implements Windows.UI.Xaml.Controls.IMenuFlyoutPresenter, Windows.UI.Xaml.Controls.IMenuFlyoutPresenter2, Windows.UI.Xaml.Controls.IMenuFlyoutPresenter3 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    ContainerFromIndex(index: number): Windows.UI.Xaml.DependencyObject;
+    ContainerFromItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetContainerForItemOverride(): Windows.UI.Xaml.DependencyObject;
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetItemsOwner(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    GroupHeaderContainerFromItemContainer(itemContainer: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+    IndexFromContainer(container: Windows.UI.Xaml.DependencyObject): number;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    IsItemItsOwnContainerOverride(item: Object): boolean;
+    ItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    static ItemsControlFromItemContainer(container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnGroupStyleSelectorChanged(oldGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector, newGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnItemContainerStyleChanged(oldItemContainerStyle: Windows.UI.Xaml.Style, newItemContainerStyle: Windows.UI.Xaml.Style): void;
+    OnItemContainerStyleSelectorChanged(oldItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector, newItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector): void;
+    OnItemTemplateChanged(oldItemTemplate: Windows.UI.Xaml.DataTemplate, newItemTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnItemTemplateSelectorChanged(oldItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnItemsChanged(e: Object): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PrepareContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    IsDefaultShadowEnabled: boolean;
+    static readonly IsDefaultShadowEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.MenuFlyoutPresenterTemplateSettings;
+  }
+
+  class MenuFlyoutSeparator extends Windows.UI.Xaml.Controls.MenuFlyoutItemBase implements Windows.UI.Xaml.Controls.IMenuFlyoutSeparator {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class MenuFlyoutSubItem extends Windows.UI.Xaml.Controls.MenuFlyoutItemBase implements Windows.UI.Xaml.Controls.IMenuFlyoutSubItem, Windows.UI.Xaml.Controls.IMenuFlyoutSubItem2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Icon: Windows.UI.Xaml.Controls.IconElement;
+    static readonly IconProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.MenuFlyoutItemBase> | Windows.UI.Xaml.Controls.MenuFlyoutItemBase[];
+    Text: string;
+    static readonly TextProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class NavigationView extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.INavigationView, Windows.UI.Xaml.Controls.INavigationView2, Windows.UI.Xaml.Controls.INavigationView3 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    ContainerFromMenuItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    MenuItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    AlwaysShowHeader: boolean;
+    static readonly AlwaysShowHeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    AutoSuggestBox: Windows.UI.Xaml.Controls.AutoSuggestBox;
+    static readonly AutoSuggestBoxProperty: Windows.UI.Xaml.DependencyProperty;
+    CompactModeThresholdWidth: number;
+    static readonly CompactModeThresholdWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    CompactPaneLength: number;
+    static readonly CompactPaneLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    ContentOverlay: Windows.UI.Xaml.UIElement;
+    static readonly ContentOverlayProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DisplayMode: number;
+    static readonly DisplayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    ExpandedModeThresholdWidth: number;
+    static readonly ExpandedModeThresholdWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    Header: Object;
+    static readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    IsBackButtonVisible: number;
+    static readonly IsBackButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsBackEnabled: boolean;
+    static readonly IsBackEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsPaneOpen: boolean;
+    static readonly IsPaneOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    IsPaneToggleButtonVisible: boolean;
+    static readonly IsPaneToggleButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsPaneVisible: boolean;
+    static readonly IsPaneVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    IsSettingsVisible: boolean;
+    static readonly IsSettingsVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    MenuItemContainerStyle: Windows.UI.Xaml.Style;
+    static readonly MenuItemContainerStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    MenuItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector;
+    static readonly MenuItemContainerStyleSelectorProperty: Windows.UI.Xaml.DependencyProperty;
+    MenuItemTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly MenuItemTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    MenuItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector;
+    static readonly MenuItemTemplateSelectorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MenuItems: Windows.Foundation.Collections.IVector<Object> | Object[];
+    static readonly MenuItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    MenuItemsSource: Object;
+    static readonly MenuItemsSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    OpenPaneLength: number;
+    static readonly OpenPaneLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    OverflowLabelMode: number;
+    static readonly OverflowLabelModeProperty: Windows.UI.Xaml.DependencyProperty;
+    PaneCustomContent: Windows.UI.Xaml.UIElement;
+    static readonly PaneCustomContentProperty: Windows.UI.Xaml.DependencyProperty;
+    PaneDisplayMode: number;
+    static readonly PaneDisplayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    PaneFooter: Windows.UI.Xaml.UIElement;
+    static readonly PaneFooterProperty: Windows.UI.Xaml.DependencyProperty;
+    PaneHeader: Windows.UI.Xaml.UIElement;
+    static readonly PaneHeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    PaneTitle: string;
+    static readonly PaneTitleProperty: Windows.UI.Xaml.DependencyProperty;
+    PaneToggleButtonStyle: Windows.UI.Xaml.Style;
+    static readonly PaneToggleButtonStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedItem: Object;
+    static readonly SelectedItemProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionFollowsFocus: number;
+    static readonly SelectionFollowsFocusProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SettingsItem: Object;
+    static readonly SettingsItemProperty: Windows.UI.Xaml.DependencyProperty;
+    ShoulderNavigationEnabled: number;
+    static readonly ShoulderNavigationEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.NavigationViewTemplateSettings;
+    static readonly TemplateSettingsProperty: Windows.UI.Xaml.DependencyProperty;
+    DisplayModeChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.NavigationView, Windows.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs> | null;
+    ItemInvoked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.NavigationView, Windows.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs> | null;
+    SelectionChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.NavigationView, Windows.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs> | null;
+    BackRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.NavigationView, Windows.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs> | null;
+    PaneClosed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.NavigationView, Object> | null;
+    PaneClosing: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.NavigationView, Windows.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs> | null;
+    PaneOpened: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.NavigationView, Object> | null;
+    PaneOpening: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.NavigationView, Object> | null;
+  }
+
+  class NavigationViewBackRequestedEventArgs implements Windows.UI.Xaml.Controls.INavigationViewBackRequestedEventArgs {
+  }
+
+  class NavigationViewDisplayModeChangedEventArgs implements Windows.UI.Xaml.Controls.INavigationViewDisplayModeChangedEventArgs {
+    readonly DisplayMode: number;
+  }
+
+  class NavigationViewItem extends Windows.UI.Xaml.Controls.NavigationViewItemBase implements Windows.UI.Xaml.Controls.INavigationViewItem, Windows.UI.Xaml.Controls.INavigationViewItem2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly CompactPaneLength: number;
+    static readonly CompactPaneLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    Icon: Windows.UI.Xaml.Controls.IconElement;
+    static readonly IconProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectsOnInvoked: boolean;
+    static readonly SelectsOnInvokedProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class NavigationViewItemBase extends Windows.UI.Xaml.Controls.ListViewItem implements Windows.UI.Xaml.Controls.INavigationViewItemBase {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class NavigationViewItemHeader extends Windows.UI.Xaml.Controls.NavigationViewItemBase implements Windows.UI.Xaml.Controls.INavigationViewItemHeader {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class NavigationViewItemInvokedEventArgs implements Windows.UI.Xaml.Controls.INavigationViewItemInvokedEventArgs, Windows.UI.Xaml.Controls.INavigationViewItemInvokedEventArgs2 {
+    constructor();
+    readonly InvokedItem: Object;
+    readonly InvokedItemContainer: Windows.UI.Xaml.Controls.NavigationViewItemBase;
+    readonly IsSettingsInvoked: boolean;
+    readonly RecommendedNavigationTransitionInfo: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+  }
+
+  class NavigationViewItemSeparator extends Windows.UI.Xaml.Controls.NavigationViewItemBase implements Windows.UI.Xaml.Controls.INavigationViewItemSeparator {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class NavigationViewList extends Windows.UI.Xaml.Controls.ListView implements Windows.UI.Xaml.Controls.INavigationViewList {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CompleteViewChange(): void;
+    CompleteViewChangeFrom(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    CompleteViewChangeTo(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    ContainerFromIndex(index: number): Windows.UI.Xaml.DependencyObject;
+    ContainerFromItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    DeselectRange(itemIndexRange: Windows.UI.Xaml.Data.ItemIndexRange): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetContainerForItemOverride(): Windows.UI.Xaml.DependencyObject;
+    static GetIsSelectionActive(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetItemsOwner(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    GroupHeaderContainerFromItemContainer(itemContainer: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+    IndexFromContainer(container: Windows.UI.Xaml.DependencyObject): number;
+    InitializeViewChange(): void;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    IsDragSource(): boolean;
+    IsItemItsOwnContainerOverride(item: Object): boolean;
+    ItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    static ItemsControlFromItemContainer(container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    LoadMoreItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Data.LoadMoreItemsResult>;
+    MakeVisible(item: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnGroupStyleSelectorChanged(oldGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector, newGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnItemContainerStyleChanged(oldItemContainerStyle: Windows.UI.Xaml.Style, newItemContainerStyle: Windows.UI.Xaml.Style): void;
+    OnItemContainerStyleSelectorChanged(oldItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector, newItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector): void;
+    OnItemTemplateChanged(oldItemTemplate: Windows.UI.Xaml.DataTemplate, newItemTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnItemTemplateSelectorChanged(oldItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnItemsChanged(e: Object): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PrepareConnectedAnimation(key: string, item: Object, elementName: string): Windows.UI.Xaml.Media.Animation.ConnectedAnimation;
+    PrepareContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    ScrollIntoView(item: Object): void;
+    ScrollIntoView(item: Object, alignment: number): void;
+    SelectAll(): void;
+    SelectRange(itemIndexRange: Windows.UI.Xaml.Data.ItemIndexRange): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetDesiredContainerUpdateDuration(duration: Windows.Foundation.TimeSpan): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StartViewChangeFrom(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    StartViewChangeTo(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    TryStartConnectedAnimationAsync(animation: Windows.UI.Xaml.Media.Animation.ConnectedAnimation, item: Object, elementName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class NavigationViewPaneClosingEventArgs implements Windows.UI.Xaml.Controls.INavigationViewPaneClosingEventArgs {
+    Cancel: boolean;
+  }
+
+  class NavigationViewSelectionChangedEventArgs implements Windows.UI.Xaml.Controls.INavigationViewSelectionChangedEventArgs, Windows.UI.Xaml.Controls.INavigationViewSelectionChangedEventArgs2 {
+    readonly IsSettingsSelected: boolean;
+    readonly RecommendedNavigationTransitionInfo: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+    readonly SelectedItem: Object;
+    readonly SelectedItemContainer: Windows.UI.Xaml.Controls.NavigationViewItemBase;
+  }
+
+  class NavigationViewTemplateSettings extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.INavigationViewTemplateSettings {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly BackButtonVisibility: number;
+    static readonly BackButtonVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LeftPaneVisibility: number;
+    static readonly LeftPaneVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OverflowButtonVisibility: number;
+    static readonly OverflowButtonVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaneToggleButtonVisibility: number;
+    static readonly PaneToggleButtonVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SingleSelectionFollowsFocus: boolean;
+    static readonly SingleSelectionFollowsFocusProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TopPadding: number;
+    static readonly TopPaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TopPaneVisibility: number;
+    static readonly TopPaneVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class NotifyEventArgs implements Windows.UI.Xaml.Controls.INotifyEventArgs, Windows.UI.Xaml.Controls.INotifyEventArgs2 {
+    readonly CallingUri: Windows.Foundation.Uri;
+    readonly Value: string;
+  }
+
+  class Page extends Windows.UI.Xaml.Controls.UserControl implements Windows.UI.Xaml.Controls.IPage, Windows.UI.Xaml.Controls.IPageOverrides {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnNavigatedFrom(e: Windows.UI.Xaml.Navigation.NavigationEventArgs): void;
+    OnNavigatedTo(e: Windows.UI.Xaml.Navigation.NavigationEventArgs): void;
+    OnNavigatingFrom(e: Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    BottomAppBar: Windows.UI.Xaml.Controls.AppBar;
+    static readonly BottomAppBarProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Frame: Windows.UI.Xaml.Controls.Frame;
+    static readonly FrameProperty: Windows.UI.Xaml.DependencyProperty;
+    NavigationCacheMode: number;
+    TopAppBar: Windows.UI.Xaml.Controls.AppBar;
+    static readonly TopAppBarProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Panel extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Controls.IPanel, Windows.UI.Xaml.Controls.IPanel2 {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Background: Windows.UI.Xaml.Media.Brush;
+    static readonly BackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    BackgroundTransition: Windows.UI.Xaml.BrushTransition;
+    readonly Children: Windows.UI.Xaml.Controls.UIElementCollection;
+    ChildrenTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    static readonly ChildrenTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsItemsHost: boolean;
+    static readonly IsItemsHostProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ParallaxView extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Controls.IParallaxView {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RefreshAutomaticHorizontalOffsets(): void;
+    RefreshAutomaticVerticalOffsets(): void;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Child: Windows.UI.Xaml.UIElement;
+    static readonly ChildProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalShift: number;
+    static readonly HorizontalShiftProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalSourceEndOffset: number;
+    static readonly HorizontalSourceEndOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalSourceOffsetKind: number;
+    static readonly HorizontalSourceOffsetKindProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalSourceStartOffset: number;
+    static readonly HorizontalSourceStartOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    IsHorizontalShiftClamped: boolean;
+    static readonly IsHorizontalShiftClampedProperty: Windows.UI.Xaml.DependencyProperty;
+    IsVerticalShiftClamped: boolean;
+    static readonly IsVerticalShiftClampedProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxHorizontalShiftRatio: number;
+    static readonly MaxHorizontalShiftRatioProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxVerticalShiftRatio: number;
+    static readonly MaxVerticalShiftRatioProperty: Windows.UI.Xaml.DependencyProperty;
+    Source: Windows.UI.Xaml.UIElement;
+    static readonly SourceProperty: Windows.UI.Xaml.DependencyProperty;
+    VerticalShift: number;
+    static readonly VerticalShiftProperty: Windows.UI.Xaml.DependencyProperty;
+    VerticalSourceEndOffset: number;
+    static readonly VerticalSourceEndOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    VerticalSourceOffsetKind: number;
+    static readonly VerticalSourceOffsetKindProperty: Windows.UI.Xaml.DependencyProperty;
+    VerticalSourceStartOffset: number;
+    static readonly VerticalSourceStartOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PasswordBox extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IPasswordBox, Windows.UI.Xaml.Controls.IPasswordBox2, Windows.UI.Xaml.Controls.IPasswordBox3, Windows.UI.Xaml.Controls.IPasswordBox4, Windows.UI.Xaml.Controls.IPasswordBox5 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PasteFromClipboard(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SelectAll(): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly CanPasteClipboardContent: boolean;
+    static readonly CanPasteClipboardContentProperty: Windows.UI.Xaml.DependencyProperty;
+    Description: Object;
+    static readonly DescriptionProperty: Windows.UI.Xaml.DependencyProperty;
+    Header: Object;
+    static readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    InputScope: Windows.UI.Xaml.Input.InputScope;
+    static readonly InputScopeProperty: Windows.UI.Xaml.DependencyProperty;
+    IsPasswordRevealButtonEnabled: boolean;
+    static readonly IsPasswordRevealButtonEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxLength: number;
+    static readonly MaxLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    Password: string;
+    PasswordChar: string;
+    static readonly PasswordCharProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly PasswordProperty: Windows.UI.Xaml.DependencyProperty;
+    PasswordRevealMode: number;
+    static readonly PasswordRevealModeProperty: Windows.UI.Xaml.DependencyProperty;
+    PlaceholderText: string;
+    static readonly PlaceholderTextProperty: Windows.UI.Xaml.DependencyProperty;
+    PreventKeyboardDisplayOnProgrammaticFocus: boolean;
+    static readonly PreventKeyboardDisplayOnProgrammaticFocusProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionFlyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    static readonly SelectionFlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionHighlightColor: Windows.UI.Xaml.Media.SolidColorBrush;
+    static readonly SelectionHighlightColorProperty: Windows.UI.Xaml.DependencyProperty;
+    TextReadingOrder: number;
+    static readonly TextReadingOrderProperty: Windows.UI.Xaml.DependencyProperty;
+    ContextMenuOpening: Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler | null;
+    PasswordChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+    Paste: Windows.UI.Xaml.Controls.TextControlPasteEventHandler | null;
+    PasswordChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.PasswordBox, Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs> | null;
+  }
+
+  class PasswordBoxPasswordChangingEventArgs implements Windows.UI.Xaml.Controls.IPasswordBoxPasswordChangingEventArgs {
+    readonly IsContentChanging: boolean;
+  }
+
+  class PathIcon extends Windows.UI.Xaml.Controls.IconElement implements Windows.UI.Xaml.Controls.IPathIcon {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Data: Windows.UI.Xaml.Media.Geometry;
+    static readonly DataProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PathIconSource extends Windows.UI.Xaml.Controls.IconSource implements Windows.UI.Xaml.Controls.IPathIconSource {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Data: Windows.UI.Xaml.Media.Geometry;
+    static readonly DataProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PersonPicture extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IPersonPicture {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    BadgeGlyph: string;
+    static readonly BadgeGlyphProperty: Windows.UI.Xaml.DependencyProperty;
+    BadgeImageSource: Windows.UI.Xaml.Media.ImageSource;
+    static readonly BadgeImageSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    BadgeNumber: number;
+    static readonly BadgeNumberProperty: Windows.UI.Xaml.DependencyProperty;
+    BadgeText: string;
+    static readonly BadgeTextProperty: Windows.UI.Xaml.DependencyProperty;
+    Contact: Windows.ApplicationModel.Contacts.Contact;
+    static readonly ContactProperty: Windows.UI.Xaml.DependencyProperty;
+    DisplayName: string;
+    static readonly DisplayNameProperty: Windows.UI.Xaml.DependencyProperty;
+    Initials: string;
+    static readonly InitialsProperty: Windows.UI.Xaml.DependencyProperty;
+    IsGroup: boolean;
+    static readonly IsGroupProperty: Windows.UI.Xaml.DependencyProperty;
+    PreferSmallImage: boolean;
+    static readonly PreferSmallImageProperty: Windows.UI.Xaml.DependencyProperty;
+    ProfilePicture: Windows.UI.Xaml.Media.ImageSource;
+    static readonly ProfilePictureProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PickerConfirmedEventArgs extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.IPickerConfirmedEventArgs {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class PickerFlyout extends Windows.UI.Xaml.Controls.Primitives.PickerFlyoutBase implements Windows.UI.Xaml.Controls.IPickerFlyout {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreatePresenter(): Windows.UI.Xaml.Controls.Control;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement): Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    static GetTitle(element: Windows.UI.Xaml.DependencyObject): string;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Hide(): void;
+    OnConfirmed(): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static SetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement, value: Windows.UI.Xaml.Controls.Primitives.FlyoutBase): void;
+    static SetTitle(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShouldShowConfirmationButtons(): boolean;
+    ShowAt(placementTarget: Windows.UI.Xaml.FrameworkElement): void;
+    ShowAt(placementTarget: Windows.UI.Xaml.DependencyObject, showOptions: Windows.UI.Xaml.Controls.Primitives.FlyoutShowOptions): void;
+    ShowAtAsync(target: Windows.UI.Xaml.FrameworkElement): Windows.Foundation.IAsyncOperation<boolean>;
+    static ShowAttachedFlyout(flyoutOwner: Windows.UI.Xaml.FrameworkElement): void;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    ConfirmationButtonsVisible: boolean;
+    static readonly ConfirmationButtonsVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    Content: Windows.UI.Xaml.UIElement;
+    static readonly ContentProperty: Windows.UI.Xaml.DependencyProperty;
+    Confirmed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.PickerFlyout, Windows.UI.Xaml.Controls.PickerConfirmedEventArgs> | null;
+  }
+
+  class PickerFlyoutPresenter extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.IPickerFlyoutPresenter {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class Pivot extends Windows.UI.Xaml.Controls.ItemsControl implements Windows.UI.Xaml.Controls.IPivot, Windows.UI.Xaml.Controls.IPivot2, Windows.UI.Xaml.Controls.IPivot3 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    ContainerFromIndex(index: number): Windows.UI.Xaml.DependencyObject;
+    ContainerFromItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetContainerForItemOverride(): Windows.UI.Xaml.DependencyObject;
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetItemsOwner(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    static GetSlideInAnimationGroup(element: Windows.UI.Xaml.FrameworkElement): number;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    GroupHeaderContainerFromItemContainer(itemContainer: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+    IndexFromContainer(container: Windows.UI.Xaml.DependencyObject): number;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    IsItemItsOwnContainerOverride(item: Object): boolean;
+    ItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    static ItemsControlFromItemContainer(container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnGroupStyleSelectorChanged(oldGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector, newGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnItemContainerStyleChanged(oldItemContainerStyle: Windows.UI.Xaml.Style, newItemContainerStyle: Windows.UI.Xaml.Style): void;
+    OnItemContainerStyleSelectorChanged(oldItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector, newItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector): void;
+    OnItemTemplateChanged(oldItemTemplate: Windows.UI.Xaml.DataTemplate, newItemTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnItemTemplateSelectorChanged(oldItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnItemsChanged(e: Object): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PrepareContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetSlideInAnimationGroup(element: Windows.UI.Xaml.FrameworkElement, value: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    HeaderFocusVisualPlacement: number;
+    static readonly HeaderFocusVisualPlacementProperty: Windows.UI.Xaml.DependencyProperty;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    IsHeaderItemsCarouselEnabled: boolean;
+    static readonly IsHeaderItemsCarouselEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsLocked: boolean;
+    static readonly IsLockedProperty: Windows.UI.Xaml.DependencyProperty;
+    LeftHeader: Object;
+    static readonly LeftHeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    LeftHeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly LeftHeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    RightHeader: Object;
+    static readonly RightHeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    RightHeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly RightHeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedIndex: number;
+    static readonly SelectedIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedItem: Object;
+    static readonly SelectedItemProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly SlideInAnimationGroupProperty: Windows.UI.Xaml.DependencyProperty;
+    Title: Object;
+    static readonly TitleProperty: Windows.UI.Xaml.DependencyProperty;
+    TitleTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly TitleTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    PivotItemLoaded: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Pivot, Windows.UI.Xaml.Controls.PivotItemEventArgs> | null;
+    PivotItemLoading: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Pivot, Windows.UI.Xaml.Controls.PivotItemEventArgs> | null;
+    PivotItemUnloaded: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Pivot, Windows.UI.Xaml.Controls.PivotItemEventArgs> | null;
+    PivotItemUnloading: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Pivot, Windows.UI.Xaml.Controls.PivotItemEventArgs> | null;
+    SelectionChanged: Windows.UI.Xaml.Controls.SelectionChangedEventHandler | null;
+  }
+
+  class PivotItem extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.IPivotItem {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Header: Object;
+    static readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PivotItemEventArgs implements Windows.UI.Xaml.Controls.IPivotItemEventArgs {
+    constructor();
+    Item: Windows.UI.Xaml.Controls.PivotItem;
+  }
+
+  class ProgressBar extends Windows.UI.Xaml.Controls.Primitives.RangeBase implements Windows.UI.Xaml.Controls.IProgressBar {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnMaximumChanged(oldMaximum: number, newMaximum: number): void;
+    OnMinimumChanged(oldMinimum: number, newMinimum: number): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnValueChanged(oldValue: number, newValue: number): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    IsIndeterminate: boolean;
+    static readonly IsIndeterminateProperty: Windows.UI.Xaml.DependencyProperty;
+    ShowError: boolean;
+    static readonly ShowErrorProperty: Windows.UI.Xaml.DependencyProperty;
+    ShowPaused: boolean;
+    static readonly ShowPausedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.ProgressBarTemplateSettings;
+  }
+
+  class ProgressRing extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IProgressRing {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    IsActive: boolean;
+    static readonly IsActiveProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.ProgressRingTemplateSettings;
+  }
+
+  class RadioButton extends Windows.UI.Xaml.Controls.Primitives.ToggleButton implements Windows.UI.Xaml.Controls.IRadioButton {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnToggle(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    GroupName: string;
+    static readonly GroupNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class RatingControl extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IRatingControl {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Caption: string;
+    static readonly CaptionProperty: Windows.UI.Xaml.DependencyProperty;
+    InitialSetValue: number;
+    static readonly InitialSetValueProperty: Windows.UI.Xaml.DependencyProperty;
+    IsClearEnabled: boolean;
+    static readonly IsClearEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsReadOnly: boolean;
+    static readonly IsReadOnlyProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemInfo: Windows.UI.Xaml.Controls.RatingItemInfo;
+    static readonly ItemInfoProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxRating: number;
+    static readonly MaxRatingProperty: Windows.UI.Xaml.DependencyProperty;
+    PlaceholderValue: number;
+    static readonly PlaceholderValueProperty: Windows.UI.Xaml.DependencyProperty;
+    Value: number;
+    static readonly ValueProperty: Windows.UI.Xaml.DependencyProperty;
+    ValueChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RatingControl, Object> | null;
+  }
+
+  class RatingItemFontInfo extends Windows.UI.Xaml.Controls.RatingItemInfo implements Windows.UI.Xaml.Controls.IRatingItemFontInfo {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    DisabledGlyph: string;
+    static readonly DisabledGlyphProperty: Windows.UI.Xaml.DependencyProperty;
+    Glyph: string;
+    static readonly GlyphProperty: Windows.UI.Xaml.DependencyProperty;
+    PlaceholderGlyph: string;
+    static readonly PlaceholderGlyphProperty: Windows.UI.Xaml.DependencyProperty;
+    PointerOverGlyph: string;
+    static readonly PointerOverGlyphProperty: Windows.UI.Xaml.DependencyProperty;
+    PointerOverPlaceholderGlyph: string;
+    static readonly PointerOverPlaceholderGlyphProperty: Windows.UI.Xaml.DependencyProperty;
+    UnsetGlyph: string;
+    static readonly UnsetGlyphProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class RatingItemImageInfo extends Windows.UI.Xaml.Controls.RatingItemInfo implements Windows.UI.Xaml.Controls.IRatingItemImageInfo {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    DisabledImage: Windows.UI.Xaml.Media.ImageSource;
+    static readonly DisabledImageProperty: Windows.UI.Xaml.DependencyProperty;
+    Image: Windows.UI.Xaml.Media.ImageSource;
+    static readonly ImageProperty: Windows.UI.Xaml.DependencyProperty;
+    PlaceholderImage: Windows.UI.Xaml.Media.ImageSource;
+    static readonly PlaceholderImageProperty: Windows.UI.Xaml.DependencyProperty;
+    PointerOverImage: Windows.UI.Xaml.Media.ImageSource;
+    static readonly PointerOverImageProperty: Windows.UI.Xaml.DependencyProperty;
+    PointerOverPlaceholderImage: Windows.UI.Xaml.Media.ImageSource;
+    static readonly PointerOverPlaceholderImageProperty: Windows.UI.Xaml.DependencyProperty;
+    UnsetImage: Windows.UI.Xaml.Media.ImageSource;
+    static readonly UnsetImageProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class RatingItemInfo extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.IRatingItemInfo {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class RefreshContainer extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.IRefreshContainer {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    RequestRefresh(): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    PullDirection: number;
+    static readonly PullDirectionProperty: Windows.UI.Xaml.DependencyProperty;
+    Visualizer: Windows.UI.Xaml.Controls.RefreshVisualizer;
+    static readonly VisualizerProperty: Windows.UI.Xaml.DependencyProperty;
+    RefreshRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RefreshContainer, Windows.UI.Xaml.Controls.RefreshRequestedEventArgs> | null;
+  }
+
+  class RefreshInteractionRatioChangedEventArgs implements Windows.UI.Xaml.Controls.IRefreshInteractionRatioChangedEventArgs {
+    readonly InteractionRatio: number;
+  }
+
+  class RefreshRequestedEventArgs implements Windows.UI.Xaml.Controls.IRefreshRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+
+  class RefreshStateChangedEventArgs implements Windows.UI.Xaml.Controls.IRefreshStateChangedEventArgs {
+    readonly NewState: number;
+    readonly OldState: number;
+  }
+
+  class RefreshVisualizer extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IRefreshVisualizer {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    RequestRefresh(): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Content: Windows.UI.Xaml.UIElement;
+    static readonly ContentProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly InfoProviderProperty: Windows.UI.Xaml.DependencyProperty;
+    Orientation: number;
+    static readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly State: number;
+    static readonly StateProperty: Windows.UI.Xaml.DependencyProperty;
+    RefreshRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RefreshVisualizer, Windows.UI.Xaml.Controls.RefreshRequestedEventArgs> | null;
+    RefreshStateChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RefreshVisualizer, Windows.UI.Xaml.Controls.RefreshStateChangedEventArgs> | null;
+  }
+
+  class RelativePanel extends Windows.UI.Xaml.Controls.Panel implements Windows.UI.Xaml.Controls.IRelativePanel, Windows.UI.Xaml.Controls.IRelativePanel2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    static GetAbove(element: Windows.UI.Xaml.UIElement): Object;
+    static GetAlignBottomWith(element: Windows.UI.Xaml.UIElement): Object;
+    static GetAlignBottomWithPanel(element: Windows.UI.Xaml.UIElement): boolean;
+    static GetAlignHorizontalCenterWith(element: Windows.UI.Xaml.UIElement): Object;
+    static GetAlignHorizontalCenterWithPanel(element: Windows.UI.Xaml.UIElement): boolean;
+    static GetAlignLeftWith(element: Windows.UI.Xaml.UIElement): Object;
+    static GetAlignLeftWithPanel(element: Windows.UI.Xaml.UIElement): boolean;
+    static GetAlignRightWith(element: Windows.UI.Xaml.UIElement): Object;
+    static GetAlignRightWithPanel(element: Windows.UI.Xaml.UIElement): boolean;
+    static GetAlignTopWith(element: Windows.UI.Xaml.UIElement): Object;
+    static GetAlignTopWithPanel(element: Windows.UI.Xaml.UIElement): boolean;
+    static GetAlignVerticalCenterWith(element: Windows.UI.Xaml.UIElement): Object;
+    static GetAlignVerticalCenterWithPanel(element: Windows.UI.Xaml.UIElement): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetBelow(element: Windows.UI.Xaml.UIElement): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetLeftOf(element: Windows.UI.Xaml.UIElement): Object;
+    static GetRightOf(element: Windows.UI.Xaml.UIElement): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    static SetAbove(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    static SetAlignBottomWith(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    static SetAlignBottomWithPanel(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    static SetAlignHorizontalCenterWith(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    static SetAlignHorizontalCenterWithPanel(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    static SetAlignLeftWith(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    static SetAlignLeftWithPanel(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    static SetAlignRightWith(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    static SetAlignRightWithPanel(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    static SetAlignTopWith(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    static SetAlignTopWithPanel(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    static SetAlignVerticalCenterWith(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    static SetAlignVerticalCenterWithPanel(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    static SetBelow(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetLeftOf(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    static SetRightOf(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    static readonly AboveProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly AlignBottomWithPanelProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly AlignBottomWithProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly AlignHorizontalCenterWithPanelProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly AlignHorizontalCenterWithProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly AlignLeftWithPanelProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly AlignLeftWithProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly AlignRightWithPanelProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly AlignRightWithProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly AlignTopWithPanelProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly AlignTopWithProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly AlignVerticalCenterWithPanelProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly AlignVerticalCenterWithProperty: Windows.UI.Xaml.DependencyProperty;
+    BackgroundSizing: number;
+    static readonly BackgroundSizingProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly BelowProperty: Windows.UI.Xaml.DependencyProperty;
+    BorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly BorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    BorderThickness: Windows.UI.Xaml.Thickness;
+    static readonly BorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    CornerRadius: Windows.UI.Xaml.CornerRadius;
+    static readonly CornerRadiusProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly LeftOfProperty: Windows.UI.Xaml.DependencyProperty;
+    Padding: Windows.UI.Xaml.Thickness;
+    static readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly RightOfProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class RichEditBox extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IRichEditBox, Windows.UI.Xaml.Controls.IRichEditBox2, Windows.UI.Xaml.Controls.IRichEditBox3, Windows.UI.Xaml.Controls.IRichEditBox4, Windows.UI.Xaml.Controls.IRichEditBox5, Windows.UI.Xaml.Controls.IRichEditBox6, Windows.UI.Xaml.Controls.IRichEditBox7, Windows.UI.Xaml.Controls.IRichEditBox8 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetLinguisticAlternativesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    AcceptsReturn: boolean;
+    static readonly AcceptsReturnProperty: Windows.UI.Xaml.DependencyProperty;
+    CharacterCasing: number;
+    static readonly CharacterCasingProperty: Windows.UI.Xaml.DependencyProperty;
+    ClipboardCopyFormat: number;
+    static readonly ClipboardCopyFormatProperty: Windows.UI.Xaml.DependencyProperty;
+    ContentLinkBackgroundColor: Windows.UI.Xaml.Media.SolidColorBrush;
+    static readonly ContentLinkBackgroundColorProperty: Windows.UI.Xaml.DependencyProperty;
+    ContentLinkForegroundColor: Windows.UI.Xaml.Media.SolidColorBrush;
+    static readonly ContentLinkForegroundColorProperty: Windows.UI.Xaml.DependencyProperty;
+    ContentLinkProviders: Windows.UI.Xaml.Documents.ContentLinkProviderCollection;
+    static readonly ContentLinkProvidersProperty: Windows.UI.Xaml.DependencyProperty;
+    Description: Object;
+    static readonly DescriptionProperty: Windows.UI.Xaml.DependencyProperty;
+    DesiredCandidateWindowAlignment: number;
+    static readonly DesiredCandidateWindowAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    DisabledFormattingAccelerators: number;
+    static readonly DisabledFormattingAcceleratorsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Document: Windows.UI.Text.ITextDocument;
+    HandwritingView: Windows.UI.Xaml.Controls.HandwritingView;
+    static readonly HandwritingViewProperty: Windows.UI.Xaml.DependencyProperty;
+    Header: Object;
+    static readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalTextAlignment: number;
+    static readonly HorizontalTextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    InputScope: Windows.UI.Xaml.Input.InputScope;
+    static readonly InputScopeProperty: Windows.UI.Xaml.DependencyProperty;
+    IsColorFontEnabled: boolean;
+    static readonly IsColorFontEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsHandwritingViewEnabled: boolean;
+    static readonly IsHandwritingViewEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsReadOnly: boolean;
+    static readonly IsReadOnlyProperty: Windows.UI.Xaml.DependencyProperty;
+    IsSpellCheckEnabled: boolean;
+    static readonly IsSpellCheckEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsTextPredictionEnabled: boolean;
+    static readonly IsTextPredictionEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxLength: number;
+    static readonly MaxLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    PlaceholderText: string;
+    static readonly PlaceholderTextProperty: Windows.UI.Xaml.DependencyProperty;
+    PreventKeyboardDisplayOnProgrammaticFocus: boolean;
+    static readonly PreventKeyboardDisplayOnProgrammaticFocusProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ProofingMenuFlyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    static readonly ProofingMenuFlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionFlyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    static readonly SelectionFlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionHighlightColor: Windows.UI.Xaml.Media.SolidColorBrush;
+    static readonly SelectionHighlightColorProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionHighlightColorWhenNotFocused: Windows.UI.Xaml.Media.SolidColorBrush;
+    static readonly SelectionHighlightColorWhenNotFocusedProperty: Windows.UI.Xaml.DependencyProperty;
+    TextAlignment: number;
+    static readonly TextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextDocument: Windows.UI.Text.RichEditTextDocument;
+    TextReadingOrder: number;
+    static readonly TextReadingOrderProperty: Windows.UI.Xaml.DependencyProperty;
+    TextWrapping: number;
+    static readonly TextWrappingProperty: Windows.UI.Xaml.DependencyProperty;
+    ContextMenuOpening: Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler | null;
+    SelectionChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+    TextChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+    Paste: Windows.UI.Xaml.Controls.TextControlPasteEventHandler | null;
+    CandidateWindowBoundsChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs> | null;
+    TextChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs> | null;
+    TextCompositionChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs> | null;
+    TextCompositionEnded: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs> | null;
+    TextCompositionStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs> | null;
+    CopyingToClipboard: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs> | null;
+    CuttingToClipboard: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs> | null;
+    ContentLinkChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Controls.ContentLinkChangedEventArgs> | null;
+    ContentLinkInvoked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs> | null;
+    SelectionChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs> | null;
+  }
+
+  class RichEditBoxSelectionChangingEventArgs implements Windows.UI.Xaml.Controls.IRichEditBoxSelectionChangingEventArgs {
+    Cancel: boolean;
+    readonly SelectionLength: number;
+    readonly SelectionStart: number;
+  }
+
+  class RichEditBoxTextChangingEventArgs implements Windows.UI.Xaml.Controls.IRichEditBoxTextChangingEventArgs, Windows.UI.Xaml.Controls.IRichEditBoxTextChangingEventArgs2 {
+    readonly IsContentChanging: boolean;
+  }
+
+  class RichTextBlock extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Controls.IRichTextBlock, Windows.UI.Xaml.Controls.IRichTextBlock2, Windows.UI.Xaml.Controls.IRichTextBlock3, Windows.UI.Xaml.Controls.IRichTextBlock4, Windows.UI.Xaml.Controls.IRichTextBlock5, Windows.UI.Xaml.Controls.IRichTextBlock6 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CopySelectionToClipboard(): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetPositionFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Documents.TextPointer;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    Select(start: Windows.UI.Xaml.Documents.TextPointer, end: Windows.UI.Xaml.Documents.TextPointer): void;
+    SelectAll(): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly BaselineOffset: number;
+    readonly Blocks: Windows.UI.Xaml.Documents.BlockCollection;
+    CharacterSpacing: number;
+    static readonly CharacterSpacingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentEnd: Windows.UI.Xaml.Documents.TextPointer;
+    readonly ContentStart: Windows.UI.Xaml.Documents.TextPointer;
+    FontFamily: Windows.UI.Xaml.Media.FontFamily;
+    static readonly FontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    FontSize: number;
+    static readonly FontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    FontStretch: number;
+    static readonly FontStretchProperty: Windows.UI.Xaml.DependencyProperty;
+    FontStyle: number;
+    static readonly FontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    FontWeight: Windows.UI.Text.FontWeight;
+    static readonly FontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    Foreground: Windows.UI.Xaml.Media.Brush;
+    static readonly ForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HasOverflowContent: boolean;
+    static readonly HasOverflowContentProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalTextAlignment: number;
+    static readonly HorizontalTextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    IsColorFontEnabled: boolean;
+    static readonly IsColorFontEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsTextScaleFactorEnabled: boolean;
+    static readonly IsTextScaleFactorEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsTextSelectionEnabled: boolean;
+    static readonly IsTextSelectionEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsTextTrimmed: boolean;
+    static readonly IsTextTrimmedProperty: Windows.UI.Xaml.DependencyProperty;
+    LineHeight: number;
+    static readonly LineHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    LineStackingStrategy: number;
+    static readonly LineStackingStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxLines: number;
+    static readonly MaxLinesProperty: Windows.UI.Xaml.DependencyProperty;
+    OpticalMarginAlignment: number;
+    static readonly OpticalMarginAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    OverflowContentTarget: Windows.UI.Xaml.Controls.RichTextBlockOverflow;
+    static readonly OverflowContentTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    Padding: Windows.UI.Xaml.Thickness;
+    static readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedText: string;
+    static readonly SelectedTextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionEnd: Windows.UI.Xaml.Documents.TextPointer;
+    SelectionFlyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    static readonly SelectionFlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionHighlightColor: Windows.UI.Xaml.Media.SolidColorBrush;
+    static readonly SelectionHighlightColorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionStart: Windows.UI.Xaml.Documents.TextPointer;
+    TextAlignment: number;
+    static readonly TextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    TextDecorations: number;
+    static readonly TextDecorationsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextHighlighters: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Documents.TextHighlighter> | Windows.UI.Xaml.Documents.TextHighlighter[];
+    TextIndent: number;
+    static readonly TextIndentProperty: Windows.UI.Xaml.DependencyProperty;
+    TextLineBounds: number;
+    static readonly TextLineBoundsProperty: Windows.UI.Xaml.DependencyProperty;
+    TextReadingOrder: number;
+    static readonly TextReadingOrderProperty: Windows.UI.Xaml.DependencyProperty;
+    TextTrimming: number;
+    static readonly TextTrimmingProperty: Windows.UI.Xaml.DependencyProperty;
+    TextWrapping: number;
+    static readonly TextWrappingProperty: Windows.UI.Xaml.DependencyProperty;
+    ContextMenuOpening: Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler | null;
+    SelectionChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+    IsTextTrimmedChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichTextBlock, Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs> | null;
+  }
+
+  class RichTextBlockOverflow extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Controls.IRichTextBlockOverflow, Windows.UI.Xaml.Controls.IRichTextBlockOverflow2, Windows.UI.Xaml.Controls.IRichTextBlockOverflow3 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetPositionFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Documents.TextPointer;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly BaselineOffset: number;
+    readonly ContentEnd: Windows.UI.Xaml.Documents.TextPointer;
+    readonly ContentSource: Windows.UI.Xaml.Controls.RichTextBlock;
+    readonly ContentStart: Windows.UI.Xaml.Documents.TextPointer;
+    readonly HasOverflowContent: boolean;
+    static readonly HasOverflowContentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsTextTrimmed: boolean;
+    static readonly IsTextTrimmedProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxLines: number;
+    static readonly MaxLinesProperty: Windows.UI.Xaml.DependencyProperty;
+    OverflowContentTarget: Windows.UI.Xaml.Controls.RichTextBlockOverflow;
+    static readonly OverflowContentTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    Padding: Windows.UI.Xaml.Thickness;
+    static readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    IsTextTrimmedChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichTextBlockOverflow, Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs> | null;
+  }
+
+  class RowDefinition extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.IRowDefinition {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly ActualHeight: number;
+    Height: Windows.UI.Xaml.GridLength;
+    static readonly HeightProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxHeight: number;
+    static readonly MaxHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    MinHeight: number;
+    static readonly MinHeightProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class RowDefinitionCollection {
+    Append(value: Windows.UI.Xaml.Controls.RowDefinition): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Controls.RowDefinition>;
+    GetAt(index: number): Windows.UI.Xaml.Controls.RowDefinition;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Controls.RowDefinition[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Controls.RowDefinition> | Windows.UI.Xaml.Controls.RowDefinition[];
+    IndexOf(value: Windows.UI.Xaml.Controls.RowDefinition, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Controls.RowDefinition): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Controls.RowDefinition[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Controls.RowDefinition): void;
+    readonly Size: number;
+  }
+
+  class ScrollContentPresenter extends Windows.UI.Xaml.Controls.ContentPresenter implements Windows.UI.Xaml.Controls.IScrollContentPresenter, Windows.UI.Xaml.Controls.IScrollContentPresenter2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    LineDown(): void;
+    LineLeft(): void;
+    LineRight(): void;
+    LineUp(): void;
+    MakeVisible(visual: Windows.UI.Xaml.UIElement, rectangle: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    MouseWheelDown(): void;
+    MouseWheelLeft(): void;
+    MouseWheelRight(): void;
+    MouseWheelUp(): void;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PageDown(): void;
+    PageLeft(): void;
+    PageRight(): void;
+    PageUp(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetHorizontalOffset(offset: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    SetVerticalOffset(offset: number): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    CanContentRenderOutsideBounds: boolean;
+    static readonly CanContentRenderOutsideBoundsProperty: Windows.UI.Xaml.DependencyProperty;
+    CanHorizontallyScroll: boolean;
+    CanVerticallyScroll: boolean;
+    readonly ExtentHeight: number;
+    readonly ExtentWidth: number;
+    readonly HorizontalOffset: number;
+    ScrollOwner: Object;
+    SizesContentToTemplatedParent: boolean;
+    static readonly SizesContentToTemplatedParentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalOffset: number;
+    readonly ViewportHeight: number;
+    readonly ViewportWidth: number;
+  }
+
+  class ScrollViewer extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.IScrollAnchorProvider, Windows.UI.Xaml.Controls.IScrollViewer, Windows.UI.Xaml.Controls.IScrollViewer2, Windows.UI.Xaml.Controls.IScrollViewer3, Windows.UI.Xaml.Controls.IScrollViewer4 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ChangeView(horizontalOffset: number | null, verticalOffset: number | null, zoomFactor: number | null): boolean;
+    ChangeView(horizontalOffset: number | null, verticalOffset: number | null, zoomFactor: number | null, disableAnimation: boolean): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    static GetBringIntoViewOnFocusChange(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetCanContentRenderOutsideBounds(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetHorizontalScrollBarVisibility(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetHorizontalScrollMode(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetIsDeferredScrollingEnabled(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsHorizontalRailEnabled(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsHorizontalScrollChainingEnabled(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsScrollInertiaEnabled(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsVerticalRailEnabled(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsVerticalScrollChainingEnabled(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsZoomChainingEnabled(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsZoomInertiaEnabled(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetVerticalScrollBarVisibility(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetVerticalScrollMode(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetZoomMode(element: Windows.UI.Xaml.DependencyObject): number;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateScrollInfo(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterAnchorCandidate(element: Windows.UI.Xaml.UIElement): void;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    ScrollToHorizontalOffset(offset: number): void;
+    ScrollToVerticalOffset(offset: number): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetBringIntoViewOnFocusChange(element: Windows.UI.Xaml.DependencyObject, bringIntoViewOnFocusChange: boolean): void;
+    static SetCanContentRenderOutsideBounds(element: Windows.UI.Xaml.DependencyObject, canContentRenderOutsideBounds: boolean): void;
+    static SetHorizontalScrollBarVisibility(element: Windows.UI.Xaml.DependencyObject, horizontalScrollBarVisibility: number): void;
+    static SetHorizontalScrollMode(element: Windows.UI.Xaml.DependencyObject, horizontalScrollMode: number): void;
+    static SetIsDeferredScrollingEnabled(element: Windows.UI.Xaml.DependencyObject, isDeferredScrollingEnabled: boolean): void;
+    static SetIsHorizontalRailEnabled(element: Windows.UI.Xaml.DependencyObject, isHorizontalRailEnabled: boolean): void;
+    static SetIsHorizontalScrollChainingEnabled(element: Windows.UI.Xaml.DependencyObject, isHorizontalScrollChainingEnabled: boolean): void;
+    static SetIsScrollInertiaEnabled(element: Windows.UI.Xaml.DependencyObject, isScrollInertiaEnabled: boolean): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetIsVerticalRailEnabled(element: Windows.UI.Xaml.DependencyObject, isVerticalRailEnabled: boolean): void;
+    static SetIsVerticalScrollChainingEnabled(element: Windows.UI.Xaml.DependencyObject, isVerticalScrollChainingEnabled: boolean): void;
+    static SetIsZoomChainingEnabled(element: Windows.UI.Xaml.DependencyObject, isZoomChainingEnabled: boolean): void;
+    static SetIsZoomInertiaEnabled(element: Windows.UI.Xaml.DependencyObject, isZoomInertiaEnabled: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    static SetVerticalScrollBarVisibility(element: Windows.UI.Xaml.DependencyObject, verticalScrollBarVisibility: number): void;
+    static SetVerticalScrollMode(element: Windows.UI.Xaml.DependencyObject, verticalScrollMode: number): void;
+    static SetZoomMode(element: Windows.UI.Xaml.DependencyObject, zoomMode: number): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterAnchorCandidate(element: Windows.UI.Xaml.UIElement): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    ZoomToFactor(factor: number): void;
+    BringIntoViewOnFocusChange: boolean;
+    static readonly BringIntoViewOnFocusChangeProperty: Windows.UI.Xaml.DependencyProperty;
+    CanContentRenderOutsideBounds: boolean;
+    static readonly CanContentRenderOutsideBoundsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ComputedHorizontalScrollBarVisibility: number;
+    static readonly ComputedHorizontalScrollBarVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ComputedVerticalScrollBarVisibility: number;
+    static readonly ComputedVerticalScrollBarVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CurrentAnchor: Windows.UI.Xaml.UIElement;
+    readonly ExtentHeight: number;
+    static readonly ExtentHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ExtentWidth: number;
+    static readonly ExtentWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalAnchorRatio: number;
+    static readonly HorizontalAnchorRatioProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalOffset: number;
+    static readonly HorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalScrollBarVisibility: number;
+    static readonly HorizontalScrollBarVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalScrollMode: number;
+    static readonly HorizontalScrollModeProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalSnapPointsAlignment: number;
+    static readonly HorizontalSnapPointsAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalSnapPointsType: number;
+    static readonly HorizontalSnapPointsTypeProperty: Windows.UI.Xaml.DependencyProperty;
+    IsDeferredScrollingEnabled: boolean;
+    static readonly IsDeferredScrollingEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsHorizontalRailEnabled: boolean;
+    static readonly IsHorizontalRailEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsHorizontalScrollChainingEnabled: boolean;
+    static readonly IsHorizontalScrollChainingEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsScrollInertiaEnabled: boolean;
+    static readonly IsScrollInertiaEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsVerticalRailEnabled: boolean;
+    static readonly IsVerticalRailEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsVerticalScrollChainingEnabled: boolean;
+    static readonly IsVerticalScrollChainingEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsZoomChainingEnabled: boolean;
+    static readonly IsZoomChainingEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsZoomInertiaEnabled: boolean;
+    static readonly IsZoomInertiaEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    LeftHeader: Windows.UI.Xaml.UIElement;
+    static readonly LeftHeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxZoomFactor: number;
+    static readonly MaxZoomFactorProperty: Windows.UI.Xaml.DependencyProperty;
+    MinZoomFactor: number;
+    static readonly MinZoomFactorProperty: Windows.UI.Xaml.DependencyProperty;
+    ReduceViewportForCoreInputViewOcclusions: boolean;
+    static readonly ReduceViewportForCoreInputViewOcclusionsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ScrollableHeight: number;
+    static readonly ScrollableHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ScrollableWidth: number;
+    static readonly ScrollableWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    TopHeader: Windows.UI.Xaml.UIElement;
+    static readonly TopHeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    TopLeftHeader: Windows.UI.Xaml.UIElement;
+    static readonly TopLeftHeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    VerticalAnchorRatio: number;
+    static readonly VerticalAnchorRatioProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalOffset: number;
+    static readonly VerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    VerticalScrollBarVisibility: number;
+    static readonly VerticalScrollBarVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    VerticalScrollMode: number;
+    static readonly VerticalScrollModeProperty: Windows.UI.Xaml.DependencyProperty;
+    VerticalSnapPointsAlignment: number;
+    static readonly VerticalSnapPointsAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    VerticalSnapPointsType: number;
+    static readonly VerticalSnapPointsTypeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ViewportHeight: number;
+    static readonly ViewportHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ViewportWidth: number;
+    static readonly ViewportWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ZoomFactor: number;
+    static readonly ZoomFactorProperty: Windows.UI.Xaml.DependencyProperty;
+    ZoomMode: number;
+    static readonly ZoomModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ZoomSnapPoints: Windows.Foundation.Collections.IVector<number> | number[];
+    static readonly ZoomSnapPointsProperty: Windows.UI.Xaml.DependencyProperty;
+    ZoomSnapPointsType: number;
+    static readonly ZoomSnapPointsTypeProperty: Windows.UI.Xaml.DependencyProperty;
+    ViewChanged: Windows.Foundation.EventHandler<Windows.UI.Xaml.Controls.ScrollViewerViewChangedEventArgs> | null;
+    ViewChanging: Windows.Foundation.EventHandler<Windows.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs> | null;
+    DirectManipulationCompleted: Windows.Foundation.EventHandler<Object> | null;
+    DirectManipulationStarted: Windows.Foundation.EventHandler<Object> | null;
+    AnchorRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ScrollViewer, Windows.UI.Xaml.Controls.AnchorRequestedEventArgs> | null;
+  }
+
+  class ScrollViewerView implements Windows.UI.Xaml.Controls.IScrollViewerView {
+    readonly HorizontalOffset: number;
+    readonly VerticalOffset: number;
+    readonly ZoomFactor: number;
+  }
+
+  class ScrollViewerViewChangedEventArgs implements Windows.UI.Xaml.Controls.IScrollViewerViewChangedEventArgs {
+    constructor();
+    readonly IsIntermediate: boolean;
+  }
+
+  class ScrollViewerViewChangingEventArgs implements Windows.UI.Xaml.Controls.IScrollViewerViewChangingEventArgs {
+    readonly FinalView: Windows.UI.Xaml.Controls.ScrollViewerView;
+    readonly IsInertial: boolean;
+    readonly NextView: Windows.UI.Xaml.Controls.ScrollViewerView;
+  }
+
+  class SearchBox extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.ISearchBox {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetLocalContentSuggestionSettings(settings: Windows.ApplicationModel.Search.LocalContentSuggestionSettings): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    ChooseSuggestionOnEnter: boolean;
+    static readonly ChooseSuggestionOnEnterProperty: Windows.UI.Xaml.DependencyProperty;
+    FocusOnKeyboardInput: boolean;
+    static readonly FocusOnKeyboardInputProperty: Windows.UI.Xaml.DependencyProperty;
+    PlaceholderText: string;
+    static readonly PlaceholderTextProperty: Windows.UI.Xaml.DependencyProperty;
+    QueryText: string;
+    static readonly QueryTextProperty: Windows.UI.Xaml.DependencyProperty;
+    SearchHistoryContext: string;
+    static readonly SearchHistoryContextProperty: Windows.UI.Xaml.DependencyProperty;
+    SearchHistoryEnabled: boolean;
+    static readonly SearchHistoryEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    PrepareForFocusOnKeyboardInput: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SearchBox, Windows.UI.Xaml.RoutedEventArgs> | null;
+    QueryChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SearchBox, Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs> | null;
+    QuerySubmitted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SearchBox, Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs> | null;
+    ResultSuggestionChosen: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SearchBox, Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs> | null;
+    SuggestionsRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SearchBox, Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs> | null;
+  }
+
+  class SearchBoxQueryChangedEventArgs implements Windows.UI.Xaml.Controls.ISearchBoxQueryChangedEventArgs {
+    readonly Language: string;
+    readonly LinguisticDetails: Windows.ApplicationModel.Search.SearchQueryLinguisticDetails;
+    readonly QueryText: string;
+  }
+
+  class SearchBoxQuerySubmittedEventArgs implements Windows.UI.Xaml.Controls.ISearchBoxQuerySubmittedEventArgs {
+    readonly KeyModifiers: number;
+    readonly Language: string;
+    readonly LinguisticDetails: Windows.ApplicationModel.Search.SearchQueryLinguisticDetails;
+    readonly QueryText: string;
+  }
+
+  class SearchBoxResultSuggestionChosenEventArgs implements Windows.UI.Xaml.Controls.ISearchBoxResultSuggestionChosenEventArgs {
+    constructor();
+    readonly KeyModifiers: number;
+    readonly Tag: string;
+  }
+
+  class SearchBoxSuggestionsRequestedEventArgs implements Windows.UI.Xaml.Controls.ISearchBoxSuggestionsRequestedEventArgs {
+    readonly Language: string;
+    readonly LinguisticDetails: Windows.ApplicationModel.Search.SearchQueryLinguisticDetails;
+    readonly QueryText: string;
+    readonly Request: Windows.ApplicationModel.Search.SearchSuggestionsRequest;
+  }
+
+  class SectionsInViewChangedEventArgs implements Windows.UI.Xaml.Controls.ISectionsInViewChangedEventArgs {
+    readonly AddedSections: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.HubSection> | Windows.UI.Xaml.Controls.HubSection[];
+    readonly RemovedSections: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.HubSection> | Windows.UI.Xaml.Controls.HubSection[];
+  }
+
+  class SelectionChangedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Controls.ISelectionChangedEventArgs {
+    constructor(removedItems: Windows.Foundation.Collections.IVector<Object> | Object[], addedItems: Windows.Foundation.Collections.IVector<Object> | Object[]);
+    readonly AddedItems: Windows.Foundation.Collections.IVector<Object> | Object[];
+    readonly RemovedItems: Windows.Foundation.Collections.IVector<Object> | Object[];
+  }
+
+  class SemanticZoom extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.ISemanticZoom {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    ToggleActiveView(): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    CanChangeViews: boolean;
+    static readonly CanChangeViewsProperty: Windows.UI.Xaml.DependencyProperty;
+    IsZoomOutButtonEnabled: boolean;
+    static readonly IsZoomOutButtonEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsZoomedInViewActive: boolean;
+    static readonly IsZoomedInViewActiveProperty: Windows.UI.Xaml.DependencyProperty;
+    ZoomedInView: Windows.UI.Xaml.Controls.ISemanticZoomInformation;
+    static readonly ZoomedInViewProperty: Windows.UI.Xaml.DependencyProperty;
+    ZoomedOutView: Windows.UI.Xaml.Controls.ISemanticZoomInformation;
+    static readonly ZoomedOutViewProperty: Windows.UI.Xaml.DependencyProperty;
+    ViewChangeCompleted: Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventHandler | null;
+    ViewChangeStarted: Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventHandler | null;
+  }
+
+  class SemanticZoomLocation implements Windows.UI.Xaml.Controls.ISemanticZoomLocation {
+    constructor();
+    Bounds: Windows.Foundation.Rect;
+    Item: Object;
+  }
+
+  class SemanticZoomViewChangedEventArgs implements Windows.UI.Xaml.Controls.ISemanticZoomViewChangedEventArgs {
+    constructor();
+    DestinationItem: Windows.UI.Xaml.Controls.SemanticZoomLocation;
+    IsSourceZoomedInView: boolean;
+    SourceItem: Windows.UI.Xaml.Controls.SemanticZoomLocation;
+  }
+
+  class SettingsFlyout extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.ISettingsFlyout {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    Hide(): void;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    Show(): void;
+    ShowIndependent(): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    HeaderBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly HeaderBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    HeaderForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly HeaderForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    IconSource: Windows.UI.Xaml.Media.ImageSource;
+    static readonly IconSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.SettingsFlyoutTemplateSettings;
+    Title: string;
+    static readonly TitleProperty: Windows.UI.Xaml.DependencyProperty;
+    BackClick: Windows.UI.Xaml.Controls.BackClickEventHandler | null;
+  }
+
+  class Slider extends Windows.UI.Xaml.Controls.Primitives.RangeBase implements Windows.UI.Xaml.Controls.ISlider, Windows.UI.Xaml.Controls.ISlider2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnMaximumChanged(oldMaximum: number, newMaximum: number): void;
+    OnMinimumChanged(oldMinimum: number, newMinimum: number): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnValueChanged(oldValue: number, newValue: number): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Header: Object;
+    static readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    IntermediateValue: number;
+    static readonly IntermediateValueProperty: Windows.UI.Xaml.DependencyProperty;
+    IsDirectionReversed: boolean;
+    static readonly IsDirectionReversedProperty: Windows.UI.Xaml.DependencyProperty;
+    IsThumbToolTipEnabled: boolean;
+    static readonly IsThumbToolTipEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    Orientation: number;
+    static readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    SnapsTo: number;
+    static readonly SnapsToProperty: Windows.UI.Xaml.DependencyProperty;
+    StepFrequency: number;
+    static readonly StepFrequencyProperty: Windows.UI.Xaml.DependencyProperty;
+    ThumbToolTipValueConverter: Windows.UI.Xaml.Data.IValueConverter;
+    static readonly ThumbToolTipValueConverterProperty: Windows.UI.Xaml.DependencyProperty;
+    TickFrequency: number;
+    static readonly TickFrequencyProperty: Windows.UI.Xaml.DependencyProperty;
+    TickPlacement: number;
+    static readonly TickPlacementProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class SplitButton extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.ISplitButton {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Command: Windows.UI.Xaml.Input.ICommand;
+    CommandParameter: Object;
+    static readonly CommandParameterProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly CommandProperty: Windows.UI.Xaml.DependencyProperty;
+    Flyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    static readonly FlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+    Click: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SplitButton, Windows.UI.Xaml.Controls.SplitButtonClickEventArgs> | null;
+  }
+
+  class SplitButtonAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Provider.IExpandCollapseProvider, Windows.UI.Xaml.Automation.Provider.IInvokeProvider, Windows.UI.Xaml.Controls.ISplitButtonAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.SplitButton);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Collapse(): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    Expand(): void;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    Invoke(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly ExpandCollapseState: number;
+  }
+
+  class SplitButtonClickEventArgs implements Windows.UI.Xaml.Controls.ISplitButtonClickEventArgs {
+  }
+
+  class SplitView extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.ISplitView, Windows.UI.Xaml.Controls.ISplitView2, Windows.UI.Xaml.Controls.ISplitView3 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    CompactPaneLength: number;
+    static readonly CompactPaneLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    Content: Windows.UI.Xaml.UIElement;
+    static readonly ContentProperty: Windows.UI.Xaml.DependencyProperty;
+    DisplayMode: number;
+    static readonly DisplayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    IsPaneOpen: boolean;
+    static readonly IsPaneOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    LightDismissOverlayMode: number;
+    static readonly LightDismissOverlayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    OpenPaneLength: number;
+    static readonly OpenPaneLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    Pane: Windows.UI.Xaml.UIElement;
+    PaneBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly PaneBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    PanePlacement: number;
+    static readonly PanePlacementProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly PaneProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.SplitViewTemplateSettings;
+    static readonly TemplateSettingsProperty: Windows.UI.Xaml.DependencyProperty;
+    PaneClosed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SplitView, Object> | null;
+    PaneClosing: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SplitView, Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs> | null;
+    PaneOpened: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SplitView, Object> | null;
+    PaneOpening: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SplitView, Object> | null;
+  }
+
+  class SplitViewPaneClosingEventArgs implements Windows.UI.Xaml.Controls.ISplitViewPaneClosingEventArgs {
+    Cancel: boolean;
+  }
+
+  class StackPanel extends Windows.UI.Xaml.Controls.Panel implements Windows.UI.Xaml.Controls.IInsertionPanel, Windows.UI.Xaml.Controls.IStackPanel, Windows.UI.Xaml.Controls.IStackPanel2, Windows.UI.Xaml.Controls.IStackPanel4, Windows.UI.Xaml.Controls.IStackPanel5, Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetInsertionIndexes(position: Windows.Foundation.Point, first: number, second: number): void;
+    GetIrregularSnapPoints(orientation: number, alignment: number): Windows.Foundation.Collections.IVectorView<number> | number[];
+    GetRegularSnapPoints(orientation: number, alignment: number, offset: number): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly AreHorizontalSnapPointsRegular: boolean;
+    AreScrollSnapPointsRegular: boolean;
+    static readonly AreScrollSnapPointsRegularProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AreVerticalSnapPointsRegular: boolean;
+    BackgroundSizing: number;
+    static readonly BackgroundSizingProperty: Windows.UI.Xaml.DependencyProperty;
+    BorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly BorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    BorderThickness: Windows.UI.Xaml.Thickness;
+    static readonly BorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    CornerRadius: Windows.UI.Xaml.CornerRadius;
+    static readonly CornerRadiusProperty: Windows.UI.Xaml.DependencyProperty;
+    Orientation: number;
+    static readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    Padding: Windows.UI.Xaml.Thickness;
+    static readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    Spacing: number;
+    static readonly SpacingProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalSnapPointsChanged: Windows.Foundation.EventHandler<Object> | null;
+    VerticalSnapPointsChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class StyleSelector implements Windows.UI.Xaml.Controls.IStyleSelector, Windows.UI.Xaml.Controls.IStyleSelectorOverrides {
+    constructor();
+    SelectStyle(item: Object, container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Style;
+    SelectStyleCore(item: Object, container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Style;
+  }
+
+  class SwapChainBackgroundPanel extends Windows.UI.Xaml.Controls.Grid implements Windows.UI.Xaml.Controls.ISwapChainBackgroundPanel, Windows.UI.Xaml.Controls.ISwapChainBackgroundPanel2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreateCoreIndependentInputSource(deviceTypes: number): Windows.UI.Core.CoreIndependentInputSource;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetColumn(element: Windows.UI.Xaml.FrameworkElement): number;
+    static GetColumnSpan(element: Windows.UI.Xaml.FrameworkElement): number;
+    static GetRow(element: Windows.UI.Xaml.FrameworkElement): number;
+    static GetRowSpan(element: Windows.UI.Xaml.FrameworkElement): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetColumn(element: Windows.UI.Xaml.FrameworkElement, value: number): void;
+    static SetColumnSpan(element: Windows.UI.Xaml.FrameworkElement, value: number): void;
+    static SetRow(element: Windows.UI.Xaml.FrameworkElement, value: number): void;
+    static SetRowSpan(element: Windows.UI.Xaml.FrameworkElement, value: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class SwapChainPanel extends Windows.UI.Xaml.Controls.Grid implements Windows.UI.Xaml.Controls.ISwapChainPanel {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreateCoreIndependentInputSource(deviceTypes: number): Windows.UI.Core.CoreIndependentInputSource;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetColumn(element: Windows.UI.Xaml.FrameworkElement): number;
+    static GetColumnSpan(element: Windows.UI.Xaml.FrameworkElement): number;
+    static GetRow(element: Windows.UI.Xaml.FrameworkElement): number;
+    static GetRowSpan(element: Windows.UI.Xaml.FrameworkElement): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetColumn(element: Windows.UI.Xaml.FrameworkElement, value: number): void;
+    static SetColumnSpan(element: Windows.UI.Xaml.FrameworkElement, value: number): void;
+    static SetRow(element: Windows.UI.Xaml.FrameworkElement, value: number): void;
+    static SetRowSpan(element: Windows.UI.Xaml.FrameworkElement, value: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly CompositionScaleX: number;
+    static readonly CompositionScaleXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CompositionScaleY: number;
+    static readonly CompositionScaleYProperty: Windows.UI.Xaml.DependencyProperty;
+    CompositionScaleChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SwapChainPanel, Object> | null;
+  }
+
+  class SwipeControl extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.ISwipeControl {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Close(): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    BottomItems: Windows.UI.Xaml.Controls.SwipeItems;
+    static readonly BottomItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    LeftItems: Windows.UI.Xaml.Controls.SwipeItems;
+    static readonly LeftItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    RightItems: Windows.UI.Xaml.Controls.SwipeItems;
+    static readonly RightItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    TopItems: Windows.UI.Xaml.Controls.SwipeItems;
+    static readonly TopItemsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class SwipeItem extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.ISwipeItem {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Background: Windows.UI.Xaml.Media.Brush;
+    static readonly BackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    BehaviorOnInvoked: number;
+    static readonly BehaviorOnInvokedProperty: Windows.UI.Xaml.DependencyProperty;
+    Command: Windows.UI.Xaml.Input.ICommand;
+    CommandParameter: Object;
+    static readonly CommandParameterProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly CommandProperty: Windows.UI.Xaml.DependencyProperty;
+    Foreground: Windows.UI.Xaml.Media.Brush;
+    static readonly ForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    IconSource: Windows.UI.Xaml.Controls.IconSource;
+    static readonly IconSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    Text: string;
+    static readonly TextProperty: Windows.UI.Xaml.DependencyProperty;
+    Invoked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SwipeItem, Windows.UI.Xaml.Controls.SwipeItemInvokedEventArgs> | null;
+  }
+
+  class SwipeItemInvokedEventArgs implements Windows.UI.Xaml.Controls.ISwipeItemInvokedEventArgs {
+    readonly SwipeControl: Windows.UI.Xaml.Controls.SwipeControl;
+  }
+
+  class SwipeItems extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.ISwipeItems {
+    constructor();
+    Append(value: Windows.UI.Xaml.Controls.SwipeItem): void;
+    Clear(): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Controls.SwipeItem>;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAt(index: number): Windows.UI.Xaml.Controls.SwipeItem;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Controls.SwipeItem[]): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Controls.SwipeItem> | Windows.UI.Xaml.Controls.SwipeItem[];
+    IndexOf(value: Windows.UI.Xaml.Controls.SwipeItem, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Controls.SwipeItem): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Controls.SwipeItem[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Controls.SwipeItem): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Mode: number;
+    static readonly ModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Size: number;
+  }
+
+  class SymbolIcon extends Windows.UI.Xaml.Controls.IconElement implements Windows.UI.Xaml.Controls.ISymbolIcon {
+    constructor(symbol: number);
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Symbol: number;
+    static readonly SymbolProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class SymbolIconSource extends Windows.UI.Xaml.Controls.IconSource implements Windows.UI.Xaml.Controls.ISymbolIconSource {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Symbol: number;
+    static readonly SymbolProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class TextBlock extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Controls.ITextBlock, Windows.UI.Xaml.Controls.ITextBlock2, Windows.UI.Xaml.Controls.ITextBlock3, Windows.UI.Xaml.Controls.ITextBlock4, Windows.UI.Xaml.Controls.ITextBlock5, Windows.UI.Xaml.Controls.ITextBlock6, Windows.UI.Xaml.Controls.ITextBlock7 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CopySelectionToClipboard(): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAlphaMask(): Windows.UI.Composition.CompositionBrush;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    Select(start: Windows.UI.Xaml.Documents.TextPointer, end: Windows.UI.Xaml.Documents.TextPointer): void;
+    SelectAll(): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly BaselineOffset: number;
+    CharacterSpacing: number;
+    static readonly CharacterSpacingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentEnd: Windows.UI.Xaml.Documents.TextPointer;
+    readonly ContentStart: Windows.UI.Xaml.Documents.TextPointer;
+    FontFamily: Windows.UI.Xaml.Media.FontFamily;
+    static readonly FontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    FontSize: number;
+    static readonly FontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    FontStretch: number;
+    static readonly FontStretchProperty: Windows.UI.Xaml.DependencyProperty;
+    FontStyle: number;
+    static readonly FontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    FontWeight: Windows.UI.Text.FontWeight;
+    static readonly FontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    Foreground: Windows.UI.Xaml.Media.Brush;
+    static readonly ForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalTextAlignment: number;
+    static readonly HorizontalTextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Inlines: Windows.UI.Xaml.Documents.InlineCollection;
+    IsColorFontEnabled: boolean;
+    static readonly IsColorFontEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsTextScaleFactorEnabled: boolean;
+    static readonly IsTextScaleFactorEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsTextSelectionEnabled: boolean;
+    static readonly IsTextSelectionEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsTextTrimmed: boolean;
+    static readonly IsTextTrimmedProperty: Windows.UI.Xaml.DependencyProperty;
+    LineHeight: number;
+    static readonly LineHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    LineStackingStrategy: number;
+    static readonly LineStackingStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxLines: number;
+    static readonly MaxLinesProperty: Windows.UI.Xaml.DependencyProperty;
+    OpticalMarginAlignment: number;
+    static readonly OpticalMarginAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    Padding: Windows.UI.Xaml.Thickness;
+    static readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedText: string;
+    static readonly SelectedTextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionEnd: Windows.UI.Xaml.Documents.TextPointer;
+    SelectionFlyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    static readonly SelectionFlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionHighlightColor: Windows.UI.Xaml.Media.SolidColorBrush;
+    static readonly SelectionHighlightColorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionStart: Windows.UI.Xaml.Documents.TextPointer;
+    Text: string;
+    TextAlignment: number;
+    static readonly TextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    TextDecorations: number;
+    static readonly TextDecorationsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextHighlighters: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Documents.TextHighlighter> | Windows.UI.Xaml.Documents.TextHighlighter[];
+    TextLineBounds: number;
+    static readonly TextLineBoundsProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly TextProperty: Windows.UI.Xaml.DependencyProperty;
+    TextReadingOrder: number;
+    static readonly TextReadingOrderProperty: Windows.UI.Xaml.DependencyProperty;
+    TextTrimming: number;
+    static readonly TextTrimmingProperty: Windows.UI.Xaml.DependencyProperty;
+    TextWrapping: number;
+    static readonly TextWrappingProperty: Windows.UI.Xaml.DependencyProperty;
+    ContextMenuOpening: Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler | null;
+    SelectionChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+    IsTextTrimmedChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBlock, Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs> | null;
+  }
+
+  class TextBox extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.ITextBox, Windows.UI.Xaml.Controls.ITextBox2, Windows.UI.Xaml.Controls.ITextBox3, Windows.UI.Xaml.Controls.ITextBox4, Windows.UI.Xaml.Controls.ITextBox5, Windows.UI.Xaml.Controls.ITextBox6, Windows.UI.Xaml.Controls.ITextBox7, Windows.UI.Xaml.Controls.ITextBox8 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearUndoRedoHistory(): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CopySelectionToClipboard(): void;
+    CutSelectionToClipboard(): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetLinguisticAlternativesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    GetRectFromCharacterIndex(charIndex: number, trailingEdge: boolean): Windows.Foundation.Rect;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PasteFromClipboard(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Redo(): void;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    Select(start: number, length: number): void;
+    SelectAll(): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    Undo(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    AcceptsReturn: boolean;
+    static readonly AcceptsReturnProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanPasteClipboardContent: boolean;
+    static readonly CanPasteClipboardContentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanRedo: boolean;
+    static readonly CanRedoProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanUndo: boolean;
+    static readonly CanUndoProperty: Windows.UI.Xaml.DependencyProperty;
+    CharacterCasing: number;
+    static readonly CharacterCasingProperty: Windows.UI.Xaml.DependencyProperty;
+    Description: Object;
+    static readonly DescriptionProperty: Windows.UI.Xaml.DependencyProperty;
+    DesiredCandidateWindowAlignment: number;
+    static readonly DesiredCandidateWindowAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    HandwritingView: Windows.UI.Xaml.Controls.HandwritingView;
+    static readonly HandwritingViewProperty: Windows.UI.Xaml.DependencyProperty;
+    Header: Object;
+    static readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalTextAlignment: number;
+    static readonly HorizontalTextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    InputScope: Windows.UI.Xaml.Input.InputScope;
+    static readonly InputScopeProperty: Windows.UI.Xaml.DependencyProperty;
+    IsColorFontEnabled: boolean;
+    static readonly IsColorFontEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsHandwritingViewEnabled: boolean;
+    static readonly IsHandwritingViewEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsReadOnly: boolean;
+    static readonly IsReadOnlyProperty: Windows.UI.Xaml.DependencyProperty;
+    IsSpellCheckEnabled: boolean;
+    static readonly IsSpellCheckEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsTextPredictionEnabled: boolean;
+    static readonly IsTextPredictionEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxLength: number;
+    static readonly MaxLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    PlaceholderForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly PlaceholderForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    PlaceholderText: string;
+    static readonly PlaceholderTextProperty: Windows.UI.Xaml.DependencyProperty;
+    PreventKeyboardDisplayOnProgrammaticFocus: boolean;
+    static readonly PreventKeyboardDisplayOnProgrammaticFocusProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ProofingMenuFlyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    static readonly ProofingMenuFlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedText: string;
+    SelectionFlyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    static readonly SelectionFlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionHighlightColor: Windows.UI.Xaml.Media.SolidColorBrush;
+    static readonly SelectionHighlightColorProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionHighlightColorWhenNotFocused: Windows.UI.Xaml.Media.SolidColorBrush;
+    static readonly SelectionHighlightColorWhenNotFocusedProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionLength: number;
+    SelectionStart: number;
+    Text: string;
+    TextAlignment: number;
+    static readonly TextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly TextProperty: Windows.UI.Xaml.DependencyProperty;
+    TextReadingOrder: number;
+    static readonly TextReadingOrderProperty: Windows.UI.Xaml.DependencyProperty;
+    TextWrapping: number;
+    static readonly TextWrappingProperty: Windows.UI.Xaml.DependencyProperty;
+    ContextMenuOpening: Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler | null;
+    SelectionChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+    TextChanged: Windows.UI.Xaml.Controls.TextChangedEventHandler | null;
+    Paste: Windows.UI.Xaml.Controls.TextControlPasteEventHandler | null;
+    CandidateWindowBoundsChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox, Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs> | null;
+    TextChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox, Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs> | null;
+    TextCompositionChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox, Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs> | null;
+    TextCompositionEnded: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox, Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs> | null;
+    TextCompositionStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox, Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs> | null;
+    BeforeTextChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox, Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs> | null;
+    CopyingToClipboard: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox, Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs> | null;
+    CuttingToClipboard: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox, Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs> | null;
+    SelectionChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox, Windows.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs> | null;
+  }
+
+  class TextBoxBeforeTextChangingEventArgs implements Windows.UI.Xaml.Controls.ITextBoxBeforeTextChangingEventArgs {
+    Cancel: boolean;
+    readonly NewText: string;
+  }
+
+  class TextBoxSelectionChangingEventArgs implements Windows.UI.Xaml.Controls.ITextBoxSelectionChangingEventArgs {
+    Cancel: boolean;
+    readonly SelectionLength: number;
+    readonly SelectionStart: number;
+  }
+
+  class TextBoxTextChangingEventArgs implements Windows.UI.Xaml.Controls.ITextBoxTextChangingEventArgs, Windows.UI.Xaml.Controls.ITextBoxTextChangingEventArgs2 {
+    readonly IsContentChanging: boolean;
+  }
+
+  class TextChangedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Controls.ITextChangedEventArgs {
+  }
+
+  class TextCommandBarFlyout extends Windows.UI.Xaml.Controls.CommandBarFlyout implements Windows.UI.Xaml.Controls.ITextCommandBarFlyout {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreatePresenter(): Windows.UI.Xaml.Controls.Control;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement): Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Hide(): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static SetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement, value: Windows.UI.Xaml.Controls.Primitives.FlyoutBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowAt(placementTarget: Windows.UI.Xaml.FrameworkElement): void;
+    ShowAt(placementTarget: Windows.UI.Xaml.DependencyObject, showOptions: Windows.UI.Xaml.Controls.Primitives.FlyoutShowOptions): void;
+    static ShowAttachedFlyout(flyoutOwner: Windows.UI.Xaml.FrameworkElement): void;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class TextCompositionChangedEventArgs implements Windows.UI.Xaml.Controls.ITextCompositionChangedEventArgs {
+    readonly Length: number;
+    readonly StartIndex: number;
+  }
+
+  class TextCompositionEndedEventArgs implements Windows.UI.Xaml.Controls.ITextCompositionEndedEventArgs {
+    readonly Length: number;
+    readonly StartIndex: number;
+  }
+
+  class TextCompositionStartedEventArgs implements Windows.UI.Xaml.Controls.ITextCompositionStartedEventArgs {
+    readonly Length: number;
+    readonly StartIndex: number;
+  }
+
+  class TextControlCopyingToClipboardEventArgs implements Windows.UI.Xaml.Controls.ITextControlCopyingToClipboardEventArgs {
+    Handled: boolean;
+  }
+
+  class TextControlCuttingToClipboardEventArgs implements Windows.UI.Xaml.Controls.ITextControlCuttingToClipboardEventArgs {
+    Handled: boolean;
+  }
+
+  class TextControlPasteEventArgs implements Windows.UI.Xaml.Controls.ITextControlPasteEventArgs {
+    Handled: boolean;
+  }
+
+  class TimePickedEventArgs extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.ITimePickedEventArgs {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly NewTime: Windows.Foundation.TimeSpan;
+    readonly OldTime: Windows.Foundation.TimeSpan;
+  }
+
+  class TimePicker extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.ITimePicker, Windows.UI.Xaml.Controls.ITimePicker2, Windows.UI.Xaml.Controls.ITimePicker3 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    ClockIdentifier: string;
+    static readonly ClockIdentifierProperty: Windows.UI.Xaml.DependencyProperty;
+    Header: Object;
+    static readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    LightDismissOverlayMode: number;
+    static readonly LightDismissOverlayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    MinuteIncrement: number;
+    static readonly MinuteIncrementProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedTime: Windows.Foundation.TimeSpan | null;
+    static readonly SelectedTimeProperty: Windows.UI.Xaml.DependencyProperty;
+    Time: Windows.Foundation.TimeSpan;
+    static readonly TimeProperty: Windows.UI.Xaml.DependencyProperty;
+    TimeChanged: Windows.Foundation.EventHandler<Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs> | null;
+    SelectedTimeChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TimePicker, Windows.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs> | null;
+  }
+
+  class TimePickerFlyout extends Windows.UI.Xaml.Controls.Primitives.PickerFlyoutBase implements Windows.UI.Xaml.Controls.ITimePickerFlyout {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreatePresenter(): Windows.UI.Xaml.Controls.Control;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement): Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    static GetTitle(element: Windows.UI.Xaml.DependencyObject): string;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Hide(): void;
+    OnConfirmed(): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static SetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement, value: Windows.UI.Xaml.Controls.Primitives.FlyoutBase): void;
+    static SetTitle(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShouldShowConfirmationButtons(): boolean;
+    ShowAt(placementTarget: Windows.UI.Xaml.FrameworkElement): void;
+    ShowAt(placementTarget: Windows.UI.Xaml.DependencyObject, showOptions: Windows.UI.Xaml.Controls.Primitives.FlyoutShowOptions): void;
+    ShowAtAsync(target: Windows.UI.Xaml.FrameworkElement): Windows.Foundation.IAsyncOperation<Windows.Foundation.TimeSpan | null>;
+    static ShowAttachedFlyout(flyoutOwner: Windows.UI.Xaml.FrameworkElement): void;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    ClockIdentifier: string;
+    static readonly ClockIdentifierProperty: Windows.UI.Xaml.DependencyProperty;
+    MinuteIncrement: number;
+    static readonly MinuteIncrementProperty: Windows.UI.Xaml.DependencyProperty;
+    Time: Windows.Foundation.TimeSpan;
+    static readonly TimeProperty: Windows.UI.Xaml.DependencyProperty;
+    TimePicked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TimePickerFlyout, Windows.UI.Xaml.Controls.TimePickedEventArgs> | null;
+  }
+
+  class TimePickerFlyoutPresenter extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.ITimePickerFlyoutPresenter, Windows.UI.Xaml.Controls.ITimePickerFlyoutPresenter2 {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    IsDefaultShadowEnabled: boolean;
+    static readonly IsDefaultShadowEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class TimePickerSelectedValueChangedEventArgs implements Windows.UI.Xaml.Controls.ITimePickerSelectedValueChangedEventArgs {
+    readonly NewTime: Windows.Foundation.TimeSpan | null;
+    readonly OldTime: Windows.Foundation.TimeSpan | null;
+  }
+
+  class TimePickerValueChangedEventArgs implements Windows.UI.Xaml.Controls.ITimePickerValueChangedEventArgs {
+    readonly NewTime: Windows.Foundation.TimeSpan;
+    readonly OldTime: Windows.Foundation.TimeSpan;
+  }
+
+  class ToggleMenuFlyoutItem extends Windows.UI.Xaml.Controls.MenuFlyoutItem implements Windows.UI.Xaml.Controls.IToggleMenuFlyoutItem {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    IsChecked: boolean;
+    static readonly IsCheckedProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ToggleSplitButton extends Windows.UI.Xaml.Controls.SplitButton implements Windows.UI.Xaml.Controls.IToggleSplitButton {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    IsChecked: boolean;
+    IsCheckedChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ToggleSplitButton, Windows.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs> | null;
+  }
+
+  class ToggleSplitButtonAutomationPeer extends Windows.UI.Xaml.Automation.Peers.FrameworkElementAutomationPeer implements Windows.UI.Xaml.Automation.Provider.IExpandCollapseProvider, Windows.UI.Xaml.Automation.Provider.IToggleProvider, Windows.UI.Xaml.Controls.IToggleSplitButtonAutomationPeer {
+    constructor(owner: Windows.UI.Xaml.Controls.ToggleSplitButton);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Collapse(): void;
+    static CreatePeerForElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    Expand(): void;
+    static FromElement(element: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    static GenerateRawElementProviderRuntimeId(): Windows.UI.Xaml.Automation.Peers.RawElementProviderRuntimeId;
+    GetAcceleratorKey(): string;
+    GetAcceleratorKeyCore(): string;
+    GetAccessKey(): string;
+    GetAccessKeyCore(): string;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetAnnotations(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAnnotationsCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation> | Windows.UI.Xaml.Automation.Peers.AutomationPeerAnnotation[];
+    GetAutomationControlType(): number;
+    GetAutomationControlTypeCore(): number;
+    GetAutomationId(): string;
+    GetAutomationIdCore(): string;
+    GetBoundingRectangle(): Windows.Foundation.Rect;
+    GetBoundingRectangleCore(): Windows.Foundation.Rect;
+    GetChildren(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetChildrenCore(): Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetClassName(): string;
+    GetClassNameCore(): string;
+    GetClickablePoint(): Windows.Foundation.Point;
+    GetClickablePointCore(): Windows.Foundation.Point;
+    GetControlledPeers(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetControlledPeersCore(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetCulture(): number;
+    GetCultureCore(): number;
+    GetDescribedByCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetElementFromPoint(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetElementFromPointCore(pointInWindowCoordinates: Windows.Foundation.Point): Object;
+    GetFlowsFromCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFlowsToCore(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Automation.Peers.AutomationPeer> | Windows.UI.Xaml.Automation.Peers.AutomationPeer[];
+    GetFocusedElement(): Object;
+    GetFocusedElementCore(): Object;
+    GetFullDescription(): string;
+    GetFullDescriptionCore(): string;
+    GetHeadingLevel(): number;
+    GetHeadingLevelCore(): number;
+    GetHelpText(): string;
+    GetHelpTextCore(): string;
+    GetItemStatus(): string;
+    GetItemStatusCore(): string;
+    GetItemType(): string;
+    GetItemTypeCore(): string;
+    GetLabeledBy(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLabeledByCore(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetLandmarkType(): number;
+    GetLandmarkTypeCore(): number;
+    GetLevel(): number;
+    GetLevelCore(): number;
+    GetLiveSetting(): number;
+    GetLiveSettingCore(): number;
+    GetLocalizedControlType(): string;
+    GetLocalizedControlTypeCore(): string;
+    GetLocalizedLandmarkType(): string;
+    GetLocalizedLandmarkTypeCore(): string;
+    GetName(): string;
+    GetNameCore(): string;
+    GetOrientation(): number;
+    GetOrientationCore(): number;
+    GetParent(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPattern(patternInterface: number): Object;
+    GetPatternCore(patternInterface: number): Object;
+    GetPeerFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPeerFromPointCore(point: Windows.Foundation.Point): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    GetPositionInSet(): number;
+    GetPositionInSetCore(): number;
+    GetSizeOfSet(): number;
+    GetSizeOfSetCore(): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    HasKeyboardFocus(): boolean;
+    HasKeyboardFocusCore(): boolean;
+    InvalidatePeer(): void;
+    IsContentElement(): boolean;
+    IsContentElementCore(): boolean;
+    IsControlElement(): boolean;
+    IsControlElementCore(): boolean;
+    IsDataValidForForm(): boolean;
+    IsDataValidForFormCore(): boolean;
+    IsDialog(): boolean;
+    IsDialogCore(): boolean;
+    IsEnabled(): boolean;
+    IsEnabledCore(): boolean;
+    IsKeyboardFocusable(): boolean;
+    IsKeyboardFocusableCore(): boolean;
+    IsOffscreen(): boolean;
+    IsOffscreenCore(): boolean;
+    IsPassword(): boolean;
+    IsPasswordCore(): boolean;
+    IsPeripheral(): boolean;
+    IsPeripheralCore(): boolean;
+    IsRequiredForForm(): boolean;
+    IsRequiredForFormCore(): boolean;
+    static ListenerExists(eventId: number): boolean;
+    Navigate(direction: number): Object;
+    NavigateCore(direction: number): Object;
+    PeerFromProvider(provider: Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    ProviderFromPeer(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): Windows.UI.Xaml.Automation.Provider.IRawElementProviderSimple;
+    RaiseAutomationEvent(eventId: number): void;
+    RaiseNotificationEvent(notificationKind: number, notificationProcessing: number, displayString: string, activityId: string): void;
+    RaisePropertyChangedEvent(automationProperty: Windows.UI.Xaml.Automation.AutomationProperty, oldValue: Object, newValue: Object): void;
+    RaiseStructureChangedEvent(structureChangeType: number, child: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    RaiseTextEditTextChangedEvent(automationTextEditChangeType: number, changedData: Windows.Foundation.Collections.IVectorView<string> | string[]): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetFocus(): void;
+    SetFocusCore(): void;
+    SetParent(peer: Windows.UI.Xaml.Automation.Peers.AutomationPeer): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowContextMenu(): void;
+    ShowContextMenuCore(): void;
+    Toggle(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly ExpandCollapseState: number;
+    readonly ToggleState: number;
+  }
+
+  class ToggleSplitButtonIsCheckedChangedEventArgs implements Windows.UI.Xaml.Controls.IToggleSplitButtonIsCheckedChangedEventArgs {
+  }
+
+  class ToggleSwitch extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IToggleSwitch, Windows.UI.Xaml.Controls.IToggleSwitchOverrides {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHeaderChanged(oldContent: Object, newContent: Object): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnOffContentChanged(oldContent: Object, newContent: Object): void;
+    OnOnContentChanged(oldContent: Object, newContent: Object): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnToggled(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Header: Object;
+    static readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    IsOn: boolean;
+    static readonly IsOnProperty: Windows.UI.Xaml.DependencyProperty;
+    OffContent: Object;
+    static readonly OffContentProperty: Windows.UI.Xaml.DependencyProperty;
+    OffContentTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly OffContentTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    OnContent: Object;
+    static readonly OnContentProperty: Windows.UI.Xaml.DependencyProperty;
+    OnContentTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly OnContentTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.ToggleSwitchTemplateSettings;
+    Toggled: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+
+  class ToolTip extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.IToolTip, Windows.UI.Xaml.Controls.IToolTip2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    HorizontalOffset: number;
+    static readonly HorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    IsOpen: boolean;
+    static readonly IsOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    Placement: number;
+    static readonly PlacementProperty: Windows.UI.Xaml.DependencyProperty;
+    PlacementRect: Windows.Foundation.Rect | null;
+    static readonly PlacementRectProperty: Windows.UI.Xaml.DependencyProperty;
+    PlacementTarget: Windows.UI.Xaml.UIElement;
+    static readonly PlacementTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.ToolTipTemplateSettings;
+    VerticalOffset: number;
+    static readonly VerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    Closed: Windows.UI.Xaml.RoutedEventHandler | null;
+    Opened: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+
+  class ToolTipService implements Windows.UI.Xaml.Controls.IToolTipService {
+    static GetPlacement(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetPlacementTarget(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.UIElement;
+    static GetToolTip(element: Windows.UI.Xaml.DependencyObject): Object;
+    static SetPlacement(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static SetPlacementTarget(element: Windows.UI.Xaml.DependencyObject, value: Windows.UI.Xaml.UIElement): void;
+    static SetToolTip(element: Windows.UI.Xaml.DependencyObject, value: Object): void;
+    static readonly PlacementProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly PlacementTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly ToolTipProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class TreeView extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.ITreeView, Windows.UI.Xaml.Controls.ITreeView2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Collapse(value: Windows.UI.Xaml.Controls.TreeViewNode): void;
+    ContainerFromItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    ContainerFromNode(node: Windows.UI.Xaml.Controls.TreeViewNode): Windows.UI.Xaml.DependencyObject;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    Expand(value: Windows.UI.Xaml.Controls.TreeViewNode): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    ItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    NodeFromContainer(container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.TreeViewNode;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SelectAll(): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    CanDragItems: boolean;
+    static readonly CanDragItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    CanReorderItems: boolean;
+    static readonly CanReorderItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemContainerStyle: Windows.UI.Xaml.Style;
+    static readonly ItemContainerStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector;
+    static readonly ItemContainerStyleSelectorProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemContainerTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    static readonly ItemContainerTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly ItemTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector;
+    static readonly ItemTemplateSelectorProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemsSource: Object;
+    static readonly ItemsSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RootNodes: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.TreeViewNode> | Windows.UI.Xaml.Controls.TreeViewNode[];
+    readonly SelectedNodes: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.TreeViewNode> | Windows.UI.Xaml.Controls.TreeViewNode[];
+    SelectionMode: number;
+    static readonly SelectionModeProperty: Windows.UI.Xaml.DependencyProperty;
+    Collapsed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TreeView, Windows.UI.Xaml.Controls.TreeViewCollapsedEventArgs> | null;
+    Expanding: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TreeView, Windows.UI.Xaml.Controls.TreeViewExpandingEventArgs> | null;
+    ItemInvoked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TreeView, Windows.UI.Xaml.Controls.TreeViewItemInvokedEventArgs> | null;
+    DragItemsCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TreeView, Windows.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs> | null;
+    DragItemsStarting: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TreeView, Windows.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs> | null;
+  }
+
+  class TreeViewCollapsedEventArgs implements Windows.UI.Xaml.Controls.ITreeViewCollapsedEventArgs, Windows.UI.Xaml.Controls.ITreeViewCollapsedEventArgs2 {
+    readonly Item: Object;
+    readonly Node: Windows.UI.Xaml.Controls.TreeViewNode;
+  }
+
+  class TreeViewDragItemsCompletedEventArgs implements Windows.UI.Xaml.Controls.ITreeViewDragItemsCompletedEventArgs {
+    readonly DropResult: number;
+    readonly Items: Windows.Foundation.Collections.IVectorView<Object> | Object[];
+  }
+
+  class TreeViewDragItemsStartingEventArgs implements Windows.UI.Xaml.Controls.ITreeViewDragItemsStartingEventArgs {
+    Cancel: boolean;
+    readonly Data: Windows.ApplicationModel.DataTransfer.DataPackage;
+    readonly Items: Windows.Foundation.Collections.IVector<Object> | Object[];
+  }
+
+  class TreeViewExpandingEventArgs implements Windows.UI.Xaml.Controls.ITreeViewExpandingEventArgs, Windows.UI.Xaml.Controls.ITreeViewExpandingEventArgs2 {
+    readonly Item: Object;
+    readonly Node: Windows.UI.Xaml.Controls.TreeViewNode;
+  }
+
+  class TreeViewItem extends Windows.UI.Xaml.Controls.ListViewItem implements Windows.UI.Xaml.Controls.ITreeViewItem, Windows.UI.Xaml.Controls.ITreeViewItem2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    CollapsedGlyph: string;
+    static readonly CollapsedGlyphProperty: Windows.UI.Xaml.DependencyProperty;
+    ExpandedGlyph: string;
+    static readonly ExpandedGlyphProperty: Windows.UI.Xaml.DependencyProperty;
+    GlyphBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly GlyphBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    GlyphOpacity: number;
+    static readonly GlyphOpacityProperty: Windows.UI.Xaml.DependencyProperty;
+    GlyphSize: number;
+    static readonly GlyphSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    HasUnrealizedChildren: boolean;
+    static readonly HasUnrealizedChildrenProperty: Windows.UI.Xaml.DependencyProperty;
+    IsExpanded: boolean;
+    static readonly IsExpandedProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemsSource: Object;
+    static readonly ItemsSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TreeViewItemTemplateSettings: Windows.UI.Xaml.Controls.TreeViewItemTemplateSettings;
+    static readonly TreeViewItemTemplateSettingsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class TreeViewItemInvokedEventArgs implements Windows.UI.Xaml.Controls.ITreeViewItemInvokedEventArgs {
+    Handled: boolean;
+    readonly InvokedItem: Object;
+  }
+
+  class TreeViewItemTemplateSettings extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.ITreeViewItemTemplateSettings {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly CollapsedGlyphVisibility: number;
+    static readonly CollapsedGlyphVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DragItemsCount: number;
+    static readonly DragItemsCountProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ExpandedGlyphVisibility: number;
+    static readonly ExpandedGlyphVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Indentation: Windows.UI.Xaml.Thickness;
+    static readonly IndentationProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class TreeViewList extends Windows.UI.Xaml.Controls.ListView implements Windows.UI.Xaml.Controls.ITreeViewList {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CompleteViewChange(): void;
+    CompleteViewChangeFrom(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    CompleteViewChangeTo(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    ContainerFromIndex(index: number): Windows.UI.Xaml.DependencyObject;
+    ContainerFromItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    DeselectRange(itemIndexRange: Windows.UI.Xaml.Data.ItemIndexRange): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetContainerForItemOverride(): Windows.UI.Xaml.DependencyObject;
+    static GetIsSelectionActive(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetItemsOwner(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    GroupHeaderContainerFromItemContainer(itemContainer: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+    IndexFromContainer(container: Windows.UI.Xaml.DependencyObject): number;
+    InitializeViewChange(): void;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    IsDragSource(): boolean;
+    IsItemItsOwnContainerOverride(item: Object): boolean;
+    ItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    static ItemsControlFromItemContainer(container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    LoadMoreItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Data.LoadMoreItemsResult>;
+    MakeVisible(item: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnGroupStyleSelectorChanged(oldGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector, newGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnItemContainerStyleChanged(oldItemContainerStyle: Windows.UI.Xaml.Style, newItemContainerStyle: Windows.UI.Xaml.Style): void;
+    OnItemContainerStyleSelectorChanged(oldItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector, newItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector): void;
+    OnItemTemplateChanged(oldItemTemplate: Windows.UI.Xaml.DataTemplate, newItemTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnItemTemplateSelectorChanged(oldItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnItemsChanged(e: Object): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PrepareConnectedAnimation(key: string, item: Object, elementName: string): Windows.UI.Xaml.Media.Animation.ConnectedAnimation;
+    PrepareContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    ScrollIntoView(item: Object): void;
+    ScrollIntoView(item: Object, alignment: number): void;
+    SelectAll(): void;
+    SelectRange(itemIndexRange: Windows.UI.Xaml.Data.ItemIndexRange): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetDesiredContainerUpdateDuration(duration: Windows.Foundation.TimeSpan): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StartViewChangeFrom(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    StartViewChangeTo(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    TryStartConnectedAnimationAsync(animation: Windows.UI.Xaml.Media.Animation.ConnectedAnimation, item: Object, elementName: string): Windows.Foundation.IAsyncOperation<boolean>;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class TreeViewNode extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.ITreeViewNode {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly Children: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.TreeViewNode> | Windows.UI.Xaml.Controls.TreeViewNode[];
+    Content: Object;
+    static readonly ContentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Depth: number;
+    static readonly DepthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HasChildren: boolean;
+    static readonly HasChildrenProperty: Windows.UI.Xaml.DependencyProperty;
+    HasUnrealizedChildren: boolean;
+    IsExpanded: boolean;
+    static readonly IsExpandedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Parent: Windows.UI.Xaml.Controls.TreeViewNode;
+  }
+
+  class TwoPaneView extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.ITwoPaneView {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    MinTallModeHeight: number;
+    static readonly MinTallModeHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    MinWideModeWidth: number;
+    static readonly MinWideModeWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Mode: number;
+    static readonly ModeProperty: Windows.UI.Xaml.DependencyProperty;
+    Pane1: Windows.UI.Xaml.UIElement;
+    Pane1Length: Windows.UI.Xaml.GridLength;
+    static readonly Pane1LengthProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly Pane1Property: Windows.UI.Xaml.DependencyProperty;
+    Pane2: Windows.UI.Xaml.UIElement;
+    Pane2Length: Windows.UI.Xaml.GridLength;
+    static readonly Pane2LengthProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly Pane2Property: Windows.UI.Xaml.DependencyProperty;
+    PanePriority: number;
+    static readonly PanePriorityProperty: Windows.UI.Xaml.DependencyProperty;
+    TallModeConfiguration: number;
+    static readonly TallModeConfigurationProperty: Windows.UI.Xaml.DependencyProperty;
+    WideModeConfiguration: number;
+    static readonly WideModeConfigurationProperty: Windows.UI.Xaml.DependencyProperty;
+    ModeChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TwoPaneView, Object> | null;
+  }
+
+  class UIElementCollection implements Windows.UI.Xaml.Controls.IUIElementCollection {
+    Append(value: Windows.UI.Xaml.UIElement): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.UIElement>;
+    GetAt(index: number): Windows.UI.Xaml.UIElement;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.UIElement[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.UIElement> | Windows.UI.Xaml.UIElement[];
+    IndexOf(value: Windows.UI.Xaml.UIElement, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.UIElement): void;
+    Move(oldIndex: number, newIndex: number): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.UIElement[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.UIElement): void;
+    readonly Size: number;
+  }
+
+  class UserControl extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.IUserControl {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Content: Windows.UI.Xaml.UIElement;
+    static readonly ContentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class VariableSizedWrapGrid extends Windows.UI.Xaml.Controls.Panel implements Windows.UI.Xaml.Controls.IVariableSizedWrapGrid {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetColumnSpan(element: Windows.UI.Xaml.UIElement): number;
+    static GetRowSpan(element: Windows.UI.Xaml.UIElement): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetColumnSpan(element: Windows.UI.Xaml.UIElement, value: number): void;
+    static SetRowSpan(element: Windows.UI.Xaml.UIElement, value: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    static readonly ColumnSpanProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalChildrenAlignment: number;
+    static readonly HorizontalChildrenAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemHeight: number;
+    static readonly ItemHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemWidth: number;
+    static readonly ItemWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    MaximumRowsOrColumns: number;
+    static readonly MaximumRowsOrColumnsProperty: Windows.UI.Xaml.DependencyProperty;
+    Orientation: number;
+    static readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly RowSpanProperty: Windows.UI.Xaml.DependencyProperty;
+    VerticalChildrenAlignment: number;
+    static readonly VerticalChildrenAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Viewbox extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Controls.IViewbox {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Child: Windows.UI.Xaml.UIElement;
+    Stretch: number;
+    StretchDirection: number;
+    static readonly StretchDirectionProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly StretchProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class VirtualizingPanel extends Windows.UI.Xaml.Controls.Panel implements Windows.UI.Xaml.Controls.IVirtualizingPanel, Windows.UI.Xaml.Controls.IVirtualizingPanelOverrides, Windows.UI.Xaml.Controls.IVirtualizingPanelProtected {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    AddInternalChild(child: Windows.UI.Xaml.UIElement): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    BringIndexIntoView(index: number): void;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InsertInternalChild(index: number, child: Windows.UI.Xaml.UIElement): void;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnClearChildren(): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnItemsChanged(sender: Object, args: Windows.UI.Xaml.Controls.Primitives.ItemsChangedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    RemoveInternalChildRange(index: number, range: number): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly ItemContainerGenerator: Windows.UI.Xaml.Controls.ItemContainerGenerator;
+  }
+
+  class VirtualizingStackPanel extends Windows.UI.Xaml.Controls.Primitives.OrientedVirtualizingPanel implements Windows.UI.Xaml.Controls.IVirtualizingStackPanel, Windows.UI.Xaml.Controls.IVirtualizingStackPanelOverrides {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    AddInternalChild(child: Windows.UI.Xaml.UIElement): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    BringIndexIntoView(index: number): void;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetInsertionIndexes(position: Windows.Foundation.Point, first: number, second: number): void;
+    GetIrregularSnapPoints(orientation: number, alignment: number): Windows.Foundation.Collections.IVectorView<number> | number[];
+    static GetIsVirtualizing(o: Windows.UI.Xaml.DependencyObject): boolean;
+    GetRegularSnapPoints(orientation: number, alignment: number, offset: number): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetVirtualizationMode(element: Windows.UI.Xaml.DependencyObject): number;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InsertInternalChild(index: number, child: Windows.UI.Xaml.UIElement): void;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    LineDown(): void;
+    LineLeft(): void;
+    LineRight(): void;
+    LineUp(): void;
+    MakeVisible(visual: Windows.UI.Xaml.UIElement, rectangle: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    MouseWheelDown(): void;
+    MouseWheelLeft(): void;
+    MouseWheelRight(): void;
+    MouseWheelUp(): void;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCleanUpVirtualizedItem(e: Windows.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs): void;
+    OnClearChildren(): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnItemsChanged(sender: Object, args: Windows.UI.Xaml.Controls.Primitives.ItemsChangedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PageDown(): void;
+    PageLeft(): void;
+    PageRight(): void;
+    PageUp(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    RemoveInternalChildRange(index: number, range: number): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetHorizontalOffset(offset: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    SetVerticalOffset(offset: number): void;
+    static SetVirtualizationMode(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    AreScrollSnapPointsRegular: boolean;
+    static readonly AreScrollSnapPointsRegularProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly IsVirtualizingProperty: Windows.UI.Xaml.DependencyProperty;
+    Orientation: number;
+    static readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly VirtualizationModeProperty: Windows.UI.Xaml.DependencyProperty;
+    CleanUpVirtualizedItemEvent: Windows.UI.Xaml.Controls.CleanUpVirtualizedItemEventHandler | null;
+  }
+
+  class WebView extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Controls.IWebView, Windows.UI.Xaml.Controls.IWebView2, Windows.UI.Xaml.Controls.IWebView3, Windows.UI.Xaml.Controls.IWebView4, Windows.UI.Xaml.Controls.IWebView5, Windows.UI.Xaml.Controls.IWebView6, Windows.UI.Xaml.Controls.IWebView7 {
+    constructor(executionMode: number);
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    AddWebAllowedObject(name: string, pObject: Object): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    BuildLocalStreamUri(contentIdentifier: string, relativePath: string): Windows.Foundation.Uri;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    CapturePreviewToStreamAsync(stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    CaptureSelectedContentToDataPackageAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.DataTransfer.DataPackage>;
+    static ClearTemporaryWebDataAsync(): Windows.Foundation.IAsyncAction;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    DeferredPermissionRequestById(id: number): Windows.UI.Xaml.Controls.WebViewDeferredPermissionRequest;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoBack(): void;
+    GoForward(): void;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    InvokeScript(scriptName: string, arguments_: string[]): string;
+    InvokeScriptAsync(scriptName: string, arguments_: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<string>;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    Navigate(source: Windows.Foundation.Uri): void;
+    NavigateToLocalStreamUri(source: Windows.Foundation.Uri, streamResolver: Windows.Web.IUriToStreamResolver): void;
+    NavigateToString(text: string): void;
+    NavigateWithHttpRequestMessage(requestMessage: Windows.Web.Http.HttpRequestMessage): void;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Refresh(): void;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    Stop(): void;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    AllowedScriptNotifyUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    static readonly AllowedScriptNotifyUrisProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly AnyScriptNotifyUri: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly CanGoBack: boolean;
+    static readonly CanGoBackProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanGoForward: boolean;
+    static readonly CanGoForwardProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContainsFullScreenElement: boolean;
+    static readonly ContainsFullScreenElementProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DataTransferPackage: Windows.ApplicationModel.DataTransfer.DataPackage;
+    static readonly DataTransferPackageProperty: Windows.UI.Xaml.DependencyProperty;
+    DefaultBackgroundColor: Windows.UI.Color;
+    static readonly DefaultBackgroundColorProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly DefaultExecutionMode: number;
+    readonly DeferredPermissionRequests: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.WebViewDeferredPermissionRequest> | Windows.UI.Xaml.Controls.WebViewDeferredPermissionRequest[];
+    readonly DocumentTitle: string;
+    static readonly DocumentTitleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ExecutionMode: number;
+    readonly Settings: Windows.UI.Xaml.Controls.WebViewSettings;
+    Source: Windows.Foundation.Uri;
+    static readonly SourceProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusDown: Windows.UI.Xaml.DependencyObject;
+    static readonly XYFocusDownProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusLeft: Windows.UI.Xaml.DependencyObject;
+    static readonly XYFocusLeftProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusRight: Windows.UI.Xaml.DependencyObject;
+    static readonly XYFocusRightProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusUp: Windows.UI.Xaml.DependencyObject;
+    static readonly XYFocusUpProperty: Windows.UI.Xaml.DependencyProperty;
+    LoadCompleted: Windows.UI.Xaml.Navigation.LoadCompletedEventHandler | null;
+    NavigationFailed: Windows.UI.Xaml.Controls.WebViewNavigationFailedEventHandler | null;
+    ScriptNotify: Windows.UI.Xaml.Controls.NotifyEventHandler | null;
+    ContentLoading: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs> | null;
+    DOMContentLoaded: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs> | null;
+    FrameContentLoading: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs> | null;
+    FrameDOMContentLoaded: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs> | null;
+    FrameNavigationCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs> | null;
+    FrameNavigationStarting: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs> | null;
+    LongRunningScriptDetected: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewLongRunningScriptDetectedEventArgs> | null;
+    NavigationCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs> | null;
+    NavigationStarting: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs> | null;
+    UnsafeContentWarningDisplaying: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Object> | null;
+    UnviewableContentIdentified: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewUnviewableContentIdentifiedEventArgs> | null;
+    ContainsFullScreenElementChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Object> | null;
+    NewWindowRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewNewWindowRequestedEventArgs> | null;
+    PermissionRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewPermissionRequestedEventArgs> | null;
+    UnsupportedUriSchemeIdentified: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewUnsupportedUriSchemeIdentifiedEventArgs> | null;
+    SeparateProcessLost: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewSeparateProcessLostEventArgs> | null;
+    WebResourceRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewWebResourceRequestedEventArgs> | null;
+  }
+
+  class WebViewBrush extends Windows.UI.Xaml.Media.TileBrush implements Windows.UI.Xaml.Controls.IWebViewBrush {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Redraw(): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetSource(source: Windows.UI.Xaml.Controls.WebView): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    SourceName: string;
+    static readonly SourceNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class WebViewContentLoadingEventArgs implements Windows.UI.Xaml.Controls.IWebViewContentLoadingEventArgs {
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class WebViewDOMContentLoadedEventArgs implements Windows.UI.Xaml.Controls.IWebViewDOMContentLoadedEventArgs {
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class WebViewDeferredPermissionRequest implements Windows.UI.Xaml.Controls.IWebViewDeferredPermissionRequest {
+    Allow(): void;
+    Deny(): void;
+    readonly Id: number;
+    readonly PermissionType: number;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class WebViewLongRunningScriptDetectedEventArgs implements Windows.UI.Xaml.Controls.IWebViewLongRunningScriptDetectedEventArgs {
+    readonly ExecutionTime: Windows.Foundation.TimeSpan;
+    StopPageScriptExecution: boolean;
+  }
+
+  class WebViewNavigationCompletedEventArgs implements Windows.UI.Xaml.Controls.IWebViewNavigationCompletedEventArgs {
+    readonly IsSuccess: boolean;
+    readonly Uri: Windows.Foundation.Uri;
+    readonly WebErrorStatus: number;
+  }
+
+  class WebViewNavigationFailedEventArgs implements Windows.UI.Xaml.Controls.IWebViewNavigationFailedEventArgs {
+    readonly Uri: Windows.Foundation.Uri;
+    readonly WebErrorStatus: number;
+  }
+
+  class WebViewNavigationStartingEventArgs implements Windows.UI.Xaml.Controls.IWebViewNavigationStartingEventArgs {
+    Cancel: boolean;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class WebViewNewWindowRequestedEventArgs implements Windows.UI.Xaml.Controls.IWebViewNewWindowRequestedEventArgs {
+    Handled: boolean;
+    readonly Referrer: Windows.Foundation.Uri;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class WebViewPermissionRequest implements Windows.UI.Xaml.Controls.IWebViewPermissionRequest {
+    Allow(): void;
+    Defer(): void;
+    Deny(): void;
+    readonly Id: number;
+    readonly PermissionType: number;
+    readonly State: number;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class WebViewPermissionRequestedEventArgs implements Windows.UI.Xaml.Controls.IWebViewPermissionRequestedEventArgs {
+    readonly PermissionRequest: Windows.UI.Xaml.Controls.WebViewPermissionRequest;
+  }
+
+  class WebViewSeparateProcessLostEventArgs implements Windows.UI.Xaml.Controls.IWebViewSeparateProcessLostEventArgs {
+  }
+
+  class WebViewSettings implements Windows.UI.Xaml.Controls.IWebViewSettings {
+    IsIndexedDBEnabled: boolean;
+    IsJavaScriptEnabled: boolean;
+  }
+
+  class WebViewUnsupportedUriSchemeIdentifiedEventArgs implements Windows.UI.Xaml.Controls.IWebViewUnsupportedUriSchemeIdentifiedEventArgs {
+    Handled: boolean;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class WebViewUnviewableContentIdentifiedEventArgs implements Windows.UI.Xaml.Controls.IWebViewUnviewableContentIdentifiedEventArgs, Windows.UI.Xaml.Controls.IWebViewUnviewableContentIdentifiedEventArgs2 {
+    readonly MediaType: string;
+    readonly Referrer: Windows.Foundation.Uri;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class WebViewWebResourceRequestedEventArgs implements Windows.UI.Xaml.Controls.IWebViewWebResourceRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Web.Http.HttpRequestMessage;
+    Response: Windows.Web.Http.HttpResponseMessage;
+  }
+
+  class WrapGrid extends Windows.UI.Xaml.Controls.Primitives.OrientedVirtualizingPanel implements Windows.UI.Xaml.Controls.IWrapGrid {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    AddInternalChild(child: Windows.UI.Xaml.UIElement): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    BringIndexIntoView(index: number): void;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetInsertionIndexes(position: Windows.Foundation.Point, first: number, second: number): void;
+    GetIrregularSnapPoints(orientation: number, alignment: number): Windows.Foundation.Collections.IVectorView<number> | number[];
+    GetRegularSnapPoints(orientation: number, alignment: number, offset: number): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InsertInternalChild(index: number, child: Windows.UI.Xaml.UIElement): void;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    LineDown(): void;
+    LineLeft(): void;
+    LineRight(): void;
+    LineUp(): void;
+    MakeVisible(visual: Windows.UI.Xaml.UIElement, rectangle: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    MouseWheelDown(): void;
+    MouseWheelLeft(): void;
+    MouseWheelRight(): void;
+    MouseWheelUp(): void;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnClearChildren(): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnItemsChanged(sender: Object, args: Windows.UI.Xaml.Controls.Primitives.ItemsChangedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PageDown(): void;
+    PageLeft(): void;
+    PageRight(): void;
+    PageUp(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    RemoveInternalChildRange(index: number, range: number): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetHorizontalOffset(offset: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    SetVerticalOffset(offset: number): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    HorizontalChildrenAlignment: number;
+    static readonly HorizontalChildrenAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemHeight: number;
+    static readonly ItemHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemWidth: number;
+    static readonly ItemWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    MaximumRowsOrColumns: number;
+    static readonly MaximumRowsOrColumnsProperty: Windows.UI.Xaml.DependencyProperty;
+    Orientation: number;
+    static readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    VerticalChildrenAlignment: number;
+    static readonly VerticalChildrenAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  enum AppBarClosedDisplayMode {
+    Compact = 0,
+    Minimal = 1,
+    Hidden = 2,
+  }
+
+  enum AutoSuggestionBoxTextChangeReason {
+    UserInput = 0,
+    ProgrammaticChange = 1,
+    SuggestionChosen = 2,
+  }
+
+  enum BackgroundSizing {
+    InnerBorderEdge = 0,
+    OuterBorderEdge = 1,
+  }
+
+  enum CalendarViewDisplayMode {
+    Month = 0,
+    Year = 1,
+    Decade = 2,
+  }
+
+  enum CalendarViewSelectionMode {
+    None = 0,
+    Single = 1,
+    Multiple = 2,
+  }
+
+  enum CandidateWindowAlignment {
+    Default = 0,
+    BottomEdge = 1,
+  }
+
+  enum CharacterCasing {
+    Normal = 0,
+    Lower = 1,
+    Upper = 2,
+  }
+
+  enum ClickMode {
+    Release = 0,
+    Press = 1,
+    Hover = 2,
+  }
+
+  enum ColorPickerHsvChannel {
+    Hue = 0,
+    Saturation = 1,
+    Value = 2,
+    Alpha = 3,
+  }
+
+  enum ColorSpectrumComponents {
+    HueValue = 0,
+    ValueHue = 1,
+    HueSaturation = 2,
+    SaturationHue = 3,
+    SaturationValue = 4,
+    ValueSaturation = 5,
+  }
+
+  enum ColorSpectrumShape {
+    Box = 0,
+    Ring = 1,
+  }
+
+  enum ComboBoxSelectionChangedTrigger {
+    Committed = 0,
+    Always = 1,
+  }
+
+  enum CommandBarDefaultLabelPosition {
+    Bottom = 0,
+    Right = 1,
+    Collapsed = 2,
+  }
+
+  enum CommandBarDynamicOverflowAction {
+    AddingToOverflow = 0,
+    RemovingFromOverflow = 1,
+  }
+
+  enum CommandBarLabelPosition {
+    Default = 0,
+    Collapsed = 1,
+  }
+
+  enum CommandBarOverflowButtonVisibility {
+    Auto = 0,
+    Visible = 1,
+    Collapsed = 2,
+  }
+
+  enum ContentDialogButton {
+    None = 0,
+    Primary = 1,
+    Secondary = 2,
+    Close = 3,
+  }
+
+  enum ContentDialogPlacement {
+    Popup = 0,
+    InPlace = 1,
+  }
+
+  enum ContentDialogResult {
+    None = 0,
+    Primary = 1,
+    Secondary = 2,
+  }
+
+  enum ContentLinkChangeKind {
+    Inserted = 0,
+    Removed = 1,
+    Edited = 2,
+  }
+
+  enum DisabledFormattingAccelerators {
+    None = 0,
+    Bold = 1,
+    Italic = 2,
+    Underline = 4,
+    All = 4294967295,
+  }
+
+  enum HandwritingPanelPlacementAlignment {
+    Auto = 0,
+    TopLeft = 1,
+    TopRight = 2,
+    BottomLeft = 3,
+    BottomRight = 4,
+  }
+
+  enum IncrementalLoadingTrigger {
+    None = 0,
+    Edge = 1,
+  }
+
+  enum InkToolbarButtonFlyoutPlacement {
+    Auto = 0,
+    Top = 1,
+    Bottom = 2,
+    Left = 3,
+    Right = 4,
+  }
+
+  enum InkToolbarFlyoutItemKind {
+    Simple = 0,
+    Radio = 1,
+    Check = 2,
+    RadioCheck = 3,
+  }
+
+  enum InkToolbarInitialControls {
+    All = 0,
+    None = 1,
+    PensOnly = 2,
+    AllExceptPens = 3,
+  }
+
+  enum InkToolbarMenuKind {
+    Stencil = 0,
+  }
+
+  enum InkToolbarStencilKind {
+    Ruler = 0,
+    Protractor = 1,
+  }
+
+  enum InkToolbarToggle {
+    Ruler = 0,
+    Custom = 1,
+  }
+
+  enum InkToolbarTool {
+    BallpointPen = 0,
+    Pencil = 1,
+    Highlighter = 2,
+    Eraser = 3,
+    CustomPen = 4,
+    CustomTool = 5,
+  }
+
+  enum ItemsUpdatingScrollMode {
+    KeepItemsInView = 0,
+    KeepScrollOffset = 1,
+    KeepLastItemInView = 2,
+  }
+
+  enum LightDismissOverlayMode {
+    Auto = 0,
+    On = 1,
+    Off = 2,
+  }
+
+  enum ListPickerFlyoutSelectionMode {
+    Single = 0,
+    Multiple = 1,
+  }
+
+  enum ListViewReorderMode {
+    Disabled = 0,
+    Enabled = 1,
+  }
+
+  enum ListViewSelectionMode {
+    None = 0,
+    Single = 1,
+    Multiple = 2,
+    Extended = 3,
+  }
+
+  enum NavigationViewBackButtonVisible {
+    Collapsed = 0,
+    Visible = 1,
+    Auto = 2,
+  }
+
+  enum NavigationViewDisplayMode {
+    Minimal = 0,
+    Compact = 1,
+    Expanded = 2,
+  }
+
+  enum NavigationViewOverflowLabelMode {
+    MoreLabel = 0,
+    NoLabel = 1,
+  }
+
+  enum NavigationViewPaneDisplayMode {
+    Auto = 0,
+    Left = 1,
+    Top = 2,
+    LeftCompact = 3,
+    LeftMinimal = 4,
+  }
+
+  enum NavigationViewSelectionFollowsFocus {
+    Disabled = 0,
+    Enabled = 1,
+  }
+
+  enum NavigationViewShoulderNavigationEnabled {
+    WhenSelectionFollowsFocus = 0,
+    Always = 1,
+    Never = 2,
+  }
+
+  enum Orientation {
+    Vertical = 0,
+    Horizontal = 1,
+  }
+
+  enum PanelScrollingDirection {
+    None = 0,
+    Forward = 1,
+    Backward = 2,
+  }
+
+  enum ParallaxSourceOffsetKind {
+    Absolute = 0,
+    Relative = 1,
+  }
+
+  enum PasswordRevealMode {
+    Peek = 0,
+    Hidden = 1,
+    Visible = 2,
+  }
+
+  enum PivotHeaderFocusVisualPlacement {
+    ItemHeaders = 0,
+    SelectedItemHeader = 1,
+  }
+
+  enum PivotSlideInAnimationGroup {
+    Default = 0,
+    GroupOne = 1,
+    GroupTwo = 2,
+    GroupThree = 3,
+  }
+
+  enum RefreshPullDirection {
+    LeftToRight = 0,
+    TopToBottom = 1,
+    RightToLeft = 2,
+    BottomToTop = 3,
+  }
+
+  enum RefreshVisualizerOrientation {
+    Auto = 0,
+    Normal = 1,
+    Rotate90DegreesCounterclockwise = 2,
+    Rotate270DegreesCounterclockwise = 3,
+  }
+
+  enum RefreshVisualizerState {
+    Idle = 0,
+    Peeking = 1,
+    Interacting = 2,
+    Pending = 3,
+    Refreshing = 4,
+  }
+
+  enum RequiresPointer {
+    Never = 0,
+    WhenEngaged = 1,
+    WhenFocused = 2,
+  }
+
+  enum RichEditClipboardFormat {
+    AllFormats = 0,
+    PlainText = 1,
+  }
+
+  enum ScrollBarVisibility {
+    Disabled = 0,
+    Auto = 1,
+    Hidden = 2,
+    Visible = 3,
+  }
+
+  enum ScrollIntoViewAlignment {
+    Default = 0,
+    Leading = 1,
+  }
+
+  enum ScrollMode {
+    Disabled = 0,
+    Enabled = 1,
+    Auto = 2,
+  }
+
+  enum SelectionMode {
+    Single = 0,
+    Multiple = 1,
+    Extended = 2,
+  }
+
+  enum SnapPointsType {
+    None = 0,
+    Optional = 1,
+    Mandatory = 2,
+    OptionalSingle = 3,
+    MandatorySingle = 4,
+  }
+
+  enum SplitViewDisplayMode {
+    Overlay = 0,
+    Inline = 1,
+    CompactOverlay = 2,
+    CompactInline = 3,
+  }
+
+  enum SplitViewPanePlacement {
+    Left = 0,
+    Right = 1,
+  }
+
+  enum StretchDirection {
+    UpOnly = 0,
+    DownOnly = 1,
+    Both = 2,
+  }
+
+  enum SwipeBehaviorOnInvoked {
+    Auto = 0,
+    Close = 1,
+    RemainOpen = 2,
+  }
+
+  enum SwipeMode {
+    Reveal = 0,
+    Execute = 1,
+  }
+
+  enum Symbol {
+    Previous = 57600,
+    Next = 57601,
+    Play = 57602,
+    Pause = 57603,
+    Edit = 57604,
+    Save = 57605,
+    Clear = 57606,
+    Delete = 57607,
+    Remove = 57608,
+    Add = 57609,
+    Cancel = 57610,
+    Accept = 57611,
+    More = 57612,
+    Redo = 57613,
+    Undo = 57614,
+    Home = 57615,
+    Up = 57616,
+    Forward = 57617,
+    Back = 57618,
+    Favorite = 57619,
+    Camera = 57620,
+    Setting = 57621,
+    Video = 57622,
+    Sync = 57623,
+    Download = 57624,
+    Mail = 57625,
+    Find = 57626,
+    Help = 57627,
+    Upload = 57628,
+    Emoji = 57629,
+    TwoPage = 57630,
+    LeaveChat = 57631,
+    MailForward = 57632,
+    Clock = 57633,
+    Send = 57634,
+    Crop = 57635,
+    RotateCamera = 57636,
+    People = 57637,
+    OpenPane = 57638,
+    ClosePane = 57639,
+    World = 57640,
+    Flag = 57641,
+    PreviewLink = 57642,
+    Globe = 57643,
+    Trim = 57644,
+    AttachCamera = 57645,
+    ZoomIn = 57646,
+    Bookmarks = 57647,
+    Document = 57648,
+    ProtectedDocument = 57649,
+    Page = 57650,
+    Bullets = 57651,
+    Comment = 57652,
+    MailFilled = 57653,
+    ContactInfo = 57654,
+    HangUp = 57655,
+    ViewAll = 57656,
+    MapPin = 57657,
+    Phone = 57658,
+    VideoChat = 57659,
+    Switch = 57660,
+    Contact = 57661,
+    Rename = 57662,
+    Pin = 57665,
+    MusicInfo = 57666,
+    Go = 57667,
+    Keyboard = 57668,
+    DockLeft = 57669,
+    DockRight = 57670,
+    DockBottom = 57671,
+    Remote = 57672,
+    Refresh = 57673,
+    Rotate = 57674,
+    Shuffle = 57675,
+    List = 57676,
+    Shop = 57677,
+    SelectAll = 57678,
+    Orientation = 57679,
+    Import = 57680,
+    ImportAll = 57681,
+    BrowsePhotos = 57685,
+    WebCam = 57686,
+    Pictures = 57688,
+    SaveLocal = 57689,
+    Caption = 57690,
+    Stop = 57691,
+    ShowResults = 57692,
+    Volume = 57693,
+    Repair = 57694,
+    Message = 57695,
+    Page2 = 57696,
+    CalendarDay = 57697,
+    CalendarWeek = 57698,
+    Calendar = 57699,
+    Character = 57700,
+    MailReplyAll = 57701,
+    Read = 57702,
+    Link = 57703,
+    Account = 57704,
+    ShowBcc = 57705,
+    HideBcc = 57706,
+    Cut = 57707,
+    Attach = 57708,
+    Paste = 57709,
+    Filter = 57710,
+    Copy = 57711,
+    Emoji2 = 57712,
+    Important = 57713,
+    MailReply = 57714,
+    SlideShow = 57715,
+    Sort = 57716,
+    Manage = 57720,
+    AllApps = 57721,
+    DisconnectDrive = 57722,
+    MapDrive = 57723,
+    NewWindow = 57724,
+    OpenWith = 57725,
+    ContactPresence = 57729,
+    Priority = 57730,
+    GoToToday = 57732,
+    Font = 57733,
+    FontColor = 57734,
+    Contact2 = 57735,
+    Folder = 57736,
+    Audio = 57737,
+    Placeholder = 57738,
+    View = 57739,
+    SetLockScreen = 57740,
+    SetTile = 57741,
+    ClosedCaption = 57744,
+    StopSlideShow = 57745,
+    Permissions = 57746,
+    Highlight = 57747,
+    DisableUpdates = 57748,
+    UnFavorite = 57749,
+    UnPin = 57750,
+    OpenLocal = 57751,
+    Mute = 57752,
+    Italic = 57753,
+    Underline = 57754,
+    Bold = 57755,
+    MoveToFolder = 57756,
+    LikeDislike = 57757,
+    Dislike = 57758,
+    Like = 57759,
+    AlignRight = 57760,
+    AlignCenter = 57761,
+    AlignLeft = 57762,
+    Zoom = 57763,
+    ZoomOut = 57764,
+    OpenFile = 57765,
+    OtherUser = 57766,
+    Admin = 57767,
+    Street = 57795,
+    Map = 57796,
+    ClearSelection = 57797,
+    FontDecrease = 57798,
+    FontIncrease = 57799,
+    FontSize = 57800,
+    CellPhone = 57801,
+    ReShare = 57802,
+    Tag = 57803,
+    RepeatOne = 57804,
+    RepeatAll = 57805,
+    OutlineStar = 57806,
+    SolidStar = 57807,
+    Calculator = 57808,
+    Directions = 57809,
+    Target = 57810,
+    Library = 57811,
+    PhoneBook = 57812,
+    Memo = 57813,
+    Microphone = 57814,
+    PostUpdate = 57815,
+    BackToWindow = 57816,
+    FullScreen = 57817,
+    NewFolder = 57818,
+    CalendarReply = 57819,
+    UnSyncFolder = 57821,
+    ReportHacked = 57822,
+    SyncFolder = 57823,
+    BlockContact = 57824,
+    SwitchApps = 57825,
+    AddFriend = 57826,
+    TouchPointer = 57827,
+    GoToStart = 57828,
+    ZeroBars = 57829,
+    OneBar = 57830,
+    TwoBars = 57831,
+    ThreeBars = 57832,
+    FourBars = 57833,
+    Scan = 58004,
+    Preview = 58005,
+    GlobalNavigationButton = 59136,
+    Share = 59181,
+    Print = 59209,
+    XboxOneConsole = 59792,
+  }
+
+  enum TreeViewSelectionMode {
+    None = 0,
+    Single = 1,
+    Multiple = 2,
+  }
+
+  enum TwoPaneViewMode {
+    SinglePane = 0,
+    Wide = 1,
+    Tall = 2,
+  }
+
+  enum TwoPaneViewPriority {
+    Pane1 = 0,
+    Pane2 = 1,
+  }
+
+  enum TwoPaneViewTallModeConfiguration {
+    SinglePane = 0,
+    TopBottom = 1,
+    BottomTop = 2,
+  }
+
+  enum TwoPaneViewWideModeConfiguration {
+    SinglePane = 0,
+    LeftRight = 1,
+    RightLeft = 2,
+  }
+
+  enum VirtualizationMode {
+    Standard = 0,
+    Recycling = 1,
+  }
+
+  enum WebViewExecutionMode {
+    SameThread = 0,
+    SeparateThread = 1,
+    SeparateProcess = 2,
+  }
+
+  enum WebViewPermissionState {
+    Unknown = 0,
+    Defer = 1,
+    Allow = 2,
+    Deny = 3,
+  }
+
+  enum WebViewPermissionType {
+    Geolocation = 0,
+    UnlimitedIndexedDBQuota = 1,
+    Media = 2,
+    PointerLock = 3,
+    WebNotifications = 4,
+    Screen = 5,
+    ImmersiveView = 6,
+  }
+
+  enum ZoomMode {
+    Disabled = 0,
+    Enabled = 1,
+  }
+
+  interface BackClickEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Controls.BackClickEventArgs): void;
+  }
+  var BackClickEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Controls.BackClickEventArgs) => void): BackClickEventHandler;
+  };
+
+  interface CalendarViewDayItemChangingEventHandler {
+    (sender: Windows.UI.Xaml.Controls.CalendarView, e: Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs): void;
+  }
+  var CalendarViewDayItemChangingEventHandler: {
+    new(callback: (sender: Windows.UI.Xaml.Controls.CalendarView, e: Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs) => void): CalendarViewDayItemChangingEventHandler;
+  };
+
+  interface CleanUpVirtualizedItemEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs): void;
+  }
+  var CleanUpVirtualizedItemEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs) => void): CleanUpVirtualizedItemEventHandler;
+  };
+
+  interface ContextMenuOpeningEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Controls.ContextMenuEventArgs): void;
+  }
+  var ContextMenuOpeningEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Controls.ContextMenuEventArgs) => void): ContextMenuOpeningEventHandler;
+  };
+
+  interface DragItemsStartingEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Controls.DragItemsStartingEventArgs): void;
+  }
+  var DragItemsStartingEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Controls.DragItemsStartingEventArgs) => void): DragItemsStartingEventHandler;
+  };
+
+  interface HubSectionHeaderClickEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Controls.HubSectionHeaderClickEventArgs): void;
+  }
+  var HubSectionHeaderClickEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Controls.HubSectionHeaderClickEventArgs) => void): HubSectionHeaderClickEventHandler;
+  };
+
+  interface IAnchorRequestedEventArgs {
+    Anchor: Windows.UI.Xaml.UIElement;
+    readonly AnchorCandidates: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.UIElement> | Windows.UI.Xaml.UIElement[];
+  }
+  var IAnchorRequestedEventArgs: abstract new (...args: any[]) => IAnchorRequestedEventArgs;
+
+  interface IAppBar {
+    IsOpen: boolean;
+    IsSticky: boolean;
+    Closed: Windows.Foundation.EventHandler<Object> | null;
+    Opened: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IAppBar: abstract new (...args: any[]) => IAppBar;
+
+  interface IAppBar2 {
+    ClosedDisplayMode: number;
+  }
+  var IAppBar2: abstract new (...args: any[]) => IAppBar2;
+
+  interface IAppBar3 {
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.AppBarTemplateSettings;
+    Closing: Windows.Foundation.EventHandler<Object> | null;
+    Opening: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IAppBar3: abstract new (...args: any[]) => IAppBar3;
+
+  interface IAppBar4 {
+    LightDismissOverlayMode: number;
+  }
+  var IAppBar4: abstract new (...args: any[]) => IAppBar4;
+
+  interface IAppBarButton {
+    Icon: Windows.UI.Xaml.Controls.IconElement;
+    Label: string;
+  }
+  var IAppBarButton: abstract new (...args: any[]) => IAppBarButton;
+
+  interface IAppBarButton3 {
+    LabelPosition: number;
+  }
+  var IAppBarButton3: abstract new (...args: any[]) => IAppBarButton3;
+
+  interface IAppBarButton4 {
+    KeyboardAcceleratorTextOverride: string;
+  }
+  var IAppBarButton4: abstract new (...args: any[]) => IAppBarButton4;
+
+  interface IAppBarButton5 {
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.AppBarButtonTemplateSettings;
+  }
+  var IAppBarButton5: abstract new (...args: any[]) => IAppBarButton5;
+
+  interface IAppBarButtonFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.AppBarButton;
+  }
+  var IAppBarButtonFactory: abstract new (...args: any[]) => IAppBarButtonFactory;
+
+  interface IAppBarButtonStatics {
+    readonly IconProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsCompactProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LabelProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAppBarButtonStatics: abstract new (...args: any[]) => IAppBarButtonStatics;
+
+  interface IAppBarButtonStatics3 {
+    readonly DynamicOverflowOrderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsInOverflowProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LabelPositionProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAppBarButtonStatics3: abstract new (...args: any[]) => IAppBarButtonStatics3;
+
+  interface IAppBarButtonStatics4 {
+    readonly KeyboardAcceleratorTextOverrideProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAppBarButtonStatics4: abstract new (...args: any[]) => IAppBarButtonStatics4;
+
+  interface IAppBarElementContainer {
+  }
+  var IAppBarElementContainer: abstract new (...args: any[]) => IAppBarElementContainer;
+
+  interface IAppBarElementContainerFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.AppBarElementContainer;
+  }
+  var IAppBarElementContainerFactory: abstract new (...args: any[]) => IAppBarElementContainerFactory;
+
+  interface IAppBarElementContainerStatics {
+    readonly DynamicOverflowOrderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsCompactProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsInOverflowProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAppBarElementContainerStatics: abstract new (...args: any[]) => IAppBarElementContainerStatics;
+
+  interface IAppBarFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.AppBar;
+  }
+  var IAppBarFactory: abstract new (...args: any[]) => IAppBarFactory;
+
+  interface IAppBarOverrides {
+    OnClosed(e: Object): void;
+    OnOpened(e: Object): void;
+  }
+  var IAppBarOverrides: abstract new (...args: any[]) => IAppBarOverrides;
+
+  interface IAppBarOverrides3 {
+    OnClosing(e: Object): void;
+    OnOpening(e: Object): void;
+  }
+  var IAppBarOverrides3: abstract new (...args: any[]) => IAppBarOverrides3;
+
+  interface IAppBarSeparator {
+  }
+  var IAppBarSeparator: abstract new (...args: any[]) => IAppBarSeparator;
+
+  interface IAppBarSeparatorFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.AppBarSeparator;
+  }
+  var IAppBarSeparatorFactory: abstract new (...args: any[]) => IAppBarSeparatorFactory;
+
+  interface IAppBarSeparatorStatics {
+    readonly IsCompactProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAppBarSeparatorStatics: abstract new (...args: any[]) => IAppBarSeparatorStatics;
+
+  interface IAppBarSeparatorStatics3 {
+    readonly DynamicOverflowOrderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsInOverflowProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAppBarSeparatorStatics3: abstract new (...args: any[]) => IAppBarSeparatorStatics3;
+
+  interface IAppBarStatics {
+    readonly IsOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsStickyProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAppBarStatics: abstract new (...args: any[]) => IAppBarStatics;
+
+  interface IAppBarStatics2 {
+    readonly ClosedDisplayModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAppBarStatics2: abstract new (...args: any[]) => IAppBarStatics2;
+
+  interface IAppBarStatics4 {
+    readonly LightDismissOverlayModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAppBarStatics4: abstract new (...args: any[]) => IAppBarStatics4;
+
+  interface IAppBarToggleButton {
+    Icon: Windows.UI.Xaml.Controls.IconElement;
+    Label: string;
+  }
+  var IAppBarToggleButton: abstract new (...args: any[]) => IAppBarToggleButton;
+
+  interface IAppBarToggleButton3 {
+    LabelPosition: number;
+  }
+  var IAppBarToggleButton3: abstract new (...args: any[]) => IAppBarToggleButton3;
+
+  interface IAppBarToggleButton4 {
+    KeyboardAcceleratorTextOverride: string;
+  }
+  var IAppBarToggleButton4: abstract new (...args: any[]) => IAppBarToggleButton4;
+
+  interface IAppBarToggleButton5 {
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.AppBarToggleButtonTemplateSettings;
+  }
+  var IAppBarToggleButton5: abstract new (...args: any[]) => IAppBarToggleButton5;
+
+  interface IAppBarToggleButtonFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.AppBarToggleButton;
+  }
+  var IAppBarToggleButtonFactory: abstract new (...args: any[]) => IAppBarToggleButtonFactory;
+
+  interface IAppBarToggleButtonStatics {
+    readonly IconProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsCompactProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LabelProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAppBarToggleButtonStatics: abstract new (...args: any[]) => IAppBarToggleButtonStatics;
+
+  interface IAppBarToggleButtonStatics3 {
+    readonly DynamicOverflowOrderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsInOverflowProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LabelPositionProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAppBarToggleButtonStatics3: abstract new (...args: any[]) => IAppBarToggleButtonStatics3;
+
+  interface IAppBarToggleButtonStatics4 {
+    readonly KeyboardAcceleratorTextOverrideProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAppBarToggleButtonStatics4: abstract new (...args: any[]) => IAppBarToggleButtonStatics4;
+
+  interface IAutoSuggestBox {
+    AutoMaximizeSuggestionArea: boolean;
+    Header: Object;
+    IsSuggestionListOpen: boolean;
+    MaxSuggestionListHeight: number;
+    PlaceholderText: string;
+    Text: string;
+    TextBoxStyle: Windows.UI.Xaml.Style;
+    TextMemberPath: string;
+    UpdateTextOnSelect: boolean;
+    SuggestionChosen: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.AutoSuggestBox, Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs> | null;
+    TextChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.AutoSuggestBox, Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs> | null;
+  }
+  var IAutoSuggestBox: abstract new (...args: any[]) => IAutoSuggestBox;
+
+  interface IAutoSuggestBox2 {
+    QueryIcon: Windows.UI.Xaml.Controls.IconElement;
+    QuerySubmitted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.AutoSuggestBox, Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs> | null;
+  }
+  var IAutoSuggestBox2: abstract new (...args: any[]) => IAutoSuggestBox2;
+
+  interface IAutoSuggestBox3 {
+    LightDismissOverlayMode: number;
+  }
+  var IAutoSuggestBox3: abstract new (...args: any[]) => IAutoSuggestBox3;
+
+  interface IAutoSuggestBox4 {
+    Description: Object;
+  }
+  var IAutoSuggestBox4: abstract new (...args: any[]) => IAutoSuggestBox4;
+
+  interface IAutoSuggestBoxQuerySubmittedEventArgs {
+    readonly ChosenSuggestion: Object;
+    readonly QueryText: string;
+  }
+  var IAutoSuggestBoxQuerySubmittedEventArgs: abstract new (...args: any[]) => IAutoSuggestBoxQuerySubmittedEventArgs;
+
+  interface IAutoSuggestBoxStatics {
+    readonly AutoMaximizeSuggestionAreaProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsSuggestionListOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxSuggestionListHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlaceholderTextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextBoxStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextMemberPathProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly UpdateTextOnSelectProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAutoSuggestBoxStatics: abstract new (...args: any[]) => IAutoSuggestBoxStatics;
+
+  interface IAutoSuggestBoxStatics2 {
+    readonly QueryIconProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAutoSuggestBoxStatics2: abstract new (...args: any[]) => IAutoSuggestBoxStatics2;
+
+  interface IAutoSuggestBoxStatics3 {
+    readonly LightDismissOverlayModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAutoSuggestBoxStatics3: abstract new (...args: any[]) => IAutoSuggestBoxStatics3;
+
+  interface IAutoSuggestBoxStatics4 {
+    readonly DescriptionProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAutoSuggestBoxStatics4: abstract new (...args: any[]) => IAutoSuggestBoxStatics4;
+
+  interface IAutoSuggestBoxSuggestionChosenEventArgs {
+    readonly SelectedItem: Object;
+  }
+  var IAutoSuggestBoxSuggestionChosenEventArgs: abstract new (...args: any[]) => IAutoSuggestBoxSuggestionChosenEventArgs;
+
+  interface IAutoSuggestBoxTextChangedEventArgs {
+    CheckCurrent(): boolean;
+    Reason: number;
+  }
+  var IAutoSuggestBoxTextChangedEventArgs: abstract new (...args: any[]) => IAutoSuggestBoxTextChangedEventArgs;
+
+  interface IAutoSuggestBoxTextChangedEventArgsStatics {
+    readonly ReasonProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAutoSuggestBoxTextChangedEventArgsStatics: abstract new (...args: any[]) => IAutoSuggestBoxTextChangedEventArgsStatics;
+
+  interface IBackClickEventArgs {
+    Handled: boolean;
+  }
+  var IBackClickEventArgs: abstract new (...args: any[]) => IBackClickEventArgs;
+
+  interface IBitmapIcon {
+    UriSource: Windows.Foundation.Uri;
+  }
+  var IBitmapIcon: abstract new (...args: any[]) => IBitmapIcon;
+
+  interface IBitmapIcon2 {
+    ShowAsMonochrome: boolean;
+  }
+  var IBitmapIcon2: abstract new (...args: any[]) => IBitmapIcon2;
+
+  interface IBitmapIconFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.BitmapIcon;
+  }
+  var IBitmapIconFactory: abstract new (...args: any[]) => IBitmapIconFactory;
+
+  interface IBitmapIconSource {
+    ShowAsMonochrome: boolean;
+    UriSource: Windows.Foundation.Uri;
+  }
+  var IBitmapIconSource: abstract new (...args: any[]) => IBitmapIconSource;
+
+  interface IBitmapIconSourceFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.BitmapIconSource;
+  }
+  var IBitmapIconSourceFactory: abstract new (...args: any[]) => IBitmapIconSourceFactory;
+
+  interface IBitmapIconSourceStatics {
+    readonly ShowAsMonochromeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly UriSourceProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IBitmapIconSourceStatics: abstract new (...args: any[]) => IBitmapIconSourceStatics;
+
+  interface IBitmapIconStatics {
+    readonly UriSourceProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IBitmapIconStatics: abstract new (...args: any[]) => IBitmapIconStatics;
+
+  interface IBitmapIconStatics2 {
+    readonly ShowAsMonochromeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IBitmapIconStatics2: abstract new (...args: any[]) => IBitmapIconStatics2;
+
+  interface IBorder {
+    Background: Windows.UI.Xaml.Media.Brush;
+    BorderBrush: Windows.UI.Xaml.Media.Brush;
+    BorderThickness: Windows.UI.Xaml.Thickness;
+    Child: Windows.UI.Xaml.UIElement;
+    ChildTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    CornerRadius: Windows.UI.Xaml.CornerRadius;
+    Padding: Windows.UI.Xaml.Thickness;
+  }
+  var IBorder: abstract new (...args: any[]) => IBorder;
+
+  interface IBorder2 {
+    BackgroundSizing: number;
+    BackgroundTransition: Windows.UI.Xaml.BrushTransition;
+  }
+  var IBorder2: abstract new (...args: any[]) => IBorder2;
+
+  interface IBorderStatics {
+    readonly BackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ChildTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CornerRadiusProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IBorderStatics: abstract new (...args: any[]) => IBorderStatics;
+
+  interface IBorderStatics2 {
+    readonly BackgroundSizingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IBorderStatics2: abstract new (...args: any[]) => IBorderStatics2;
+
+  interface IButton {
+  }
+  var IButton: abstract new (...args: any[]) => IButton;
+
+  interface IButtonFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Button;
+  }
+  var IButtonFactory: abstract new (...args: any[]) => IButtonFactory;
+
+  interface IButtonStaticsWithFlyout {
+    readonly FlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IButtonStaticsWithFlyout: abstract new (...args: any[]) => IButtonStaticsWithFlyout;
+
+  interface IButtonWithFlyout {
+    Flyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+  }
+  var IButtonWithFlyout: abstract new (...args: any[]) => IButtonWithFlyout;
+
+  interface ICalendarDatePicker {
+    SetDisplayDate(date: Windows.Foundation.DateTime): void;
+    SetYearDecadeDisplayDimensions(columns: number, rows: number): void;
+    CalendarIdentifier: string;
+    CalendarViewStyle: Windows.UI.Xaml.Style;
+    Date: Windows.Foundation.DateTime | null;
+    DateFormat: string;
+    DayOfWeekFormat: string;
+    DisplayMode: number;
+    FirstDayOfWeek: number;
+    Header: Object;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    IsCalendarOpen: boolean;
+    IsGroupLabelVisible: boolean;
+    IsOutOfScopeEnabled: boolean;
+    IsTodayHighlighted: boolean;
+    MaxDate: Windows.Foundation.DateTime;
+    MinDate: Windows.Foundation.DateTime;
+    PlaceholderText: string;
+    CalendarViewDayItemChanging: Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventHandler | null;
+    Closed: Windows.Foundation.EventHandler<Object> | null;
+    DateChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.CalendarDatePicker, Windows.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs> | null;
+    Opened: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var ICalendarDatePicker: abstract new (...args: any[]) => ICalendarDatePicker;
+
+  interface ICalendarDatePicker2 {
+    LightDismissOverlayMode: number;
+  }
+  var ICalendarDatePicker2: abstract new (...args: any[]) => ICalendarDatePicker2;
+
+  interface ICalendarDatePicker3 {
+    Description: Object;
+  }
+  var ICalendarDatePicker3: abstract new (...args: any[]) => ICalendarDatePicker3;
+
+  interface ICalendarDatePickerDateChangedEventArgs {
+    readonly NewDate: Windows.Foundation.DateTime | null;
+    readonly OldDate: Windows.Foundation.DateTime | null;
+  }
+  var ICalendarDatePickerDateChangedEventArgs: abstract new (...args: any[]) => ICalendarDatePickerDateChangedEventArgs;
+
+  interface ICalendarDatePickerFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.CalendarDatePicker;
+  }
+  var ICalendarDatePickerFactory: abstract new (...args: any[]) => ICalendarDatePickerFactory;
+
+  interface ICalendarDatePickerStatics {
+    readonly CalendarIdentifierProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CalendarViewStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DateFormatProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DayOfWeekFormatProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DisplayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FirstDayOfWeekProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsCalendarOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsGroupLabelVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsOutOfScopeEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsTodayHighlightedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxDateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinDateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlaceholderTextProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ICalendarDatePickerStatics: abstract new (...args: any[]) => ICalendarDatePickerStatics;
+
+  interface ICalendarDatePickerStatics2 {
+    readonly LightDismissOverlayModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ICalendarDatePickerStatics2: abstract new (...args: any[]) => ICalendarDatePickerStatics2;
+
+  interface ICalendarDatePickerStatics3 {
+    readonly DescriptionProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ICalendarDatePickerStatics3: abstract new (...args: any[]) => ICalendarDatePickerStatics3;
+
+  interface ICalendarView {
+    SetDisplayDate(date: Windows.Foundation.DateTime): void;
+    SetYearDecadeDisplayDimensions(columns: number, rows: number): void;
+    BlackoutForeground: Windows.UI.Xaml.Media.Brush;
+    CalendarIdentifier: string;
+    CalendarItemBackground: Windows.UI.Xaml.Media.Brush;
+    CalendarItemBorderBrush: Windows.UI.Xaml.Media.Brush;
+    CalendarItemBorderThickness: Windows.UI.Xaml.Thickness;
+    CalendarItemForeground: Windows.UI.Xaml.Media.Brush;
+    CalendarViewDayItemStyle: Windows.UI.Xaml.Style;
+    DayItemFontFamily: Windows.UI.Xaml.Media.FontFamily;
+    DayItemFontSize: number;
+    DayItemFontStyle: number;
+    DayItemFontWeight: Windows.UI.Text.FontWeight;
+    DayOfWeekFormat: string;
+    DisplayMode: number;
+    FirstDayOfWeek: number;
+    FirstOfMonthLabelFontFamily: Windows.UI.Xaml.Media.FontFamily;
+    FirstOfMonthLabelFontSize: number;
+    FirstOfMonthLabelFontStyle: number;
+    FirstOfMonthLabelFontWeight: Windows.UI.Text.FontWeight;
+    FirstOfYearDecadeLabelFontFamily: Windows.UI.Xaml.Media.FontFamily;
+    FirstOfYearDecadeLabelFontSize: number;
+    FirstOfYearDecadeLabelFontStyle: number;
+    FirstOfYearDecadeLabelFontWeight: Windows.UI.Text.FontWeight;
+    FocusBorderBrush: Windows.UI.Xaml.Media.Brush;
+    HorizontalDayItemAlignment: number;
+    HorizontalFirstOfMonthLabelAlignment: number;
+    HoverBorderBrush: Windows.UI.Xaml.Media.Brush;
+    IsGroupLabelVisible: boolean;
+    IsOutOfScopeEnabled: boolean;
+    IsTodayHighlighted: boolean;
+    MaxDate: Windows.Foundation.DateTime;
+    MinDate: Windows.Foundation.DateTime;
+    MonthYearItemFontFamily: Windows.UI.Xaml.Media.FontFamily;
+    MonthYearItemFontSize: number;
+    MonthYearItemFontStyle: number;
+    MonthYearItemFontWeight: Windows.UI.Text.FontWeight;
+    NumberOfWeeksInView: number;
+    OutOfScopeBackground: Windows.UI.Xaml.Media.Brush;
+    OutOfScopeForeground: Windows.UI.Xaml.Media.Brush;
+    PressedBorderBrush: Windows.UI.Xaml.Media.Brush;
+    PressedForeground: Windows.UI.Xaml.Media.Brush;
+    SelectedBorderBrush: Windows.UI.Xaml.Media.Brush;
+    readonly SelectedDates: Windows.Foundation.Collections.IVector<Windows.Foundation.DateTime> | Windows.Foundation.DateTime[];
+    SelectedForeground: Windows.UI.Xaml.Media.Brush;
+    SelectedHoverBorderBrush: Windows.UI.Xaml.Media.Brush;
+    SelectedPressedBorderBrush: Windows.UI.Xaml.Media.Brush;
+    SelectionMode: number;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.CalendarViewTemplateSettings;
+    TodayFontWeight: Windows.UI.Text.FontWeight;
+    TodayForeground: Windows.UI.Xaml.Media.Brush;
+    VerticalDayItemAlignment: number;
+    VerticalFirstOfMonthLabelAlignment: number;
+    CalendarViewDayItemChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.CalendarView, Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs> | null;
+    SelectedDatesChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.CalendarView, Windows.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs> | null;
+  }
+  var ICalendarView: abstract new (...args: any[]) => ICalendarView;
+
+  interface ICalendarView2 {
+    BlackoutBackground: Windows.UI.Xaml.Media.Brush;
+    BlackoutStrikethroughBrush: Windows.UI.Xaml.Media.Brush;
+    CalendarItemCornerRadius: Windows.UI.Xaml.CornerRadius;
+    CalendarItemDisabledBackground: Windows.UI.Xaml.Media.Brush;
+    CalendarItemHoverBackground: Windows.UI.Xaml.Media.Brush;
+    CalendarItemPressedBackground: Windows.UI.Xaml.Media.Brush;
+    DayItemMargin: Windows.UI.Xaml.Thickness;
+    DisabledForeground: Windows.UI.Xaml.Media.Brush;
+    FirstOfMonthLabelMargin: Windows.UI.Xaml.Thickness;
+    FirstOfYearDecadeLabelMargin: Windows.UI.Xaml.Thickness;
+    MonthYearItemMargin: Windows.UI.Xaml.Thickness;
+    OutOfScopeHoverForeground: Windows.UI.Xaml.Media.Brush;
+    OutOfScopePressedForeground: Windows.UI.Xaml.Media.Brush;
+    SelectedDisabledBorderBrush: Windows.UI.Xaml.Media.Brush;
+    SelectedDisabledForeground: Windows.UI.Xaml.Media.Brush;
+    SelectedHoverForeground: Windows.UI.Xaml.Media.Brush;
+    SelectedPressedForeground: Windows.UI.Xaml.Media.Brush;
+    TodayBackground: Windows.UI.Xaml.Media.Brush;
+    TodayBlackoutBackground: Windows.UI.Xaml.Media.Brush;
+    TodayBlackoutForeground: Windows.UI.Xaml.Media.Brush;
+    TodayDisabledBackground: Windows.UI.Xaml.Media.Brush;
+    TodayHoverBackground: Windows.UI.Xaml.Media.Brush;
+    TodayPressedBackground: Windows.UI.Xaml.Media.Brush;
+    TodaySelectedInnerBorderBrush: Windows.UI.Xaml.Media.Brush;
+  }
+  var ICalendarView2: abstract new (...args: any[]) => ICalendarView2;
+
+  interface ICalendarViewDayItem {
+    SetDensityColors(colors: Windows.Foundation.Collections.IIterable<Windows.UI.Color> | Windows.UI.Color[]): void;
+    readonly Date: Windows.Foundation.DateTime;
+    IsBlackout: boolean;
+  }
+  var ICalendarViewDayItem: abstract new (...args: any[]) => ICalendarViewDayItem;
+
+  interface ICalendarViewDayItemChangingEventArgs {
+    RegisterUpdateCallback(callback: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.CalendarView, Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs>): void;
+    RegisterUpdateCallback(callbackPhase: number, callback: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.CalendarView, Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs>): void;
+    readonly InRecycleQueue: boolean;
+    readonly Item: Windows.UI.Xaml.Controls.CalendarViewDayItem;
+    readonly Phase: number;
+  }
+  var ICalendarViewDayItemChangingEventArgs: abstract new (...args: any[]) => ICalendarViewDayItemChangingEventArgs;
+
+  interface ICalendarViewDayItemFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.CalendarViewDayItem;
+  }
+  var ICalendarViewDayItemFactory: abstract new (...args: any[]) => ICalendarViewDayItemFactory;
+
+  interface ICalendarViewDayItemStatics {
+    readonly DateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsBlackoutProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ICalendarViewDayItemStatics: abstract new (...args: any[]) => ICalendarViewDayItemStatics;
+
+  interface ICalendarViewFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.CalendarView;
+  }
+  var ICalendarViewFactory: abstract new (...args: any[]) => ICalendarViewFactory;
+
+  interface ICalendarViewSelectedDatesChangedEventArgs {
+    readonly AddedDates: Windows.Foundation.Collections.IVectorView<Windows.Foundation.DateTime> | Windows.Foundation.DateTime[];
+    readonly RemovedDates: Windows.Foundation.Collections.IVectorView<Windows.Foundation.DateTime> | Windows.Foundation.DateTime[];
+  }
+  var ICalendarViewSelectedDatesChangedEventArgs: abstract new (...args: any[]) => ICalendarViewSelectedDatesChangedEventArgs;
+
+  interface ICalendarViewStatics {
+    readonly BlackoutForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CalendarIdentifierProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CalendarItemBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CalendarItemBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CalendarItemBorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CalendarItemForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CalendarViewDayItemStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DayItemFontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DayItemFontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DayItemFontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DayItemFontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DayOfWeekFormatProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DisplayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FirstDayOfWeekProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FirstOfMonthLabelFontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FirstOfMonthLabelFontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FirstOfMonthLabelFontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FirstOfMonthLabelFontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FirstOfYearDecadeLabelFontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FirstOfYearDecadeLabelFontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FirstOfYearDecadeLabelFontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FirstOfYearDecadeLabelFontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FocusBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalDayItemAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalFirstOfMonthLabelAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HoverBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsGroupLabelVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsOutOfScopeEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsTodayHighlightedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxDateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinDateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MonthYearItemFontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MonthYearItemFontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MonthYearItemFontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MonthYearItemFontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly NumberOfWeeksInViewProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OutOfScopeBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OutOfScopeForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PressedBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PressedForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedDatesProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedHoverBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedPressedBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TemplateSettingsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TodayFontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TodayForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalDayItemAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalFirstOfMonthLabelAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ICalendarViewStatics: abstract new (...args: any[]) => ICalendarViewStatics;
+
+  interface ICalendarViewStatics2 {
+    readonly BlackoutBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BlackoutStrikethroughBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CalendarItemCornerRadiusProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CalendarItemDisabledBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CalendarItemHoverBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CalendarItemPressedBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DayItemMarginProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DisabledForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FirstOfMonthLabelMarginProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FirstOfYearDecadeLabelMarginProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MonthYearItemMarginProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OutOfScopeHoverForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OutOfScopePressedForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedDisabledBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedDisabledForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedHoverForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedPressedForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TodayBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TodayBlackoutBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TodayBlackoutForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TodayDisabledBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TodayHoverBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TodayPressedBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TodaySelectedInnerBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ICalendarViewStatics2: abstract new (...args: any[]) => ICalendarViewStatics2;
+
+  interface ICandidateWindowBoundsChangedEventArgs {
+    readonly Bounds: Windows.Foundation.Rect;
+  }
+  var ICandidateWindowBoundsChangedEventArgs: abstract new (...args: any[]) => ICandidateWindowBoundsChangedEventArgs;
+
+  interface ICanvas {
+  }
+  var ICanvas: abstract new (...args: any[]) => ICanvas;
+
+  interface ICanvasFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Canvas;
+  }
+  var ICanvasFactory: abstract new (...args: any[]) => ICanvasFactory;
+
+  interface ICanvasStatics {
+    GetLeft(element: Windows.UI.Xaml.UIElement): number;
+    GetTop(element: Windows.UI.Xaml.UIElement): number;
+    GetZIndex(element: Windows.UI.Xaml.UIElement): number;
+    SetLeft(element: Windows.UI.Xaml.UIElement, length: number): void;
+    SetTop(element: Windows.UI.Xaml.UIElement, length: number): void;
+    SetZIndex(element: Windows.UI.Xaml.UIElement, value: number): void;
+    readonly LeftProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TopProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ZIndexProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ICanvasStatics: abstract new (...args: any[]) => ICanvasStatics;
+
+  interface ICaptureElement {
+    Source: Windows.Media.Capture.MediaCapture;
+    Stretch: number;
+  }
+  var ICaptureElement: abstract new (...args: any[]) => ICaptureElement;
+
+  interface ICaptureElementStatics {
+    readonly SourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StretchProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ICaptureElementStatics: abstract new (...args: any[]) => ICaptureElementStatics;
+
+  interface ICheckBox {
+  }
+  var ICheckBox: abstract new (...args: any[]) => ICheckBox;
+
+  interface ICheckBoxFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.CheckBox;
+  }
+  var ICheckBoxFactory: abstract new (...args: any[]) => ICheckBoxFactory;
+
+  interface IChoosingGroupHeaderContainerEventArgs {
+    readonly Group: Object;
+    GroupHeaderContainer: Windows.UI.Xaml.Controls.ListViewBaseHeaderItem;
+    readonly GroupIndex: number;
+  }
+  var IChoosingGroupHeaderContainerEventArgs: abstract new (...args: any[]) => IChoosingGroupHeaderContainerEventArgs;
+
+  interface IChoosingItemContainerEventArgs {
+    IsContainerPrepared: boolean;
+    readonly Item: Object;
+    ItemContainer: Windows.UI.Xaml.Controls.Primitives.SelectorItem;
+    readonly ItemIndex: number;
+  }
+  var IChoosingItemContainerEventArgs: abstract new (...args: any[]) => IChoosingItemContainerEventArgs;
+
+  interface ICleanUpVirtualizedItemEventArgs {
+    Cancel: boolean;
+    readonly UIElement: Windows.UI.Xaml.UIElement;
+    readonly Value: Object;
+  }
+  var ICleanUpVirtualizedItemEventArgs: abstract new (...args: any[]) => ICleanUpVirtualizedItemEventArgs;
+
+  interface IColorChangedEventArgs {
+    readonly NewColor: Windows.UI.Color;
+    readonly OldColor: Windows.UI.Color;
+  }
+  var IColorChangedEventArgs: abstract new (...args: any[]) => IColorChangedEventArgs;
+
+  interface IColorPicker {
+    Color: Windows.UI.Color;
+    ColorSpectrumComponents: number;
+    ColorSpectrumShape: number;
+    IsAlphaEnabled: boolean;
+    IsAlphaSliderVisible: boolean;
+    IsAlphaTextInputVisible: boolean;
+    IsColorChannelTextInputVisible: boolean;
+    IsColorPreviewVisible: boolean;
+    IsColorSliderVisible: boolean;
+    IsColorSpectrumVisible: boolean;
+    IsHexInputVisible: boolean;
+    IsMoreButtonVisible: boolean;
+    MaxHue: number;
+    MaxSaturation: number;
+    MaxValue: number;
+    MinHue: number;
+    MinSaturation: number;
+    MinValue: number;
+    PreviousColor: Windows.UI.Color | null;
+    ColorChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ColorPicker, Windows.UI.Xaml.Controls.ColorChangedEventArgs> | null;
+  }
+  var IColorPicker: abstract new (...args: any[]) => IColorPicker;
+
+  interface IColorPickerFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.ColorPicker;
+  }
+  var IColorPickerFactory: abstract new (...args: any[]) => IColorPickerFactory;
+
+  interface IColorPickerStatics {
+    readonly ColorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ColorSpectrumComponentsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ColorSpectrumShapeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsAlphaEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsAlphaSliderVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsAlphaTextInputVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsColorChannelTextInputVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsColorPreviewVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsColorSliderVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsColorSpectrumVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsHexInputVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsMoreButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxHueProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxSaturationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxValueProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinHueProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinSaturationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinValueProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PreviousColorProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IColorPickerStatics: abstract new (...args: any[]) => IColorPickerStatics;
+
+  interface IColumnDefinition {
+    readonly ActualWidth: number;
+    MaxWidth: number;
+    MinWidth: number;
+    Width: Windows.UI.Xaml.GridLength;
+  }
+  var IColumnDefinition: abstract new (...args: any[]) => IColumnDefinition;
+
+  interface IColumnDefinitionStatics {
+    readonly MaxWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly WidthProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IColumnDefinitionStatics: abstract new (...args: any[]) => IColumnDefinitionStatics;
+
+  interface IComboBox {
+    IsDropDownOpen: boolean;
+    readonly IsEditable: boolean;
+    readonly IsSelectionBoxHighlighted: boolean;
+    MaxDropDownHeight: number;
+    readonly SelectionBoxItem: Object;
+    readonly SelectionBoxItemTemplate: Windows.UI.Xaml.DataTemplate;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.ComboBoxTemplateSettings;
+    DropDownClosed: Windows.Foundation.EventHandler<Object> | null;
+    DropDownOpened: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IComboBox: abstract new (...args: any[]) => IComboBox;
+
+  interface IComboBox2 {
+    Header: Object;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    PlaceholderText: string;
+  }
+  var IComboBox2: abstract new (...args: any[]) => IComboBox2;
+
+  interface IComboBox3 {
+    IsTextSearchEnabled: boolean;
+    LightDismissOverlayMode: number;
+  }
+  var IComboBox3: abstract new (...args: any[]) => IComboBox3;
+
+  interface IComboBox4 {
+    SelectionChangedTrigger: number;
+  }
+  var IComboBox4: abstract new (...args: any[]) => IComboBox4;
+
+  interface IComboBox5 {
+    PlaceholderForeground: Windows.UI.Xaml.Media.Brush;
+  }
+  var IComboBox5: abstract new (...args: any[]) => IComboBox5;
+
+  interface IComboBox6 {
+    Description: Object;
+    IsEditable: Object;
+    Text: string;
+    TextBoxStyle: Windows.UI.Xaml.Style;
+    TextSubmitted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ComboBox, Windows.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs> | null;
+  }
+  var IComboBox6: abstract new (...args: any[]) => IComboBox6;
+
+  interface IComboBoxFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.ComboBox;
+  }
+  var IComboBoxFactory: abstract new (...args: any[]) => IComboBoxFactory;
+
+  interface IComboBoxItem {
+  }
+  var IComboBoxItem: abstract new (...args: any[]) => IComboBoxItem;
+
+  interface IComboBoxItemFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.ComboBoxItem;
+  }
+  var IComboBoxItemFactory: abstract new (...args: any[]) => IComboBoxItemFactory;
+
+  interface IComboBoxOverrides {
+    OnDropDownClosed(e: Object): void;
+    OnDropDownOpened(e: Object): void;
+  }
+  var IComboBoxOverrides: abstract new (...args: any[]) => IComboBoxOverrides;
+
+  interface IComboBoxStatics {
+    readonly IsDropDownOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxDropDownHeightProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IComboBoxStatics: abstract new (...args: any[]) => IComboBoxStatics;
+
+  interface IComboBoxStatics2 {
+    readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlaceholderTextProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IComboBoxStatics2: abstract new (...args: any[]) => IComboBoxStatics2;
+
+  interface IComboBoxStatics3 {
+    readonly IsTextSearchEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LightDismissOverlayModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IComboBoxStatics3: abstract new (...args: any[]) => IComboBoxStatics3;
+
+  interface IComboBoxStatics4 {
+    readonly SelectionChangedTriggerProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IComboBoxStatics4: abstract new (...args: any[]) => IComboBoxStatics4;
+
+  interface IComboBoxStatics5 {
+    readonly PlaceholderForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IComboBoxStatics5: abstract new (...args: any[]) => IComboBoxStatics5;
+
+  interface IComboBoxStatics6 {
+    readonly DescriptionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsEditableProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextBoxStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IComboBoxStatics6: abstract new (...args: any[]) => IComboBoxStatics6;
+
+  interface IComboBoxTextSubmittedEventArgs {
+    Handled: boolean;
+    readonly Text: string;
+  }
+  var IComboBoxTextSubmittedEventArgs: abstract new (...args: any[]) => IComboBoxTextSubmittedEventArgs;
+
+  interface ICommandBar {
+    readonly PrimaryCommands: Windows.Foundation.Collections.IObservableVector<Windows.UI.Xaml.Controls.ICommandBarElement>;
+    readonly SecondaryCommands: Windows.Foundation.Collections.IObservableVector<Windows.UI.Xaml.Controls.ICommandBarElement>;
+  }
+  var ICommandBar: abstract new (...args: any[]) => ICommandBar;
+
+  interface ICommandBar2 {
+    CommandBarOverflowPresenterStyle: Windows.UI.Xaml.Style;
+    readonly CommandBarTemplateSettings: Windows.UI.Xaml.Controls.Primitives.CommandBarTemplateSettings;
+  }
+  var ICommandBar2: abstract new (...args: any[]) => ICommandBar2;
+
+  interface ICommandBar3 {
+    DefaultLabelPosition: number;
+    IsDynamicOverflowEnabled: boolean;
+    OverflowButtonVisibility: number;
+    DynamicOverflowItemsChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.CommandBar, Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs> | null;
+  }
+  var ICommandBar3: abstract new (...args: any[]) => ICommandBar3;
+
+  interface ICommandBarElement {
+    IsCompact: boolean;
+  }
+  var ICommandBarElement: abstract new (...args: any[]) => ICommandBarElement;
+
+  interface ICommandBarElement2 {
+    DynamicOverflowOrder: number;
+    readonly IsInOverflow: boolean;
+  }
+  var ICommandBarElement2: abstract new (...args: any[]) => ICommandBarElement2;
+
+  interface ICommandBarFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.CommandBar;
+  }
+  var ICommandBarFactory: abstract new (...args: any[]) => ICommandBarFactory;
+
+  interface ICommandBarFlyout {
+    readonly PrimaryCommands: Windows.Foundation.Collections.IObservableVector<Windows.UI.Xaml.Controls.ICommandBarElement>;
+    readonly SecondaryCommands: Windows.Foundation.Collections.IObservableVector<Windows.UI.Xaml.Controls.ICommandBarElement>;
+  }
+  var ICommandBarFlyout: abstract new (...args: any[]) => ICommandBarFlyout;
+
+  interface ICommandBarFlyoutFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.CommandBarFlyout;
+  }
+  var ICommandBarFlyoutFactory: abstract new (...args: any[]) => ICommandBarFlyoutFactory;
+
+  interface ICommandBarOverflowPresenter {
+  }
+  var ICommandBarOverflowPresenter: abstract new (...args: any[]) => ICommandBarOverflowPresenter;
+
+  interface ICommandBarOverflowPresenterFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.CommandBarOverflowPresenter;
+  }
+  var ICommandBarOverflowPresenterFactory: abstract new (...args: any[]) => ICommandBarOverflowPresenterFactory;
+
+  interface ICommandBarStatics {
+    readonly PrimaryCommandsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SecondaryCommandsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ICommandBarStatics: abstract new (...args: any[]) => ICommandBarStatics;
+
+  interface ICommandBarStatics2 {
+    readonly CommandBarOverflowPresenterStyleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ICommandBarStatics2: abstract new (...args: any[]) => ICommandBarStatics2;
+
+  interface ICommandBarStatics3 {
+    readonly DefaultLabelPositionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsDynamicOverflowEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OverflowButtonVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ICommandBarStatics3: abstract new (...args: any[]) => ICommandBarStatics3;
+
+  interface IContainerContentChangingEventArgs {
+    RegisterUpdateCallback(callback: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ListViewBase, Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs>): void;
+    RegisterUpdateCallback(callbackPhase: number, callback: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ListViewBase, Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs>): void;
+    Handled: boolean;
+    readonly InRecycleQueue: boolean;
+    readonly Item: Object;
+    readonly ItemContainer: Windows.UI.Xaml.Controls.Primitives.SelectorItem;
+    readonly ItemIndex: number;
+    readonly Phase: number;
+  }
+  var IContainerContentChangingEventArgs: abstract new (...args: any[]) => IContainerContentChangingEventArgs;
+
+  interface IContentControl {
+    Content: Object;
+    ContentTemplate: Windows.UI.Xaml.DataTemplate;
+    ContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector;
+    ContentTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+  }
+  var IContentControl: abstract new (...args: any[]) => IContentControl;
+
+  interface IContentControl2 {
+    readonly ContentTemplateRoot: Windows.UI.Xaml.UIElement;
+  }
+  var IContentControl2: abstract new (...args: any[]) => IContentControl2;
+
+  interface IContentControlFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.ContentControl;
+  }
+  var IContentControlFactory: abstract new (...args: any[]) => IContentControlFactory;
+
+  interface IContentControlOverrides {
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+  }
+  var IContentControlOverrides: abstract new (...args: any[]) => IContentControlOverrides;
+
+  interface IContentControlStatics {
+    readonly ContentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentTemplateSelectorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IContentControlStatics: abstract new (...args: any[]) => IContentControlStatics;
+
+  interface IContentDialog {
+    Hide(): void;
+    ShowAsync(): Windows.Foundation.IAsyncOperation<number>;
+    FullSizeDesired: boolean;
+    IsPrimaryButtonEnabled: boolean;
+    IsSecondaryButtonEnabled: boolean;
+    PrimaryButtonCommand: Windows.UI.Xaml.Input.ICommand;
+    PrimaryButtonCommandParameter: Object;
+    PrimaryButtonText: string;
+    SecondaryButtonCommand: Windows.UI.Xaml.Input.ICommand;
+    SecondaryButtonCommandParameter: Object;
+    SecondaryButtonText: string;
+    Title: Object;
+    TitleTemplate: Windows.UI.Xaml.DataTemplate;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ContentDialog, Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs> | null;
+    Closing: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ContentDialog, Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs> | null;
+    Opened: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ContentDialog, Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs> | null;
+    PrimaryButtonClick: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ContentDialog, Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs> | null;
+    SecondaryButtonClick: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ContentDialog, Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs> | null;
+  }
+  var IContentDialog: abstract new (...args: any[]) => IContentDialog;
+
+  interface IContentDialog2 {
+    CloseButtonCommand: Windows.UI.Xaml.Input.ICommand;
+    CloseButtonCommandParameter: Object;
+    CloseButtonStyle: Windows.UI.Xaml.Style;
+    CloseButtonText: string;
+    DefaultButton: number;
+    PrimaryButtonStyle: Windows.UI.Xaml.Style;
+    SecondaryButtonStyle: Windows.UI.Xaml.Style;
+    CloseButtonClick: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ContentDialog, Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs> | null;
+  }
+  var IContentDialog2: abstract new (...args: any[]) => IContentDialog2;
+
+  interface IContentDialog3 {
+    ShowAsync(placement: number): Windows.Foundation.IAsyncOperation<number>;
+  }
+  var IContentDialog3: abstract new (...args: any[]) => IContentDialog3;
+
+  interface IContentDialogButtonClickDeferral {
+    Complete(): void;
+  }
+  var IContentDialogButtonClickDeferral: abstract new (...args: any[]) => IContentDialogButtonClickDeferral;
+
+  interface IContentDialogButtonClickEventArgs {
+    GetDeferral(): Windows.UI.Xaml.Controls.ContentDialogButtonClickDeferral;
+    Cancel: boolean;
+  }
+  var IContentDialogButtonClickEventArgs: abstract new (...args: any[]) => IContentDialogButtonClickEventArgs;
+
+  interface IContentDialogClosedEventArgs {
+    readonly Result: number;
+  }
+  var IContentDialogClosedEventArgs: abstract new (...args: any[]) => IContentDialogClosedEventArgs;
+
+  interface IContentDialogClosingDeferral {
+    Complete(): void;
+  }
+  var IContentDialogClosingDeferral: abstract new (...args: any[]) => IContentDialogClosingDeferral;
+
+  interface IContentDialogClosingEventArgs {
+    GetDeferral(): Windows.UI.Xaml.Controls.ContentDialogClosingDeferral;
+    Cancel: boolean;
+    readonly Result: number;
+  }
+  var IContentDialogClosingEventArgs: abstract new (...args: any[]) => IContentDialogClosingEventArgs;
+
+  interface IContentDialogFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.ContentDialog;
+  }
+  var IContentDialogFactory: abstract new (...args: any[]) => IContentDialogFactory;
+
+  interface IContentDialogOpenedEventArgs {
+  }
+  var IContentDialogOpenedEventArgs: abstract new (...args: any[]) => IContentDialogOpenedEventArgs;
+
+  interface IContentDialogStatics {
+    readonly FullSizeDesiredProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsPrimaryButtonEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsSecondaryButtonEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PrimaryButtonCommandParameterProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PrimaryButtonCommandProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PrimaryButtonTextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SecondaryButtonCommandParameterProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SecondaryButtonCommandProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SecondaryButtonTextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TitleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TitleTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IContentDialogStatics: abstract new (...args: any[]) => IContentDialogStatics;
+
+  interface IContentDialogStatics2 {
+    readonly CloseButtonCommandParameterProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CloseButtonCommandProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CloseButtonStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CloseButtonTextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DefaultButtonProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PrimaryButtonStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SecondaryButtonStyleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IContentDialogStatics2: abstract new (...args: any[]) => IContentDialogStatics2;
+
+  interface IContentLinkChangedEventArgs {
+    readonly ChangeKind: number;
+    readonly ContentLinkInfo: Windows.UI.Text.ContentLinkInfo;
+    readonly TextRange: Windows.UI.Xaml.Documents.TextRange;
+  }
+  var IContentLinkChangedEventArgs: abstract new (...args: any[]) => IContentLinkChangedEventArgs;
+
+  interface IContentPresenter {
+    CharacterSpacing: number;
+    Content: Object;
+    ContentTemplate: Windows.UI.Xaml.DataTemplate;
+    ContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector;
+    ContentTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    FontFamily: Windows.UI.Xaml.Media.FontFamily;
+    FontSize: number;
+    FontStretch: number;
+    FontStyle: number;
+    FontWeight: Windows.UI.Text.FontWeight;
+    Foreground: Windows.UI.Xaml.Media.Brush;
+  }
+  var IContentPresenter: abstract new (...args: any[]) => IContentPresenter;
+
+  interface IContentPresenter2 {
+    OpticalMarginAlignment: number;
+    TextLineBounds: number;
+  }
+  var IContentPresenter2: abstract new (...args: any[]) => IContentPresenter2;
+
+  interface IContentPresenter3 {
+    IsTextScaleFactorEnabled: boolean;
+  }
+  var IContentPresenter3: abstract new (...args: any[]) => IContentPresenter3;
+
+  interface IContentPresenter4 {
+    Background: Windows.UI.Xaml.Media.Brush;
+    BorderBrush: Windows.UI.Xaml.Media.Brush;
+    BorderThickness: Windows.UI.Xaml.Thickness;
+    CornerRadius: Windows.UI.Xaml.CornerRadius;
+    HorizontalContentAlignment: number;
+    LineHeight: number;
+    LineStackingStrategy: number;
+    MaxLines: number;
+    Padding: Windows.UI.Xaml.Thickness;
+    TextWrapping: number;
+    VerticalContentAlignment: number;
+  }
+  var IContentPresenter4: abstract new (...args: any[]) => IContentPresenter4;
+
+  interface IContentPresenter5 {
+    BackgroundSizing: number;
+    BackgroundTransition: Windows.UI.Xaml.BrushTransition;
+  }
+  var IContentPresenter5: abstract new (...args: any[]) => IContentPresenter5;
+
+  interface IContentPresenterFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.ContentPresenter;
+  }
+  var IContentPresenterFactory: abstract new (...args: any[]) => IContentPresenterFactory;
+
+  interface IContentPresenterOverrides {
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+  }
+  var IContentPresenterOverrides: abstract new (...args: any[]) => IContentPresenterOverrides;
+
+  interface IContentPresenterStatics {
+    readonly CharacterSpacingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentTemplateSelectorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontStretchProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IContentPresenterStatics: abstract new (...args: any[]) => IContentPresenterStatics;
+
+  interface IContentPresenterStatics2 {
+    readonly OpticalMarginAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextLineBoundsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IContentPresenterStatics2: abstract new (...args: any[]) => IContentPresenterStatics2;
+
+  interface IContentPresenterStatics3 {
+    readonly IsTextScaleFactorEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IContentPresenterStatics3: abstract new (...args: any[]) => IContentPresenterStatics3;
+
+  interface IContentPresenterStatics4 {
+    readonly BackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CornerRadiusProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalContentAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LineHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LineStackingStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxLinesProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextWrappingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalContentAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IContentPresenterStatics4: abstract new (...args: any[]) => IContentPresenterStatics4;
+
+  interface IContentPresenterStatics5 {
+    readonly BackgroundSizingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IContentPresenterStatics5: abstract new (...args: any[]) => IContentPresenterStatics5;
+
+  interface IContextMenuEventArgs {
+    readonly CursorLeft: number;
+    readonly CursorTop: number;
+    Handled: boolean;
+  }
+  var IContextMenuEventArgs: abstract new (...args: any[]) => IContextMenuEventArgs;
+
+  interface IControl {
+    ApplyTemplate(): boolean;
+    Focus(value: number): boolean;
+    Background: Windows.UI.Xaml.Media.Brush;
+    BorderBrush: Windows.UI.Xaml.Media.Brush;
+    BorderThickness: Windows.UI.Xaml.Thickness;
+    CharacterSpacing: number;
+    readonly FocusState: number;
+    FontFamily: Windows.UI.Xaml.Media.FontFamily;
+    FontSize: number;
+    FontStretch: number;
+    FontStyle: number;
+    FontWeight: Windows.UI.Text.FontWeight;
+    Foreground: Windows.UI.Xaml.Media.Brush;
+    HorizontalContentAlignment: number;
+    IsEnabled: boolean;
+    IsTabStop: boolean;
+    Padding: Windows.UI.Xaml.Thickness;
+    TabIndex: number;
+    TabNavigation: number;
+    Template: Windows.UI.Xaml.Controls.ControlTemplate;
+    VerticalContentAlignment: number;
+    IsEnabledChanged: Windows.UI.Xaml.DependencyPropertyChangedEventHandler | null;
+  }
+  var IControl: abstract new (...args: any[]) => IControl;
+
+  interface IControl2 {
+    IsTextScaleFactorEnabled: boolean;
+  }
+  var IControl2: abstract new (...args: any[]) => IControl2;
+
+  interface IControl3 {
+    UseSystemFocusVisuals: boolean;
+  }
+  var IControl3: abstract new (...args: any[]) => IControl3;
+
+  interface IControl4 {
+    RemoveFocusEngagement(): void;
+    ElementSoundMode: number;
+    IsFocusEngaged: boolean;
+    IsFocusEngagementEnabled: boolean;
+    RequiresPointer: number;
+    XYFocusDown: Windows.UI.Xaml.DependencyObject;
+    XYFocusLeft: Windows.UI.Xaml.DependencyObject;
+    XYFocusRight: Windows.UI.Xaml.DependencyObject;
+    XYFocusUp: Windows.UI.Xaml.DependencyObject;
+    FocusDisengaged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Control, Windows.UI.Xaml.Controls.FocusDisengagedEventArgs> | null;
+    FocusEngaged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Control, Windows.UI.Xaml.Controls.FocusEngagedEventArgs> | null;
+  }
+  var IControl4: abstract new (...args: any[]) => IControl4;
+
+  interface IControl5 {
+    DefaultStyleResourceUri: Windows.Foundation.Uri;
+  }
+  var IControl5: abstract new (...args: any[]) => IControl5;
+
+  interface IControl7 {
+    BackgroundSizing: number;
+    CornerRadius: Windows.UI.Xaml.CornerRadius;
+  }
+  var IControl7: abstract new (...args: any[]) => IControl7;
+
+  interface IControlFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Control;
+  }
+  var IControlFactory: abstract new (...args: any[]) => IControlFactory;
+
+  interface IControlOverrides {
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+  }
+  var IControlOverrides: abstract new (...args: any[]) => IControlOverrides;
+
+  interface IControlOverrides6 {
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+  }
+  var IControlOverrides6: abstract new (...args: any[]) => IControlOverrides6;
+
+  interface IControlProtected {
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    DefaultStyleKey: Object;
+  }
+  var IControlProtected: abstract new (...args: any[]) => IControlProtected;
+
+  interface IControlStatics {
+    readonly BackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CharacterSpacingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DefaultStyleKeyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FocusStateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontStretchProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalContentAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsTabStopProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TabIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TabNavigationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalContentAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IControlStatics: abstract new (...args: any[]) => IControlStatics;
+
+  interface IControlStatics2 {
+    readonly IsTextScaleFactorEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IControlStatics2: abstract new (...args: any[]) => IControlStatics2;
+
+  interface IControlStatics3 {
+    GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    readonly IsTemplateFocusTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly UseSystemFocusVisualsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IControlStatics3: abstract new (...args: any[]) => IControlStatics3;
+
+  interface IControlStatics4 {
+    readonly ElementSoundModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsFocusEngagedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsFocusEngagementEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RequiresPointerProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusDownProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusLeftProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusRightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusUpProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IControlStatics4: abstract new (...args: any[]) => IControlStatics4;
+
+  interface IControlStatics5 {
+    GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    readonly DefaultStyleResourceUriProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsTemplateKeyTipTargetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IControlStatics5: abstract new (...args: any[]) => IControlStatics5;
+
+  interface IControlStatics7 {
+    readonly BackgroundSizingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CornerRadiusProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IControlStatics7: abstract new (...args: any[]) => IControlStatics7;
+
+  interface IControlTemplate {
+    TargetType: Windows.UI.Xaml.Interop.TypeName;
+  }
+  var IControlTemplate: abstract new (...args: any[]) => IControlTemplate;
+
+  interface IDataTemplateSelector {
+    SelectTemplate(item: Object, container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DataTemplate;
+  }
+  var IDataTemplateSelector: abstract new (...args: any[]) => IDataTemplateSelector;
+
+  interface IDataTemplateSelector2 {
+    SelectTemplate(item: Object): Windows.UI.Xaml.DataTemplate;
+  }
+  var IDataTemplateSelector2: abstract new (...args: any[]) => IDataTemplateSelector2;
+
+  interface IDataTemplateSelectorFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.DataTemplateSelector;
+  }
+  var IDataTemplateSelectorFactory: abstract new (...args: any[]) => IDataTemplateSelectorFactory;
+
+  interface IDataTemplateSelectorOverrides {
+    SelectTemplateCore(item: Object, container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DataTemplate;
+  }
+  var IDataTemplateSelectorOverrides: abstract new (...args: any[]) => IDataTemplateSelectorOverrides;
+
+  interface IDataTemplateSelectorOverrides2 {
+    SelectTemplateCore(item: Object): Windows.UI.Xaml.DataTemplate;
+  }
+  var IDataTemplateSelectorOverrides2: abstract new (...args: any[]) => IDataTemplateSelectorOverrides2;
+
+  interface IDatePickedEventArgs {
+    readonly NewDate: Windows.Foundation.DateTime;
+    readonly OldDate: Windows.Foundation.DateTime;
+  }
+  var IDatePickedEventArgs: abstract new (...args: any[]) => IDatePickedEventArgs;
+
+  interface IDatePicker {
+    CalendarIdentifier: string;
+    Date: Windows.Foundation.DateTime;
+    DayFormat: string;
+    DayVisible: boolean;
+    Header: Object;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    MaxYear: Windows.Foundation.DateTime;
+    MinYear: Windows.Foundation.DateTime;
+    MonthFormat: string;
+    MonthVisible: boolean;
+    Orientation: number;
+    YearFormat: string;
+    YearVisible: boolean;
+    DateChanged: Windows.Foundation.EventHandler<Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs> | null;
+  }
+  var IDatePicker: abstract new (...args: any[]) => IDatePicker;
+
+  interface IDatePicker2 {
+    LightDismissOverlayMode: number;
+  }
+  var IDatePicker2: abstract new (...args: any[]) => IDatePicker2;
+
+  interface IDatePicker3 {
+    SelectedDate: Windows.Foundation.DateTime | null;
+    SelectedDateChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.DatePicker, Windows.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs> | null;
+  }
+  var IDatePicker3: abstract new (...args: any[]) => IDatePicker3;
+
+  interface IDatePickerFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.DatePicker;
+  }
+  var IDatePickerFactory: abstract new (...args: any[]) => IDatePickerFactory;
+
+  interface IDatePickerFlyout {
+    ShowAtAsync(target: Windows.UI.Xaml.FrameworkElement): Windows.Foundation.IAsyncOperation<Windows.Foundation.DateTime | null>;
+    CalendarIdentifier: string;
+    Date: Windows.Foundation.DateTime;
+    DayVisible: boolean;
+    MaxYear: Windows.Foundation.DateTime;
+    MinYear: Windows.Foundation.DateTime;
+    MonthVisible: boolean;
+    YearVisible: boolean;
+    DatePicked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.DatePickerFlyout, Windows.UI.Xaml.Controls.DatePickedEventArgs> | null;
+  }
+  var IDatePickerFlyout: abstract new (...args: any[]) => IDatePickerFlyout;
+
+  interface IDatePickerFlyout2 {
+    DayFormat: string;
+    MonthFormat: string;
+    YearFormat: string;
+  }
+  var IDatePickerFlyout2: abstract new (...args: any[]) => IDatePickerFlyout2;
+
+  interface IDatePickerFlyoutItem {
+    PrimaryText: string;
+    SecondaryText: string;
+  }
+  var IDatePickerFlyoutItem: abstract new (...args: any[]) => IDatePickerFlyoutItem;
+
+  interface IDatePickerFlyoutItemStatics {
+    readonly PrimaryTextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SecondaryTextProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IDatePickerFlyoutItemStatics: abstract new (...args: any[]) => IDatePickerFlyoutItemStatics;
+
+  interface IDatePickerFlyoutPresenter {
+  }
+  var IDatePickerFlyoutPresenter: abstract new (...args: any[]) => IDatePickerFlyoutPresenter;
+
+  interface IDatePickerFlyoutPresenter2 {
+    IsDefaultShadowEnabled: boolean;
+  }
+  var IDatePickerFlyoutPresenter2: abstract new (...args: any[]) => IDatePickerFlyoutPresenter2;
+
+  interface IDatePickerFlyoutPresenterStatics2 {
+    readonly IsDefaultShadowEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IDatePickerFlyoutPresenterStatics2: abstract new (...args: any[]) => IDatePickerFlyoutPresenterStatics2;
+
+  interface IDatePickerFlyoutStatics {
+    readonly CalendarIdentifierProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DayVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxYearProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinYearProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MonthVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly YearVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IDatePickerFlyoutStatics: abstract new (...args: any[]) => IDatePickerFlyoutStatics;
+
+  interface IDatePickerFlyoutStatics2 {
+    readonly DayFormatProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MonthFormatProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly YearFormatProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IDatePickerFlyoutStatics2: abstract new (...args: any[]) => IDatePickerFlyoutStatics2;
+
+  interface IDatePickerSelectedValueChangedEventArgs {
+    readonly NewDate: Windows.Foundation.DateTime | null;
+    readonly OldDate: Windows.Foundation.DateTime | null;
+  }
+  var IDatePickerSelectedValueChangedEventArgs: abstract new (...args: any[]) => IDatePickerSelectedValueChangedEventArgs;
+
+  interface IDatePickerStatics {
+    readonly CalendarIdentifierProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DayFormatProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DayVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxYearProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinYearProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MonthFormatProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MonthVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly YearFormatProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly YearVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IDatePickerStatics: abstract new (...args: any[]) => IDatePickerStatics;
+
+  interface IDatePickerStatics2 {
+    readonly LightDismissOverlayModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IDatePickerStatics2: abstract new (...args: any[]) => IDatePickerStatics2;
+
+  interface IDatePickerStatics3 {
+    readonly SelectedDateProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IDatePickerStatics3: abstract new (...args: any[]) => IDatePickerStatics3;
+
+  interface IDatePickerValueChangedEventArgs {
+    readonly NewDate: Windows.Foundation.DateTime;
+    readonly OldDate: Windows.Foundation.DateTime;
+  }
+  var IDatePickerValueChangedEventArgs: abstract new (...args: any[]) => IDatePickerValueChangedEventArgs;
+
+  interface IDragItemsCompletedEventArgs {
+    readonly DropResult: number;
+    readonly Items: Windows.Foundation.Collections.IVectorView<Object> | Object[];
+  }
+  var IDragItemsCompletedEventArgs: abstract new (...args: any[]) => IDragItemsCompletedEventArgs;
+
+  interface IDragItemsStartingEventArgs {
+    Cancel: boolean;
+    readonly Data: Windows.ApplicationModel.DataTransfer.DataPackage;
+    readonly Items: Windows.Foundation.Collections.IVector<Object> | Object[];
+  }
+  var IDragItemsStartingEventArgs: abstract new (...args: any[]) => IDragItemsStartingEventArgs;
+
+  interface IDropDownButton {
+  }
+  var IDropDownButton: abstract new (...args: any[]) => IDropDownButton;
+
+  interface IDropDownButtonAutomationPeer {
+  }
+  var IDropDownButtonAutomationPeer: abstract new (...args: any[]) => IDropDownButtonAutomationPeer;
+
+  interface IDropDownButtonAutomationPeerFactory {
+    CreateInstance(owner: Windows.UI.Xaml.Controls.DropDownButton, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.DropDownButtonAutomationPeer;
+  }
+  var IDropDownButtonAutomationPeerFactory: abstract new (...args: any[]) => IDropDownButtonAutomationPeerFactory;
+
+  interface IDropDownButtonFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.DropDownButton;
+  }
+  var IDropDownButtonFactory: abstract new (...args: any[]) => IDropDownButtonFactory;
+
+  interface IDynamicOverflowItemsChangingEventArgs {
+    readonly Action: number;
+  }
+  var IDynamicOverflowItemsChangingEventArgs: abstract new (...args: any[]) => IDynamicOverflowItemsChangingEventArgs;
+
+  interface IFlipView {
+  }
+  var IFlipView: abstract new (...args: any[]) => IFlipView;
+
+  interface IFlipView2 {
+    UseTouchAnimationsForAllNavigation: boolean;
+  }
+  var IFlipView2: abstract new (...args: any[]) => IFlipView2;
+
+  interface IFlipViewFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.FlipView;
+  }
+  var IFlipViewFactory: abstract new (...args: any[]) => IFlipViewFactory;
+
+  interface IFlipViewItem {
+  }
+  var IFlipViewItem: abstract new (...args: any[]) => IFlipViewItem;
+
+  interface IFlipViewItemFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.FlipViewItem;
+  }
+  var IFlipViewItemFactory: abstract new (...args: any[]) => IFlipViewItemFactory;
+
+  interface IFlipViewStatics2 {
+    readonly UseTouchAnimationsForAllNavigationProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFlipViewStatics2: abstract new (...args: any[]) => IFlipViewStatics2;
+
+  interface IFlyout {
+    Content: Windows.UI.Xaml.UIElement;
+    FlyoutPresenterStyle: Windows.UI.Xaml.Style;
+  }
+  var IFlyout: abstract new (...args: any[]) => IFlyout;
+
+  interface IFlyoutFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Flyout;
+  }
+  var IFlyoutFactory: abstract new (...args: any[]) => IFlyoutFactory;
+
+  interface IFlyoutPresenter {
+  }
+  var IFlyoutPresenter: abstract new (...args: any[]) => IFlyoutPresenter;
+
+  interface IFlyoutPresenter2 {
+    IsDefaultShadowEnabled: boolean;
+  }
+  var IFlyoutPresenter2: abstract new (...args: any[]) => IFlyoutPresenter2;
+
+  interface IFlyoutPresenterFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.FlyoutPresenter;
+  }
+  var IFlyoutPresenterFactory: abstract new (...args: any[]) => IFlyoutPresenterFactory;
+
+  interface IFlyoutPresenterStatics2 {
+    readonly IsDefaultShadowEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFlyoutPresenterStatics2: abstract new (...args: any[]) => IFlyoutPresenterStatics2;
+
+  interface IFlyoutStatics {
+    readonly ContentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FlyoutPresenterStyleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFlyoutStatics: abstract new (...args: any[]) => IFlyoutStatics;
+
+  interface IFocusDisengagedEventArgs {
+  }
+  var IFocusDisengagedEventArgs: abstract new (...args: any[]) => IFocusDisengagedEventArgs;
+
+  interface IFocusEngagedEventArgs {
+  }
+  var IFocusEngagedEventArgs: abstract new (...args: any[]) => IFocusEngagedEventArgs;
+
+  interface IFocusEngagedEventArgs2 {
+    Handled: boolean;
+  }
+  var IFocusEngagedEventArgs2: abstract new (...args: any[]) => IFocusEngagedEventArgs2;
+
+  interface IFontIcon {
+    FontFamily: Windows.UI.Xaml.Media.FontFamily;
+    FontSize: number;
+    FontStyle: number;
+    FontWeight: Windows.UI.Text.FontWeight;
+    Glyph: string;
+  }
+  var IFontIcon: abstract new (...args: any[]) => IFontIcon;
+
+  interface IFontIcon2 {
+    IsTextScaleFactorEnabled: boolean;
+  }
+  var IFontIcon2: abstract new (...args: any[]) => IFontIcon2;
+
+  interface IFontIcon3 {
+    MirroredWhenRightToLeft: boolean;
+  }
+  var IFontIcon3: abstract new (...args: any[]) => IFontIcon3;
+
+  interface IFontIconFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.FontIcon;
+  }
+  var IFontIconFactory: abstract new (...args: any[]) => IFontIconFactory;
+
+  interface IFontIconSource {
+    FontFamily: Windows.UI.Xaml.Media.FontFamily;
+    FontSize: number;
+    FontStyle: number;
+    FontWeight: Windows.UI.Text.FontWeight;
+    Glyph: string;
+    IsTextScaleFactorEnabled: boolean;
+    MirroredWhenRightToLeft: boolean;
+  }
+  var IFontIconSource: abstract new (...args: any[]) => IFontIconSource;
+
+  interface IFontIconSourceFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.FontIconSource;
+  }
+  var IFontIconSourceFactory: abstract new (...args: any[]) => IFontIconSourceFactory;
+
+  interface IFontIconSourceStatics {
+    readonly FontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GlyphProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsTextScaleFactorEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MirroredWhenRightToLeftProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFontIconSourceStatics: abstract new (...args: any[]) => IFontIconSourceStatics;
+
+  interface IFontIconStatics {
+    readonly FontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GlyphProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFontIconStatics: abstract new (...args: any[]) => IFontIconStatics;
+
+  interface IFontIconStatics2 {
+    readonly IsTextScaleFactorEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFontIconStatics2: abstract new (...args: any[]) => IFontIconStatics2;
+
+  interface IFontIconStatics3 {
+    readonly MirroredWhenRightToLeftProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFontIconStatics3: abstract new (...args: any[]) => IFontIconStatics3;
+
+  interface IFrame {
+    GetNavigationState(): string;
+    GoBack(): void;
+    GoForward(): void;
+    Navigate(sourcePageType: Windows.UI.Xaml.Interop.TypeName, parameter: Object): boolean;
+    SetNavigationState(navigationState: string): void;
+    readonly BackStackDepth: number;
+    CacheSize: number;
+    readonly CanGoBack: boolean;
+    readonly CanGoForward: boolean;
+    readonly CurrentSourcePageType: Windows.UI.Xaml.Interop.TypeName;
+    SourcePageType: Windows.UI.Xaml.Interop.TypeName;
+    Navigated: Windows.UI.Xaml.Navigation.NavigatedEventHandler | null;
+    Navigating: Windows.UI.Xaml.Navigation.NavigatingCancelEventHandler | null;
+    NavigationFailed: Windows.UI.Xaml.Navigation.NavigationFailedEventHandler | null;
+    NavigationStopped: Windows.UI.Xaml.Navigation.NavigationStoppedEventHandler | null;
+  }
+  var IFrame: abstract new (...args: any[]) => IFrame;
+
+  interface IFrame2 {
+    Navigate(sourcePageType: Windows.UI.Xaml.Interop.TypeName, parameter: Object, infoOverride: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo): boolean;
+    readonly BackStack: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Navigation.PageStackEntry> | Windows.UI.Xaml.Navigation.PageStackEntry[];
+    readonly ForwardStack: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Navigation.PageStackEntry> | Windows.UI.Xaml.Navigation.PageStackEntry[];
+  }
+  var IFrame2: abstract new (...args: any[]) => IFrame2;
+
+  interface IFrame3 {
+    GoBack(transitionInfoOverride: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo): void;
+  }
+  var IFrame3: abstract new (...args: any[]) => IFrame3;
+
+  interface IFrame4 {
+    SetNavigationState(navigationState: string, suppressNavigate: boolean): void;
+  }
+  var IFrame4: abstract new (...args: any[]) => IFrame4;
+
+  interface IFrame5 {
+    NavigateToType(sourcePageType: Windows.UI.Xaml.Interop.TypeName, parameter: Object, navigationOptions: Windows.UI.Xaml.Navigation.FrameNavigationOptions): boolean;
+    IsNavigationStackEnabled: boolean;
+  }
+  var IFrame5: abstract new (...args: any[]) => IFrame5;
+
+  interface IFrameFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Frame;
+  }
+  var IFrameFactory: abstract new (...args: any[]) => IFrameFactory;
+
+  interface IFrameStatics {
+    readonly BackStackDepthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CacheSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanGoBackProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanGoForwardProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CurrentSourcePageTypeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SourcePageTypeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFrameStatics: abstract new (...args: any[]) => IFrameStatics;
+
+  interface IFrameStatics2 {
+    readonly BackStackProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ForwardStackProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFrameStatics2: abstract new (...args: any[]) => IFrameStatics2;
+
+  interface IFrameStatics5 {
+    readonly IsNavigationStackEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFrameStatics5: abstract new (...args: any[]) => IFrameStatics5;
+
+  interface IGrid {
+    readonly ColumnDefinitions: Windows.UI.Xaml.Controls.ColumnDefinitionCollection;
+    readonly RowDefinitions: Windows.UI.Xaml.Controls.RowDefinitionCollection;
+  }
+  var IGrid: abstract new (...args: any[]) => IGrid;
+
+  interface IGrid2 {
+    BorderBrush: Windows.UI.Xaml.Media.Brush;
+    BorderThickness: Windows.UI.Xaml.Thickness;
+    CornerRadius: Windows.UI.Xaml.CornerRadius;
+    Padding: Windows.UI.Xaml.Thickness;
+  }
+  var IGrid2: abstract new (...args: any[]) => IGrid2;
+
+  interface IGrid3 {
+    ColumnSpacing: number;
+    RowSpacing: number;
+  }
+  var IGrid3: abstract new (...args: any[]) => IGrid3;
+
+  interface IGrid4 {
+    BackgroundSizing: number;
+  }
+  var IGrid4: abstract new (...args: any[]) => IGrid4;
+
+  interface IGridFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Grid;
+  }
+  var IGridFactory: abstract new (...args: any[]) => IGridFactory;
+
+  interface IGridStatics {
+    GetColumn(element: Windows.UI.Xaml.FrameworkElement): number;
+    GetColumnSpan(element: Windows.UI.Xaml.FrameworkElement): number;
+    GetRow(element: Windows.UI.Xaml.FrameworkElement): number;
+    GetRowSpan(element: Windows.UI.Xaml.FrameworkElement): number;
+    SetColumn(element: Windows.UI.Xaml.FrameworkElement, value: number): void;
+    SetColumnSpan(element: Windows.UI.Xaml.FrameworkElement, value: number): void;
+    SetRow(element: Windows.UI.Xaml.FrameworkElement, value: number): void;
+    SetRowSpan(element: Windows.UI.Xaml.FrameworkElement, value: number): void;
+    readonly ColumnProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ColumnSpanProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RowProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RowSpanProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IGridStatics: abstract new (...args: any[]) => IGridStatics;
+
+  interface IGridStatics2 {
+    readonly BorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CornerRadiusProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IGridStatics2: abstract new (...args: any[]) => IGridStatics2;
+
+  interface IGridStatics3 {
+    readonly ColumnSpacingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RowSpacingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IGridStatics3: abstract new (...args: any[]) => IGridStatics3;
+
+  interface IGridStatics4 {
+    readonly BackgroundSizingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IGridStatics4: abstract new (...args: any[]) => IGridStatics4;
+
+  interface IGridView {
+  }
+  var IGridView: abstract new (...args: any[]) => IGridView;
+
+  interface IGridViewFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.GridView;
+  }
+  var IGridViewFactory: abstract new (...args: any[]) => IGridViewFactory;
+
+  interface IGridViewHeaderItem {
+  }
+  var IGridViewHeaderItem: abstract new (...args: any[]) => IGridViewHeaderItem;
+
+  interface IGridViewHeaderItemFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.GridViewHeaderItem;
+  }
+  var IGridViewHeaderItemFactory: abstract new (...args: any[]) => IGridViewHeaderItemFactory;
+
+  interface IGridViewItem {
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.GridViewItemTemplateSettings;
+  }
+  var IGridViewItem: abstract new (...args: any[]) => IGridViewItem;
+
+  interface IGridViewItemFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.GridViewItem;
+  }
+  var IGridViewItemFactory: abstract new (...args: any[]) => IGridViewItemFactory;
+
+  interface IGroupItem {
+  }
+  var IGroupItem: abstract new (...args: any[]) => IGroupItem;
+
+  interface IGroupItemFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.GroupItem;
+  }
+  var IGroupItemFactory: abstract new (...args: any[]) => IGroupItemFactory;
+
+  interface IGroupStyle {
+    ContainerStyle: Windows.UI.Xaml.Style;
+    ContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    HeaderTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector;
+    HidesIfEmpty: boolean;
+    Panel: Windows.UI.Xaml.Controls.ItemsPanelTemplate;
+  }
+  var IGroupStyle: abstract new (...args: any[]) => IGroupStyle;
+
+  interface IGroupStyle2 {
+    HeaderContainerStyle: Windows.UI.Xaml.Style;
+  }
+  var IGroupStyle2: abstract new (...args: any[]) => IGroupStyle2;
+
+  interface IGroupStyleFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.GroupStyle;
+  }
+  var IGroupStyleFactory: abstract new (...args: any[]) => IGroupStyleFactory;
+
+  interface IGroupStyleSelector {
+    SelectGroupStyle(group: Object, level: number): Windows.UI.Xaml.Controls.GroupStyle;
+  }
+  var IGroupStyleSelector: abstract new (...args: any[]) => IGroupStyleSelector;
+
+  interface IGroupStyleSelectorFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.GroupStyleSelector;
+  }
+  var IGroupStyleSelectorFactory: abstract new (...args: any[]) => IGroupStyleSelectorFactory;
+
+  interface IGroupStyleSelectorOverrides {
+    SelectGroupStyleCore(group: Object, level: number): Windows.UI.Xaml.Controls.GroupStyle;
+  }
+  var IGroupStyleSelectorOverrides: abstract new (...args: any[]) => IGroupStyleSelectorOverrides;
+
+  interface IHandwritingPanelClosedEventArgs {
+  }
+  var IHandwritingPanelClosedEventArgs: abstract new (...args: any[]) => IHandwritingPanelClosedEventArgs;
+
+  interface IHandwritingPanelOpenedEventArgs {
+  }
+  var IHandwritingPanelOpenedEventArgs: abstract new (...args: any[]) => IHandwritingPanelOpenedEventArgs;
+
+  interface IHandwritingView {
+    TryClose(): boolean;
+    TryOpen(): boolean;
+    AreCandidatesEnabled: boolean;
+    readonly IsOpen: boolean;
+    PlacementAlignment: number;
+    PlacementTarget: Windows.UI.Xaml.UIElement;
+    Closed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.HandwritingView, Windows.UI.Xaml.Controls.HandwritingPanelClosedEventArgs> | null;
+    Opened: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.HandwritingView, Windows.UI.Xaml.Controls.HandwritingPanelOpenedEventArgs> | null;
+  }
+  var IHandwritingView: abstract new (...args: any[]) => IHandwritingView;
+
+  interface IHandwritingView2 {
+    GetCandidates(candidatesSessionId: number): Windows.Foundation.Collections.IVectorView<string> | string[];
+    SelectCandidate(candidatesSessionId: number, selectedCandidateIndex: number): void;
+    InputDeviceTypes: number;
+    IsCommandBarOpen: boolean;
+    IsSwitchToKeyboardEnabled: boolean;
+    CandidatesChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.HandwritingView, Windows.UI.Xaml.Controls.HandwritingViewCandidatesChangedEventArgs> | null;
+    TextSubmitted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.HandwritingView, Windows.UI.Xaml.Controls.HandwritingViewTextSubmittedEventArgs> | null;
+  }
+  var IHandwritingView2: abstract new (...args: any[]) => IHandwritingView2;
+
+  interface IHandwritingViewCandidatesChangedEventArgs {
+    readonly CandidatesSessionId: number;
+  }
+  var IHandwritingViewCandidatesChangedEventArgs: abstract new (...args: any[]) => IHandwritingViewCandidatesChangedEventArgs;
+
+  interface IHandwritingViewFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.HandwritingView;
+  }
+  var IHandwritingViewFactory: abstract new (...args: any[]) => IHandwritingViewFactory;
+
+  interface IHandwritingViewStatics {
+    readonly AreCandidatesEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlacementAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlacementTargetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IHandwritingViewStatics: abstract new (...args: any[]) => IHandwritingViewStatics;
+
+  interface IHandwritingViewStatics2 {
+    readonly IsCommandBarOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsSwitchToKeyboardEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IHandwritingViewStatics2: abstract new (...args: any[]) => IHandwritingViewStatics2;
+
+  interface IHandwritingViewTextSubmittedEventArgs {
+  }
+  var IHandwritingViewTextSubmittedEventArgs: abstract new (...args: any[]) => IHandwritingViewTextSubmittedEventArgs;
+
+  interface IHub {
+    ScrollToSection(section: Windows.UI.Xaml.Controls.HubSection): void;
+    DefaultSectionIndex: number;
+    Header: Object;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    Orientation: number;
+    readonly SectionHeaders: Windows.Foundation.Collections.IObservableVector<Object>;
+    readonly Sections: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.HubSection> | Windows.UI.Xaml.Controls.HubSection[];
+    readonly SectionsInView: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.HubSection> | Windows.UI.Xaml.Controls.HubSection[];
+    SectionHeaderClick: Windows.UI.Xaml.Controls.HubSectionHeaderClickEventHandler | null;
+    SectionsInViewChanged: Windows.UI.Xaml.Controls.SectionsInViewChangedEventHandler | null;
+  }
+  var IHub: abstract new (...args: any[]) => IHub;
+
+  interface IHubFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Hub;
+  }
+  var IHubFactory: abstract new (...args: any[]) => IHubFactory;
+
+  interface IHubSection {
+    ContentTemplate: Windows.UI.Xaml.DataTemplate;
+    Header: Object;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    IsHeaderInteractive: boolean;
+  }
+  var IHubSection: abstract new (...args: any[]) => IHubSection;
+
+  interface IHubSectionFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.HubSection;
+  }
+  var IHubSectionFactory: abstract new (...args: any[]) => IHubSectionFactory;
+
+  interface IHubSectionHeaderClickEventArgs {
+    readonly Section: Windows.UI.Xaml.Controls.HubSection;
+  }
+  var IHubSectionHeaderClickEventArgs: abstract new (...args: any[]) => IHubSectionHeaderClickEventArgs;
+
+  interface IHubSectionStatics {
+    readonly ContentTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsHeaderInteractiveProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IHubSectionStatics: abstract new (...args: any[]) => IHubSectionStatics;
+
+  interface IHubStatics {
+    readonly DefaultSectionIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsActiveViewProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsZoomedInViewProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SemanticZoomOwnerProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IHubStatics: abstract new (...args: any[]) => IHubStatics;
+
+  interface IHyperlinkButton {
+    NavigateUri: Windows.Foundation.Uri;
+  }
+  var IHyperlinkButton: abstract new (...args: any[]) => IHyperlinkButton;
+
+  interface IHyperlinkButtonFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.HyperlinkButton;
+  }
+  var IHyperlinkButtonFactory: abstract new (...args: any[]) => IHyperlinkButtonFactory;
+
+  interface IHyperlinkButtonStatics {
+    readonly NavigateUriProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IHyperlinkButtonStatics: abstract new (...args: any[]) => IHyperlinkButtonStatics;
+
+  interface IIconElement {
+    Foreground: Windows.UI.Xaml.Media.Brush;
+  }
+  var IIconElement: abstract new (...args: any[]) => IIconElement;
+
+  interface IIconElementFactory {
+  }
+  var IIconElementFactory: abstract new (...args: any[]) => IIconElementFactory;
+
+  interface IIconElementStatics {
+    readonly ForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IIconElementStatics: abstract new (...args: any[]) => IIconElementStatics;
+
+  interface IIconSource {
+    Foreground: Windows.UI.Xaml.Media.Brush;
+  }
+  var IIconSource: abstract new (...args: any[]) => IIconSource;
+
+  interface IIconSourceElement {
+    IconSource: Windows.UI.Xaml.Controls.IconSource;
+  }
+  var IIconSourceElement: abstract new (...args: any[]) => IIconSourceElement;
+
+  interface IIconSourceElementFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.IconSourceElement;
+  }
+  var IIconSourceElementFactory: abstract new (...args: any[]) => IIconSourceElementFactory;
+
+  interface IIconSourceElementStatics {
+    readonly IconSourceProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IIconSourceElementStatics: abstract new (...args: any[]) => IIconSourceElementStatics;
+
+  interface IIconSourceFactory {
+  }
+  var IIconSourceFactory: abstract new (...args: any[]) => IIconSourceFactory;
+
+  interface IIconSourceStatics {
+    readonly ForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IIconSourceStatics: abstract new (...args: any[]) => IIconSourceStatics;
+
+  interface IImage {
+    NineGrid: Windows.UI.Xaml.Thickness;
+    readonly PlayToSource: Windows.Media.PlayTo.PlayToSource;
+    Source: Windows.UI.Xaml.Media.ImageSource;
+    Stretch: number;
+    ImageFailed: Windows.UI.Xaml.ExceptionRoutedEventHandler | null;
+    ImageOpened: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+  var IImage: abstract new (...args: any[]) => IImage;
+
+  interface IImage2 {
+    GetAsCastingSource(): Windows.Media.Casting.CastingSource;
+  }
+  var IImage2: abstract new (...args: any[]) => IImage2;
+
+  interface IImage3 {
+    GetAlphaMask(): Windows.UI.Composition.CompositionBrush;
+  }
+  var IImage3: abstract new (...args: any[]) => IImage3;
+
+  interface IImageStatics {
+    readonly NineGridProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlayToSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StretchProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IImageStatics: abstract new (...args: any[]) => IImageStatics;
+
+  interface IInkCanvas {
+    readonly InkPresenter: Windows.UI.Input.Inking.InkPresenter;
+  }
+  var IInkCanvas: abstract new (...args: any[]) => IInkCanvas;
+
+  interface IInkCanvasFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.InkCanvas;
+  }
+  var IInkCanvasFactory: abstract new (...args: any[]) => IInkCanvasFactory;
+
+  interface IInkToolbar {
+    GetToggleButton(tool: number): Windows.UI.Xaml.Controls.InkToolbarToggleButton;
+    GetToolButton(tool: number): Windows.UI.Xaml.Controls.InkToolbarToolButton;
+    ActiveTool: Windows.UI.Xaml.Controls.InkToolbarToolButton;
+    readonly Children: Windows.UI.Xaml.DependencyObjectCollection;
+    InitialControls: number;
+    readonly InkDrawingAttributes: Windows.UI.Input.Inking.InkDrawingAttributes;
+    IsRulerButtonChecked: boolean;
+    TargetInkCanvas: Windows.UI.Xaml.Controls.InkCanvas;
+    ActiveToolChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.InkToolbar, Object> | null;
+    EraseAllClicked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.InkToolbar, Object> | null;
+    InkDrawingAttributesChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.InkToolbar, Object> | null;
+    IsRulerButtonCheckedChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.InkToolbar, Object> | null;
+  }
+  var IInkToolbar: abstract new (...args: any[]) => IInkToolbar;
+
+  interface IInkToolbar2 {
+    GetMenuButton(menu: number): Windows.UI.Xaml.Controls.InkToolbarMenuButton;
+    ButtonFlyoutPlacement: number;
+    IsStencilButtonChecked: boolean;
+    Orientation: number;
+    IsStencilButtonCheckedChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.InkToolbar, Windows.UI.Xaml.Controls.InkToolbarIsStencilButtonCheckedChangedEventArgs> | null;
+  }
+  var IInkToolbar2: abstract new (...args: any[]) => IInkToolbar2;
+
+  interface IInkToolbar3 {
+    TargetInkPresenter: Windows.UI.Input.Inking.InkPresenter;
+  }
+  var IInkToolbar3: abstract new (...args: any[]) => IInkToolbar3;
+
+  interface IInkToolbarBallpointPenButton {
+  }
+  var IInkToolbarBallpointPenButton: abstract new (...args: any[]) => IInkToolbarBallpointPenButton;
+
+  interface IInkToolbarBallpointPenButtonFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.InkToolbarBallpointPenButton;
+  }
+  var IInkToolbarBallpointPenButtonFactory: abstract new (...args: any[]) => IInkToolbarBallpointPenButtonFactory;
+
+  interface IInkToolbarCustomPen {
+    CreateInkDrawingAttributes(brush: Windows.UI.Xaml.Media.Brush, strokeWidth: number): Windows.UI.Input.Inking.InkDrawingAttributes;
+  }
+  var IInkToolbarCustomPen: abstract new (...args: any[]) => IInkToolbarCustomPen;
+
+  interface IInkToolbarCustomPenButton {
+    ConfigurationContent: Windows.UI.Xaml.UIElement;
+    CustomPen: Windows.UI.Xaml.Controls.InkToolbarCustomPen;
+  }
+  var IInkToolbarCustomPenButton: abstract new (...args: any[]) => IInkToolbarCustomPenButton;
+
+  interface IInkToolbarCustomPenButtonFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.InkToolbarCustomPenButton;
+  }
+  var IInkToolbarCustomPenButtonFactory: abstract new (...args: any[]) => IInkToolbarCustomPenButtonFactory;
+
+  interface IInkToolbarCustomPenButtonStatics {
+    readonly ConfigurationContentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CustomPenProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IInkToolbarCustomPenButtonStatics: abstract new (...args: any[]) => IInkToolbarCustomPenButtonStatics;
+
+  interface IInkToolbarCustomPenFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.InkToolbarCustomPen;
+  }
+  var IInkToolbarCustomPenFactory: abstract new (...args: any[]) => IInkToolbarCustomPenFactory;
+
+  interface IInkToolbarCustomPenOverrides {
+    CreateInkDrawingAttributesCore(brush: Windows.UI.Xaml.Media.Brush, strokeWidth: number): Windows.UI.Input.Inking.InkDrawingAttributes;
+  }
+  var IInkToolbarCustomPenOverrides: abstract new (...args: any[]) => IInkToolbarCustomPenOverrides;
+
+  interface IInkToolbarCustomToggleButton {
+  }
+  var IInkToolbarCustomToggleButton: abstract new (...args: any[]) => IInkToolbarCustomToggleButton;
+
+  interface IInkToolbarCustomToggleButtonFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.InkToolbarCustomToggleButton;
+  }
+  var IInkToolbarCustomToggleButtonFactory: abstract new (...args: any[]) => IInkToolbarCustomToggleButtonFactory;
+
+  interface IInkToolbarCustomToolButton {
+    ConfigurationContent: Windows.UI.Xaml.UIElement;
+  }
+  var IInkToolbarCustomToolButton: abstract new (...args: any[]) => IInkToolbarCustomToolButton;
+
+  interface IInkToolbarCustomToolButtonFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.InkToolbarCustomToolButton;
+  }
+  var IInkToolbarCustomToolButtonFactory: abstract new (...args: any[]) => IInkToolbarCustomToolButtonFactory;
+
+  interface IInkToolbarCustomToolButtonStatics {
+    readonly ConfigurationContentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IInkToolbarCustomToolButtonStatics: abstract new (...args: any[]) => IInkToolbarCustomToolButtonStatics;
+
+  interface IInkToolbarEraserButton {
+  }
+  var IInkToolbarEraserButton: abstract new (...args: any[]) => IInkToolbarEraserButton;
+
+  interface IInkToolbarEraserButton2 {
+    IsClearAllVisible: boolean;
+  }
+  var IInkToolbarEraserButton2: abstract new (...args: any[]) => IInkToolbarEraserButton2;
+
+  interface IInkToolbarEraserButtonFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.InkToolbarEraserButton;
+  }
+  var IInkToolbarEraserButtonFactory: abstract new (...args: any[]) => IInkToolbarEraserButtonFactory;
+
+  interface IInkToolbarEraserButtonStatics2 {
+    readonly IsClearAllVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IInkToolbarEraserButtonStatics2: abstract new (...args: any[]) => IInkToolbarEraserButtonStatics2;
+
+  interface IInkToolbarFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.InkToolbar;
+  }
+  var IInkToolbarFactory: abstract new (...args: any[]) => IInkToolbarFactory;
+
+  interface IInkToolbarFlyoutItem {
+    IsChecked: boolean;
+    Kind: number;
+    Checked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.InkToolbarFlyoutItem, Object> | null;
+    Unchecked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.InkToolbarFlyoutItem, Object> | null;
+  }
+  var IInkToolbarFlyoutItem: abstract new (...args: any[]) => IInkToolbarFlyoutItem;
+
+  interface IInkToolbarFlyoutItemFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.InkToolbarFlyoutItem;
+  }
+  var IInkToolbarFlyoutItemFactory: abstract new (...args: any[]) => IInkToolbarFlyoutItemFactory;
+
+  interface IInkToolbarFlyoutItemStatics {
+    readonly IsCheckedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly KindProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IInkToolbarFlyoutItemStatics: abstract new (...args: any[]) => IInkToolbarFlyoutItemStatics;
+
+  interface IInkToolbarHighlighterButton {
+  }
+  var IInkToolbarHighlighterButton: abstract new (...args: any[]) => IInkToolbarHighlighterButton;
+
+  interface IInkToolbarHighlighterButtonFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.InkToolbarHighlighterButton;
+  }
+  var IInkToolbarHighlighterButtonFactory: abstract new (...args: any[]) => IInkToolbarHighlighterButtonFactory;
+
+  interface IInkToolbarIsStencilButtonCheckedChangedEventArgs {
+    readonly StencilButton: Windows.UI.Xaml.Controls.InkToolbarStencilButton;
+    readonly StencilKind: number;
+  }
+  var IInkToolbarIsStencilButtonCheckedChangedEventArgs: abstract new (...args: any[]) => IInkToolbarIsStencilButtonCheckedChangedEventArgs;
+
+  interface IInkToolbarMenuButton {
+    IsExtensionGlyphShown: boolean;
+    readonly MenuKind: number;
+  }
+  var IInkToolbarMenuButton: abstract new (...args: any[]) => IInkToolbarMenuButton;
+
+  interface IInkToolbarMenuButtonFactory {
+  }
+  var IInkToolbarMenuButtonFactory: abstract new (...args: any[]) => IInkToolbarMenuButtonFactory;
+
+  interface IInkToolbarMenuButtonStatics {
+    readonly IsExtensionGlyphShownProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IInkToolbarMenuButtonStatics: abstract new (...args: any[]) => IInkToolbarMenuButtonStatics;
+
+  interface IInkToolbarPenButton {
+    MaxStrokeWidth: number;
+    MinStrokeWidth: number;
+    Palette: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Media.Brush> | Windows.UI.Xaml.Media.Brush[];
+    readonly SelectedBrush: Windows.UI.Xaml.Media.Brush;
+    SelectedBrushIndex: number;
+    SelectedStrokeWidth: number;
+  }
+  var IInkToolbarPenButton: abstract new (...args: any[]) => IInkToolbarPenButton;
+
+  interface IInkToolbarPenButtonFactory {
+  }
+  var IInkToolbarPenButtonFactory: abstract new (...args: any[]) => IInkToolbarPenButtonFactory;
+
+  interface IInkToolbarPenButtonStatics {
+    readonly MaxStrokeWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinStrokeWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaletteProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedBrushIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedStrokeWidthProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IInkToolbarPenButtonStatics: abstract new (...args: any[]) => IInkToolbarPenButtonStatics;
+
+  interface IInkToolbarPenConfigurationControl {
+    readonly PenButton: Windows.UI.Xaml.Controls.InkToolbarPenButton;
+  }
+  var IInkToolbarPenConfigurationControl: abstract new (...args: any[]) => IInkToolbarPenConfigurationControl;
+
+  interface IInkToolbarPenConfigurationControlFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.InkToolbarPenConfigurationControl;
+  }
+  var IInkToolbarPenConfigurationControlFactory: abstract new (...args: any[]) => IInkToolbarPenConfigurationControlFactory;
+
+  interface IInkToolbarPenConfigurationControlStatics {
+    readonly PenButtonProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IInkToolbarPenConfigurationControlStatics: abstract new (...args: any[]) => IInkToolbarPenConfigurationControlStatics;
+
+  interface IInkToolbarPencilButton {
+  }
+  var IInkToolbarPencilButton: abstract new (...args: any[]) => IInkToolbarPencilButton;
+
+  interface IInkToolbarPencilButtonFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.InkToolbarPencilButton;
+  }
+  var IInkToolbarPencilButtonFactory: abstract new (...args: any[]) => IInkToolbarPencilButtonFactory;
+
+  interface IInkToolbarRulerButton {
+    readonly Ruler: Windows.UI.Input.Inking.InkPresenterRuler;
+  }
+  var IInkToolbarRulerButton: abstract new (...args: any[]) => IInkToolbarRulerButton;
+
+  interface IInkToolbarRulerButtonFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.InkToolbarRulerButton;
+  }
+  var IInkToolbarRulerButtonFactory: abstract new (...args: any[]) => IInkToolbarRulerButtonFactory;
+
+  interface IInkToolbarRulerButtonStatics {
+    readonly RulerProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IInkToolbarRulerButtonStatics: abstract new (...args: any[]) => IInkToolbarRulerButtonStatics;
+
+  interface IInkToolbarStatics {
+    readonly ActiveToolProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ChildrenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly InitialControlsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly InkDrawingAttributesProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsRulerButtonCheckedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TargetInkCanvasProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IInkToolbarStatics: abstract new (...args: any[]) => IInkToolbarStatics;
+
+  interface IInkToolbarStatics2 {
+    readonly ButtonFlyoutPlacementProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsStencilButtonCheckedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IInkToolbarStatics2: abstract new (...args: any[]) => IInkToolbarStatics2;
+
+  interface IInkToolbarStatics3 {
+    readonly TargetInkPresenterProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IInkToolbarStatics3: abstract new (...args: any[]) => IInkToolbarStatics3;
+
+  interface IInkToolbarStencilButton {
+    IsProtractorItemVisible: boolean;
+    IsRulerItemVisible: boolean;
+    readonly Protractor: Windows.UI.Input.Inking.InkPresenterProtractor;
+    readonly Ruler: Windows.UI.Input.Inking.InkPresenterRuler;
+    SelectedStencil: number;
+  }
+  var IInkToolbarStencilButton: abstract new (...args: any[]) => IInkToolbarStencilButton;
+
+  interface IInkToolbarStencilButtonFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.InkToolbarStencilButton;
+  }
+  var IInkToolbarStencilButtonFactory: abstract new (...args: any[]) => IInkToolbarStencilButtonFactory;
+
+  interface IInkToolbarStencilButtonStatics {
+    readonly IsProtractorItemVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsRulerItemVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ProtractorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RulerProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedStencilProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IInkToolbarStencilButtonStatics: abstract new (...args: any[]) => IInkToolbarStencilButtonStatics;
+
+  interface IInkToolbarToggleButton {
+    readonly ToggleKind: number;
+  }
+  var IInkToolbarToggleButton: abstract new (...args: any[]) => IInkToolbarToggleButton;
+
+  interface IInkToolbarToggleButtonFactory {
+  }
+  var IInkToolbarToggleButtonFactory: abstract new (...args: any[]) => IInkToolbarToggleButtonFactory;
+
+  interface IInkToolbarToolButton {
+    IsExtensionGlyphShown: boolean;
+    readonly ToolKind: number;
+  }
+  var IInkToolbarToolButton: abstract new (...args: any[]) => IInkToolbarToolButton;
+
+  interface IInkToolbarToolButtonFactory {
+  }
+  var IInkToolbarToolButtonFactory: abstract new (...args: any[]) => IInkToolbarToolButtonFactory;
+
+  interface IInkToolbarToolButtonStatics {
+    readonly IsExtensionGlyphShownProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IInkToolbarToolButtonStatics: abstract new (...args: any[]) => IInkToolbarToolButtonStatics;
+
+  interface IInsertionPanel {
+    GetInsertionIndexes(position: Windows.Foundation.Point, first: number, second: number): void;
+  }
+  var IInsertionPanel: abstract new (...args: any[]) => IInsertionPanel;
+
+  interface IIsTextTrimmedChangedEventArgs {
+  }
+  var IIsTextTrimmedChangedEventArgs: abstract new (...args: any[]) => IIsTextTrimmedChangedEventArgs;
+
+  interface IItemClickEventArgs {
+    readonly ClickedItem: Object;
+  }
+  var IItemClickEventArgs: abstract new (...args: any[]) => IItemClickEventArgs;
+
+  interface IItemContainerGenerator {
+    ContainerFromIndex(index: number): Windows.UI.Xaml.DependencyObject;
+    ContainerFromItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    GenerateNext(isNewlyRealized: boolean): Windows.UI.Xaml.DependencyObject;
+    GeneratorPositionFromIndex(itemIndex: number): Windows.UI.Xaml.Controls.Primitives.GeneratorPosition;
+    GetItemContainerGeneratorForPanel(panel: Windows.UI.Xaml.Controls.Panel): Windows.UI.Xaml.Controls.ItemContainerGenerator;
+    IndexFromContainer(container: Windows.UI.Xaml.DependencyObject): number;
+    IndexFromGeneratorPosition(position: Windows.UI.Xaml.Controls.Primitives.GeneratorPosition): number;
+    ItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    PrepareItemContainer(container: Windows.UI.Xaml.DependencyObject): void;
+    Recycle(position: Windows.UI.Xaml.Controls.Primitives.GeneratorPosition, count: number): void;
+    Remove(position: Windows.UI.Xaml.Controls.Primitives.GeneratorPosition, count: number): void;
+    RemoveAll(): void;
+    StartAt(position: Windows.UI.Xaml.Controls.Primitives.GeneratorPosition, direction: number, allowStartAtRealizedItem: boolean): void;
+    Stop(): void;
+    ItemsChanged: Windows.UI.Xaml.Controls.Primitives.ItemsChangedEventHandler | null;
+  }
+  var IItemContainerGenerator: abstract new (...args: any[]) => IItemContainerGenerator;
+
+  interface IItemContainerMapping {
+    ContainerFromIndex(index: number): Windows.UI.Xaml.DependencyObject;
+    ContainerFromItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    IndexFromContainer(container: Windows.UI.Xaml.DependencyObject): number;
+    ItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+  }
+  var IItemContainerMapping: abstract new (...args: any[]) => IItemContainerMapping;
+
+  interface IItemsControl {
+    DisplayMemberPath: string;
+    readonly GroupStyle: Windows.Foundation.Collections.IObservableVector<Windows.UI.Xaml.Controls.GroupStyle>;
+    GroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector;
+    readonly IsGrouping: boolean;
+    readonly ItemContainerGenerator: Windows.UI.Xaml.Controls.ItemContainerGenerator;
+    ItemContainerStyle: Windows.UI.Xaml.Style;
+    ItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector;
+    ItemContainerTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    ItemTemplate: Windows.UI.Xaml.DataTemplate;
+    ItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector;
+    readonly Items: Windows.UI.Xaml.Controls.ItemCollection;
+    ItemsPanel: Windows.UI.Xaml.Controls.ItemsPanelTemplate;
+    ItemsSource: Object;
+  }
+  var IItemsControl: abstract new (...args: any[]) => IItemsControl;
+
+  interface IItemsControl2 {
+    readonly ItemsPanelRoot: Windows.UI.Xaml.Controls.Panel;
+  }
+  var IItemsControl2: abstract new (...args: any[]) => IItemsControl2;
+
+  interface IItemsControl3 {
+    GroupHeaderContainerFromItemContainer(itemContainer: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+  }
+  var IItemsControl3: abstract new (...args: any[]) => IItemsControl3;
+
+  interface IItemsControlFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.ItemsControl;
+  }
+  var IItemsControlFactory: abstract new (...args: any[]) => IItemsControlFactory;
+
+  interface IItemsControlOverrides {
+    ClearContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    GetContainerForItemOverride(): Windows.UI.Xaml.DependencyObject;
+    IsItemItsOwnContainerOverride(item: Object): boolean;
+    OnGroupStyleSelectorChanged(oldGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector, newGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector): void;
+    OnItemContainerStyleChanged(oldItemContainerStyle: Windows.UI.Xaml.Style, newItemContainerStyle: Windows.UI.Xaml.Style): void;
+    OnItemContainerStyleSelectorChanged(oldItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector, newItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector): void;
+    OnItemTemplateChanged(oldItemTemplate: Windows.UI.Xaml.DataTemplate, newItemTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnItemTemplateSelectorChanged(oldItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnItemsChanged(e: Object): void;
+    PrepareContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+  }
+  var IItemsControlOverrides: abstract new (...args: any[]) => IItemsControlOverrides;
+
+  interface IItemsControlStatics {
+    GetItemsOwner(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    ItemsControlFromItemContainer(container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    readonly DisplayMemberPathProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GroupStyleSelectorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsGroupingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemContainerStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemContainerStyleSelectorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemContainerTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemTemplateSelectorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemsPanelProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemsSourceProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IItemsControlStatics: abstract new (...args: any[]) => IItemsControlStatics;
+
+  interface IItemsPanelTemplate {
+  }
+  var IItemsPanelTemplate: abstract new (...args: any[]) => IItemsPanelTemplate;
+
+  interface IItemsPickedEventArgs {
+    readonly AddedItems: Windows.Foundation.Collections.IVector<Object> | Object[];
+    readonly RemovedItems: Windows.Foundation.Collections.IVector<Object> | Object[];
+  }
+  var IItemsPickedEventArgs: abstract new (...args: any[]) => IItemsPickedEventArgs;
+
+  interface IItemsPresenter {
+    Header: Object;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    HeaderTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    Padding: Windows.UI.Xaml.Thickness;
+  }
+  var IItemsPresenter: abstract new (...args: any[]) => IItemsPresenter;
+
+  interface IItemsPresenter2 {
+    Footer: Object;
+    FooterTemplate: Windows.UI.Xaml.DataTemplate;
+    FooterTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+  }
+  var IItemsPresenter2: abstract new (...args: any[]) => IItemsPresenter2;
+
+  interface IItemsPresenterStatics {
+    readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IItemsPresenterStatics: abstract new (...args: any[]) => IItemsPresenterStatics;
+
+  interface IItemsPresenterStatics2 {
+    readonly FooterProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FooterTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FooterTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IItemsPresenterStatics2: abstract new (...args: any[]) => IItemsPresenterStatics2;
+
+  interface IItemsStackPanel {
+    CacheLength: number;
+    readonly FirstCacheIndex: number;
+    readonly FirstVisibleIndex: number;
+    GroupHeaderPlacement: number;
+    GroupPadding: Windows.UI.Xaml.Thickness;
+    ItemsUpdatingScrollMode: number;
+    readonly LastCacheIndex: number;
+    readonly LastVisibleIndex: number;
+    Orientation: number;
+    readonly ScrollingDirection: number;
+  }
+  var IItemsStackPanel: abstract new (...args: any[]) => IItemsStackPanel;
+
+  interface IItemsStackPanel2 {
+    AreStickyGroupHeadersEnabled: boolean;
+  }
+  var IItemsStackPanel2: abstract new (...args: any[]) => IItemsStackPanel2;
+
+  interface IItemsStackPanelStatics {
+    readonly CacheLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GroupHeaderPlacementProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GroupPaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IItemsStackPanelStatics: abstract new (...args: any[]) => IItemsStackPanelStatics;
+
+  interface IItemsStackPanelStatics2 {
+    readonly AreStickyGroupHeadersEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IItemsStackPanelStatics2: abstract new (...args: any[]) => IItemsStackPanelStatics2;
+
+  interface IItemsWrapGrid {
+    CacheLength: number;
+    readonly FirstCacheIndex: number;
+    readonly FirstVisibleIndex: number;
+    GroupHeaderPlacement: number;
+    GroupPadding: Windows.UI.Xaml.Thickness;
+    ItemHeight: number;
+    ItemWidth: number;
+    readonly LastCacheIndex: number;
+    readonly LastVisibleIndex: number;
+    MaximumRowsOrColumns: number;
+    Orientation: number;
+    readonly ScrollingDirection: number;
+  }
+  var IItemsWrapGrid: abstract new (...args: any[]) => IItemsWrapGrid;
+
+  interface IItemsWrapGrid2 {
+    AreStickyGroupHeadersEnabled: boolean;
+  }
+  var IItemsWrapGrid2: abstract new (...args: any[]) => IItemsWrapGrid2;
+
+  interface IItemsWrapGridStatics {
+    readonly CacheLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GroupHeaderPlacementProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GroupPaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaximumRowsOrColumnsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IItemsWrapGridStatics: abstract new (...args: any[]) => IItemsWrapGridStatics;
+
+  interface IItemsWrapGridStatics2 {
+    readonly AreStickyGroupHeadersEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IItemsWrapGridStatics2: abstract new (...args: any[]) => IItemsWrapGridStatics2;
+
+  interface IListBox {
+    ScrollIntoView(item: Object): void;
+    SelectAll(): void;
+    readonly SelectedItems: Windows.Foundation.Collections.IVector<Object> | Object[];
+    SelectionMode: number;
+  }
+  var IListBox: abstract new (...args: any[]) => IListBox;
+
+  interface IListBox2 {
+    SingleSelectionFollowsFocus: boolean;
+  }
+  var IListBox2: abstract new (...args: any[]) => IListBox2;
+
+  interface IListBoxFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.ListBox;
+  }
+  var IListBoxFactory: abstract new (...args: any[]) => IListBoxFactory;
+
+  interface IListBoxItem {
+  }
+  var IListBoxItem: abstract new (...args: any[]) => IListBoxItem;
+
+  interface IListBoxItemFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.ListBoxItem;
+  }
+  var IListBoxItemFactory: abstract new (...args: any[]) => IListBoxItemFactory;
+
+  interface IListBoxStatics {
+    readonly SelectionModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IListBoxStatics: abstract new (...args: any[]) => IListBoxStatics;
+
+  interface IListBoxStatics2 {
+    readonly SingleSelectionFollowsFocusProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IListBoxStatics2: abstract new (...args: any[]) => IListBoxStatics2;
+
+  interface IListPickerFlyout {
+    ShowAtAsync(target: Windows.UI.Xaml.FrameworkElement): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Object> | Object[]>;
+    DisplayMemberPath: string;
+    ItemTemplate: Windows.UI.Xaml.DataTemplate;
+    ItemsSource: Object;
+    SelectedIndex: number;
+    SelectedItem: Object;
+    readonly SelectedItems: Windows.Foundation.Collections.IVector<Object> | Object[];
+    SelectedValue: Object;
+    SelectedValuePath: string;
+    SelectionMode: number;
+    ItemsPicked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ListPickerFlyout, Windows.UI.Xaml.Controls.ItemsPickedEventArgs> | null;
+  }
+  var IListPickerFlyout: abstract new (...args: any[]) => IListPickerFlyout;
+
+  interface IListPickerFlyoutPresenter {
+  }
+  var IListPickerFlyoutPresenter: abstract new (...args: any[]) => IListPickerFlyoutPresenter;
+
+  interface IListPickerFlyoutStatics {
+    readonly DisplayMemberPathProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemsSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedItemProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedValuePathProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedValueProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IListPickerFlyoutStatics: abstract new (...args: any[]) => IListPickerFlyoutStatics;
+
+  interface IListView {
+  }
+  var IListView: abstract new (...args: any[]) => IListView;
+
+  interface IListViewBase {
+    LoadMoreItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Data.LoadMoreItemsResult>;
+    ScrollIntoView(item: Object): void;
+    ScrollIntoView(item: Object, alignment: number): void;
+    SelectAll(): void;
+    CanDragItems: boolean;
+    CanReorderItems: boolean;
+    DataFetchSize: number;
+    Header: Object;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    HeaderTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    IncrementalLoadingThreshold: number;
+    IncrementalLoadingTrigger: number;
+    IsItemClickEnabled: boolean;
+    IsSwipeEnabled: boolean;
+    readonly SelectedItems: Windows.Foundation.Collections.IVector<Object> | Object[];
+    SelectionMode: number;
+    DragItemsStarting: Windows.UI.Xaml.Controls.DragItemsStartingEventHandler | null;
+    ItemClick: Windows.UI.Xaml.Controls.ItemClickEventHandler | null;
+  }
+  var IListViewBase: abstract new (...args: any[]) => IListViewBase;
+
+  interface IListViewBase2 {
+    SetDesiredContainerUpdateDuration(duration: Windows.Foundation.TimeSpan): void;
+    Footer: Object;
+    FooterTemplate: Windows.UI.Xaml.DataTemplate;
+    FooterTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    ShowsScrollingPlaceholders: boolean;
+    ContainerContentChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ListViewBase, Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs> | null;
+  }
+  var IListViewBase2: abstract new (...args: any[]) => IListViewBase2;
+
+  interface IListViewBase3 {
+    ReorderMode: number;
+  }
+  var IListViewBase3: abstract new (...args: any[]) => IListViewBase3;
+
+  interface IListViewBase4 {
+    DeselectRange(itemIndexRange: Windows.UI.Xaml.Data.ItemIndexRange): void;
+    SelectRange(itemIndexRange: Windows.UI.Xaml.Data.ItemIndexRange): void;
+    IsMultiSelectCheckBoxEnabled: boolean;
+    readonly SelectedRanges: Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Data.ItemIndexRange> | Windows.UI.Xaml.Data.ItemIndexRange[];
+    ChoosingGroupHeaderContainer: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ListViewBase, Windows.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs> | null;
+    ChoosingItemContainer: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ListViewBase, Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs> | null;
+    DragItemsCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ListViewBase, Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs> | null;
+  }
+  var IListViewBase4: abstract new (...args: any[]) => IListViewBase4;
+
+  interface IListViewBase5 {
+    IsDragSource(): boolean;
+    SingleSelectionFollowsFocus: boolean;
+  }
+  var IListViewBase5: abstract new (...args: any[]) => IListViewBase5;
+
+  interface IListViewBase6 {
+    PrepareConnectedAnimation(key: string, item: Object, elementName: string): Windows.UI.Xaml.Media.Animation.ConnectedAnimation;
+    TryStartConnectedAnimationAsync(animation: Windows.UI.Xaml.Media.Animation.ConnectedAnimation, item: Object, elementName: string): Windows.Foundation.IAsyncOperation<boolean>;
+  }
+  var IListViewBase6: abstract new (...args: any[]) => IListViewBase6;
+
+  interface IListViewBaseFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.ListViewBase;
+  }
+  var IListViewBaseFactory: abstract new (...args: any[]) => IListViewBaseFactory;
+
+  interface IListViewBaseHeaderItem {
+  }
+  var IListViewBaseHeaderItem: abstract new (...args: any[]) => IListViewBaseHeaderItem;
+
+  interface IListViewBaseHeaderItemFactory {
+  }
+  var IListViewBaseHeaderItemFactory: abstract new (...args: any[]) => IListViewBaseHeaderItemFactory;
+
+  interface IListViewBaseStatics {
+    readonly CanDragItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanReorderItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DataFetchSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IncrementalLoadingThresholdProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IncrementalLoadingTriggerProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsActiveViewProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsItemClickEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsSwipeEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsZoomedInViewProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SemanticZoomOwnerProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IListViewBaseStatics: abstract new (...args: any[]) => IListViewBaseStatics;
+
+  interface IListViewBaseStatics2 {
+    readonly FooterProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FooterTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FooterTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ShowsScrollingPlaceholdersProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IListViewBaseStatics2: abstract new (...args: any[]) => IListViewBaseStatics2;
+
+  interface IListViewBaseStatics3 {
+    readonly ReorderModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IListViewBaseStatics3: abstract new (...args: any[]) => IListViewBaseStatics3;
+
+  interface IListViewBaseStatics4 {
+    readonly IsMultiSelectCheckBoxEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IListViewBaseStatics4: abstract new (...args: any[]) => IListViewBaseStatics4;
+
+  interface IListViewBaseStatics5 {
+    readonly SingleSelectionFollowsFocusProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IListViewBaseStatics5: abstract new (...args: any[]) => IListViewBaseStatics5;
+
+  interface IListViewFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.ListView;
+  }
+  var IListViewFactory: abstract new (...args: any[]) => IListViewFactory;
+
+  interface IListViewHeaderItem {
+  }
+  var IListViewHeaderItem: abstract new (...args: any[]) => IListViewHeaderItem;
+
+  interface IListViewHeaderItemFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.ListViewHeaderItem;
+  }
+  var IListViewHeaderItemFactory: abstract new (...args: any[]) => IListViewHeaderItemFactory;
+
+  interface IListViewItem {
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.ListViewItemTemplateSettings;
+  }
+  var IListViewItem: abstract new (...args: any[]) => IListViewItem;
+
+  interface IListViewItemFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.ListViewItem;
+  }
+  var IListViewItemFactory: abstract new (...args: any[]) => IListViewItemFactory;
+
+  interface IListViewPersistenceHelper {
+  }
+  var IListViewPersistenceHelper: abstract new (...args: any[]) => IListViewPersistenceHelper;
+
+  interface IListViewPersistenceHelperStatics {
+    GetRelativeScrollPosition(listViewBase: Windows.UI.Xaml.Controls.ListViewBase, itemToKeyHandler: Windows.UI.Xaml.Controls.ListViewItemToKeyHandler): string;
+    SetRelativeScrollPositionAsync(listViewBase: Windows.UI.Xaml.Controls.ListViewBase, relativeScrollPosition: string, keyToItemHandler: Windows.UI.Xaml.Controls.ListViewKeyToItemHandler): Windows.Foundation.IAsyncAction;
+  }
+  var IListViewPersistenceHelperStatics: abstract new (...args: any[]) => IListViewPersistenceHelperStatics;
+
+  interface IMediaElement {
+    AddAudioEffect(effectID: string, effectOptional: boolean, effectConfiguration: Windows.Foundation.Collections.IPropertySet): void;
+    AddVideoEffect(effectID: string, effectOptional: boolean, effectConfiguration: Windows.Foundation.Collections.IPropertySet): void;
+    CanPlayType(type: string): number;
+    GetAudioStreamLanguage(index: number | null): string;
+    Pause(): void;
+    Play(): void;
+    RemoveAllEffects(): void;
+    SetSource(stream: Windows.Storage.Streams.IRandomAccessStream, mimeType: string): void;
+    Stop(): void;
+    readonly ActualStereo3DVideoPackingMode: number;
+    readonly AspectRatioHeight: number;
+    readonly AspectRatioWidth: number;
+    AudioCategory: number;
+    AudioDeviceType: number;
+    readonly AudioStreamCount: number;
+    AudioStreamIndex: number | null;
+    AutoPlay: boolean;
+    Balance: number;
+    readonly BufferingProgress: number;
+    readonly CanPause: boolean;
+    readonly CanSeek: boolean;
+    readonly CurrentState: number;
+    DefaultPlaybackRate: number;
+    readonly DownloadProgress: number;
+    readonly DownloadProgressOffset: number;
+    readonly IsAudioOnly: boolean;
+    IsLooping: boolean;
+    IsMuted: boolean;
+    readonly IsStereo3DVideo: boolean;
+    readonly Markers: Windows.UI.Xaml.Media.TimelineMarkerCollection;
+    readonly NaturalDuration: Windows.UI.Xaml.Duration;
+    readonly NaturalVideoHeight: number;
+    readonly NaturalVideoWidth: number;
+    readonly PlayToSource: Windows.Media.PlayTo.PlayToSource;
+    PlaybackRate: number;
+    Position: Windows.Foundation.TimeSpan;
+    PosterSource: Windows.UI.Xaml.Media.ImageSource;
+    ProtectionManager: Windows.Media.Protection.MediaProtectionManager;
+    RealTimePlayback: boolean;
+    Source: Windows.Foundation.Uri;
+    Stereo3DVideoPackingMode: number;
+    Stereo3DVideoRenderMode: number;
+    Volume: number;
+    BufferingProgressChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+    CurrentStateChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+    DownloadProgressChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+    MarkerReached: Windows.UI.Xaml.Media.TimelineMarkerRoutedEventHandler | null;
+    MediaEnded: Windows.UI.Xaml.RoutedEventHandler | null;
+    MediaFailed: Windows.UI.Xaml.ExceptionRoutedEventHandler | null;
+    MediaOpened: Windows.UI.Xaml.RoutedEventHandler | null;
+    RateChanged: Windows.UI.Xaml.Media.RateChangedRoutedEventHandler | null;
+    SeekCompleted: Windows.UI.Xaml.RoutedEventHandler | null;
+    VolumeChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+  var IMediaElement: abstract new (...args: any[]) => IMediaElement;
+
+  interface IMediaElement2 {
+    SetMediaStreamSource(source: Windows.Media.Core.IMediaSource): void;
+    AreTransportControlsEnabled: boolean;
+    IsFullWindow: boolean;
+    PlayToPreferredSourceUri: Windows.Foundation.Uri;
+    Stretch: number;
+  }
+  var IMediaElement2: abstract new (...args: any[]) => IMediaElement2;
+
+  interface IMediaElement3 {
+    GetAsCastingSource(): Windows.Media.Casting.CastingSource;
+    SetPlaybackSource(source: Windows.Media.Playback.IMediaPlaybackSource): void;
+    TransportControls: Windows.UI.Xaml.Controls.MediaTransportControls;
+    PartialMediaFailureDetected: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.MediaElement, Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs> | null;
+  }
+  var IMediaElement3: abstract new (...args: any[]) => IMediaElement3;
+
+  interface IMediaElementStatics {
+    readonly ActualStereo3DVideoPackingModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AspectRatioHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AspectRatioWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AudioCategoryProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AudioDeviceTypeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AudioStreamCountProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AudioStreamIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AutoPlayProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BalanceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BufferingProgressProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanPauseProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanSeekProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CurrentStateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DefaultPlaybackRateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DownloadProgressOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DownloadProgressProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsAudioOnlyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsLoopingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsMutedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsStereo3DVideoProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly NaturalDurationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly NaturalVideoHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly NaturalVideoWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlayToSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlaybackRateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PositionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PosterSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ProtectionManagerProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RealTimePlaybackProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Stereo3DVideoPackingModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Stereo3DVideoRenderModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VolumeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMediaElementStatics: abstract new (...args: any[]) => IMediaElementStatics;
+
+  interface IMediaElementStatics2 {
+    readonly AreTransportControlsEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsFullWindowProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlayToPreferredSourceUriProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StretchProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMediaElementStatics2: abstract new (...args: any[]) => IMediaElementStatics2;
+
+  interface IMediaPlayerElement {
+    SetMediaPlayer(mediaPlayer: Windows.Media.Playback.MediaPlayer): void;
+    AreTransportControlsEnabled: boolean;
+    AutoPlay: boolean;
+    IsFullWindow: boolean;
+    readonly MediaPlayer: Windows.Media.Playback.MediaPlayer;
+    PosterSource: Windows.UI.Xaml.Media.ImageSource;
+    Source: Windows.Media.Playback.IMediaPlaybackSource;
+    Stretch: number;
+    TransportControls: Windows.UI.Xaml.Controls.MediaTransportControls;
+  }
+  var IMediaPlayerElement: abstract new (...args: any[]) => IMediaPlayerElement;
+
+  interface IMediaPlayerElementFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.MediaPlayerElement;
+  }
+  var IMediaPlayerElementFactory: abstract new (...args: any[]) => IMediaPlayerElementFactory;
+
+  interface IMediaPlayerElementStatics {
+    readonly AreTransportControlsEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AutoPlayProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsFullWindowProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MediaPlayerProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PosterSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StretchProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMediaPlayerElementStatics: abstract new (...args: any[]) => IMediaPlayerElementStatics;
+
+  interface IMediaPlayerPresenter {
+    IsFullWindow: boolean;
+    MediaPlayer: Windows.Media.Playback.MediaPlayer;
+    Stretch: number;
+  }
+  var IMediaPlayerPresenter: abstract new (...args: any[]) => IMediaPlayerPresenter;
+
+  interface IMediaPlayerPresenterFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.MediaPlayerPresenter;
+  }
+  var IMediaPlayerPresenterFactory: abstract new (...args: any[]) => IMediaPlayerPresenterFactory;
+
+  interface IMediaPlayerPresenterStatics {
+    readonly IsFullWindowProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MediaPlayerProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StretchProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMediaPlayerPresenterStatics: abstract new (...args: any[]) => IMediaPlayerPresenterStatics;
+
+  interface IMediaTransportControls {
+    IsCompact: boolean;
+    IsFastForwardButtonVisible: boolean;
+    IsFastForwardEnabled: boolean;
+    IsFastRewindButtonVisible: boolean;
+    IsFastRewindEnabled: boolean;
+    IsFullWindowButtonVisible: boolean;
+    IsFullWindowEnabled: boolean;
+    IsPlaybackRateButtonVisible: boolean;
+    IsPlaybackRateEnabled: boolean;
+    IsSeekBarVisible: boolean;
+    IsSeekEnabled: boolean;
+    IsStopButtonVisible: boolean;
+    IsStopEnabled: boolean;
+    IsVolumeButtonVisible: boolean;
+    IsVolumeEnabled: boolean;
+    IsZoomButtonVisible: boolean;
+    IsZoomEnabled: boolean;
+  }
+  var IMediaTransportControls: abstract new (...args: any[]) => IMediaTransportControls;
+
+  interface IMediaTransportControls2 {
+    FastPlayFallbackBehaviour: number;
+    IsNextTrackButtonVisible: boolean;
+    IsPreviousTrackButtonVisible: boolean;
+    IsSkipBackwardButtonVisible: boolean;
+    IsSkipBackwardEnabled: boolean;
+    IsSkipForwardButtonVisible: boolean;
+    IsSkipForwardEnabled: boolean;
+    ThumbnailRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.MediaTransportControls, Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs> | null;
+  }
+  var IMediaTransportControls2: abstract new (...args: any[]) => IMediaTransportControls2;
+
+  interface IMediaTransportControls3 {
+    Hide(): void;
+    Show(): void;
+    IsRepeatButtonVisible: boolean;
+    IsRepeatEnabled: boolean;
+    ShowAndHideAutomatically: boolean;
+  }
+  var IMediaTransportControls3: abstract new (...args: any[]) => IMediaTransportControls3;
+
+  interface IMediaTransportControls4 {
+    IsCompactOverlayButtonVisible: boolean;
+    IsCompactOverlayEnabled: boolean;
+  }
+  var IMediaTransportControls4: abstract new (...args: any[]) => IMediaTransportControls4;
+
+  interface IMediaTransportControlsFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.MediaTransportControls;
+  }
+  var IMediaTransportControlsFactory: abstract new (...args: any[]) => IMediaTransportControlsFactory;
+
+  interface IMediaTransportControlsHelper {
+  }
+  var IMediaTransportControlsHelper: abstract new (...args: any[]) => IMediaTransportControlsHelper;
+
+  interface IMediaTransportControlsHelperStatics {
+    GetDropoutOrder(element: Windows.UI.Xaml.UIElement): number | null;
+    SetDropoutOrder(element: Windows.UI.Xaml.UIElement, value: number | null): void;
+    readonly DropoutOrderProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMediaTransportControlsHelperStatics: abstract new (...args: any[]) => IMediaTransportControlsHelperStatics;
+
+  interface IMediaTransportControlsStatics {
+    readonly IsCompactProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsFastForwardButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsFastForwardEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsFastRewindButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsFastRewindEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsFullWindowButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsFullWindowEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsPlaybackRateButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsPlaybackRateEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsSeekBarVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsSeekEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsStopButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsStopEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsVolumeButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsVolumeEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsZoomButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsZoomEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMediaTransportControlsStatics: abstract new (...args: any[]) => IMediaTransportControlsStatics;
+
+  interface IMediaTransportControlsStatics2 {
+    readonly FastPlayFallbackBehaviourProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsNextTrackButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsPreviousTrackButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsSkipBackwardButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsSkipBackwardEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsSkipForwardButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsSkipForwardEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMediaTransportControlsStatics2: abstract new (...args: any[]) => IMediaTransportControlsStatics2;
+
+  interface IMediaTransportControlsStatics3 {
+    readonly IsRepeatButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsRepeatEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ShowAndHideAutomaticallyProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMediaTransportControlsStatics3: abstract new (...args: any[]) => IMediaTransportControlsStatics3;
+
+  interface IMediaTransportControlsStatics4 {
+    readonly IsCompactOverlayButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsCompactOverlayEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMediaTransportControlsStatics4: abstract new (...args: any[]) => IMediaTransportControlsStatics4;
+
+  interface IMenuBar {
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.MenuBarItem> | Windows.UI.Xaml.Controls.MenuBarItem[];
+  }
+  var IMenuBar: abstract new (...args: any[]) => IMenuBar;
+
+  interface IMenuBarFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.MenuBar;
+  }
+  var IMenuBarFactory: abstract new (...args: any[]) => IMenuBarFactory;
+
+  interface IMenuBarItem {
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.MenuFlyoutItemBase> | Windows.UI.Xaml.Controls.MenuFlyoutItemBase[];
+    Title: string;
+  }
+  var IMenuBarItem: abstract new (...args: any[]) => IMenuBarItem;
+
+  interface IMenuBarItemFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.MenuBarItem;
+  }
+  var IMenuBarItemFactory: abstract new (...args: any[]) => IMenuBarItemFactory;
+
+  interface IMenuBarItemFlyout {
+  }
+  var IMenuBarItemFlyout: abstract new (...args: any[]) => IMenuBarItemFlyout;
+
+  interface IMenuBarItemFlyoutFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.MenuBarItemFlyout;
+  }
+  var IMenuBarItemFlyoutFactory: abstract new (...args: any[]) => IMenuBarItemFlyoutFactory;
+
+  interface IMenuBarItemStatics {
+    readonly ItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TitleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMenuBarItemStatics: abstract new (...args: any[]) => IMenuBarItemStatics;
+
+  interface IMenuBarStatics {
+    readonly ItemsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMenuBarStatics: abstract new (...args: any[]) => IMenuBarStatics;
+
+  interface IMenuFlyout {
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.MenuFlyoutItemBase> | Windows.UI.Xaml.Controls.MenuFlyoutItemBase[];
+    MenuFlyoutPresenterStyle: Windows.UI.Xaml.Style;
+  }
+  var IMenuFlyout: abstract new (...args: any[]) => IMenuFlyout;
+
+  interface IMenuFlyout2 {
+    ShowAt(targetElement: Windows.UI.Xaml.UIElement, point: Windows.Foundation.Point): void;
+  }
+  var IMenuFlyout2: abstract new (...args: any[]) => IMenuFlyout2;
+
+  interface IMenuFlyoutFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.MenuFlyout;
+  }
+  var IMenuFlyoutFactory: abstract new (...args: any[]) => IMenuFlyoutFactory;
+
+  interface IMenuFlyoutItem {
+    Command: Windows.UI.Xaml.Input.ICommand;
+    CommandParameter: Object;
+    Text: string;
+    Click: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+  var IMenuFlyoutItem: abstract new (...args: any[]) => IMenuFlyoutItem;
+
+  interface IMenuFlyoutItem2 {
+    Icon: Windows.UI.Xaml.Controls.IconElement;
+  }
+  var IMenuFlyoutItem2: abstract new (...args: any[]) => IMenuFlyoutItem2;
+
+  interface IMenuFlyoutItem3 {
+    KeyboardAcceleratorTextOverride: string;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.MenuFlyoutItemTemplateSettings;
+  }
+  var IMenuFlyoutItem3: abstract new (...args: any[]) => IMenuFlyoutItem3;
+
+  interface IMenuFlyoutItemBase {
+  }
+  var IMenuFlyoutItemBase: abstract new (...args: any[]) => IMenuFlyoutItemBase;
+
+  interface IMenuFlyoutItemBaseFactory {
+  }
+  var IMenuFlyoutItemBaseFactory: abstract new (...args: any[]) => IMenuFlyoutItemBaseFactory;
+
+  interface IMenuFlyoutItemFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.MenuFlyoutItem;
+  }
+  var IMenuFlyoutItemFactory: abstract new (...args: any[]) => IMenuFlyoutItemFactory;
+
+  interface IMenuFlyoutItemStatics {
+    readonly CommandParameterProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CommandProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMenuFlyoutItemStatics: abstract new (...args: any[]) => IMenuFlyoutItemStatics;
+
+  interface IMenuFlyoutItemStatics2 {
+    readonly IconProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMenuFlyoutItemStatics2: abstract new (...args: any[]) => IMenuFlyoutItemStatics2;
+
+  interface IMenuFlyoutItemStatics3 {
+    readonly KeyboardAcceleratorTextOverrideProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMenuFlyoutItemStatics3: abstract new (...args: any[]) => IMenuFlyoutItemStatics3;
+
+  interface IMenuFlyoutPresenter {
+  }
+  var IMenuFlyoutPresenter: abstract new (...args: any[]) => IMenuFlyoutPresenter;
+
+  interface IMenuFlyoutPresenter2 {
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.MenuFlyoutPresenterTemplateSettings;
+  }
+  var IMenuFlyoutPresenter2: abstract new (...args: any[]) => IMenuFlyoutPresenter2;
+
+  interface IMenuFlyoutPresenter3 {
+    IsDefaultShadowEnabled: boolean;
+  }
+  var IMenuFlyoutPresenter3: abstract new (...args: any[]) => IMenuFlyoutPresenter3;
+
+  interface IMenuFlyoutPresenterFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.MenuFlyoutPresenter;
+  }
+  var IMenuFlyoutPresenterFactory: abstract new (...args: any[]) => IMenuFlyoutPresenterFactory;
+
+  interface IMenuFlyoutPresenterStatics3 {
+    readonly IsDefaultShadowEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMenuFlyoutPresenterStatics3: abstract new (...args: any[]) => IMenuFlyoutPresenterStatics3;
+
+  interface IMenuFlyoutSeparator {
+  }
+  var IMenuFlyoutSeparator: abstract new (...args: any[]) => IMenuFlyoutSeparator;
+
+  interface IMenuFlyoutSeparatorFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.MenuFlyoutSeparator;
+  }
+  var IMenuFlyoutSeparatorFactory: abstract new (...args: any[]) => IMenuFlyoutSeparatorFactory;
+
+  interface IMenuFlyoutStatics {
+    readonly MenuFlyoutPresenterStyleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMenuFlyoutStatics: abstract new (...args: any[]) => IMenuFlyoutStatics;
+
+  interface IMenuFlyoutSubItem {
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.MenuFlyoutItemBase> | Windows.UI.Xaml.Controls.MenuFlyoutItemBase[];
+    Text: string;
+  }
+  var IMenuFlyoutSubItem: abstract new (...args: any[]) => IMenuFlyoutSubItem;
+
+  interface IMenuFlyoutSubItem2 {
+    Icon: Windows.UI.Xaml.Controls.IconElement;
+  }
+  var IMenuFlyoutSubItem2: abstract new (...args: any[]) => IMenuFlyoutSubItem2;
+
+  interface IMenuFlyoutSubItemStatics {
+    readonly TextProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMenuFlyoutSubItemStatics: abstract new (...args: any[]) => IMenuFlyoutSubItemStatics;
+
+  interface IMenuFlyoutSubItemStatics2 {
+    readonly IconProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMenuFlyoutSubItemStatics2: abstract new (...args: any[]) => IMenuFlyoutSubItemStatics2;
+
+  interface INavigate {
+    Navigate(sourcePageType: Windows.UI.Xaml.Interop.TypeName): boolean;
+  }
+  var INavigate: abstract new (...args: any[]) => INavigate;
+
+  interface INavigationView {
+    ContainerFromMenuItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    MenuItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    AlwaysShowHeader: boolean;
+    AutoSuggestBox: Windows.UI.Xaml.Controls.AutoSuggestBox;
+    CompactModeThresholdWidth: number;
+    CompactPaneLength: number;
+    readonly DisplayMode: number;
+    ExpandedModeThresholdWidth: number;
+    Header: Object;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    IsPaneOpen: boolean;
+    IsPaneToggleButtonVisible: boolean;
+    IsSettingsVisible: boolean;
+    MenuItemContainerStyle: Windows.UI.Xaml.Style;
+    MenuItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector;
+    MenuItemTemplate: Windows.UI.Xaml.DataTemplate;
+    MenuItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector;
+    readonly MenuItems: Windows.Foundation.Collections.IVector<Object> | Object[];
+    MenuItemsSource: Object;
+    OpenPaneLength: number;
+    PaneFooter: Windows.UI.Xaml.UIElement;
+    PaneToggleButtonStyle: Windows.UI.Xaml.Style;
+    SelectedItem: Object;
+    readonly SettingsItem: Object;
+    DisplayModeChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.NavigationView, Windows.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs> | null;
+    ItemInvoked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.NavigationView, Windows.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs> | null;
+    SelectionChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.NavigationView, Windows.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs> | null;
+  }
+  var INavigationView: abstract new (...args: any[]) => INavigationView;
+
+  interface INavigationView2 {
+    IsBackButtonVisible: number;
+    IsBackEnabled: boolean;
+    PaneTitle: string;
+    BackRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.NavigationView, Windows.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs> | null;
+    PaneClosed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.NavigationView, Object> | null;
+    PaneClosing: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.NavigationView, Windows.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs> | null;
+    PaneOpened: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.NavigationView, Object> | null;
+    PaneOpening: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.NavigationView, Object> | null;
+  }
+  var INavigationView2: abstract new (...args: any[]) => INavigationView2;
+
+  interface INavigationView3 {
+    ContentOverlay: Windows.UI.Xaml.UIElement;
+    IsPaneVisible: boolean;
+    OverflowLabelMode: number;
+    PaneCustomContent: Windows.UI.Xaml.UIElement;
+    PaneDisplayMode: number;
+    PaneHeader: Windows.UI.Xaml.UIElement;
+    SelectionFollowsFocus: number;
+    ShoulderNavigationEnabled: number;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.NavigationViewTemplateSettings;
+  }
+  var INavigationView3: abstract new (...args: any[]) => INavigationView3;
+
+  interface INavigationViewBackRequestedEventArgs {
+  }
+  var INavigationViewBackRequestedEventArgs: abstract new (...args: any[]) => INavigationViewBackRequestedEventArgs;
+
+  interface INavigationViewDisplayModeChangedEventArgs {
+    readonly DisplayMode: number;
+  }
+  var INavigationViewDisplayModeChangedEventArgs: abstract new (...args: any[]) => INavigationViewDisplayModeChangedEventArgs;
+
+  interface INavigationViewFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.NavigationView;
+  }
+  var INavigationViewFactory: abstract new (...args: any[]) => INavigationViewFactory;
+
+  interface INavigationViewItem {
+    readonly CompactPaneLength: number;
+    Icon: Windows.UI.Xaml.Controls.IconElement;
+  }
+  var INavigationViewItem: abstract new (...args: any[]) => INavigationViewItem;
+
+  interface INavigationViewItem2 {
+    SelectsOnInvoked: boolean;
+  }
+  var INavigationViewItem2: abstract new (...args: any[]) => INavigationViewItem2;
+
+  interface INavigationViewItemBase {
+  }
+  var INavigationViewItemBase: abstract new (...args: any[]) => INavigationViewItemBase;
+
+  interface INavigationViewItemBaseFactory {
+  }
+  var INavigationViewItemBaseFactory: abstract new (...args: any[]) => INavigationViewItemBaseFactory;
+
+  interface INavigationViewItemFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.NavigationViewItem;
+  }
+  var INavigationViewItemFactory: abstract new (...args: any[]) => INavigationViewItemFactory;
+
+  interface INavigationViewItemHeader {
+  }
+  var INavigationViewItemHeader: abstract new (...args: any[]) => INavigationViewItemHeader;
+
+  interface INavigationViewItemHeaderFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.NavigationViewItemHeader;
+  }
+  var INavigationViewItemHeaderFactory: abstract new (...args: any[]) => INavigationViewItemHeaderFactory;
+
+  interface INavigationViewItemInvokedEventArgs {
+    readonly InvokedItem: Object;
+    readonly IsSettingsInvoked: boolean;
+  }
+  var INavigationViewItemInvokedEventArgs: abstract new (...args: any[]) => INavigationViewItemInvokedEventArgs;
+
+  interface INavigationViewItemInvokedEventArgs2 {
+    readonly InvokedItemContainer: Windows.UI.Xaml.Controls.NavigationViewItemBase;
+    readonly RecommendedNavigationTransitionInfo: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+  }
+  var INavigationViewItemInvokedEventArgs2: abstract new (...args: any[]) => INavigationViewItemInvokedEventArgs2;
+
+  interface INavigationViewItemSeparator {
+  }
+  var INavigationViewItemSeparator: abstract new (...args: any[]) => INavigationViewItemSeparator;
+
+  interface INavigationViewItemSeparatorFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.NavigationViewItemSeparator;
+  }
+  var INavigationViewItemSeparatorFactory: abstract new (...args: any[]) => INavigationViewItemSeparatorFactory;
+
+  interface INavigationViewItemStatics {
+    readonly CompactPaneLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IconProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var INavigationViewItemStatics: abstract new (...args: any[]) => INavigationViewItemStatics;
+
+  interface INavigationViewItemStatics2 {
+    readonly SelectsOnInvokedProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var INavigationViewItemStatics2: abstract new (...args: any[]) => INavigationViewItemStatics2;
+
+  interface INavigationViewList {
+  }
+  var INavigationViewList: abstract new (...args: any[]) => INavigationViewList;
+
+  interface INavigationViewListFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.NavigationViewList;
+  }
+  var INavigationViewListFactory: abstract new (...args: any[]) => INavigationViewListFactory;
+
+  interface INavigationViewPaneClosingEventArgs {
+    Cancel: boolean;
+  }
+  var INavigationViewPaneClosingEventArgs: abstract new (...args: any[]) => INavigationViewPaneClosingEventArgs;
+
+  interface INavigationViewSelectionChangedEventArgs {
+    readonly IsSettingsSelected: boolean;
+    readonly SelectedItem: Object;
+  }
+  var INavigationViewSelectionChangedEventArgs: abstract new (...args: any[]) => INavigationViewSelectionChangedEventArgs;
+
+  interface INavigationViewSelectionChangedEventArgs2 {
+    readonly RecommendedNavigationTransitionInfo: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+    readonly SelectedItemContainer: Windows.UI.Xaml.Controls.NavigationViewItemBase;
+  }
+  var INavigationViewSelectionChangedEventArgs2: abstract new (...args: any[]) => INavigationViewSelectionChangedEventArgs2;
+
+  interface INavigationViewStatics {
+    readonly AlwaysShowHeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AutoSuggestBoxProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CompactModeThresholdWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CompactPaneLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DisplayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ExpandedModeThresholdWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsPaneOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsPaneToggleButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsSettingsVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MenuItemContainerStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MenuItemContainerStyleSelectorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MenuItemTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MenuItemTemplateSelectorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MenuItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MenuItemsSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OpenPaneLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaneFooterProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaneToggleButtonStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedItemProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SettingsItemProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var INavigationViewStatics: abstract new (...args: any[]) => INavigationViewStatics;
+
+  interface INavigationViewStatics2 {
+    readonly IsBackButtonVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsBackEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaneTitleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var INavigationViewStatics2: abstract new (...args: any[]) => INavigationViewStatics2;
+
+  interface INavigationViewStatics3 {
+    readonly ContentOverlayProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsPaneVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OverflowLabelModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaneCustomContentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaneDisplayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaneHeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionFollowsFocusProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ShoulderNavigationEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TemplateSettingsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var INavigationViewStatics3: abstract new (...args: any[]) => INavigationViewStatics3;
+
+  interface INavigationViewTemplateSettings {
+    readonly BackButtonVisibility: number;
+    readonly LeftPaneVisibility: number;
+    readonly OverflowButtonVisibility: number;
+    readonly PaneToggleButtonVisibility: number;
+    readonly SingleSelectionFollowsFocus: boolean;
+    readonly TopPadding: number;
+    readonly TopPaneVisibility: number;
+  }
+  var INavigationViewTemplateSettings: abstract new (...args: any[]) => INavigationViewTemplateSettings;
+
+  interface INavigationViewTemplateSettingsFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.NavigationViewTemplateSettings;
+  }
+  var INavigationViewTemplateSettingsFactory: abstract new (...args: any[]) => INavigationViewTemplateSettingsFactory;
+
+  interface INavigationViewTemplateSettingsStatics {
+    readonly BackButtonVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LeftPaneVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OverflowButtonVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaneToggleButtonVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SingleSelectionFollowsFocusProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TopPaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TopPaneVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var INavigationViewTemplateSettingsStatics: abstract new (...args: any[]) => INavigationViewTemplateSettingsStatics;
+
+  interface INotifyEventArgs {
+    readonly Value: string;
+  }
+  var INotifyEventArgs: abstract new (...args: any[]) => INotifyEventArgs;
+
+  interface INotifyEventArgs2 {
+    readonly CallingUri: Windows.Foundation.Uri;
+  }
+  var INotifyEventArgs2: abstract new (...args: any[]) => INotifyEventArgs2;
+
+  interface IPage {
+    BottomAppBar: Windows.UI.Xaml.Controls.AppBar;
+    readonly Frame: Windows.UI.Xaml.Controls.Frame;
+    NavigationCacheMode: number;
+    TopAppBar: Windows.UI.Xaml.Controls.AppBar;
+  }
+  var IPage: abstract new (...args: any[]) => IPage;
+
+  interface IPageFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Page;
+  }
+  var IPageFactory: abstract new (...args: any[]) => IPageFactory;
+
+  interface IPageOverrides {
+    OnNavigatedFrom(e: Windows.UI.Xaml.Navigation.NavigationEventArgs): void;
+    OnNavigatedTo(e: Windows.UI.Xaml.Navigation.NavigationEventArgs): void;
+    OnNavigatingFrom(e: Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs): void;
+  }
+  var IPageOverrides: abstract new (...args: any[]) => IPageOverrides;
+
+  interface IPageStatics {
+    readonly BottomAppBarProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FrameProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TopAppBarProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPageStatics: abstract new (...args: any[]) => IPageStatics;
+
+  interface IPanel {
+    Background: Windows.UI.Xaml.Media.Brush;
+    readonly Children: Windows.UI.Xaml.Controls.UIElementCollection;
+    ChildrenTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    readonly IsItemsHost: boolean;
+  }
+  var IPanel: abstract new (...args: any[]) => IPanel;
+
+  interface IPanel2 {
+    BackgroundTransition: Windows.UI.Xaml.BrushTransition;
+  }
+  var IPanel2: abstract new (...args: any[]) => IPanel2;
+
+  interface IPanelFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Panel;
+  }
+  var IPanelFactory: abstract new (...args: any[]) => IPanelFactory;
+
+  interface IPanelStatics {
+    readonly BackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ChildrenTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsItemsHostProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPanelStatics: abstract new (...args: any[]) => IPanelStatics;
+
+  interface IParallaxView {
+    RefreshAutomaticHorizontalOffsets(): void;
+    RefreshAutomaticVerticalOffsets(): void;
+    Child: Windows.UI.Xaml.UIElement;
+    HorizontalShift: number;
+    HorizontalSourceEndOffset: number;
+    HorizontalSourceOffsetKind: number;
+    HorizontalSourceStartOffset: number;
+    IsHorizontalShiftClamped: boolean;
+    IsVerticalShiftClamped: boolean;
+    MaxHorizontalShiftRatio: number;
+    MaxVerticalShiftRatio: number;
+    Source: Windows.UI.Xaml.UIElement;
+    VerticalShift: number;
+    VerticalSourceEndOffset: number;
+    VerticalSourceOffsetKind: number;
+    VerticalSourceStartOffset: number;
+  }
+  var IParallaxView: abstract new (...args: any[]) => IParallaxView;
+
+  interface IParallaxViewFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.ParallaxView;
+  }
+  var IParallaxViewFactory: abstract new (...args: any[]) => IParallaxViewFactory;
+
+  interface IParallaxViewStatics {
+    readonly ChildProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalShiftProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalSourceEndOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalSourceOffsetKindProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalSourceStartOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsHorizontalShiftClampedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsVerticalShiftClampedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxHorizontalShiftRatioProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxVerticalShiftRatioProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalShiftProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalSourceEndOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalSourceOffsetKindProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalSourceStartOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IParallaxViewStatics: abstract new (...args: any[]) => IParallaxViewStatics;
+
+  interface IPasswordBox {
+    SelectAll(): void;
+    IsPasswordRevealButtonEnabled: boolean;
+    MaxLength: number;
+    Password: string;
+    PasswordChar: string;
+    ContextMenuOpening: Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler | null;
+    PasswordChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+  var IPasswordBox: abstract new (...args: any[]) => IPasswordBox;
+
+  interface IPasswordBox2 {
+    Header: Object;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    PlaceholderText: string;
+    PreventKeyboardDisplayOnProgrammaticFocus: boolean;
+    SelectionHighlightColor: Windows.UI.Xaml.Media.SolidColorBrush;
+    Paste: Windows.UI.Xaml.Controls.TextControlPasteEventHandler | null;
+  }
+  var IPasswordBox2: abstract new (...args: any[]) => IPasswordBox2;
+
+  interface IPasswordBox3 {
+    InputScope: Windows.UI.Xaml.Input.InputScope;
+    PasswordRevealMode: number;
+    TextReadingOrder: number;
+  }
+  var IPasswordBox3: abstract new (...args: any[]) => IPasswordBox3;
+
+  interface IPasswordBox4 {
+    PasswordChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.PasswordBox, Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs> | null;
+  }
+  var IPasswordBox4: abstract new (...args: any[]) => IPasswordBox4;
+
+  interface IPasswordBox5 {
+    PasteFromClipboard(): void;
+    readonly CanPasteClipboardContent: boolean;
+    Description: Object;
+    SelectionFlyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+  }
+  var IPasswordBox5: abstract new (...args: any[]) => IPasswordBox5;
+
+  interface IPasswordBoxPasswordChangingEventArgs {
+    readonly IsContentChanging: boolean;
+  }
+  var IPasswordBoxPasswordChangingEventArgs: abstract new (...args: any[]) => IPasswordBoxPasswordChangingEventArgs;
+
+  interface IPasswordBoxStatics {
+    readonly IsPasswordRevealButtonEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PasswordCharProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PasswordProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPasswordBoxStatics: abstract new (...args: any[]) => IPasswordBoxStatics;
+
+  interface IPasswordBoxStatics2 {
+    readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlaceholderTextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PreventKeyboardDisplayOnProgrammaticFocusProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionHighlightColorProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPasswordBoxStatics2: abstract new (...args: any[]) => IPasswordBoxStatics2;
+
+  interface IPasswordBoxStatics3 {
+    readonly InputScopeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PasswordRevealModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextReadingOrderProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPasswordBoxStatics3: abstract new (...args: any[]) => IPasswordBoxStatics3;
+
+  interface IPasswordBoxStatics5 {
+    readonly CanPasteClipboardContentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DescriptionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionFlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPasswordBoxStatics5: abstract new (...args: any[]) => IPasswordBoxStatics5;
+
+  interface IPathIcon {
+    Data: Windows.UI.Xaml.Media.Geometry;
+  }
+  var IPathIcon: abstract new (...args: any[]) => IPathIcon;
+
+  interface IPathIconFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.PathIcon;
+  }
+  var IPathIconFactory: abstract new (...args: any[]) => IPathIconFactory;
+
+  interface IPathIconSource {
+    Data: Windows.UI.Xaml.Media.Geometry;
+  }
+  var IPathIconSource: abstract new (...args: any[]) => IPathIconSource;
+
+  interface IPathIconSourceFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.PathIconSource;
+  }
+  var IPathIconSourceFactory: abstract new (...args: any[]) => IPathIconSourceFactory;
+
+  interface IPathIconSourceStatics {
+    readonly DataProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPathIconSourceStatics: abstract new (...args: any[]) => IPathIconSourceStatics;
+
+  interface IPathIconStatics {
+    readonly DataProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPathIconStatics: abstract new (...args: any[]) => IPathIconStatics;
+
+  interface IPersonPicture {
+    BadgeGlyph: string;
+    BadgeImageSource: Windows.UI.Xaml.Media.ImageSource;
+    BadgeNumber: number;
+    BadgeText: string;
+    Contact: Windows.ApplicationModel.Contacts.Contact;
+    DisplayName: string;
+    Initials: string;
+    IsGroup: boolean;
+    PreferSmallImage: boolean;
+    ProfilePicture: Windows.UI.Xaml.Media.ImageSource;
+  }
+  var IPersonPicture: abstract new (...args: any[]) => IPersonPicture;
+
+  interface IPersonPictureFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.PersonPicture;
+  }
+  var IPersonPictureFactory: abstract new (...args: any[]) => IPersonPictureFactory;
+
+  interface IPersonPictureStatics {
+    readonly BadgeGlyphProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BadgeImageSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BadgeNumberProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BadgeTextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContactProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DisplayNameProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly InitialsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsGroupProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PreferSmallImageProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ProfilePictureProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPersonPictureStatics: abstract new (...args: any[]) => IPersonPictureStatics;
+
+  interface IPickerConfirmedEventArgs {
+  }
+  var IPickerConfirmedEventArgs: abstract new (...args: any[]) => IPickerConfirmedEventArgs;
+
+  interface IPickerFlyout {
+    ShowAtAsync(target: Windows.UI.Xaml.FrameworkElement): Windows.Foundation.IAsyncOperation<boolean>;
+    ConfirmationButtonsVisible: boolean;
+    Content: Windows.UI.Xaml.UIElement;
+    Confirmed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.PickerFlyout, Windows.UI.Xaml.Controls.PickerConfirmedEventArgs> | null;
+  }
+  var IPickerFlyout: abstract new (...args: any[]) => IPickerFlyout;
+
+  interface IPickerFlyoutPresenter {
+  }
+  var IPickerFlyoutPresenter: abstract new (...args: any[]) => IPickerFlyoutPresenter;
+
+  interface IPickerFlyoutStatics {
+    readonly ConfirmationButtonsVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPickerFlyoutStatics: abstract new (...args: any[]) => IPickerFlyoutStatics;
+
+  interface IPivot {
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    IsLocked: boolean;
+    SelectedIndex: number;
+    SelectedItem: Object;
+    Title: Object;
+    TitleTemplate: Windows.UI.Xaml.DataTemplate;
+    PivotItemLoaded: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Pivot, Windows.UI.Xaml.Controls.PivotItemEventArgs> | null;
+    PivotItemLoading: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Pivot, Windows.UI.Xaml.Controls.PivotItemEventArgs> | null;
+    PivotItemUnloaded: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Pivot, Windows.UI.Xaml.Controls.PivotItemEventArgs> | null;
+    PivotItemUnloading: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Pivot, Windows.UI.Xaml.Controls.PivotItemEventArgs> | null;
+    SelectionChanged: Windows.UI.Xaml.Controls.SelectionChangedEventHandler | null;
+  }
+  var IPivot: abstract new (...args: any[]) => IPivot;
+
+  interface IPivot2 {
+    LeftHeader: Object;
+    LeftHeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    RightHeader: Object;
+    RightHeaderTemplate: Windows.UI.Xaml.DataTemplate;
+  }
+  var IPivot2: abstract new (...args: any[]) => IPivot2;
+
+  interface IPivot3 {
+    HeaderFocusVisualPlacement: number;
+    IsHeaderItemsCarouselEnabled: boolean;
+  }
+  var IPivot3: abstract new (...args: any[]) => IPivot3;
+
+  interface IPivotFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Pivot;
+  }
+  var IPivotFactory: abstract new (...args: any[]) => IPivotFactory;
+
+  interface IPivotItem {
+    Header: Object;
+  }
+  var IPivotItem: abstract new (...args: any[]) => IPivotItem;
+
+  interface IPivotItemEventArgs {
+    Item: Windows.UI.Xaml.Controls.PivotItem;
+  }
+  var IPivotItemEventArgs: abstract new (...args: any[]) => IPivotItemEventArgs;
+
+  interface IPivotItemFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.PivotItem;
+  }
+  var IPivotItemFactory: abstract new (...args: any[]) => IPivotItemFactory;
+
+  interface IPivotItemStatics {
+    readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPivotItemStatics: abstract new (...args: any[]) => IPivotItemStatics;
+
+  interface IPivotStatics {
+    GetSlideInAnimationGroup(element: Windows.UI.Xaml.FrameworkElement): number;
+    SetSlideInAnimationGroup(element: Windows.UI.Xaml.FrameworkElement, value: number): void;
+    readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsLockedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedItemProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SlideInAnimationGroupProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TitleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TitleTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPivotStatics: abstract new (...args: any[]) => IPivotStatics;
+
+  interface IPivotStatics2 {
+    readonly LeftHeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LeftHeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RightHeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RightHeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPivotStatics2: abstract new (...args: any[]) => IPivotStatics2;
+
+  interface IPivotStatics3 {
+    readonly HeaderFocusVisualPlacementProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsHeaderItemsCarouselEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPivotStatics3: abstract new (...args: any[]) => IPivotStatics3;
+
+  interface IProgressBar {
+    IsIndeterminate: boolean;
+    ShowError: boolean;
+    ShowPaused: boolean;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.ProgressBarTemplateSettings;
+  }
+  var IProgressBar: abstract new (...args: any[]) => IProgressBar;
+
+  interface IProgressBarFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.ProgressBar;
+  }
+  var IProgressBarFactory: abstract new (...args: any[]) => IProgressBarFactory;
+
+  interface IProgressBarStatics {
+    readonly IsIndeterminateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ShowErrorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ShowPausedProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IProgressBarStatics: abstract new (...args: any[]) => IProgressBarStatics;
+
+  interface IProgressRing {
+    IsActive: boolean;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.ProgressRingTemplateSettings;
+  }
+  var IProgressRing: abstract new (...args: any[]) => IProgressRing;
+
+  interface IProgressRingStatics {
+    readonly IsActiveProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IProgressRingStatics: abstract new (...args: any[]) => IProgressRingStatics;
+
+  interface IRadioButton {
+    GroupName: string;
+  }
+  var IRadioButton: abstract new (...args: any[]) => IRadioButton;
+
+  interface IRadioButtonFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.RadioButton;
+  }
+  var IRadioButtonFactory: abstract new (...args: any[]) => IRadioButtonFactory;
+
+  interface IRadioButtonStatics {
+    readonly GroupNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRadioButtonStatics: abstract new (...args: any[]) => IRadioButtonStatics;
+
+  interface IRatingControl {
+    Caption: string;
+    InitialSetValue: number;
+    IsClearEnabled: boolean;
+    IsReadOnly: boolean;
+    ItemInfo: Windows.UI.Xaml.Controls.RatingItemInfo;
+    MaxRating: number;
+    PlaceholderValue: number;
+    Value: number;
+    ValueChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RatingControl, Object> | null;
+  }
+  var IRatingControl: abstract new (...args: any[]) => IRatingControl;
+
+  interface IRatingControlFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.RatingControl;
+  }
+  var IRatingControlFactory: abstract new (...args: any[]) => IRatingControlFactory;
+
+  interface IRatingControlStatics {
+    readonly CaptionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly InitialSetValueProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsClearEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsReadOnlyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemInfoProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxRatingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlaceholderValueProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ValueProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRatingControlStatics: abstract new (...args: any[]) => IRatingControlStatics;
+
+  interface IRatingItemFontInfo {
+    DisabledGlyph: string;
+    Glyph: string;
+    PlaceholderGlyph: string;
+    PointerOverGlyph: string;
+    PointerOverPlaceholderGlyph: string;
+    UnsetGlyph: string;
+  }
+  var IRatingItemFontInfo: abstract new (...args: any[]) => IRatingItemFontInfo;
+
+  interface IRatingItemFontInfoFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.RatingItemFontInfo;
+  }
+  var IRatingItemFontInfoFactory: abstract new (...args: any[]) => IRatingItemFontInfoFactory;
+
+  interface IRatingItemFontInfoStatics {
+    readonly DisabledGlyphProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GlyphProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlaceholderGlyphProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PointerOverGlyphProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PointerOverPlaceholderGlyphProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly UnsetGlyphProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRatingItemFontInfoStatics: abstract new (...args: any[]) => IRatingItemFontInfoStatics;
+
+  interface IRatingItemImageInfo {
+    DisabledImage: Windows.UI.Xaml.Media.ImageSource;
+    Image: Windows.UI.Xaml.Media.ImageSource;
+    PlaceholderImage: Windows.UI.Xaml.Media.ImageSource;
+    PointerOverImage: Windows.UI.Xaml.Media.ImageSource;
+    PointerOverPlaceholderImage: Windows.UI.Xaml.Media.ImageSource;
+    UnsetImage: Windows.UI.Xaml.Media.ImageSource;
+  }
+  var IRatingItemImageInfo: abstract new (...args: any[]) => IRatingItemImageInfo;
+
+  interface IRatingItemImageInfoFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.RatingItemImageInfo;
+  }
+  var IRatingItemImageInfoFactory: abstract new (...args: any[]) => IRatingItemImageInfoFactory;
+
+  interface IRatingItemImageInfoStatics {
+    readonly DisabledImageProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ImageProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlaceholderImageProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PointerOverImageProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PointerOverPlaceholderImageProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly UnsetImageProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRatingItemImageInfoStatics: abstract new (...args: any[]) => IRatingItemImageInfoStatics;
+
+  interface IRatingItemInfo {
+  }
+  var IRatingItemInfo: abstract new (...args: any[]) => IRatingItemInfo;
+
+  interface IRatingItemInfoFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.RatingItemInfo;
+  }
+  var IRatingItemInfoFactory: abstract new (...args: any[]) => IRatingItemInfoFactory;
+
+  interface IRefreshContainer {
+    RequestRefresh(): void;
+    PullDirection: number;
+    Visualizer: Windows.UI.Xaml.Controls.RefreshVisualizer;
+    RefreshRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RefreshContainer, Windows.UI.Xaml.Controls.RefreshRequestedEventArgs> | null;
+  }
+  var IRefreshContainer: abstract new (...args: any[]) => IRefreshContainer;
+
+  interface IRefreshContainerFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.RefreshContainer;
+  }
+  var IRefreshContainerFactory: abstract new (...args: any[]) => IRefreshContainerFactory;
+
+  interface IRefreshContainerStatics {
+    readonly PullDirectionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VisualizerProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRefreshContainerStatics: abstract new (...args: any[]) => IRefreshContainerStatics;
+
+  interface IRefreshInteractionRatioChangedEventArgs {
+    readonly InteractionRatio: number;
+  }
+  var IRefreshInteractionRatioChangedEventArgs: abstract new (...args: any[]) => IRefreshInteractionRatioChangedEventArgs;
+
+  interface IRefreshRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+  }
+  var IRefreshRequestedEventArgs: abstract new (...args: any[]) => IRefreshRequestedEventArgs;
+
+  interface IRefreshStateChangedEventArgs {
+    readonly NewState: number;
+    readonly OldState: number;
+  }
+  var IRefreshStateChangedEventArgs: abstract new (...args: any[]) => IRefreshStateChangedEventArgs;
+
+  interface IRefreshVisualizer {
+    RequestRefresh(): void;
+    Content: Windows.UI.Xaml.UIElement;
+    Orientation: number;
+    readonly State: number;
+    RefreshRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RefreshVisualizer, Windows.UI.Xaml.Controls.RefreshRequestedEventArgs> | null;
+    RefreshStateChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RefreshVisualizer, Windows.UI.Xaml.Controls.RefreshStateChangedEventArgs> | null;
+  }
+  var IRefreshVisualizer: abstract new (...args: any[]) => IRefreshVisualizer;
+
+  interface IRefreshVisualizerFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.RefreshVisualizer;
+  }
+  var IRefreshVisualizerFactory: abstract new (...args: any[]) => IRefreshVisualizerFactory;
+
+  interface IRefreshVisualizerStatics {
+    readonly ContentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly InfoProviderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StateProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRefreshVisualizerStatics: abstract new (...args: any[]) => IRefreshVisualizerStatics;
+
+  interface IRelativePanel {
+    BorderBrush: Windows.UI.Xaml.Media.Brush;
+    BorderThickness: Windows.UI.Xaml.Thickness;
+    CornerRadius: Windows.UI.Xaml.CornerRadius;
+    Padding: Windows.UI.Xaml.Thickness;
+  }
+  var IRelativePanel: abstract new (...args: any[]) => IRelativePanel;
+
+  interface IRelativePanel2 {
+    BackgroundSizing: number;
+  }
+  var IRelativePanel2: abstract new (...args: any[]) => IRelativePanel2;
+
+  interface IRelativePanelFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.RelativePanel;
+  }
+  var IRelativePanelFactory: abstract new (...args: any[]) => IRelativePanelFactory;
+
+  interface IRelativePanelStatics {
+    GetAbove(element: Windows.UI.Xaml.UIElement): Object;
+    GetAlignBottomWith(element: Windows.UI.Xaml.UIElement): Object;
+    GetAlignBottomWithPanel(element: Windows.UI.Xaml.UIElement): boolean;
+    GetAlignHorizontalCenterWith(element: Windows.UI.Xaml.UIElement): Object;
+    GetAlignHorizontalCenterWithPanel(element: Windows.UI.Xaml.UIElement): boolean;
+    GetAlignLeftWith(element: Windows.UI.Xaml.UIElement): Object;
+    GetAlignLeftWithPanel(element: Windows.UI.Xaml.UIElement): boolean;
+    GetAlignRightWith(element: Windows.UI.Xaml.UIElement): Object;
+    GetAlignRightWithPanel(element: Windows.UI.Xaml.UIElement): boolean;
+    GetAlignTopWith(element: Windows.UI.Xaml.UIElement): Object;
+    GetAlignTopWithPanel(element: Windows.UI.Xaml.UIElement): boolean;
+    GetAlignVerticalCenterWith(element: Windows.UI.Xaml.UIElement): Object;
+    GetAlignVerticalCenterWithPanel(element: Windows.UI.Xaml.UIElement): boolean;
+    GetBelow(element: Windows.UI.Xaml.UIElement): Object;
+    GetLeftOf(element: Windows.UI.Xaml.UIElement): Object;
+    GetRightOf(element: Windows.UI.Xaml.UIElement): Object;
+    SetAbove(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    SetAlignBottomWith(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    SetAlignBottomWithPanel(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    SetAlignHorizontalCenterWith(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    SetAlignHorizontalCenterWithPanel(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    SetAlignLeftWith(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    SetAlignLeftWithPanel(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    SetAlignRightWith(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    SetAlignRightWithPanel(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    SetAlignTopWith(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    SetAlignTopWithPanel(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    SetAlignVerticalCenterWith(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    SetAlignVerticalCenterWithPanel(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    SetBelow(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    SetLeftOf(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    SetRightOf(element: Windows.UI.Xaml.UIElement, value: Object): void;
+    readonly AboveProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AlignBottomWithPanelProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AlignBottomWithProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AlignHorizontalCenterWithPanelProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AlignHorizontalCenterWithProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AlignLeftWithPanelProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AlignLeftWithProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AlignRightWithPanelProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AlignRightWithProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AlignTopWithPanelProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AlignTopWithProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AlignVerticalCenterWithPanelProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AlignVerticalCenterWithProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BelowProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CornerRadiusProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LeftOfProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RightOfProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRelativePanelStatics: abstract new (...args: any[]) => IRelativePanelStatics;
+
+  interface IRelativePanelStatics2 {
+    readonly BackgroundSizingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRelativePanelStatics2: abstract new (...args: any[]) => IRelativePanelStatics2;
+
+  interface IRichEditBox {
+    AcceptsReturn: boolean;
+    readonly Document: Windows.UI.Text.ITextDocument;
+    InputScope: Windows.UI.Xaml.Input.InputScope;
+    IsReadOnly: boolean;
+    IsSpellCheckEnabled: boolean;
+    IsTextPredictionEnabled: boolean;
+    TextAlignment: number;
+    TextWrapping: number;
+    ContextMenuOpening: Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler | null;
+    SelectionChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+    TextChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+  var IRichEditBox: abstract new (...args: any[]) => IRichEditBox;
+
+  interface IRichEditBox2 {
+    Header: Object;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    IsColorFontEnabled: boolean;
+    PlaceholderText: string;
+    PreventKeyboardDisplayOnProgrammaticFocus: boolean;
+    SelectionHighlightColor: Windows.UI.Xaml.Media.SolidColorBrush;
+    Paste: Windows.UI.Xaml.Controls.TextControlPasteEventHandler | null;
+  }
+  var IRichEditBox2: abstract new (...args: any[]) => IRichEditBox2;
+
+  interface IRichEditBox3 {
+    DesiredCandidateWindowAlignment: number;
+    TextReadingOrder: number;
+    CandidateWindowBoundsChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs> | null;
+    TextChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs> | null;
+    TextCompositionChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs> | null;
+    TextCompositionEnded: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs> | null;
+    TextCompositionStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs> | null;
+  }
+  var IRichEditBox3: abstract new (...args: any[]) => IRichEditBox3;
+
+  interface IRichEditBox4 {
+    GetLinguisticAlternativesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+    ClipboardCopyFormat: number;
+  }
+  var IRichEditBox4: abstract new (...args: any[]) => IRichEditBox4;
+
+  interface IRichEditBox5 {
+    MaxLength: number;
+    SelectionHighlightColorWhenNotFocused: Windows.UI.Xaml.Media.SolidColorBrush;
+  }
+  var IRichEditBox5: abstract new (...args: any[]) => IRichEditBox5;
+
+  interface IRichEditBox6 {
+    CharacterCasing: number;
+    DisabledFormattingAccelerators: number;
+    HorizontalTextAlignment: number;
+    CopyingToClipboard: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs> | null;
+    CuttingToClipboard: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs> | null;
+  }
+  var IRichEditBox6: abstract new (...args: any[]) => IRichEditBox6;
+
+  interface IRichEditBox7 {
+    ContentLinkBackgroundColor: Windows.UI.Xaml.Media.SolidColorBrush;
+    ContentLinkForegroundColor: Windows.UI.Xaml.Media.SolidColorBrush;
+    ContentLinkProviders: Windows.UI.Xaml.Documents.ContentLinkProviderCollection;
+    HandwritingView: Windows.UI.Xaml.Controls.HandwritingView;
+    IsHandwritingViewEnabled: boolean;
+    ContentLinkChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Controls.ContentLinkChangedEventArgs> | null;
+    ContentLinkInvoked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs> | null;
+  }
+  var IRichEditBox7: abstract new (...args: any[]) => IRichEditBox7;
+
+  interface IRichEditBox8 {
+    Description: Object;
+    readonly ProofingMenuFlyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    SelectionFlyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    readonly TextDocument: Windows.UI.Text.RichEditTextDocument;
+    SelectionChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichEditBox, Windows.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs> | null;
+  }
+  var IRichEditBox8: abstract new (...args: any[]) => IRichEditBox8;
+
+  interface IRichEditBoxFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.RichEditBox;
+  }
+  var IRichEditBoxFactory: abstract new (...args: any[]) => IRichEditBoxFactory;
+
+  interface IRichEditBoxSelectionChangingEventArgs {
+    Cancel: boolean;
+    readonly SelectionLength: number;
+    readonly SelectionStart: number;
+  }
+  var IRichEditBoxSelectionChangingEventArgs: abstract new (...args: any[]) => IRichEditBoxSelectionChangingEventArgs;
+
+  interface IRichEditBoxStatics {
+    readonly AcceptsReturnProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly InputScopeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsReadOnlyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsSpellCheckEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsTextPredictionEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextWrappingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRichEditBoxStatics: abstract new (...args: any[]) => IRichEditBoxStatics;
+
+  interface IRichEditBoxStatics2 {
+    readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsColorFontEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlaceholderTextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PreventKeyboardDisplayOnProgrammaticFocusProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionHighlightColorProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRichEditBoxStatics2: abstract new (...args: any[]) => IRichEditBoxStatics2;
+
+  interface IRichEditBoxStatics3 {
+    readonly DesiredCandidateWindowAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextReadingOrderProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRichEditBoxStatics3: abstract new (...args: any[]) => IRichEditBoxStatics3;
+
+  interface IRichEditBoxStatics4 {
+    readonly ClipboardCopyFormatProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRichEditBoxStatics4: abstract new (...args: any[]) => IRichEditBoxStatics4;
+
+  interface IRichEditBoxStatics5 {
+    readonly MaxLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionHighlightColorWhenNotFocusedProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRichEditBoxStatics5: abstract new (...args: any[]) => IRichEditBoxStatics5;
+
+  interface IRichEditBoxStatics6 {
+    readonly CharacterCasingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DisabledFormattingAcceleratorsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalTextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRichEditBoxStatics6: abstract new (...args: any[]) => IRichEditBoxStatics6;
+
+  interface IRichEditBoxStatics7 {
+    readonly ContentLinkBackgroundColorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentLinkForegroundColorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentLinkProvidersProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HandwritingViewProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsHandwritingViewEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRichEditBoxStatics7: abstract new (...args: any[]) => IRichEditBoxStatics7;
+
+  interface IRichEditBoxStatics8 {
+    readonly DescriptionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ProofingMenuFlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionFlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRichEditBoxStatics8: abstract new (...args: any[]) => IRichEditBoxStatics8;
+
+  interface IRichEditBoxTextChangingEventArgs {
+  }
+  var IRichEditBoxTextChangingEventArgs: abstract new (...args: any[]) => IRichEditBoxTextChangingEventArgs;
+
+  interface IRichEditBoxTextChangingEventArgs2 {
+    readonly IsContentChanging: boolean;
+  }
+  var IRichEditBoxTextChangingEventArgs2: abstract new (...args: any[]) => IRichEditBoxTextChangingEventArgs2;
+
+  interface IRichTextBlock {
+    Focus(value: number): boolean;
+    GetPositionFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Documents.TextPointer;
+    Select(start: Windows.UI.Xaml.Documents.TextPointer, end: Windows.UI.Xaml.Documents.TextPointer): void;
+    SelectAll(): void;
+    readonly BaselineOffset: number;
+    readonly Blocks: Windows.UI.Xaml.Documents.BlockCollection;
+    CharacterSpacing: number;
+    readonly ContentEnd: Windows.UI.Xaml.Documents.TextPointer;
+    readonly ContentStart: Windows.UI.Xaml.Documents.TextPointer;
+    FontFamily: Windows.UI.Xaml.Media.FontFamily;
+    FontSize: number;
+    FontStretch: number;
+    FontStyle: number;
+    FontWeight: Windows.UI.Text.FontWeight;
+    Foreground: Windows.UI.Xaml.Media.Brush;
+    readonly HasOverflowContent: boolean;
+    IsTextSelectionEnabled: boolean;
+    LineHeight: number;
+    LineStackingStrategy: number;
+    OverflowContentTarget: Windows.UI.Xaml.Controls.RichTextBlockOverflow;
+    Padding: Windows.UI.Xaml.Thickness;
+    readonly SelectedText: string;
+    readonly SelectionEnd: Windows.UI.Xaml.Documents.TextPointer;
+    readonly SelectionStart: Windows.UI.Xaml.Documents.TextPointer;
+    TextAlignment: number;
+    TextIndent: number;
+    TextTrimming: number;
+    TextWrapping: number;
+    ContextMenuOpening: Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler | null;
+    SelectionChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+  var IRichTextBlock: abstract new (...args: any[]) => IRichTextBlock;
+
+  interface IRichTextBlock2 {
+    IsColorFontEnabled: boolean;
+    MaxLines: number;
+    OpticalMarginAlignment: number;
+    SelectionHighlightColor: Windows.UI.Xaml.Media.SolidColorBrush;
+    TextLineBounds: number;
+    TextReadingOrder: number;
+  }
+  var IRichTextBlock2: abstract new (...args: any[]) => IRichTextBlock2;
+
+  interface IRichTextBlock3 {
+    IsTextScaleFactorEnabled: boolean;
+  }
+  var IRichTextBlock3: abstract new (...args: any[]) => IRichTextBlock3;
+
+  interface IRichTextBlock4 {
+    TextDecorations: number;
+  }
+  var IRichTextBlock4: abstract new (...args: any[]) => IRichTextBlock4;
+
+  interface IRichTextBlock5 {
+    HorizontalTextAlignment: number;
+    readonly IsTextTrimmed: boolean;
+    readonly TextHighlighters: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Documents.TextHighlighter> | Windows.UI.Xaml.Documents.TextHighlighter[];
+    IsTextTrimmedChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichTextBlock, Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs> | null;
+  }
+  var IRichTextBlock5: abstract new (...args: any[]) => IRichTextBlock5;
+
+  interface IRichTextBlock6 {
+    CopySelectionToClipboard(): void;
+    SelectionFlyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+  }
+  var IRichTextBlock6: abstract new (...args: any[]) => IRichTextBlock6;
+
+  interface IRichTextBlockOverflow {
+    Focus(value: number): boolean;
+    GetPositionFromPoint(point: Windows.Foundation.Point): Windows.UI.Xaml.Documents.TextPointer;
+    readonly BaselineOffset: number;
+    readonly ContentEnd: Windows.UI.Xaml.Documents.TextPointer;
+    readonly ContentSource: Windows.UI.Xaml.Controls.RichTextBlock;
+    readonly ContentStart: Windows.UI.Xaml.Documents.TextPointer;
+    readonly HasOverflowContent: boolean;
+    OverflowContentTarget: Windows.UI.Xaml.Controls.RichTextBlockOverflow;
+    Padding: Windows.UI.Xaml.Thickness;
+  }
+  var IRichTextBlockOverflow: abstract new (...args: any[]) => IRichTextBlockOverflow;
+
+  interface IRichTextBlockOverflow2 {
+    MaxLines: number;
+  }
+  var IRichTextBlockOverflow2: abstract new (...args: any[]) => IRichTextBlockOverflow2;
+
+  interface IRichTextBlockOverflow3 {
+    readonly IsTextTrimmed: boolean;
+    IsTextTrimmedChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.RichTextBlockOverflow, Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs> | null;
+  }
+  var IRichTextBlockOverflow3: abstract new (...args: any[]) => IRichTextBlockOverflow3;
+
+  interface IRichTextBlockOverflowStatics {
+    readonly HasOverflowContentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OverflowContentTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRichTextBlockOverflowStatics: abstract new (...args: any[]) => IRichTextBlockOverflowStatics;
+
+  interface IRichTextBlockOverflowStatics2 {
+    readonly MaxLinesProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRichTextBlockOverflowStatics2: abstract new (...args: any[]) => IRichTextBlockOverflowStatics2;
+
+  interface IRichTextBlockOverflowStatics3 {
+    readonly IsTextTrimmedProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRichTextBlockOverflowStatics3: abstract new (...args: any[]) => IRichTextBlockOverflowStatics3;
+
+  interface IRichTextBlockStatics {
+    readonly CharacterSpacingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontStretchProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HasOverflowContentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsTextSelectionEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LineHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LineStackingStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OverflowContentTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedTextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextIndentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextTrimmingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextWrappingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRichTextBlockStatics: abstract new (...args: any[]) => IRichTextBlockStatics;
+
+  interface IRichTextBlockStatics2 {
+    readonly IsColorFontEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxLinesProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OpticalMarginAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionHighlightColorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextLineBoundsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextReadingOrderProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRichTextBlockStatics2: abstract new (...args: any[]) => IRichTextBlockStatics2;
+
+  interface IRichTextBlockStatics3 {
+    readonly IsTextScaleFactorEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRichTextBlockStatics3: abstract new (...args: any[]) => IRichTextBlockStatics3;
+
+  interface IRichTextBlockStatics4 {
+    readonly TextDecorationsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRichTextBlockStatics4: abstract new (...args: any[]) => IRichTextBlockStatics4;
+
+  interface IRichTextBlockStatics5 {
+    readonly HorizontalTextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsTextTrimmedProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRichTextBlockStatics5: abstract new (...args: any[]) => IRichTextBlockStatics5;
+
+  interface IRichTextBlockStatics6 {
+    readonly SelectionFlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRichTextBlockStatics6: abstract new (...args: any[]) => IRichTextBlockStatics6;
+
+  interface IRowDefinition {
+    readonly ActualHeight: number;
+    Height: Windows.UI.Xaml.GridLength;
+    MaxHeight: number;
+    MinHeight: number;
+  }
+  var IRowDefinition: abstract new (...args: any[]) => IRowDefinition;
+
+  interface IRowDefinitionStatics {
+    readonly HeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinHeightProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRowDefinitionStatics: abstract new (...args: any[]) => IRowDefinitionStatics;
+
+  interface IScrollAnchorProvider {
+    RegisterAnchorCandidate(element: Windows.UI.Xaml.UIElement): void;
+    UnregisterAnchorCandidate(element: Windows.UI.Xaml.UIElement): void;
+    readonly CurrentAnchor: Windows.UI.Xaml.UIElement;
+  }
+  var IScrollAnchorProvider: abstract new (...args: any[]) => IScrollAnchorProvider;
+
+  interface IScrollContentPresenter {
+    LineDown(): void;
+    LineLeft(): void;
+    LineRight(): void;
+    LineUp(): void;
+    MakeVisible(visual: Windows.UI.Xaml.UIElement, rectangle: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    MouseWheelDown(): void;
+    MouseWheelLeft(): void;
+    MouseWheelRight(): void;
+    MouseWheelUp(): void;
+    PageDown(): void;
+    PageLeft(): void;
+    PageRight(): void;
+    PageUp(): void;
+    SetHorizontalOffset(offset: number): void;
+    SetVerticalOffset(offset: number): void;
+    CanHorizontallyScroll: boolean;
+    CanVerticallyScroll: boolean;
+    readonly ExtentHeight: number;
+    readonly ExtentWidth: number;
+    readonly HorizontalOffset: number;
+    ScrollOwner: Object;
+    readonly VerticalOffset: number;
+    readonly ViewportHeight: number;
+    readonly ViewportWidth: number;
+  }
+  var IScrollContentPresenter: abstract new (...args: any[]) => IScrollContentPresenter;
+
+  interface IScrollContentPresenter2 {
+    CanContentRenderOutsideBounds: boolean;
+    SizesContentToTemplatedParent: boolean;
+  }
+  var IScrollContentPresenter2: abstract new (...args: any[]) => IScrollContentPresenter2;
+
+  interface IScrollContentPresenterStatics2 {
+    readonly CanContentRenderOutsideBoundsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SizesContentToTemplatedParentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IScrollContentPresenterStatics2: abstract new (...args: any[]) => IScrollContentPresenterStatics2;
+
+  interface IScrollViewer {
+    InvalidateScrollInfo(): void;
+    ScrollToHorizontalOffset(offset: number): void;
+    ScrollToVerticalOffset(offset: number): void;
+    ZoomToFactor(factor: number): void;
+    BringIntoViewOnFocusChange: boolean;
+    readonly ComputedHorizontalScrollBarVisibility: number;
+    readonly ComputedVerticalScrollBarVisibility: number;
+    readonly ExtentHeight: number;
+    readonly ExtentWidth: number;
+    readonly HorizontalOffset: number;
+    HorizontalScrollBarVisibility: number;
+    HorizontalScrollMode: number;
+    HorizontalSnapPointsAlignment: number;
+    HorizontalSnapPointsType: number;
+    IsDeferredScrollingEnabled: boolean;
+    IsHorizontalRailEnabled: boolean;
+    IsHorizontalScrollChainingEnabled: boolean;
+    IsScrollInertiaEnabled: boolean;
+    IsVerticalRailEnabled: boolean;
+    IsVerticalScrollChainingEnabled: boolean;
+    IsZoomChainingEnabled: boolean;
+    IsZoomInertiaEnabled: boolean;
+    MaxZoomFactor: number;
+    MinZoomFactor: number;
+    readonly ScrollableHeight: number;
+    readonly ScrollableWidth: number;
+    readonly VerticalOffset: number;
+    VerticalScrollBarVisibility: number;
+    VerticalScrollMode: number;
+    VerticalSnapPointsAlignment: number;
+    VerticalSnapPointsType: number;
+    readonly ViewportHeight: number;
+    readonly ViewportWidth: number;
+    readonly ZoomFactor: number;
+    ZoomMode: number;
+    readonly ZoomSnapPoints: Windows.Foundation.Collections.IVector<number> | number[];
+    ZoomSnapPointsType: number;
+    ViewChanged: Windows.Foundation.EventHandler<Windows.UI.Xaml.Controls.ScrollViewerViewChangedEventArgs> | null;
+  }
+  var IScrollViewer: abstract new (...args: any[]) => IScrollViewer;
+
+  interface IScrollViewer2 {
+    ChangeView(horizontalOffset: number | null, verticalOffset: number | null, zoomFactor: number | null): boolean;
+    ChangeView(horizontalOffset: number | null, verticalOffset: number | null, zoomFactor: number | null, disableAnimation: boolean): boolean;
+    LeftHeader: Windows.UI.Xaml.UIElement;
+    TopHeader: Windows.UI.Xaml.UIElement;
+    TopLeftHeader: Windows.UI.Xaml.UIElement;
+    ViewChanging: Windows.Foundation.EventHandler<Windows.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs> | null;
+  }
+  var IScrollViewer2: abstract new (...args: any[]) => IScrollViewer2;
+
+  interface IScrollViewer3 {
+    DirectManipulationCompleted: Windows.Foundation.EventHandler<Object> | null;
+    DirectManipulationStarted: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IScrollViewer3: abstract new (...args: any[]) => IScrollViewer3;
+
+  interface IScrollViewer4 {
+    CanContentRenderOutsideBounds: boolean;
+    HorizontalAnchorRatio: number;
+    ReduceViewportForCoreInputViewOcclusions: boolean;
+    VerticalAnchorRatio: number;
+    AnchorRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ScrollViewer, Windows.UI.Xaml.Controls.AnchorRequestedEventArgs> | null;
+  }
+  var IScrollViewer4: abstract new (...args: any[]) => IScrollViewer4;
+
+  interface IScrollViewerStatics {
+    GetBringIntoViewOnFocusChange(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetHorizontalScrollBarVisibility(element: Windows.UI.Xaml.DependencyObject): number;
+    GetHorizontalScrollMode(element: Windows.UI.Xaml.DependencyObject): number;
+    GetIsDeferredScrollingEnabled(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetIsHorizontalRailEnabled(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetIsHorizontalScrollChainingEnabled(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetIsScrollInertiaEnabled(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetIsVerticalRailEnabled(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetIsVerticalScrollChainingEnabled(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetIsZoomChainingEnabled(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetIsZoomInertiaEnabled(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetVerticalScrollBarVisibility(element: Windows.UI.Xaml.DependencyObject): number;
+    GetVerticalScrollMode(element: Windows.UI.Xaml.DependencyObject): number;
+    GetZoomMode(element: Windows.UI.Xaml.DependencyObject): number;
+    SetBringIntoViewOnFocusChange(element: Windows.UI.Xaml.DependencyObject, bringIntoViewOnFocusChange: boolean): void;
+    SetHorizontalScrollBarVisibility(element: Windows.UI.Xaml.DependencyObject, horizontalScrollBarVisibility: number): void;
+    SetHorizontalScrollMode(element: Windows.UI.Xaml.DependencyObject, horizontalScrollMode: number): void;
+    SetIsDeferredScrollingEnabled(element: Windows.UI.Xaml.DependencyObject, isDeferredScrollingEnabled: boolean): void;
+    SetIsHorizontalRailEnabled(element: Windows.UI.Xaml.DependencyObject, isHorizontalRailEnabled: boolean): void;
+    SetIsHorizontalScrollChainingEnabled(element: Windows.UI.Xaml.DependencyObject, isHorizontalScrollChainingEnabled: boolean): void;
+    SetIsScrollInertiaEnabled(element: Windows.UI.Xaml.DependencyObject, isScrollInertiaEnabled: boolean): void;
+    SetIsVerticalRailEnabled(element: Windows.UI.Xaml.DependencyObject, isVerticalRailEnabled: boolean): void;
+    SetIsVerticalScrollChainingEnabled(element: Windows.UI.Xaml.DependencyObject, isVerticalScrollChainingEnabled: boolean): void;
+    SetIsZoomChainingEnabled(element: Windows.UI.Xaml.DependencyObject, isZoomChainingEnabled: boolean): void;
+    SetIsZoomInertiaEnabled(element: Windows.UI.Xaml.DependencyObject, isZoomInertiaEnabled: boolean): void;
+    SetVerticalScrollBarVisibility(element: Windows.UI.Xaml.DependencyObject, verticalScrollBarVisibility: number): void;
+    SetVerticalScrollMode(element: Windows.UI.Xaml.DependencyObject, verticalScrollMode: number): void;
+    SetZoomMode(element: Windows.UI.Xaml.DependencyObject, zoomMode: number): void;
+    readonly BringIntoViewOnFocusChangeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ComputedHorizontalScrollBarVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ComputedVerticalScrollBarVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ExtentHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ExtentWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalScrollBarVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalScrollModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalSnapPointsAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalSnapPointsTypeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsDeferredScrollingEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsHorizontalRailEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsHorizontalScrollChainingEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsScrollInertiaEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsVerticalRailEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsVerticalScrollChainingEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsZoomChainingEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsZoomInertiaEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxZoomFactorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinZoomFactorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ScrollableHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ScrollableWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalScrollBarVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalScrollModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalSnapPointsAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalSnapPointsTypeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ViewportHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ViewportWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ZoomFactorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ZoomModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ZoomSnapPointsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ZoomSnapPointsTypeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IScrollViewerStatics: abstract new (...args: any[]) => IScrollViewerStatics;
+
+  interface IScrollViewerStatics2 {
+    readonly LeftHeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TopHeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TopLeftHeaderProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IScrollViewerStatics2: abstract new (...args: any[]) => IScrollViewerStatics2;
+
+  interface IScrollViewerStatics4 {
+    GetCanContentRenderOutsideBounds(element: Windows.UI.Xaml.DependencyObject): boolean;
+    SetCanContentRenderOutsideBounds(element: Windows.UI.Xaml.DependencyObject, canContentRenderOutsideBounds: boolean): void;
+    readonly CanContentRenderOutsideBoundsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalAnchorRatioProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ReduceViewportForCoreInputViewOcclusionsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalAnchorRatioProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IScrollViewerStatics4: abstract new (...args: any[]) => IScrollViewerStatics4;
+
+  interface IScrollViewerView {
+    readonly HorizontalOffset: number;
+    readonly VerticalOffset: number;
+    readonly ZoomFactor: number;
+  }
+  var IScrollViewerView: abstract new (...args: any[]) => IScrollViewerView;
+
+  interface IScrollViewerViewChangedEventArgs {
+    readonly IsIntermediate: boolean;
+  }
+  var IScrollViewerViewChangedEventArgs: abstract new (...args: any[]) => IScrollViewerViewChangedEventArgs;
+
+  interface IScrollViewerViewChangingEventArgs {
+    readonly FinalView: Windows.UI.Xaml.Controls.ScrollViewerView;
+    readonly IsInertial: boolean;
+    readonly NextView: Windows.UI.Xaml.Controls.ScrollViewerView;
+  }
+  var IScrollViewerViewChangingEventArgs: abstract new (...args: any[]) => IScrollViewerViewChangingEventArgs;
+
+  interface ISearchBox {
+    SetLocalContentSuggestionSettings(settings: Windows.ApplicationModel.Search.LocalContentSuggestionSettings): void;
+    ChooseSuggestionOnEnter: boolean;
+    FocusOnKeyboardInput: boolean;
+    PlaceholderText: string;
+    QueryText: string;
+    SearchHistoryContext: string;
+    SearchHistoryEnabled: boolean;
+    PrepareForFocusOnKeyboardInput: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SearchBox, Windows.UI.Xaml.RoutedEventArgs> | null;
+    QueryChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SearchBox, Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs> | null;
+    QuerySubmitted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SearchBox, Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs> | null;
+    ResultSuggestionChosen: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SearchBox, Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs> | null;
+    SuggestionsRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SearchBox, Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs> | null;
+  }
+  var ISearchBox: abstract new (...args: any[]) => ISearchBox;
+
+  interface ISearchBoxFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.SearchBox;
+  }
+  var ISearchBoxFactory: abstract new (...args: any[]) => ISearchBoxFactory;
+
+  interface ISearchBoxQueryChangedEventArgs {
+    readonly Language: string;
+    readonly LinguisticDetails: Windows.ApplicationModel.Search.SearchQueryLinguisticDetails;
+    readonly QueryText: string;
+  }
+  var ISearchBoxQueryChangedEventArgs: abstract new (...args: any[]) => ISearchBoxQueryChangedEventArgs;
+
+  interface ISearchBoxQuerySubmittedEventArgs {
+    readonly KeyModifiers: number;
+    readonly Language: string;
+    readonly LinguisticDetails: Windows.ApplicationModel.Search.SearchQueryLinguisticDetails;
+    readonly QueryText: string;
+  }
+  var ISearchBoxQuerySubmittedEventArgs: abstract new (...args: any[]) => ISearchBoxQuerySubmittedEventArgs;
+
+  interface ISearchBoxResultSuggestionChosenEventArgs {
+    readonly KeyModifiers: number;
+    readonly Tag: string;
+  }
+  var ISearchBoxResultSuggestionChosenEventArgs: abstract new (...args: any[]) => ISearchBoxResultSuggestionChosenEventArgs;
+
+  interface ISearchBoxStatics {
+    readonly ChooseSuggestionOnEnterProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FocusOnKeyboardInputProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlaceholderTextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly QueryTextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SearchHistoryContextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SearchHistoryEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISearchBoxStatics: abstract new (...args: any[]) => ISearchBoxStatics;
+
+  interface ISearchBoxSuggestionsRequestedEventArgs {
+    readonly Language: string;
+    readonly LinguisticDetails: Windows.ApplicationModel.Search.SearchQueryLinguisticDetails;
+    readonly QueryText: string;
+    readonly Request: Windows.ApplicationModel.Search.SearchSuggestionsRequest;
+  }
+  var ISearchBoxSuggestionsRequestedEventArgs: abstract new (...args: any[]) => ISearchBoxSuggestionsRequestedEventArgs;
+
+  interface ISectionsInViewChangedEventArgs {
+    readonly AddedSections: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.HubSection> | Windows.UI.Xaml.Controls.HubSection[];
+    readonly RemovedSections: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.HubSection> | Windows.UI.Xaml.Controls.HubSection[];
+  }
+  var ISectionsInViewChangedEventArgs: abstract new (...args: any[]) => ISectionsInViewChangedEventArgs;
+
+  interface ISectionsInViewChangedEventArgsFactory {
+  }
+  var ISectionsInViewChangedEventArgsFactory: abstract new (...args: any[]) => ISectionsInViewChangedEventArgsFactory;
+
+  interface ISelectionChangedEventArgs {
+    readonly AddedItems: Windows.Foundation.Collections.IVector<Object> | Object[];
+    readonly RemovedItems: Windows.Foundation.Collections.IVector<Object> | Object[];
+  }
+  var ISelectionChangedEventArgs: abstract new (...args: any[]) => ISelectionChangedEventArgs;
+
+  interface ISelectionChangedEventArgsFactory {
+    CreateInstanceWithRemovedItemsAndAddedItems(removedItems: Windows.Foundation.Collections.IVector<Object> | Object[], addedItems: Windows.Foundation.Collections.IVector<Object> | Object[], baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.SelectionChangedEventArgs;
+  }
+  var ISelectionChangedEventArgsFactory: abstract new (...args: any[]) => ISelectionChangedEventArgsFactory;
+
+  interface ISemanticZoom {
+    ToggleActiveView(): void;
+    CanChangeViews: boolean;
+    IsZoomOutButtonEnabled: boolean;
+    IsZoomedInViewActive: boolean;
+    ZoomedInView: Windows.UI.Xaml.Controls.ISemanticZoomInformation;
+    ZoomedOutView: Windows.UI.Xaml.Controls.ISemanticZoomInformation;
+    ViewChangeCompleted: Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventHandler | null;
+    ViewChangeStarted: Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventHandler | null;
+  }
+  var ISemanticZoom: abstract new (...args: any[]) => ISemanticZoom;
+
+  interface ISemanticZoomInformation {
+    CompleteViewChange(): void;
+    CompleteViewChangeFrom(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    CompleteViewChangeTo(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    InitializeViewChange(): void;
+    MakeVisible(item: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    StartViewChangeFrom(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    StartViewChangeTo(source: Windows.UI.Xaml.Controls.SemanticZoomLocation, destination: Windows.UI.Xaml.Controls.SemanticZoomLocation): void;
+    IsActiveView: boolean;
+    IsZoomedInView: boolean;
+    SemanticZoomOwner: Windows.UI.Xaml.Controls.SemanticZoom;
+  }
+  var ISemanticZoomInformation: abstract new (...args: any[]) => ISemanticZoomInformation;
+
+  interface ISemanticZoomLocation {
+    Bounds: Windows.Foundation.Rect;
+    Item: Object;
+  }
+  var ISemanticZoomLocation: abstract new (...args: any[]) => ISemanticZoomLocation;
+
+  interface ISemanticZoomStatics {
+    readonly CanChangeViewsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsZoomOutButtonEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsZoomedInViewActiveProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ZoomedInViewProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ZoomedOutViewProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISemanticZoomStatics: abstract new (...args: any[]) => ISemanticZoomStatics;
+
+  interface ISemanticZoomViewChangedEventArgs {
+    DestinationItem: Windows.UI.Xaml.Controls.SemanticZoomLocation;
+    IsSourceZoomedInView: boolean;
+    SourceItem: Windows.UI.Xaml.Controls.SemanticZoomLocation;
+  }
+  var ISemanticZoomViewChangedEventArgs: abstract new (...args: any[]) => ISemanticZoomViewChangedEventArgs;
+
+  interface ISettingsFlyout {
+    Hide(): void;
+    Show(): void;
+    ShowIndependent(): void;
+    HeaderBackground: Windows.UI.Xaml.Media.Brush;
+    HeaderForeground: Windows.UI.Xaml.Media.Brush;
+    IconSource: Windows.UI.Xaml.Media.ImageSource;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.SettingsFlyoutTemplateSettings;
+    Title: string;
+    BackClick: Windows.UI.Xaml.Controls.BackClickEventHandler | null;
+  }
+  var ISettingsFlyout: abstract new (...args: any[]) => ISettingsFlyout;
+
+  interface ISettingsFlyoutFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.SettingsFlyout;
+  }
+  var ISettingsFlyoutFactory: abstract new (...args: any[]) => ISettingsFlyoutFactory;
+
+  interface ISettingsFlyoutStatics {
+    readonly HeaderBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IconSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TitleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISettingsFlyoutStatics: abstract new (...args: any[]) => ISettingsFlyoutStatics;
+
+  interface ISlider {
+    IntermediateValue: number;
+    IsDirectionReversed: boolean;
+    IsThumbToolTipEnabled: boolean;
+    Orientation: number;
+    SnapsTo: number;
+    StepFrequency: number;
+    ThumbToolTipValueConverter: Windows.UI.Xaml.Data.IValueConverter;
+    TickFrequency: number;
+    TickPlacement: number;
+  }
+  var ISlider: abstract new (...args: any[]) => ISlider;
+
+  interface ISlider2 {
+    Header: Object;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+  }
+  var ISlider2: abstract new (...args: any[]) => ISlider2;
+
+  interface ISliderFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Slider;
+  }
+  var ISliderFactory: abstract new (...args: any[]) => ISliderFactory;
+
+  interface ISliderStatics {
+    readonly IntermediateValueProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsDirectionReversedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsThumbToolTipEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SnapsToProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StepFrequencyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ThumbToolTipValueConverterProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TickFrequencyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TickPlacementProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISliderStatics: abstract new (...args: any[]) => ISliderStatics;
+
+  interface ISliderStatics2 {
+    readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISliderStatics2: abstract new (...args: any[]) => ISliderStatics2;
+
+  interface ISplitButton {
+    Command: Windows.UI.Xaml.Input.ICommand;
+    CommandParameter: Object;
+    Flyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    Click: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SplitButton, Windows.UI.Xaml.Controls.SplitButtonClickEventArgs> | null;
+  }
+  var ISplitButton: abstract new (...args: any[]) => ISplitButton;
+
+  interface ISplitButtonAutomationPeer {
+  }
+  var ISplitButtonAutomationPeer: abstract new (...args: any[]) => ISplitButtonAutomationPeer;
+
+  interface ISplitButtonAutomationPeerFactory {
+    CreateInstance(owner: Windows.UI.Xaml.Controls.SplitButton, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.SplitButtonAutomationPeer;
+  }
+  var ISplitButtonAutomationPeerFactory: abstract new (...args: any[]) => ISplitButtonAutomationPeerFactory;
+
+  interface ISplitButtonClickEventArgs {
+  }
+  var ISplitButtonClickEventArgs: abstract new (...args: any[]) => ISplitButtonClickEventArgs;
+
+  interface ISplitButtonFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.SplitButton;
+  }
+  var ISplitButtonFactory: abstract new (...args: any[]) => ISplitButtonFactory;
+
+  interface ISplitButtonStatics {
+    readonly CommandParameterProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CommandProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISplitButtonStatics: abstract new (...args: any[]) => ISplitButtonStatics;
+
+  interface ISplitView {
+    CompactPaneLength: number;
+    Content: Windows.UI.Xaml.UIElement;
+    DisplayMode: number;
+    IsPaneOpen: boolean;
+    OpenPaneLength: number;
+    Pane: Windows.UI.Xaml.UIElement;
+    PaneBackground: Windows.UI.Xaml.Media.Brush;
+    PanePlacement: number;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.SplitViewTemplateSettings;
+    PaneClosed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SplitView, Object> | null;
+    PaneClosing: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SplitView, Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs> | null;
+  }
+  var ISplitView: abstract new (...args: any[]) => ISplitView;
+
+  interface ISplitView2 {
+    LightDismissOverlayMode: number;
+  }
+  var ISplitView2: abstract new (...args: any[]) => ISplitView2;
+
+  interface ISplitView3 {
+    PaneOpened: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SplitView, Object> | null;
+    PaneOpening: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SplitView, Object> | null;
+  }
+  var ISplitView3: abstract new (...args: any[]) => ISplitView3;
+
+  interface ISplitViewFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.SplitView;
+  }
+  var ISplitViewFactory: abstract new (...args: any[]) => ISplitViewFactory;
+
+  interface ISplitViewPaneClosingEventArgs {
+    Cancel: boolean;
+  }
+  var ISplitViewPaneClosingEventArgs: abstract new (...args: any[]) => ISplitViewPaneClosingEventArgs;
+
+  interface ISplitViewStatics {
+    readonly CompactPaneLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DisplayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsPaneOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OpenPaneLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaneBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PanePlacementProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaneProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TemplateSettingsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISplitViewStatics: abstract new (...args: any[]) => ISplitViewStatics;
+
+  interface ISplitViewStatics2 {
+    readonly LightDismissOverlayModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISplitViewStatics2: abstract new (...args: any[]) => ISplitViewStatics2;
+
+  interface IStackPanel {
+    AreScrollSnapPointsRegular: boolean;
+    Orientation: number;
+  }
+  var IStackPanel: abstract new (...args: any[]) => IStackPanel;
+
+  interface IStackPanel2 {
+    BorderBrush: Windows.UI.Xaml.Media.Brush;
+    BorderThickness: Windows.UI.Xaml.Thickness;
+    CornerRadius: Windows.UI.Xaml.CornerRadius;
+    Padding: Windows.UI.Xaml.Thickness;
+  }
+  var IStackPanel2: abstract new (...args: any[]) => IStackPanel2;
+
+  interface IStackPanel4 {
+    Spacing: number;
+  }
+  var IStackPanel4: abstract new (...args: any[]) => IStackPanel4;
+
+  interface IStackPanel5 {
+    BackgroundSizing: number;
+  }
+  var IStackPanel5: abstract new (...args: any[]) => IStackPanel5;
+
+  interface IStackPanelFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.StackPanel;
+  }
+  var IStackPanelFactory: abstract new (...args: any[]) => IStackPanelFactory;
+
+  interface IStackPanelStatics {
+    readonly AreScrollSnapPointsRegularProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IStackPanelStatics: abstract new (...args: any[]) => IStackPanelStatics;
+
+  interface IStackPanelStatics2 {
+    readonly BorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CornerRadiusProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IStackPanelStatics2: abstract new (...args: any[]) => IStackPanelStatics2;
+
+  interface IStackPanelStatics4 {
+    readonly SpacingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IStackPanelStatics4: abstract new (...args: any[]) => IStackPanelStatics4;
+
+  interface IStackPanelStatics5 {
+    readonly BackgroundSizingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IStackPanelStatics5: abstract new (...args: any[]) => IStackPanelStatics5;
+
+  interface IStyleSelector {
+    SelectStyle(item: Object, container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Style;
+  }
+  var IStyleSelector: abstract new (...args: any[]) => IStyleSelector;
+
+  interface IStyleSelectorFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.StyleSelector;
+  }
+  var IStyleSelectorFactory: abstract new (...args: any[]) => IStyleSelectorFactory;
+
+  interface IStyleSelectorOverrides {
+    SelectStyleCore(item: Object, container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Style;
+  }
+  var IStyleSelectorOverrides: abstract new (...args: any[]) => IStyleSelectorOverrides;
+
+  interface ISwapChainBackgroundPanel {
+  }
+  var ISwapChainBackgroundPanel: abstract new (...args: any[]) => ISwapChainBackgroundPanel;
+
+  interface ISwapChainBackgroundPanel2 {
+    CreateCoreIndependentInputSource(deviceTypes: number): Windows.UI.Core.CoreIndependentInputSource;
+  }
+  var ISwapChainBackgroundPanel2: abstract new (...args: any[]) => ISwapChainBackgroundPanel2;
+
+  interface ISwapChainBackgroundPanelFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.SwapChainBackgroundPanel;
+  }
+  var ISwapChainBackgroundPanelFactory: abstract new (...args: any[]) => ISwapChainBackgroundPanelFactory;
+
+  interface ISwapChainPanel {
+    CreateCoreIndependentInputSource(deviceTypes: number): Windows.UI.Core.CoreIndependentInputSource;
+    readonly CompositionScaleX: number;
+    readonly CompositionScaleY: number;
+    CompositionScaleChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SwapChainPanel, Object> | null;
+  }
+  var ISwapChainPanel: abstract new (...args: any[]) => ISwapChainPanel;
+
+  interface ISwapChainPanelFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.SwapChainPanel;
+  }
+  var ISwapChainPanelFactory: abstract new (...args: any[]) => ISwapChainPanelFactory;
+
+  interface ISwapChainPanelStatics {
+    readonly CompositionScaleXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CompositionScaleYProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISwapChainPanelStatics: abstract new (...args: any[]) => ISwapChainPanelStatics;
+
+  interface ISwipeControl {
+    Close(): void;
+    BottomItems: Windows.UI.Xaml.Controls.SwipeItems;
+    LeftItems: Windows.UI.Xaml.Controls.SwipeItems;
+    RightItems: Windows.UI.Xaml.Controls.SwipeItems;
+    TopItems: Windows.UI.Xaml.Controls.SwipeItems;
+  }
+  var ISwipeControl: abstract new (...args: any[]) => ISwipeControl;
+
+  interface ISwipeControlFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.SwipeControl;
+  }
+  var ISwipeControlFactory: abstract new (...args: any[]) => ISwipeControlFactory;
+
+  interface ISwipeControlStatics {
+    readonly BottomItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LeftItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RightItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TopItemsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISwipeControlStatics: abstract new (...args: any[]) => ISwipeControlStatics;
+
+  interface ISwipeItem {
+    Background: Windows.UI.Xaml.Media.Brush;
+    BehaviorOnInvoked: number;
+    Command: Windows.UI.Xaml.Input.ICommand;
+    CommandParameter: Object;
+    Foreground: Windows.UI.Xaml.Media.Brush;
+    IconSource: Windows.UI.Xaml.Controls.IconSource;
+    Text: string;
+    Invoked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.SwipeItem, Windows.UI.Xaml.Controls.SwipeItemInvokedEventArgs> | null;
+  }
+  var ISwipeItem: abstract new (...args: any[]) => ISwipeItem;
+
+  interface ISwipeItemFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.SwipeItem;
+  }
+  var ISwipeItemFactory: abstract new (...args: any[]) => ISwipeItemFactory;
+
+  interface ISwipeItemInvokedEventArgs {
+    readonly SwipeControl: Windows.UI.Xaml.Controls.SwipeControl;
+  }
+  var ISwipeItemInvokedEventArgs: abstract new (...args: any[]) => ISwipeItemInvokedEventArgs;
+
+  interface ISwipeItemStatics {
+    readonly BackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BehaviorOnInvokedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CommandParameterProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CommandProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IconSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISwipeItemStatics: abstract new (...args: any[]) => ISwipeItemStatics;
+
+  interface ISwipeItems {
+    Mode: number;
+  }
+  var ISwipeItems: abstract new (...args: any[]) => ISwipeItems;
+
+  interface ISwipeItemsFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.SwipeItems;
+  }
+  var ISwipeItemsFactory: abstract new (...args: any[]) => ISwipeItemsFactory;
+
+  interface ISwipeItemsStatics {
+    readonly ModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISwipeItemsStatics: abstract new (...args: any[]) => ISwipeItemsStatics;
+
+  interface ISymbolIcon {
+    Symbol: number;
+  }
+  var ISymbolIcon: abstract new (...args: any[]) => ISymbolIcon;
+
+  interface ISymbolIconFactory {
+    CreateInstanceWithSymbol(symbol: number): Windows.UI.Xaml.Controls.SymbolIcon;
+  }
+  var ISymbolIconFactory: abstract new (...args: any[]) => ISymbolIconFactory;
+
+  interface ISymbolIconSource {
+    Symbol: number;
+  }
+  var ISymbolIconSource: abstract new (...args: any[]) => ISymbolIconSource;
+
+  interface ISymbolIconSourceFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.SymbolIconSource;
+  }
+  var ISymbolIconSourceFactory: abstract new (...args: any[]) => ISymbolIconSourceFactory;
+
+  interface ISymbolIconSourceStatics {
+    readonly SymbolProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISymbolIconSourceStatics: abstract new (...args: any[]) => ISymbolIconSourceStatics;
+
+  interface ISymbolIconStatics {
+    readonly SymbolProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISymbolIconStatics: abstract new (...args: any[]) => ISymbolIconStatics;
+
+  interface ITextBlock {
+    Focus(value: number): boolean;
+    Select(start: Windows.UI.Xaml.Documents.TextPointer, end: Windows.UI.Xaml.Documents.TextPointer): void;
+    SelectAll(): void;
+    readonly BaselineOffset: number;
+    CharacterSpacing: number;
+    readonly ContentEnd: Windows.UI.Xaml.Documents.TextPointer;
+    readonly ContentStart: Windows.UI.Xaml.Documents.TextPointer;
+    FontFamily: Windows.UI.Xaml.Media.FontFamily;
+    FontSize: number;
+    FontStretch: number;
+    FontStyle: number;
+    FontWeight: Windows.UI.Text.FontWeight;
+    Foreground: Windows.UI.Xaml.Media.Brush;
+    readonly Inlines: Windows.UI.Xaml.Documents.InlineCollection;
+    IsTextSelectionEnabled: boolean;
+    LineHeight: number;
+    LineStackingStrategy: number;
+    Padding: Windows.UI.Xaml.Thickness;
+    readonly SelectedText: string;
+    readonly SelectionEnd: Windows.UI.Xaml.Documents.TextPointer;
+    readonly SelectionStart: Windows.UI.Xaml.Documents.TextPointer;
+    Text: string;
+    TextAlignment: number;
+    TextTrimming: number;
+    TextWrapping: number;
+    ContextMenuOpening: Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler | null;
+    SelectionChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+  var ITextBlock: abstract new (...args: any[]) => ITextBlock;
+
+  interface ITextBlock2 {
+    IsColorFontEnabled: boolean;
+    MaxLines: number;
+    OpticalMarginAlignment: number;
+    SelectionHighlightColor: Windows.UI.Xaml.Media.SolidColorBrush;
+    TextLineBounds: number;
+    TextReadingOrder: number;
+  }
+  var ITextBlock2: abstract new (...args: any[]) => ITextBlock2;
+
+  interface ITextBlock3 {
+    IsTextScaleFactorEnabled: boolean;
+  }
+  var ITextBlock3: abstract new (...args: any[]) => ITextBlock3;
+
+  interface ITextBlock4 {
+    GetAlphaMask(): Windows.UI.Composition.CompositionBrush;
+  }
+  var ITextBlock4: abstract new (...args: any[]) => ITextBlock4;
+
+  interface ITextBlock5 {
+    TextDecorations: number;
+  }
+  var ITextBlock5: abstract new (...args: any[]) => ITextBlock5;
+
+  interface ITextBlock6 {
+    HorizontalTextAlignment: number;
+    readonly IsTextTrimmed: boolean;
+    readonly TextHighlighters: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Documents.TextHighlighter> | Windows.UI.Xaml.Documents.TextHighlighter[];
+    IsTextTrimmedChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBlock, Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs> | null;
+  }
+  var ITextBlock6: abstract new (...args: any[]) => ITextBlock6;
+
+  interface ITextBlock7 {
+    CopySelectionToClipboard(): void;
+    SelectionFlyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+  }
+  var ITextBlock7: abstract new (...args: any[]) => ITextBlock7;
+
+  interface ITextBlockStatics {
+    readonly CharacterSpacingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontStretchProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsTextSelectionEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LineHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LineStackingStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedTextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextTrimmingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextWrappingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITextBlockStatics: abstract new (...args: any[]) => ITextBlockStatics;
+
+  interface ITextBlockStatics2 {
+    readonly IsColorFontEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxLinesProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OpticalMarginAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionHighlightColorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextLineBoundsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextReadingOrderProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITextBlockStatics2: abstract new (...args: any[]) => ITextBlockStatics2;
+
+  interface ITextBlockStatics3 {
+    readonly IsTextScaleFactorEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITextBlockStatics3: abstract new (...args: any[]) => ITextBlockStatics3;
+
+  interface ITextBlockStatics5 {
+    readonly TextDecorationsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITextBlockStatics5: abstract new (...args: any[]) => ITextBlockStatics5;
+
+  interface ITextBlockStatics6 {
+    readonly HorizontalTextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsTextTrimmedProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITextBlockStatics6: abstract new (...args: any[]) => ITextBlockStatics6;
+
+  interface ITextBlockStatics7 {
+    readonly SelectionFlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITextBlockStatics7: abstract new (...args: any[]) => ITextBlockStatics7;
+
+  interface ITextBox {
+    GetRectFromCharacterIndex(charIndex: number, trailingEdge: boolean): Windows.Foundation.Rect;
+    Select(start: number, length: number): void;
+    SelectAll(): void;
+    AcceptsReturn: boolean;
+    InputScope: Windows.UI.Xaml.Input.InputScope;
+    IsReadOnly: boolean;
+    IsSpellCheckEnabled: boolean;
+    IsTextPredictionEnabled: boolean;
+    MaxLength: number;
+    SelectedText: string;
+    SelectionLength: number;
+    SelectionStart: number;
+    Text: string;
+    TextAlignment: number;
+    TextWrapping: number;
+    ContextMenuOpening: Windows.UI.Xaml.Controls.ContextMenuOpeningEventHandler | null;
+    SelectionChanged: Windows.UI.Xaml.RoutedEventHandler | null;
+    TextChanged: Windows.UI.Xaml.Controls.TextChangedEventHandler | null;
+  }
+  var ITextBox: abstract new (...args: any[]) => ITextBox;
+
+  interface ITextBox2 {
+    Header: Object;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    IsColorFontEnabled: boolean;
+    PlaceholderText: string;
+    PreventKeyboardDisplayOnProgrammaticFocus: boolean;
+    SelectionHighlightColor: Windows.UI.Xaml.Media.SolidColorBrush;
+    Paste: Windows.UI.Xaml.Controls.TextControlPasteEventHandler | null;
+  }
+  var ITextBox2: abstract new (...args: any[]) => ITextBox2;
+
+  interface ITextBox3 {
+    DesiredCandidateWindowAlignment: number;
+    TextReadingOrder: number;
+    CandidateWindowBoundsChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox, Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs> | null;
+    TextChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox, Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs> | null;
+    TextCompositionChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox, Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs> | null;
+    TextCompositionEnded: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox, Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs> | null;
+    TextCompositionStarted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox, Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs> | null;
+  }
+  var ITextBox3: abstract new (...args: any[]) => ITextBox3;
+
+  interface ITextBox4 {
+    GetLinguisticAlternativesAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<string> | string[]>;
+  }
+  var ITextBox4: abstract new (...args: any[]) => ITextBox4;
+
+  interface ITextBox5 {
+    SelectionHighlightColorWhenNotFocused: Windows.UI.Xaml.Media.SolidColorBrush;
+  }
+  var ITextBox5: abstract new (...args: any[]) => ITextBox5;
+
+  interface ITextBox6 {
+    CharacterCasing: number;
+    HorizontalTextAlignment: number;
+    PlaceholderForeground: Windows.UI.Xaml.Media.Brush;
+    BeforeTextChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox, Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs> | null;
+    CopyingToClipboard: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox, Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs> | null;
+    CuttingToClipboard: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox, Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs> | null;
+  }
+  var ITextBox6: abstract new (...args: any[]) => ITextBox6;
+
+  interface ITextBox7 {
+    HandwritingView: Windows.UI.Xaml.Controls.HandwritingView;
+    IsHandwritingViewEnabled: boolean;
+  }
+  var ITextBox7: abstract new (...args: any[]) => ITextBox7;
+
+  interface ITextBox8 {
+    ClearUndoRedoHistory(): void;
+    CopySelectionToClipboard(): void;
+    CutSelectionToClipboard(): void;
+    PasteFromClipboard(): void;
+    Redo(): void;
+    Undo(): void;
+    readonly CanPasteClipboardContent: boolean;
+    readonly CanRedo: boolean;
+    readonly CanUndo: boolean;
+    Description: Object;
+    readonly ProofingMenuFlyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    SelectionFlyout: Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    SelectionChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TextBox, Windows.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs> | null;
+  }
+  var ITextBox8: abstract new (...args: any[]) => ITextBox8;
+
+  interface ITextBoxBeforeTextChangingEventArgs {
+    Cancel: boolean;
+    readonly NewText: string;
+  }
+  var ITextBoxBeforeTextChangingEventArgs: abstract new (...args: any[]) => ITextBoxBeforeTextChangingEventArgs;
+
+  interface ITextBoxFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.TextBox;
+  }
+  var ITextBoxFactory: abstract new (...args: any[]) => ITextBoxFactory;
+
+  interface ITextBoxSelectionChangingEventArgs {
+    Cancel: boolean;
+    readonly SelectionLength: number;
+    readonly SelectionStart: number;
+  }
+  var ITextBoxSelectionChangingEventArgs: abstract new (...args: any[]) => ITextBoxSelectionChangingEventArgs;
+
+  interface ITextBoxStatics {
+    readonly AcceptsReturnProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly InputScopeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsReadOnlyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsSpellCheckEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsTextPredictionEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextWrappingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITextBoxStatics: abstract new (...args: any[]) => ITextBoxStatics;
+
+  interface ITextBoxStatics2 {
+    readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsColorFontEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlaceholderTextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PreventKeyboardDisplayOnProgrammaticFocusProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionHighlightColorProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITextBoxStatics2: abstract new (...args: any[]) => ITextBoxStatics2;
+
+  interface ITextBoxStatics3 {
+    readonly DesiredCandidateWindowAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextReadingOrderProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITextBoxStatics3: abstract new (...args: any[]) => ITextBoxStatics3;
+
+  interface ITextBoxStatics5 {
+    readonly SelectionHighlightColorWhenNotFocusedProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITextBoxStatics5: abstract new (...args: any[]) => ITextBoxStatics5;
+
+  interface ITextBoxStatics6 {
+    readonly CharacterCasingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalTextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlaceholderForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITextBoxStatics6: abstract new (...args: any[]) => ITextBoxStatics6;
+
+  interface ITextBoxStatics7 {
+    readonly HandwritingViewProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsHandwritingViewEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITextBoxStatics7: abstract new (...args: any[]) => ITextBoxStatics7;
+
+  interface ITextBoxStatics8 {
+    readonly CanPasteClipboardContentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanRedoProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanUndoProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DescriptionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ProofingMenuFlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionFlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITextBoxStatics8: abstract new (...args: any[]) => ITextBoxStatics8;
+
+  interface ITextBoxTextChangingEventArgs {
+  }
+  var ITextBoxTextChangingEventArgs: abstract new (...args: any[]) => ITextBoxTextChangingEventArgs;
+
+  interface ITextBoxTextChangingEventArgs2 {
+    readonly IsContentChanging: boolean;
+  }
+  var ITextBoxTextChangingEventArgs2: abstract new (...args: any[]) => ITextBoxTextChangingEventArgs2;
+
+  interface ITextChangedEventArgs {
+  }
+  var ITextChangedEventArgs: abstract new (...args: any[]) => ITextChangedEventArgs;
+
+  interface ITextCommandBarFlyout {
+  }
+  var ITextCommandBarFlyout: abstract new (...args: any[]) => ITextCommandBarFlyout;
+
+  interface ITextCommandBarFlyoutFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.TextCommandBarFlyout;
+  }
+  var ITextCommandBarFlyoutFactory: abstract new (...args: any[]) => ITextCommandBarFlyoutFactory;
+
+  interface ITextCompositionChangedEventArgs {
+    readonly Length: number;
+    readonly StartIndex: number;
+  }
+  var ITextCompositionChangedEventArgs: abstract new (...args: any[]) => ITextCompositionChangedEventArgs;
+
+  interface ITextCompositionEndedEventArgs {
+    readonly Length: number;
+    readonly StartIndex: number;
+  }
+  var ITextCompositionEndedEventArgs: abstract new (...args: any[]) => ITextCompositionEndedEventArgs;
+
+  interface ITextCompositionStartedEventArgs {
+    readonly Length: number;
+    readonly StartIndex: number;
+  }
+  var ITextCompositionStartedEventArgs: abstract new (...args: any[]) => ITextCompositionStartedEventArgs;
+
+  interface ITextControlCopyingToClipboardEventArgs {
+    Handled: boolean;
+  }
+  var ITextControlCopyingToClipboardEventArgs: abstract new (...args: any[]) => ITextControlCopyingToClipboardEventArgs;
+
+  interface ITextControlCuttingToClipboardEventArgs {
+    Handled: boolean;
+  }
+  var ITextControlCuttingToClipboardEventArgs: abstract new (...args: any[]) => ITextControlCuttingToClipboardEventArgs;
+
+  interface ITextControlPasteEventArgs {
+    Handled: boolean;
+  }
+  var ITextControlPasteEventArgs: abstract new (...args: any[]) => ITextControlPasteEventArgs;
+
+  interface ITimePickedEventArgs {
+    readonly NewTime: Windows.Foundation.TimeSpan;
+    readonly OldTime: Windows.Foundation.TimeSpan;
+  }
+  var ITimePickedEventArgs: abstract new (...args: any[]) => ITimePickedEventArgs;
+
+  interface ITimePicker {
+    ClockIdentifier: string;
+    Header: Object;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    MinuteIncrement: number;
+    Time: Windows.Foundation.TimeSpan;
+    TimeChanged: Windows.Foundation.EventHandler<Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs> | null;
+  }
+  var ITimePicker: abstract new (...args: any[]) => ITimePicker;
+
+  interface ITimePicker2 {
+    LightDismissOverlayMode: number;
+  }
+  var ITimePicker2: abstract new (...args: any[]) => ITimePicker2;
+
+  interface ITimePicker3 {
+    SelectedTime: Windows.Foundation.TimeSpan | null;
+    SelectedTimeChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TimePicker, Windows.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs> | null;
+  }
+  var ITimePicker3: abstract new (...args: any[]) => ITimePicker3;
+
+  interface ITimePickerFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.TimePicker;
+  }
+  var ITimePickerFactory: abstract new (...args: any[]) => ITimePickerFactory;
+
+  interface ITimePickerFlyout {
+    ShowAtAsync(target: Windows.UI.Xaml.FrameworkElement): Windows.Foundation.IAsyncOperation<Windows.Foundation.TimeSpan | null>;
+    ClockIdentifier: string;
+    MinuteIncrement: number;
+    Time: Windows.Foundation.TimeSpan;
+    TimePicked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TimePickerFlyout, Windows.UI.Xaml.Controls.TimePickedEventArgs> | null;
+  }
+  var ITimePickerFlyout: abstract new (...args: any[]) => ITimePickerFlyout;
+
+  interface ITimePickerFlyoutPresenter {
+  }
+  var ITimePickerFlyoutPresenter: abstract new (...args: any[]) => ITimePickerFlyoutPresenter;
+
+  interface ITimePickerFlyoutPresenter2 {
+    IsDefaultShadowEnabled: boolean;
+  }
+  var ITimePickerFlyoutPresenter2: abstract new (...args: any[]) => ITimePickerFlyoutPresenter2;
+
+  interface ITimePickerFlyoutPresenterStatics2 {
+    readonly IsDefaultShadowEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITimePickerFlyoutPresenterStatics2: abstract new (...args: any[]) => ITimePickerFlyoutPresenterStatics2;
+
+  interface ITimePickerFlyoutStatics {
+    readonly ClockIdentifierProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinuteIncrementProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TimeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITimePickerFlyoutStatics: abstract new (...args: any[]) => ITimePickerFlyoutStatics;
+
+  interface ITimePickerSelectedValueChangedEventArgs {
+    readonly NewTime: Windows.Foundation.TimeSpan | null;
+    readonly OldTime: Windows.Foundation.TimeSpan | null;
+  }
+  var ITimePickerSelectedValueChangedEventArgs: abstract new (...args: any[]) => ITimePickerSelectedValueChangedEventArgs;
+
+  interface ITimePickerStatics {
+    readonly ClockIdentifierProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinuteIncrementProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TimeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITimePickerStatics: abstract new (...args: any[]) => ITimePickerStatics;
+
+  interface ITimePickerStatics2 {
+    readonly LightDismissOverlayModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITimePickerStatics2: abstract new (...args: any[]) => ITimePickerStatics2;
+
+  interface ITimePickerStatics3 {
+    readonly SelectedTimeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITimePickerStatics3: abstract new (...args: any[]) => ITimePickerStatics3;
+
+  interface ITimePickerValueChangedEventArgs {
+    readonly NewTime: Windows.Foundation.TimeSpan;
+    readonly OldTime: Windows.Foundation.TimeSpan;
+  }
+  var ITimePickerValueChangedEventArgs: abstract new (...args: any[]) => ITimePickerValueChangedEventArgs;
+
+  interface IToggleMenuFlyoutItem {
+    IsChecked: boolean;
+  }
+  var IToggleMenuFlyoutItem: abstract new (...args: any[]) => IToggleMenuFlyoutItem;
+
+  interface IToggleMenuFlyoutItemFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.ToggleMenuFlyoutItem;
+  }
+  var IToggleMenuFlyoutItemFactory: abstract new (...args: any[]) => IToggleMenuFlyoutItemFactory;
+
+  interface IToggleMenuFlyoutItemStatics {
+    readonly IsCheckedProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IToggleMenuFlyoutItemStatics: abstract new (...args: any[]) => IToggleMenuFlyoutItemStatics;
+
+  interface IToggleSplitButton {
+    IsChecked: boolean;
+    IsCheckedChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.ToggleSplitButton, Windows.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs> | null;
+  }
+  var IToggleSplitButton: abstract new (...args: any[]) => IToggleSplitButton;
+
+  interface IToggleSplitButtonAutomationPeer {
+  }
+  var IToggleSplitButtonAutomationPeer: abstract new (...args: any[]) => IToggleSplitButtonAutomationPeer;
+
+  interface IToggleSplitButtonAutomationPeerFactory {
+    CreateInstance(owner: Windows.UI.Xaml.Controls.ToggleSplitButton, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.ToggleSplitButtonAutomationPeer;
+  }
+  var IToggleSplitButtonAutomationPeerFactory: abstract new (...args: any[]) => IToggleSplitButtonAutomationPeerFactory;
+
+  interface IToggleSplitButtonFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.ToggleSplitButton;
+  }
+  var IToggleSplitButtonFactory: abstract new (...args: any[]) => IToggleSplitButtonFactory;
+
+  interface IToggleSplitButtonIsCheckedChangedEventArgs {
+  }
+  var IToggleSplitButtonIsCheckedChangedEventArgs: abstract new (...args: any[]) => IToggleSplitButtonIsCheckedChangedEventArgs;
+
+  interface IToggleSwitch {
+    Header: Object;
+    HeaderTemplate: Windows.UI.Xaml.DataTemplate;
+    IsOn: boolean;
+    OffContent: Object;
+    OffContentTemplate: Windows.UI.Xaml.DataTemplate;
+    OnContent: Object;
+    OnContentTemplate: Windows.UI.Xaml.DataTemplate;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.ToggleSwitchTemplateSettings;
+    Toggled: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+  var IToggleSwitch: abstract new (...args: any[]) => IToggleSwitch;
+
+  interface IToggleSwitchOverrides {
+    OnHeaderChanged(oldContent: Object, newContent: Object): void;
+    OnOffContentChanged(oldContent: Object, newContent: Object): void;
+    OnOnContentChanged(oldContent: Object, newContent: Object): void;
+    OnToggled(): void;
+  }
+  var IToggleSwitchOverrides: abstract new (...args: any[]) => IToggleSwitchOverrides;
+
+  interface IToggleSwitchStatics {
+    readonly HeaderProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeaderTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsOnProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OffContentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OffContentTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OnContentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OnContentTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IToggleSwitchStatics: abstract new (...args: any[]) => IToggleSwitchStatics;
+
+  interface IToolTip {
+    HorizontalOffset: number;
+    IsOpen: boolean;
+    Placement: number;
+    PlacementTarget: Windows.UI.Xaml.UIElement;
+    readonly TemplateSettings: Windows.UI.Xaml.Controls.Primitives.ToolTipTemplateSettings;
+    VerticalOffset: number;
+    Closed: Windows.UI.Xaml.RoutedEventHandler | null;
+    Opened: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+  var IToolTip: abstract new (...args: any[]) => IToolTip;
+
+  interface IToolTip2 {
+    PlacementRect: Windows.Foundation.Rect | null;
+  }
+  var IToolTip2: abstract new (...args: any[]) => IToolTip2;
+
+  interface IToolTipFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.ToolTip;
+  }
+  var IToolTipFactory: abstract new (...args: any[]) => IToolTipFactory;
+
+  interface IToolTipService {
+  }
+  var IToolTipService: abstract new (...args: any[]) => IToolTipService;
+
+  interface IToolTipServiceStatics {
+    GetPlacement(element: Windows.UI.Xaml.DependencyObject): number;
+    GetPlacementTarget(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.UIElement;
+    GetToolTip(element: Windows.UI.Xaml.DependencyObject): Object;
+    SetPlacement(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    SetPlacementTarget(element: Windows.UI.Xaml.DependencyObject, value: Windows.UI.Xaml.UIElement): void;
+    SetToolTip(element: Windows.UI.Xaml.DependencyObject, value: Object): void;
+    readonly PlacementProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlacementTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ToolTipProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IToolTipServiceStatics: abstract new (...args: any[]) => IToolTipServiceStatics;
+
+  interface IToolTipStatics {
+    readonly HorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlacementProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlacementTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IToolTipStatics: abstract new (...args: any[]) => IToolTipStatics;
+
+  interface IToolTipStatics2 {
+    readonly PlacementRectProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IToolTipStatics2: abstract new (...args: any[]) => IToolTipStatics2;
+
+  interface ITreeView {
+    Collapse(value: Windows.UI.Xaml.Controls.TreeViewNode): void;
+    Expand(value: Windows.UI.Xaml.Controls.TreeViewNode): void;
+    SelectAll(): void;
+    readonly RootNodes: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.TreeViewNode> | Windows.UI.Xaml.Controls.TreeViewNode[];
+    readonly SelectedNodes: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.TreeViewNode> | Windows.UI.Xaml.Controls.TreeViewNode[];
+    SelectionMode: number;
+    Collapsed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TreeView, Windows.UI.Xaml.Controls.TreeViewCollapsedEventArgs> | null;
+    Expanding: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TreeView, Windows.UI.Xaml.Controls.TreeViewExpandingEventArgs> | null;
+    ItemInvoked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TreeView, Windows.UI.Xaml.Controls.TreeViewItemInvokedEventArgs> | null;
+  }
+  var ITreeView: abstract new (...args: any[]) => ITreeView;
+
+  interface ITreeView2 {
+    ContainerFromItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    ContainerFromNode(node: Windows.UI.Xaml.Controls.TreeViewNode): Windows.UI.Xaml.DependencyObject;
+    ItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    NodeFromContainer(container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.TreeViewNode;
+    CanDragItems: boolean;
+    CanReorderItems: boolean;
+    ItemContainerStyle: Windows.UI.Xaml.Style;
+    ItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector;
+    ItemContainerTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    ItemTemplate: Windows.UI.Xaml.DataTemplate;
+    ItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector;
+    ItemsSource: Object;
+    DragItemsCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TreeView, Windows.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs> | null;
+    DragItemsStarting: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TreeView, Windows.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs> | null;
+  }
+  var ITreeView2: abstract new (...args: any[]) => ITreeView2;
+
+  interface ITreeViewCollapsedEventArgs {
+    readonly Node: Windows.UI.Xaml.Controls.TreeViewNode;
+  }
+  var ITreeViewCollapsedEventArgs: abstract new (...args: any[]) => ITreeViewCollapsedEventArgs;
+
+  interface ITreeViewCollapsedEventArgs2 {
+    readonly Item: Object;
+  }
+  var ITreeViewCollapsedEventArgs2: abstract new (...args: any[]) => ITreeViewCollapsedEventArgs2;
+
+  interface ITreeViewDragItemsCompletedEventArgs {
+    readonly DropResult: number;
+    readonly Items: Windows.Foundation.Collections.IVectorView<Object> | Object[];
+  }
+  var ITreeViewDragItemsCompletedEventArgs: abstract new (...args: any[]) => ITreeViewDragItemsCompletedEventArgs;
+
+  interface ITreeViewDragItemsStartingEventArgs {
+    Cancel: boolean;
+    readonly Data: Windows.ApplicationModel.DataTransfer.DataPackage;
+    readonly Items: Windows.Foundation.Collections.IVector<Object> | Object[];
+  }
+  var ITreeViewDragItemsStartingEventArgs: abstract new (...args: any[]) => ITreeViewDragItemsStartingEventArgs;
+
+  interface ITreeViewExpandingEventArgs {
+    readonly Node: Windows.UI.Xaml.Controls.TreeViewNode;
+  }
+  var ITreeViewExpandingEventArgs: abstract new (...args: any[]) => ITreeViewExpandingEventArgs;
+
+  interface ITreeViewExpandingEventArgs2 {
+    readonly Item: Object;
+  }
+  var ITreeViewExpandingEventArgs2: abstract new (...args: any[]) => ITreeViewExpandingEventArgs2;
+
+  interface ITreeViewFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.TreeView;
+  }
+  var ITreeViewFactory: abstract new (...args: any[]) => ITreeViewFactory;
+
+  interface ITreeViewItem {
+    CollapsedGlyph: string;
+    ExpandedGlyph: string;
+    GlyphBrush: Windows.UI.Xaml.Media.Brush;
+    GlyphOpacity: number;
+    GlyphSize: number;
+    IsExpanded: boolean;
+    readonly TreeViewItemTemplateSettings: Windows.UI.Xaml.Controls.TreeViewItemTemplateSettings;
+  }
+  var ITreeViewItem: abstract new (...args: any[]) => ITreeViewItem;
+
+  interface ITreeViewItem2 {
+    HasUnrealizedChildren: boolean;
+    ItemsSource: Object;
+  }
+  var ITreeViewItem2: abstract new (...args: any[]) => ITreeViewItem2;
+
+  interface ITreeViewItemFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.TreeViewItem;
+  }
+  var ITreeViewItemFactory: abstract new (...args: any[]) => ITreeViewItemFactory;
+
+  interface ITreeViewItemInvokedEventArgs {
+    Handled: boolean;
+    readonly InvokedItem: Object;
+  }
+  var ITreeViewItemInvokedEventArgs: abstract new (...args: any[]) => ITreeViewItemInvokedEventArgs;
+
+  interface ITreeViewItemStatics {
+    readonly CollapsedGlyphProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ExpandedGlyphProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GlyphBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GlyphOpacityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GlyphSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsExpandedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TreeViewItemTemplateSettingsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITreeViewItemStatics: abstract new (...args: any[]) => ITreeViewItemStatics;
+
+  interface ITreeViewItemStatics2 {
+    readonly HasUnrealizedChildrenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemsSourceProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITreeViewItemStatics2: abstract new (...args: any[]) => ITreeViewItemStatics2;
+
+  interface ITreeViewItemTemplateSettings {
+    readonly CollapsedGlyphVisibility: number;
+    readonly DragItemsCount: number;
+    readonly ExpandedGlyphVisibility: number;
+    readonly Indentation: Windows.UI.Xaml.Thickness;
+  }
+  var ITreeViewItemTemplateSettings: abstract new (...args: any[]) => ITreeViewItemTemplateSettings;
+
+  interface ITreeViewItemTemplateSettingsFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.TreeViewItemTemplateSettings;
+  }
+  var ITreeViewItemTemplateSettingsFactory: abstract new (...args: any[]) => ITreeViewItemTemplateSettingsFactory;
+
+  interface ITreeViewItemTemplateSettingsStatics {
+    readonly CollapsedGlyphVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DragItemsCountProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ExpandedGlyphVisibilityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IndentationProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITreeViewItemTemplateSettingsStatics: abstract new (...args: any[]) => ITreeViewItemTemplateSettingsStatics;
+
+  interface ITreeViewList {
+  }
+  var ITreeViewList: abstract new (...args: any[]) => ITreeViewList;
+
+  interface ITreeViewListFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.TreeViewList;
+  }
+  var ITreeViewListFactory: abstract new (...args: any[]) => ITreeViewListFactory;
+
+  interface ITreeViewNode {
+    readonly Children: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.TreeViewNode> | Windows.UI.Xaml.Controls.TreeViewNode[];
+    Content: Object;
+    readonly Depth: number;
+    readonly HasChildren: boolean;
+    HasUnrealizedChildren: boolean;
+    IsExpanded: boolean;
+    readonly Parent: Windows.UI.Xaml.Controls.TreeViewNode;
+  }
+  var ITreeViewNode: abstract new (...args: any[]) => ITreeViewNode;
+
+  interface ITreeViewNodeFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.TreeViewNode;
+  }
+  var ITreeViewNodeFactory: abstract new (...args: any[]) => ITreeViewNodeFactory;
+
+  interface ITreeViewNodeStatics {
+    readonly ContentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DepthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HasChildrenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsExpandedProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITreeViewNodeStatics: abstract new (...args: any[]) => ITreeViewNodeStatics;
+
+  interface ITreeViewStatics {
+    readonly SelectionModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITreeViewStatics: abstract new (...args: any[]) => ITreeViewStatics;
+
+  interface ITreeViewStatics2 {
+    readonly CanDragItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanReorderItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemContainerStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemContainerStyleSelectorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemContainerTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemTemplateSelectorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemsSourceProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITreeViewStatics2: abstract new (...args: any[]) => ITreeViewStatics2;
+
+  interface ITwoPaneView {
+    MinTallModeHeight: number;
+    MinWideModeWidth: number;
+    readonly Mode: number;
+    Pane1: Windows.UI.Xaml.UIElement;
+    Pane1Length: Windows.UI.Xaml.GridLength;
+    Pane2: Windows.UI.Xaml.UIElement;
+    Pane2Length: Windows.UI.Xaml.GridLength;
+    PanePriority: number;
+    TallModeConfiguration: number;
+    WideModeConfiguration: number;
+    ModeChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.TwoPaneView, Object> | null;
+  }
+  var ITwoPaneView: abstract new (...args: any[]) => ITwoPaneView;
+
+  interface ITwoPaneViewFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.TwoPaneView;
+  }
+  var ITwoPaneViewFactory: abstract new (...args: any[]) => ITwoPaneViewFactory;
+
+  interface ITwoPaneViewStatics {
+    readonly MinTallModeHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinWideModeWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Pane1LengthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Pane1Property: Windows.UI.Xaml.DependencyProperty;
+    readonly Pane2LengthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Pane2Property: Windows.UI.Xaml.DependencyProperty;
+    readonly PanePriorityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TallModeConfigurationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly WideModeConfigurationProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITwoPaneViewStatics: abstract new (...args: any[]) => ITwoPaneViewStatics;
+
+  interface IUIElementCollection {
+    Move(oldIndex: number, newIndex: number): void;
+  }
+  var IUIElementCollection: abstract new (...args: any[]) => IUIElementCollection;
+
+  interface IUserControl {
+    Content: Windows.UI.Xaml.UIElement;
+  }
+  var IUserControl: abstract new (...args: any[]) => IUserControl;
+
+  interface IUserControlFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.UserControl;
+  }
+  var IUserControlFactory: abstract new (...args: any[]) => IUserControlFactory;
+
+  interface IUserControlStatics {
+    readonly ContentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IUserControlStatics: abstract new (...args: any[]) => IUserControlStatics;
+
+  interface IVariableSizedWrapGrid {
+    HorizontalChildrenAlignment: number;
+    ItemHeight: number;
+    ItemWidth: number;
+    MaximumRowsOrColumns: number;
+    Orientation: number;
+    VerticalChildrenAlignment: number;
+  }
+  var IVariableSizedWrapGrid: abstract new (...args: any[]) => IVariableSizedWrapGrid;
+
+  interface IVariableSizedWrapGridStatics {
+    GetColumnSpan(element: Windows.UI.Xaml.UIElement): number;
+    GetRowSpan(element: Windows.UI.Xaml.UIElement): number;
+    SetColumnSpan(element: Windows.UI.Xaml.UIElement, value: number): void;
+    SetRowSpan(element: Windows.UI.Xaml.UIElement, value: number): void;
+    readonly ColumnSpanProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalChildrenAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaximumRowsOrColumnsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RowSpanProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalChildrenAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IVariableSizedWrapGridStatics: abstract new (...args: any[]) => IVariableSizedWrapGridStatics;
+
+  interface IViewbox {
+    Child: Windows.UI.Xaml.UIElement;
+    Stretch: number;
+    StretchDirection: number;
+  }
+  var IViewbox: abstract new (...args: any[]) => IViewbox;
+
+  interface IViewboxStatics {
+    readonly StretchDirectionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StretchProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IViewboxStatics: abstract new (...args: any[]) => IViewboxStatics;
+
+  interface IVirtualizingPanel {
+    readonly ItemContainerGenerator: Windows.UI.Xaml.Controls.ItemContainerGenerator;
+  }
+  var IVirtualizingPanel: abstract new (...args: any[]) => IVirtualizingPanel;
+
+  interface IVirtualizingPanelFactory {
+  }
+  var IVirtualizingPanelFactory: abstract new (...args: any[]) => IVirtualizingPanelFactory;
+
+  interface IVirtualizingPanelOverrides {
+    BringIndexIntoView(index: number): void;
+    OnClearChildren(): void;
+    OnItemsChanged(sender: Object, args: Windows.UI.Xaml.Controls.Primitives.ItemsChangedEventArgs): void;
+  }
+  var IVirtualizingPanelOverrides: abstract new (...args: any[]) => IVirtualizingPanelOverrides;
+
+  interface IVirtualizingPanelProtected {
+    AddInternalChild(child: Windows.UI.Xaml.UIElement): void;
+    InsertInternalChild(index: number, child: Windows.UI.Xaml.UIElement): void;
+    RemoveInternalChildRange(index: number, range: number): void;
+  }
+  var IVirtualizingPanelProtected: abstract new (...args: any[]) => IVirtualizingPanelProtected;
+
+  interface IVirtualizingStackPanel {
+    AreScrollSnapPointsRegular: boolean;
+    Orientation: number;
+    CleanUpVirtualizedItemEvent: Windows.UI.Xaml.Controls.CleanUpVirtualizedItemEventHandler | null;
+  }
+  var IVirtualizingStackPanel: abstract new (...args: any[]) => IVirtualizingStackPanel;
+
+  interface IVirtualizingStackPanelOverrides {
+    OnCleanUpVirtualizedItem(e: Windows.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs): void;
+  }
+  var IVirtualizingStackPanelOverrides: abstract new (...args: any[]) => IVirtualizingStackPanelOverrides;
+
+  interface IVirtualizingStackPanelStatics {
+    GetIsVirtualizing(o: Windows.UI.Xaml.DependencyObject): boolean;
+    GetVirtualizationMode(element: Windows.UI.Xaml.DependencyObject): number;
+    SetVirtualizationMode(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    readonly AreScrollSnapPointsRegularProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsVirtualizingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VirtualizationModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IVirtualizingStackPanelStatics: abstract new (...args: any[]) => IVirtualizingStackPanelStatics;
+
+  interface IWebView {
+    InvokeScript(scriptName: string, arguments_: string[]): string;
+    Navigate(source: Windows.Foundation.Uri): void;
+    NavigateToString(text: string): void;
+    AllowedScriptNotifyUris: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly DataTransferPackage: Windows.ApplicationModel.DataTransfer.DataPackage;
+    Source: Windows.Foundation.Uri;
+    LoadCompleted: Windows.UI.Xaml.Navigation.LoadCompletedEventHandler | null;
+    NavigationFailed: Windows.UI.Xaml.Controls.WebViewNavigationFailedEventHandler | null;
+    ScriptNotify: Windows.UI.Xaml.Controls.NotifyEventHandler | null;
+  }
+  var IWebView: abstract new (...args: any[]) => IWebView;
+
+  interface IWebView2 {
+    BuildLocalStreamUri(contentIdentifier: string, relativePath: string): Windows.Foundation.Uri;
+    CapturePreviewToStreamAsync(stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    CaptureSelectedContentToDataPackageAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.DataTransfer.DataPackage>;
+    Focus(value: number): boolean;
+    GoBack(): void;
+    GoForward(): void;
+    InvokeScriptAsync(scriptName: string, arguments_: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<string>;
+    NavigateToLocalStreamUri(source: Windows.Foundation.Uri, streamResolver: Windows.Web.IUriToStreamResolver): void;
+    NavigateWithHttpRequestMessage(requestMessage: Windows.Web.Http.HttpRequestMessage): void;
+    Refresh(): void;
+    Stop(): void;
+    readonly CanGoBack: boolean;
+    readonly CanGoForward: boolean;
+    DefaultBackgroundColor: Windows.UI.Color;
+    readonly DocumentTitle: string;
+    ContentLoading: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs> | null;
+    DOMContentLoaded: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs> | null;
+    FrameContentLoading: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs> | null;
+    FrameDOMContentLoaded: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs> | null;
+    FrameNavigationCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs> | null;
+    FrameNavigationStarting: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs> | null;
+    LongRunningScriptDetected: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewLongRunningScriptDetectedEventArgs> | null;
+    NavigationCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs> | null;
+    NavigationStarting: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs> | null;
+    UnsafeContentWarningDisplaying: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Object> | null;
+    UnviewableContentIdentified: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewUnviewableContentIdentifiedEventArgs> | null;
+  }
+  var IWebView2: abstract new (...args: any[]) => IWebView2;
+
+  interface IWebView3 {
+    readonly ContainsFullScreenElement: boolean;
+    ContainsFullScreenElementChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Object> | null;
+  }
+  var IWebView3: abstract new (...args: any[]) => IWebView3;
+
+  interface IWebView4 {
+    AddWebAllowedObject(name: string, pObject: Object): void;
+    DeferredPermissionRequestById(id: number): Windows.UI.Xaml.Controls.WebViewDeferredPermissionRequest;
+    readonly DeferredPermissionRequests: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.WebViewDeferredPermissionRequest> | Windows.UI.Xaml.Controls.WebViewDeferredPermissionRequest[];
+    readonly ExecutionMode: number;
+    readonly Settings: Windows.UI.Xaml.Controls.WebViewSettings;
+    NewWindowRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewNewWindowRequestedEventArgs> | null;
+    PermissionRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewPermissionRequestedEventArgs> | null;
+    UnsupportedUriSchemeIdentified: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewUnsupportedUriSchemeIdentifiedEventArgs> | null;
+  }
+  var IWebView4: abstract new (...args: any[]) => IWebView4;
+
+  interface IWebView5 {
+    XYFocusDown: Windows.UI.Xaml.DependencyObject;
+    XYFocusLeft: Windows.UI.Xaml.DependencyObject;
+    XYFocusRight: Windows.UI.Xaml.DependencyObject;
+    XYFocusUp: Windows.UI.Xaml.DependencyObject;
+  }
+  var IWebView5: abstract new (...args: any[]) => IWebView5;
+
+  interface IWebView6 {
+    SeparateProcessLost: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewSeparateProcessLostEventArgs> | null;
+  }
+  var IWebView6: abstract new (...args: any[]) => IWebView6;
+
+  interface IWebView7 {
+    WebResourceRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.WebView, Windows.UI.Xaml.Controls.WebViewWebResourceRequestedEventArgs> | null;
+  }
+  var IWebView7: abstract new (...args: any[]) => IWebView7;
+
+  interface IWebViewBrush {
+    Redraw(): void;
+    SetSource(source: Windows.UI.Xaml.Controls.WebView): void;
+    SourceName: string;
+  }
+  var IWebViewBrush: abstract new (...args: any[]) => IWebViewBrush;
+
+  interface IWebViewBrushStatics {
+    readonly SourceNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IWebViewBrushStatics: abstract new (...args: any[]) => IWebViewBrushStatics;
+
+  interface IWebViewContentLoadingEventArgs {
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IWebViewContentLoadingEventArgs: abstract new (...args: any[]) => IWebViewContentLoadingEventArgs;
+
+  interface IWebViewDOMContentLoadedEventArgs {
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IWebViewDOMContentLoadedEventArgs: abstract new (...args: any[]) => IWebViewDOMContentLoadedEventArgs;
+
+  interface IWebViewDeferredPermissionRequest {
+    Allow(): void;
+    Deny(): void;
+    readonly Id: number;
+    readonly PermissionType: number;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IWebViewDeferredPermissionRequest: abstract new (...args: any[]) => IWebViewDeferredPermissionRequest;
+
+  interface IWebViewFactory4 {
+    CreateInstanceWithExecutionMode(executionMode: number): Windows.UI.Xaml.Controls.WebView;
+  }
+  var IWebViewFactory4: abstract new (...args: any[]) => IWebViewFactory4;
+
+  interface IWebViewLongRunningScriptDetectedEventArgs {
+    readonly ExecutionTime: Windows.Foundation.TimeSpan;
+    StopPageScriptExecution: boolean;
+  }
+  var IWebViewLongRunningScriptDetectedEventArgs: abstract new (...args: any[]) => IWebViewLongRunningScriptDetectedEventArgs;
+
+  interface IWebViewNavigationCompletedEventArgs {
+    readonly IsSuccess: boolean;
+    readonly Uri: Windows.Foundation.Uri;
+    readonly WebErrorStatus: number;
+  }
+  var IWebViewNavigationCompletedEventArgs: abstract new (...args: any[]) => IWebViewNavigationCompletedEventArgs;
+
+  interface IWebViewNavigationFailedEventArgs {
+    readonly Uri: Windows.Foundation.Uri;
+    readonly WebErrorStatus: number;
+  }
+  var IWebViewNavigationFailedEventArgs: abstract new (...args: any[]) => IWebViewNavigationFailedEventArgs;
+
+  interface IWebViewNavigationStartingEventArgs {
+    Cancel: boolean;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IWebViewNavigationStartingEventArgs: abstract new (...args: any[]) => IWebViewNavigationStartingEventArgs;
+
+  interface IWebViewNewWindowRequestedEventArgs {
+    Handled: boolean;
+    readonly Referrer: Windows.Foundation.Uri;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IWebViewNewWindowRequestedEventArgs: abstract new (...args: any[]) => IWebViewNewWindowRequestedEventArgs;
+
+  interface IWebViewPermissionRequest {
+    Allow(): void;
+    Defer(): void;
+    Deny(): void;
+    readonly Id: number;
+    readonly PermissionType: number;
+    readonly State: number;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IWebViewPermissionRequest: abstract new (...args: any[]) => IWebViewPermissionRequest;
+
+  interface IWebViewPermissionRequestedEventArgs {
+    readonly PermissionRequest: Windows.UI.Xaml.Controls.WebViewPermissionRequest;
+  }
+  var IWebViewPermissionRequestedEventArgs: abstract new (...args: any[]) => IWebViewPermissionRequestedEventArgs;
+
+  interface IWebViewSeparateProcessLostEventArgs {
+  }
+  var IWebViewSeparateProcessLostEventArgs: abstract new (...args: any[]) => IWebViewSeparateProcessLostEventArgs;
+
+  interface IWebViewSettings {
+    IsIndexedDBEnabled: boolean;
+    IsJavaScriptEnabled: boolean;
+  }
+  var IWebViewSettings: abstract new (...args: any[]) => IWebViewSettings;
+
+  interface IWebViewStatics {
+    readonly AllowedScriptNotifyUrisProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AnyScriptNotifyUri: Windows.Foundation.Collections.IVector<Windows.Foundation.Uri> | Windows.Foundation.Uri[];
+    readonly DataTransferPackageProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SourceProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IWebViewStatics: abstract new (...args: any[]) => IWebViewStatics;
+
+  interface IWebViewStatics2 {
+    readonly CanGoBackProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanGoForwardProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DefaultBackgroundColorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DocumentTitleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IWebViewStatics2: abstract new (...args: any[]) => IWebViewStatics2;
+
+  interface IWebViewStatics3 {
+    readonly ContainsFullScreenElementProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IWebViewStatics3: abstract new (...args: any[]) => IWebViewStatics3;
+
+  interface IWebViewStatics4 {
+    ClearTemporaryWebDataAsync(): Windows.Foundation.IAsyncAction;
+    readonly DefaultExecutionMode: number;
+  }
+  var IWebViewStatics4: abstract new (...args: any[]) => IWebViewStatics4;
+
+  interface IWebViewStatics5 {
+    readonly XYFocusDownProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusLeftProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusRightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusUpProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IWebViewStatics5: abstract new (...args: any[]) => IWebViewStatics5;
+
+  interface IWebViewUnsupportedUriSchemeIdentifiedEventArgs {
+    Handled: boolean;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IWebViewUnsupportedUriSchemeIdentifiedEventArgs: abstract new (...args: any[]) => IWebViewUnsupportedUriSchemeIdentifiedEventArgs;
+
+  interface IWebViewUnviewableContentIdentifiedEventArgs {
+    readonly Referrer: Windows.Foundation.Uri;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IWebViewUnviewableContentIdentifiedEventArgs: abstract new (...args: any[]) => IWebViewUnviewableContentIdentifiedEventArgs;
+
+  interface IWebViewUnviewableContentIdentifiedEventArgs2 {
+    readonly MediaType: string;
+  }
+  var IWebViewUnviewableContentIdentifiedEventArgs2: abstract new (...args: any[]) => IWebViewUnviewableContentIdentifiedEventArgs2;
+
+  interface IWebViewWebResourceRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Web.Http.HttpRequestMessage;
+    Response: Windows.Web.Http.HttpResponseMessage;
+  }
+  var IWebViewWebResourceRequestedEventArgs: abstract new (...args: any[]) => IWebViewWebResourceRequestedEventArgs;
+
+  interface IWrapGrid {
+    HorizontalChildrenAlignment: number;
+    ItemHeight: number;
+    ItemWidth: number;
+    MaximumRowsOrColumns: number;
+    Orientation: number;
+    VerticalChildrenAlignment: number;
+  }
+  var IWrapGrid: abstract new (...args: any[]) => IWrapGrid;
+
+  interface IWrapGridStatics {
+    readonly HorizontalChildrenAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaximumRowsOrColumnsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalChildrenAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IWrapGridStatics: abstract new (...args: any[]) => IWrapGridStatics;
+
+  interface ItemClickEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Controls.ItemClickEventArgs): void;
+  }
+  var ItemClickEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Controls.ItemClickEventArgs) => void): ItemClickEventHandler;
+  };
+
+  interface ListViewItemToKeyHandler {
+    (item: Object): string;
+  }
+  var ListViewItemToKeyHandler: {
+    new(callback: (item: Object) => string): ListViewItemToKeyHandler;
+  };
+
+  interface ListViewKeyToItemHandler {
+    (key: string): Windows.Foundation.IAsyncOperation<Object>;
+  }
+  var ListViewKeyToItemHandler: {
+    new(callback: (key: string) => Windows.Foundation.IAsyncOperation<Object>): ListViewKeyToItemHandler;
+  };
+
+  interface NotifyEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Controls.NotifyEventArgs): void;
+  }
+  var NotifyEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Controls.NotifyEventArgs) => void): NotifyEventHandler;
+  };
+
+  interface SectionsInViewChangedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Controls.SectionsInViewChangedEventArgs): void;
+  }
+  var SectionsInViewChangedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Controls.SectionsInViewChangedEventArgs) => void): SectionsInViewChangedEventHandler;
+  };
+
+  interface SelectionChangedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Controls.SelectionChangedEventArgs): void;
+  }
+  var SelectionChangedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Controls.SelectionChangedEventArgs) => void): SelectionChangedEventHandler;
+  };
+
+  interface SemanticZoomViewChangedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs): void;
+  }
+  var SemanticZoomViewChangedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs) => void): SemanticZoomViewChangedEventHandler;
+  };
+
+  interface TextChangedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Controls.TextChangedEventArgs): void;
+  }
+  var TextChangedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Controls.TextChangedEventArgs) => void): TextChangedEventHandler;
+  };
+
+  interface TextControlPasteEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Controls.TextControlPasteEventArgs): void;
+  }
+  var TextControlPasteEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Controls.TextControlPasteEventArgs) => void): TextControlPasteEventHandler;
+  };
+
+  interface WebViewNavigationFailedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Controls.WebViewNavigationFailedEventArgs): void;
+  }
+  var WebViewNavigationFailedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Controls.WebViewNavigationFailedEventArgs) => void): WebViewNavigationFailedEventHandler;
+  };
+
+}
+
+declare namespace Windows.UI.Xaml.Controls.Maps {
+  class CustomMapTileDataSource extends Windows.UI.Xaml.Controls.Maps.MapTileDataSource implements Windows.UI.Xaml.Controls.Maps.ICustomMapTileDataSource {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    BitmapRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource, Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestedEventArgs> | null;
+  }
+
+  class HttpMapTileDataSource extends Windows.UI.Xaml.Controls.Maps.MapTileDataSource implements Windows.UI.Xaml.Controls.Maps.IHttpMapTileDataSource {
+    constructor();
+    constructor(uriFormatString: string);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly AdditionalRequestHeaders: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    AllowCaching: boolean;
+    UriFormatString: string;
+    UriRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource, Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs> | null;
+  }
+
+  class LocalMapTileDataSource extends Windows.UI.Xaml.Controls.Maps.MapTileDataSource implements Windows.UI.Xaml.Controls.Maps.ILocalMapTileDataSource {
+    constructor();
+    constructor(uriFormatString: string);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UriFormatString: string;
+    UriRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource, Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs> | null;
+  }
+
+  class MapActualCameraChangedEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapActualCameraChangedEventArgs, Windows.UI.Xaml.Controls.Maps.IMapActualCameraChangedEventArgs2 {
+    constructor();
+    readonly Camera: Windows.UI.Xaml.Controls.Maps.MapCamera;
+    readonly ChangeReason: number;
+  }
+
+  class MapActualCameraChangingEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapActualCameraChangingEventArgs, Windows.UI.Xaml.Controls.Maps.IMapActualCameraChangingEventArgs2 {
+    constructor();
+    readonly Camera: Windows.UI.Xaml.Controls.Maps.MapCamera;
+    readonly ChangeReason: number;
+  }
+
+  class MapBillboard extends Windows.UI.Xaml.Controls.Maps.MapElement implements Windows.UI.Xaml.Controls.Maps.IMapBillboard {
+    constructor(camera: Windows.UI.Xaml.Controls.Maps.MapCamera);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    CollisionBehaviorDesired: number;
+    static readonly CollisionBehaviorDesiredProperty: Windows.UI.Xaml.DependencyProperty;
+    Image: Windows.Storage.Streams.IRandomAccessStreamReference;
+    Location: Windows.Devices.Geolocation.Geopoint;
+    static readonly LocationProperty: Windows.UI.Xaml.DependencyProperty;
+    NormalizedAnchorPoint: Windows.Foundation.Point;
+    static readonly NormalizedAnchorPointProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ReferenceCamera: Windows.UI.Xaml.Controls.Maps.MapCamera;
+  }
+
+  class MapCamera extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Maps.IMapCamera {
+    constructor(location: Windows.Devices.Geolocation.Geopoint);
+    constructor(location: Windows.Devices.Geolocation.Geopoint, headingInDegrees: number);
+    constructor(location: Windows.Devices.Geolocation.Geopoint, headingInDegrees: number, pitchInDegrees: number);
+    constructor(location: Windows.Devices.Geolocation.Geopoint, headingInDegrees: number, pitchInDegrees: number, rollInDegrees: number, fieldOfViewInDegrees: number);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    FieldOfView: number;
+    Heading: number;
+    Location: Windows.Devices.Geolocation.Geopoint;
+    Pitch: number;
+    Roll: number;
+  }
+
+  class MapContextRequestedEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapContextRequestedEventArgs {
+    constructor();
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly MapElements: Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Controls.Maps.MapElement> | Windows.UI.Xaml.Controls.Maps.MapElement[];
+    readonly Position: Windows.Foundation.Point;
+  }
+
+  class MapControl extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.Maps.IMapControl, Windows.UI.Xaml.Controls.Maps.IMapControl2, Windows.UI.Xaml.Controls.Maps.IMapControl3, Windows.UI.Xaml.Controls.Maps.IMapControl4, Windows.UI.Xaml.Controls.Maps.IMapControl5, Windows.UI.Xaml.Controls.Maps.IMapControl6, Windows.UI.Xaml.Controls.Maps.IMapControl7, Windows.UI.Xaml.Controls.Maps.IMapControl8 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindMapElementsAtOffset(offset: Windows.Foundation.Point): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Controls.Maps.MapElement> | Windows.UI.Xaml.Controls.Maps.MapElement[];
+    FindMapElementsAtOffset(offset: Windows.Foundation.Point, radius: number): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Controls.Maps.MapElement> | Windows.UI.Xaml.Controls.Maps.MapElement[];
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetLocation(element: Windows.UI.Xaml.DependencyObject): Windows.Devices.Geolocation.Geopoint;
+    GetLocationFromOffset(offset: Windows.Foundation.Point, location: Windows.Devices.Geolocation.Geopoint): void;
+    GetLocationFromOffset(offset: Windows.Foundation.Point, desiredReferenceSystem: number, location: Windows.Devices.Geolocation.Geopoint): void;
+    static GetNormalizedAnchorPoint(element: Windows.UI.Xaml.DependencyObject): Windows.Foundation.Point;
+    GetOffsetFromLocation(location: Windows.Devices.Geolocation.Geopoint, offset: Windows.Foundation.Point): void;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetVisibleRegion(region: number): Windows.Devices.Geolocation.Geopath;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    IsLocationInView(location: Windows.Devices.Geolocation.Geopoint, isInView: boolean): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetLocation(element: Windows.UI.Xaml.DependencyObject, value: Windows.Devices.Geolocation.Geopoint): void;
+    static SetNormalizedAnchorPoint(element: Windows.UI.Xaml.DependencyObject, value: Windows.Foundation.Point): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartContinuousPan(horizontalPixelsPerSecond: number, verticalPixelsPerSecond: number): void;
+    StartContinuousRotate(rateInDegreesPerSecond: number): void;
+    StartContinuousTilt(rateInDegreesPerSecond: number): void;
+    StartContinuousZoom(rateOfChangePerSecond: number): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StopContinuousPan(): void;
+    StopContinuousRotate(): void;
+    StopContinuousTilt(): void;
+    StopContinuousZoom(): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryGetLocationFromOffset(offset: Windows.Foundation.Point, location: Windows.Devices.Geolocation.Geopoint): boolean;
+    TryGetLocationFromOffset(offset: Windows.Foundation.Point, desiredReferenceSystem: number, location: Windows.Devices.Geolocation.Geopoint): boolean;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    TryPanAsync(horizontalPixels: number, verticalPixels: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryPanToAsync(location: Windows.Devices.Geolocation.Geopoint): Windows.Foundation.IAsyncOperation<boolean>;
+    TryRotateAsync(degrees: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryRotateToAsync(angleInDegrees: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySetSceneAsync(scene: Windows.UI.Xaml.Controls.Maps.MapScene): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySetSceneAsync(scene: Windows.UI.Xaml.Controls.Maps.MapScene, animationKind: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySetViewAsync(center: Windows.Devices.Geolocation.Geopoint): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySetViewAsync(center: Windows.Devices.Geolocation.Geopoint, zoomLevel: number | null): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySetViewAsync(center: Windows.Devices.Geolocation.Geopoint, zoomLevel: number | null, heading: number | null, desiredPitch: number | null): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySetViewAsync(center: Windows.Devices.Geolocation.Geopoint, zoomLevel: number | null, heading: number | null, desiredPitch: number | null, animation: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySetViewBoundsAsync(bounds: Windows.Devices.Geolocation.GeoboundingBox, margin: Windows.UI.Xaml.Thickness | null, animation: number): Windows.Foundation.IAsyncOperation<boolean>;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    TryTiltAsync(degrees: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryTiltToAsync(angleInDegrees: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryZoomInAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryZoomOutAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryZoomToAsync(zoomLevel: number): Windows.Foundation.IAsyncOperation<boolean>;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly ActualCamera: Windows.UI.Xaml.Controls.Maps.MapCamera;
+    BusinessLandmarksEnabled: boolean;
+    static readonly BusinessLandmarksEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    BusinessLandmarksVisible: boolean;
+    static readonly BusinessLandmarksVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanTiltDown: boolean;
+    static readonly CanTiltDownProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanTiltUp: boolean;
+    static readonly CanTiltUpProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanZoomIn: boolean;
+    static readonly CanZoomInProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanZoomOut: boolean;
+    static readonly CanZoomOutProperty: Windows.UI.Xaml.DependencyProperty;
+    Center: Windows.Devices.Geolocation.Geopoint;
+    static readonly CenterProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Children: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static readonly ChildrenProperty: Windows.UI.Xaml.DependencyProperty;
+    ColorScheme: number;
+    static readonly ColorSchemeProperty: Windows.UI.Xaml.DependencyProperty;
+    CustomExperience: Windows.UI.Xaml.Controls.Maps.MapCustomExperience;
+    DesiredPitch: number;
+    static readonly DesiredPitchProperty: Windows.UI.Xaml.DependencyProperty;
+    Heading: number;
+    static readonly HeadingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Is3DSupported: boolean;
+    static readonly Is3DSupportedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsStreetsideSupported: boolean;
+    static readonly IsStreetsideSupportedProperty: Windows.UI.Xaml.DependencyProperty;
+    LandmarksVisible: boolean;
+    static readonly LandmarksVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    Layers: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.Maps.MapLayer> | Windows.UI.Xaml.Controls.Maps.MapLayer[];
+    static readonly LayersProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LoadingStatus: number;
+    static readonly LoadingStatusProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly LocationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MapElements: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.Maps.MapElement> | Windows.UI.Xaml.Controls.Maps.MapElement[];
+    static readonly MapElementsProperty: Windows.UI.Xaml.DependencyProperty;
+    MapProjection: number;
+    static readonly MapProjectionProperty: Windows.UI.Xaml.DependencyProperty;
+    MapServiceToken: string;
+    static readonly MapServiceTokenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxZoomLevel: number;
+    readonly MinZoomLevel: number;
+    static readonly NormalizedAnchorPointProperty: Windows.UI.Xaml.DependencyProperty;
+    PanInteractionMode: number;
+    static readonly PanInteractionModeProperty: Windows.UI.Xaml.DependencyProperty;
+    PedestrianFeaturesVisible: boolean;
+    static readonly PedestrianFeaturesVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Pitch: number;
+    static readonly PitchProperty: Windows.UI.Xaml.DependencyProperty;
+    Region: string;
+    static readonly RegionProperty: Windows.UI.Xaml.DependencyProperty;
+    RotateInteractionMode: number;
+    static readonly RotateInteractionModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Routes: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.Maps.MapRouteView> | Windows.UI.Xaml.Controls.Maps.MapRouteView[];
+    static readonly RoutesProperty: Windows.UI.Xaml.DependencyProperty;
+    Scene: Windows.UI.Xaml.Controls.Maps.MapScene;
+    static readonly SceneProperty: Windows.UI.Xaml.DependencyProperty;
+    Style: number;
+    static readonly StyleProperty: Windows.UI.Xaml.DependencyProperty;
+    StyleSheet: Windows.UI.Xaml.Controls.Maps.MapStyleSheet;
+    static readonly StyleSheetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TargetCamera: Windows.UI.Xaml.Controls.Maps.MapCamera;
+    readonly TileSources: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.Maps.MapTileSource> | Windows.UI.Xaml.Controls.Maps.MapTileSource[];
+    static readonly TileSourcesProperty: Windows.UI.Xaml.DependencyProperty;
+    TiltInteractionMode: number;
+    static readonly TiltInteractionModeProperty: Windows.UI.Xaml.DependencyProperty;
+    TrafficFlowVisible: boolean;
+    static readonly TrafficFlowVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    TransformOrigin: Windows.Foundation.Point;
+    static readonly TransformOriginProperty: Windows.UI.Xaml.DependencyProperty;
+    TransitFeaturesEnabled: boolean;
+    static readonly TransitFeaturesEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    TransitFeaturesVisible: boolean;
+    static readonly TransitFeaturesVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    ViewPadding: Windows.UI.Xaml.Thickness;
+    static readonly ViewPaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    WatermarkMode: number;
+    static readonly WatermarkModeProperty: Windows.UI.Xaml.DependencyProperty;
+    ZoomInteractionMode: number;
+    static readonly ZoomInteractionModeProperty: Windows.UI.Xaml.DependencyProperty;
+    ZoomLevel: number;
+    static readonly ZoomLevelProperty: Windows.UI.Xaml.DependencyProperty;
+    CenterChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Object> | null;
+    HeadingChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Object> | null;
+    LoadingStatusChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Object> | null;
+    MapDoubleTapped: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapInputEventArgs> | null;
+    MapHolding: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapInputEventArgs> | null;
+    MapTapped: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapInputEventArgs> | null;
+    PitchChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Object> | null;
+    TransformOriginChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Object> | null;
+    ZoomLevelChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Object> | null;
+    ActualCameraChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapActualCameraChangedEventArgs> | null;
+    ActualCameraChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapActualCameraChangingEventArgs> | null;
+    CustomExperienceChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapCustomExperienceChangedEventArgs> | null;
+    MapElementClick: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapElementClickEventArgs> | null;
+    MapElementPointerEntered: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapElementPointerEnteredEventArgs> | null;
+    MapElementPointerExited: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapElementPointerExitedEventArgs> | null;
+    TargetCameraChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs> | null;
+    MapRightTapped: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapRightTappedEventArgs> | null;
+    MapContextRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapContextRequestedEventArgs> | null;
+  }
+
+  class MapControlBusinessLandmarkClickEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapControlBusinessLandmarkClickEventArgs {
+    constructor();
+    readonly LocalLocations: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.LocalSearch.LocalLocation> | Windows.Services.Maps.LocalSearch.LocalLocation[];
+  }
+
+  class MapControlBusinessLandmarkPointerEnteredEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapControlBusinessLandmarkPointerEnteredEventArgs {
+    constructor();
+    readonly LocalLocations: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.LocalSearch.LocalLocation> | Windows.Services.Maps.LocalSearch.LocalLocation[];
+  }
+
+  class MapControlBusinessLandmarkPointerExitedEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapControlBusinessLandmarkPointerExitedEventArgs {
+    constructor();
+    readonly LocalLocations: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.LocalSearch.LocalLocation> | Windows.Services.Maps.LocalSearch.LocalLocation[];
+  }
+
+  class MapControlBusinessLandmarkRightTappedEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapControlBusinessLandmarkRightTappedEventArgs {
+    constructor();
+    readonly LocalLocations: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.LocalSearch.LocalLocation> | Windows.Services.Maps.LocalSearch.LocalLocation[];
+  }
+
+  class MapControlDataHelper extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Maps.IMapControlDataHelper, Windows.UI.Xaml.Controls.Maps.IMapControlDataHelper2 {
+    constructor(map: Windows.UI.Xaml.Controls.Maps.MapControl);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreateMapControl(rasterRenderMode: boolean): Windows.UI.Xaml.Controls.Maps.MapControl;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    BusinessLandmarkClick: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkClickEventArgs> | null;
+    BusinessLandmarkRightTapped: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkRightTappedEventArgs> | null;
+    TransitFeatureClick: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureClickEventArgs> | null;
+    TransitFeatureRightTapped: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureRightTappedEventArgs> | null;
+    BusinessLandmarkPointerEntered: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerEnteredEventArgs> | null;
+    BusinessLandmarkPointerExited: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerExitedEventArgs> | null;
+    TransitFeaturePointerEntered: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerEnteredEventArgs> | null;
+    TransitFeaturePointerExited: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerExitedEventArgs> | null;
+  }
+
+  class MapControlTransitFeatureClickEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapControlTransitFeatureClickEventArgs {
+    constructor();
+    readonly DisplayName: string;
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly TransitProperties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+
+  class MapControlTransitFeaturePointerEnteredEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapControlTransitFeaturePointerEnteredEventArgs {
+    constructor();
+    readonly DisplayName: string;
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly TransitProperties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+
+  class MapControlTransitFeaturePointerExitedEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapControlTransitFeaturePointerExitedEventArgs {
+    constructor();
+    readonly DisplayName: string;
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly TransitProperties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+
+  class MapControlTransitFeatureRightTappedEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapControlTransitFeatureRightTappedEventArgs {
+    constructor();
+    readonly DisplayName: string;
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly TransitProperties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+
+  class MapCustomExperience extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Maps.IMapCustomExperience {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class MapCustomExperienceChangedEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapCustomExperienceChangedEventArgs {
+    constructor();
+  }
+
+  class MapElement extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Maps.IMapElement, Windows.UI.Xaml.Controls.Maps.IMapElement2, Windows.UI.Xaml.Controls.Maps.IMapElement3, Windows.UI.Xaml.Controls.Maps.IMapElement4 {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    IsEnabled: boolean;
+    static readonly IsEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    MapStyleSheetEntry: string;
+    static readonly MapStyleSheetEntryProperty: Windows.UI.Xaml.DependencyProperty;
+    MapStyleSheetEntryState: string;
+    static readonly MapStyleSheetEntryStateProperty: Windows.UI.Xaml.DependencyProperty;
+    MapTabIndex: number;
+    static readonly MapTabIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    Tag: Object;
+    static readonly TagProperty: Windows.UI.Xaml.DependencyProperty;
+    Visible: boolean;
+    static readonly VisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    ZIndex: number;
+    static readonly ZIndexProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class MapElement3D extends Windows.UI.Xaml.Controls.Maps.MapElement implements Windows.UI.Xaml.Controls.Maps.IMapElement3D {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Heading: number;
+    static readonly HeadingProperty: Windows.UI.Xaml.DependencyProperty;
+    Location: Windows.Devices.Geolocation.Geopoint;
+    static readonly LocationProperty: Windows.UI.Xaml.DependencyProperty;
+    Model: Windows.UI.Xaml.Controls.Maps.MapModel3D;
+    Pitch: number;
+    static readonly PitchProperty: Windows.UI.Xaml.DependencyProperty;
+    Roll: number;
+    static readonly RollProperty: Windows.UI.Xaml.DependencyProperty;
+    Scale: Windows.Foundation.Numerics.Vector3;
+    static readonly ScaleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class MapElementClickEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapElementClickEventArgs {
+    constructor();
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly MapElements: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.Maps.MapElement> | Windows.UI.Xaml.Controls.Maps.MapElement[];
+    readonly Position: Windows.Foundation.Point;
+  }
+
+  class MapElementPointerEnteredEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapElementPointerEnteredEventArgs {
+    constructor();
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly MapElement: Windows.UI.Xaml.Controls.Maps.MapElement;
+    readonly Position: Windows.Foundation.Point;
+  }
+
+  class MapElementPointerExitedEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapElementPointerExitedEventArgs {
+    constructor();
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly MapElement: Windows.UI.Xaml.Controls.Maps.MapElement;
+    readonly Position: Windows.Foundation.Point;
+  }
+
+  class MapElementsLayer extends Windows.UI.Xaml.Controls.Maps.MapLayer implements Windows.UI.Xaml.Controls.Maps.IMapElementsLayer {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    MapElements: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.Maps.MapElement> | Windows.UI.Xaml.Controls.Maps.MapElement[];
+    static readonly MapElementsProperty: Windows.UI.Xaml.DependencyProperty;
+    MapContextRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapElementsLayer, Windows.UI.Xaml.Controls.Maps.MapElementsLayerContextRequestedEventArgs> | null;
+    MapElementClick: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapElementsLayer, Windows.UI.Xaml.Controls.Maps.MapElementsLayerClickEventArgs> | null;
+    MapElementPointerEntered: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapElementsLayer, Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerEnteredEventArgs> | null;
+    MapElementPointerExited: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapElementsLayer, Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerExitedEventArgs> | null;
+  }
+
+  class MapElementsLayerClickEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapElementsLayerClickEventArgs {
+    constructor();
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly MapElements: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.Maps.MapElement> | Windows.UI.Xaml.Controls.Maps.MapElement[];
+    readonly Position: Windows.Foundation.Point;
+  }
+
+  class MapElementsLayerContextRequestedEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapElementsLayerContextRequestedEventArgs {
+    constructor();
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly MapElements: Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Controls.Maps.MapElement> | Windows.UI.Xaml.Controls.Maps.MapElement[];
+    readonly Position: Windows.Foundation.Point;
+  }
+
+  class MapElementsLayerPointerEnteredEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapElementsLayerPointerEnteredEventArgs {
+    constructor();
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly MapElement: Windows.UI.Xaml.Controls.Maps.MapElement;
+    readonly Position: Windows.Foundation.Point;
+  }
+
+  class MapElementsLayerPointerExitedEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapElementsLayerPointerExitedEventArgs {
+    constructor();
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly MapElement: Windows.UI.Xaml.Controls.Maps.MapElement;
+    readonly Position: Windows.Foundation.Point;
+  }
+
+  class MapIcon extends Windows.UI.Xaml.Controls.Maps.MapElement implements Windows.UI.Xaml.Controls.Maps.IMapIcon, Windows.UI.Xaml.Controls.Maps.IMapIcon2 {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    CollisionBehaviorDesired: number;
+    static readonly CollisionBehaviorDesiredProperty: Windows.UI.Xaml.DependencyProperty;
+    Image: Windows.Storage.Streams.IRandomAccessStreamReference;
+    Location: Windows.Devices.Geolocation.Geopoint;
+    static readonly LocationProperty: Windows.UI.Xaml.DependencyProperty;
+    NormalizedAnchorPoint: Windows.Foundation.Point;
+    static readonly NormalizedAnchorPointProperty: Windows.UI.Xaml.DependencyProperty;
+    Title: string;
+    static readonly TitleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class MapInputEventArgs extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Maps.IMapInputEventArgs {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly Position: Windows.Foundation.Point;
+  }
+
+  class MapItemsControl extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Maps.IMapItemsControl {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    ItemTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly ItemTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static readonly ItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemsSource: Object;
+    static readonly ItemsSourceProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class MapLayer extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Maps.IMapLayer {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    MapTabIndex: number;
+    static readonly MapTabIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    Visible: boolean;
+    static readonly VisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    ZIndex: number;
+    static readonly ZIndexProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class MapModel3D extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Maps.IMapModel3D {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreateFrom3MFAsync(source: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Controls.Maps.MapModel3D>;
+    static CreateFrom3MFAsync(source: Windows.Storage.Streams.IRandomAccessStreamReference, shadingOption: number): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Controls.Maps.MapModel3D>;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class MapPolygon extends Windows.UI.Xaml.Controls.Maps.MapElement implements Windows.UI.Xaml.Controls.Maps.IMapPolygon, Windows.UI.Xaml.Controls.Maps.IMapPolygon2 {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    FillColor: Windows.UI.Color;
+    Path: Windows.Devices.Geolocation.Geopath;
+    static readonly PathProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Paths: Windows.Foundation.Collections.IVector<Windows.Devices.Geolocation.Geopath> | Windows.Devices.Geolocation.Geopath[];
+    StrokeColor: Windows.UI.Color;
+    StrokeDashed: boolean;
+    static readonly StrokeDashedProperty: Windows.UI.Xaml.DependencyProperty;
+    StrokeThickness: number;
+    static readonly StrokeThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class MapPolyline extends Windows.UI.Xaml.Controls.Maps.MapElement implements Windows.UI.Xaml.Controls.Maps.IMapPolyline {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Path: Windows.Devices.Geolocation.Geopath;
+    static readonly PathProperty: Windows.UI.Xaml.DependencyProperty;
+    StrokeColor: Windows.UI.Color;
+    StrokeDashed: boolean;
+    static readonly StrokeDashedProperty: Windows.UI.Xaml.DependencyProperty;
+    StrokeThickness: number;
+  }
+
+  class MapRightTappedEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapRightTappedEventArgs {
+    constructor();
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly Position: Windows.Foundation.Point;
+  }
+
+  class MapRouteView extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Maps.IMapRouteView {
+    constructor(route: Windows.Services.Maps.MapRoute);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    OutlineColor: Windows.UI.Color;
+    readonly Route: Windows.Services.Maps.MapRoute;
+    RouteColor: Windows.UI.Color;
+  }
+
+  class MapScene extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Maps.IMapScene {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static CreateFromBoundingBox(bounds: Windows.Devices.Geolocation.GeoboundingBox): Windows.UI.Xaml.Controls.Maps.MapScene;
+    static CreateFromBoundingBox(bounds: Windows.Devices.Geolocation.GeoboundingBox, headingInDegrees: number, pitchInDegrees: number): Windows.UI.Xaml.Controls.Maps.MapScene;
+    static CreateFromCamera(camera: Windows.UI.Xaml.Controls.Maps.MapCamera): Windows.UI.Xaml.Controls.Maps.MapScene;
+    static CreateFromLocation(location: Windows.Devices.Geolocation.Geopoint): Windows.UI.Xaml.Controls.Maps.MapScene;
+    static CreateFromLocation(location: Windows.Devices.Geolocation.Geopoint, headingInDegrees: number, pitchInDegrees: number): Windows.UI.Xaml.Controls.Maps.MapScene;
+    static CreateFromLocationAndRadius(location: Windows.Devices.Geolocation.Geopoint, radiusInMeters: number): Windows.UI.Xaml.Controls.Maps.MapScene;
+    static CreateFromLocationAndRadius(location: Windows.Devices.Geolocation.Geopoint, radiusInMeters: number, headingInDegrees: number, pitchInDegrees: number): Windows.UI.Xaml.Controls.Maps.MapScene;
+    static CreateFromLocations(locations: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.Geopoint> | Windows.Devices.Geolocation.Geopoint[]): Windows.UI.Xaml.Controls.Maps.MapScene;
+    static CreateFromLocations(locations: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.Geopoint> | Windows.Devices.Geolocation.Geopoint[], headingInDegrees: number, pitchInDegrees: number): Windows.UI.Xaml.Controls.Maps.MapScene;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly TargetCamera: Windows.UI.Xaml.Controls.Maps.MapCamera;
+    TargetCameraChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapScene, Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs> | null;
+  }
+
+  class MapStyleSheet extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Maps.IMapStyleSheet {
+    static Aerial(): Windows.UI.Xaml.Controls.Maps.MapStyleSheet;
+    static AerialWithOverlay(): Windows.UI.Xaml.Controls.Maps.MapStyleSheet;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static Combine(styleSheets: Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Controls.Maps.MapStyleSheet> | Windows.UI.Xaml.Controls.Maps.MapStyleSheet[]): Windows.UI.Xaml.Controls.Maps.MapStyleSheet;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static ParseFromJson(styleAsJson: string): Windows.UI.Xaml.Controls.Maps.MapStyleSheet;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static RoadDark(): Windows.UI.Xaml.Controls.Maps.MapStyleSheet;
+    static RoadHighContrastDark(): Windows.UI.Xaml.Controls.Maps.MapStyleSheet;
+    static RoadHighContrastLight(): Windows.UI.Xaml.Controls.Maps.MapStyleSheet;
+    static RoadLight(): Windows.UI.Xaml.Controls.Maps.MapStyleSheet;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    static TryParseFromJson(styleAsJson: string, styleSheet: Windows.UI.Xaml.Controls.Maps.MapStyleSheet): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class MapStyleSheetEntries {
+    static readonly AdminDistrict: string;
+    static readonly AdminDistrictCapital: string;
+    static readonly Airport: string;
+    static readonly Area: string;
+    static readonly ArterialRoad: string;
+    static readonly Building: string;
+    static readonly Business: string;
+    static readonly Capital: string;
+    static readonly Cemetery: string;
+    static readonly Continent: string;
+    static readonly ControlledAccessHighway: string;
+    static readonly CountryRegion: string;
+    static readonly CountryRegionCapital: string;
+    static readonly District: string;
+    static readonly DrivingRoute: string;
+    static readonly Education: string;
+    static readonly EducationBuilding: string;
+    static readonly FoodPoint: string;
+    static readonly Forest: string;
+    static readonly GolfCourse: string;
+    static readonly HighSpeedRamp: string;
+    static readonly Highway: string;
+    static readonly IndigenousPeoplesReserve: string;
+    static readonly Island: string;
+    static readonly MajorRoad: string;
+    static readonly Medical: string;
+    static readonly MedicalBuilding: string;
+    static readonly Military: string;
+    static readonly NaturalPoint: string;
+    static readonly Nautical: string;
+    static readonly Neighborhood: string;
+    static readonly Park: string;
+    static readonly Peak: string;
+    static readonly PlayingField: string;
+    static readonly Point: string;
+    static readonly PointOfInterest: string;
+    static readonly Political: string;
+    static readonly PopulatedPlace: string;
+    static readonly Railway: string;
+    static readonly Ramp: string;
+    static readonly Reserve: string;
+    static readonly River: string;
+    static readonly Road: string;
+    static readonly RoadExit: string;
+    static readonly RoadShield: string;
+    static readonly RouteLine: string;
+    static readonly Runway: string;
+    static readonly Sand: string;
+    static readonly ShoppingCenter: string;
+    static readonly Stadium: string;
+    static readonly Street: string;
+    static readonly Structure: string;
+    static readonly TollRoad: string;
+    static readonly Trail: string;
+    static readonly Transit: string;
+    static readonly TransitBuilding: string;
+    static readonly Transportation: string;
+    static readonly UnpavedStreet: string;
+    static readonly Vegetation: string;
+    static readonly VolcanicPeak: string;
+    static readonly WalkingRoute: string;
+    static readonly Water: string;
+    static readonly WaterPoint: string;
+    static readonly WaterRoute: string;
+  }
+
+  class MapStyleSheetEntryStates {
+    static readonly Disabled: string;
+    static readonly Hover: string;
+    static readonly Selected: string;
+  }
+
+  class MapTargetCameraChangedEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapTargetCameraChangedEventArgs, Windows.UI.Xaml.Controls.Maps.IMapTargetCameraChangedEventArgs2 {
+    constructor();
+    readonly Camera: Windows.UI.Xaml.Controls.Maps.MapCamera;
+    readonly ChangeReason: number;
+  }
+
+  class MapTileBitmapRequest implements Windows.UI.Xaml.Controls.Maps.IMapTileBitmapRequest {
+    constructor();
+    GetDeferral(): Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestDeferral;
+    PixelData: Windows.Storage.Streams.IRandomAccessStreamReference;
+  }
+
+  class MapTileBitmapRequestDeferral implements Windows.UI.Xaml.Controls.Maps.IMapTileBitmapRequestDeferral {
+    constructor();
+    Complete(): void;
+  }
+
+  class MapTileBitmapRequestedEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapTileBitmapRequestedEventArgs, Windows.UI.Xaml.Controls.Maps.IMapTileBitmapRequestedEventArgs2 {
+    constructor();
+    readonly FrameIndex: number;
+    readonly Request: Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequest;
+    readonly X: number;
+    readonly Y: number;
+    readonly ZoomLevel: number;
+  }
+
+  class MapTileDataSource extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Maps.IMapTileDataSource {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class MapTileSource extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Maps.IMapTileSource, Windows.UI.Xaml.Controls.Maps.IMapTileSource2 {
+    constructor();
+    constructor(dataSource: Windows.UI.Xaml.Controls.Maps.MapTileDataSource);
+    constructor(dataSource: Windows.UI.Xaml.Controls.Maps.MapTileDataSource, zoomLevelRange: Windows.UI.Xaml.Controls.Maps.MapZoomLevelRange);
+    constructor(dataSource: Windows.UI.Xaml.Controls.Maps.MapTileDataSource, zoomLevelRange: Windows.UI.Xaml.Controls.Maps.MapZoomLevelRange, bounds: Windows.Devices.Geolocation.GeoboundingBox);
+    constructor(dataSource: Windows.UI.Xaml.Controls.Maps.MapTileDataSource, zoomLevelRange: Windows.UI.Xaml.Controls.Maps.MapZoomLevelRange, bounds: Windows.Devices.Geolocation.GeoboundingBox, tileSizeInPixels: number);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Pause(): void;
+    Play(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    Stop(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    AllowOverstretch: boolean;
+    static readonly AllowOverstretchProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AnimationState: number;
+    static readonly AnimationStateProperty: Windows.UI.Xaml.DependencyProperty;
+    AutoPlay: boolean;
+    static readonly AutoPlayProperty: Windows.UI.Xaml.DependencyProperty;
+    Bounds: Windows.Devices.Geolocation.GeoboundingBox;
+    static readonly BoundsProperty: Windows.UI.Xaml.DependencyProperty;
+    DataSource: Windows.UI.Xaml.Controls.Maps.MapTileDataSource;
+    static readonly DataSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    FrameCount: number;
+    static readonly FrameCountProperty: Windows.UI.Xaml.DependencyProperty;
+    FrameDuration: Windows.Foundation.TimeSpan;
+    static readonly FrameDurationProperty: Windows.UI.Xaml.DependencyProperty;
+    IsFadingEnabled: boolean;
+    static readonly IsFadingEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsRetryEnabled: boolean;
+    static readonly IsRetryEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsTransparencyEnabled: boolean;
+    static readonly IsTransparencyEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    Layer: number;
+    static readonly LayerProperty: Windows.UI.Xaml.DependencyProperty;
+    TilePixelSize: number;
+    static readonly TilePixelSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    Visible: boolean;
+    static readonly VisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    ZIndex: number;
+    static readonly ZIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    ZoomLevelRange: Windows.UI.Xaml.Controls.Maps.MapZoomLevelRange;
+    static readonly ZoomLevelRangeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class MapTileUriRequest implements Windows.UI.Xaml.Controls.Maps.IMapTileUriRequest {
+    constructor();
+    GetDeferral(): Windows.UI.Xaml.Controls.Maps.MapTileUriRequestDeferral;
+    Uri: Windows.Foundation.Uri;
+  }
+
+  class MapTileUriRequestDeferral implements Windows.UI.Xaml.Controls.Maps.IMapTileUriRequestDeferral {
+    constructor();
+    Complete(): void;
+  }
+
+  class MapTileUriRequestedEventArgs implements Windows.UI.Xaml.Controls.Maps.IMapTileUriRequestedEventArgs, Windows.UI.Xaml.Controls.Maps.IMapTileUriRequestedEventArgs2 {
+    constructor();
+    readonly FrameIndex: number;
+    readonly Request: Windows.UI.Xaml.Controls.Maps.MapTileUriRequest;
+    readonly X: number;
+    readonly Y: number;
+    readonly ZoomLevel: number;
+  }
+
+  class StreetsideExperience extends Windows.UI.Xaml.Controls.Maps.MapCustomExperience implements Windows.UI.Xaml.Controls.Maps.IStreetsideExperience {
+    constructor(panorama: Windows.UI.Xaml.Controls.Maps.StreetsidePanorama);
+    constructor(panorama: Windows.UI.Xaml.Controls.Maps.StreetsidePanorama, headingInDegrees: number, pitchInDegrees: number, fieldOfViewInDegrees: number);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    AddressTextVisible: boolean;
+    CursorVisible: boolean;
+    ExitButtonVisible: boolean;
+    OverviewMapVisible: boolean;
+    StreetLabelsVisible: boolean;
+    ZoomButtonsVisible: boolean;
+  }
+
+  class StreetsidePanorama extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Maps.IStreetsidePanorama {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static FindNearbyAsync(location: Windows.Devices.Geolocation.Geopoint): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Controls.Maps.StreetsidePanorama>;
+    static FindNearbyAsync(location: Windows.Devices.Geolocation.Geopoint, radiusInMeters: number): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Controls.Maps.StreetsidePanorama>;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+  }
+
+  enum MapAnimationKind {
+    Default = 0,
+    None = 1,
+    Linear = 2,
+    Bow = 3,
+  }
+
+  enum MapCameraChangeReason {
+    System = 0,
+    UserInteraction = 1,
+    Programmatic = 2,
+  }
+
+  enum MapColorScheme {
+    Light = 0,
+    Dark = 1,
+  }
+
+  enum MapElementCollisionBehavior {
+    Hide = 0,
+    RemainVisible = 1,
+  }
+
+  enum MapInteractionMode {
+    Auto = 0,
+    Disabled = 1,
+    GestureOnly = 2,
+    PointerAndKeyboard = 2,
+    ControlOnly = 3,
+    GestureAndControl = 4,
+    PointerKeyboardAndControl = 4,
+    PointerOnly = 5,
+  }
+
+  enum MapLoadingStatus {
+    Loading = 0,
+    Loaded = 1,
+    DataUnavailable = 2,
+    DownloadedMapsManagerUnavailable = 3,
+  }
+
+  enum MapModel3DShadingOption {
+    Default = 0,
+    Flat = 1,
+    Smooth = 2,
+  }
+
+  enum MapPanInteractionMode {
+    Auto = 0,
+    Disabled = 1,
+  }
+
+  enum MapProjection {
+    WebMercator = 0,
+    Globe = 1,
+  }
+
+  enum MapStyle {
+    None = 0,
+    Road = 1,
+    Aerial = 2,
+    AerialWithRoads = 3,
+    Terrain = 4,
+    Aerial3D = 5,
+    Aerial3DWithRoads = 6,
+    Custom = 7,
+  }
+
+  enum MapTileAnimationState {
+    Stopped = 0,
+    Paused = 1,
+    Playing = 2,
+  }
+
+  enum MapTileLayer {
+    LabelOverlay = 0,
+    RoadOverlay = 1,
+    AreaOverlay = 2,
+    BackgroundOverlay = 3,
+    BackgroundReplacement = 4,
+  }
+
+  enum MapVisibleRegionKind {
+    Near = 0,
+    Full = 1,
+  }
+
+  enum MapWatermarkMode {
+    Automatic = 0,
+    On = 1,
+  }
+
+  interface ICustomMapTileDataSource {
+    BitmapRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource, Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestedEventArgs> | null;
+  }
+  var ICustomMapTileDataSource: abstract new (...args: any[]) => ICustomMapTileDataSource;
+
+  interface ICustomMapTileDataSourceFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Maps.CustomMapTileDataSource;
+  }
+  var ICustomMapTileDataSourceFactory: abstract new (...args: any[]) => ICustomMapTileDataSourceFactory;
+
+  interface IHttpMapTileDataSource {
+    readonly AdditionalRequestHeaders: Windows.Foundation.Collections.IMap<string, string> | Record<string, string>;
+    AllowCaching: boolean;
+    UriFormatString: string;
+    UriRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource, Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs> | null;
+  }
+  var IHttpMapTileDataSource: abstract new (...args: any[]) => IHttpMapTileDataSource;
+
+  interface IHttpMapTileDataSourceFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource;
+    CreateInstanceWithUriFormatString(uriFormatString: string, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Maps.HttpMapTileDataSource;
+  }
+  var IHttpMapTileDataSourceFactory: abstract new (...args: any[]) => IHttpMapTileDataSourceFactory;
+
+  interface ILocalMapTileDataSource {
+    UriFormatString: string;
+    UriRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource, Windows.UI.Xaml.Controls.Maps.MapTileUriRequestedEventArgs> | null;
+  }
+  var ILocalMapTileDataSource: abstract new (...args: any[]) => ILocalMapTileDataSource;
+
+  interface ILocalMapTileDataSourceFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource;
+    CreateInstanceWithUriFormatString(uriFormatString: string, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Maps.LocalMapTileDataSource;
+  }
+  var ILocalMapTileDataSourceFactory: abstract new (...args: any[]) => ILocalMapTileDataSourceFactory;
+
+  interface IMapActualCameraChangedEventArgs {
+    readonly Camera: Windows.UI.Xaml.Controls.Maps.MapCamera;
+  }
+  var IMapActualCameraChangedEventArgs: abstract new (...args: any[]) => IMapActualCameraChangedEventArgs;
+
+  interface IMapActualCameraChangedEventArgs2 {
+    readonly ChangeReason: number;
+  }
+  var IMapActualCameraChangedEventArgs2: abstract new (...args: any[]) => IMapActualCameraChangedEventArgs2;
+
+  interface IMapActualCameraChangingEventArgs {
+    readonly Camera: Windows.UI.Xaml.Controls.Maps.MapCamera;
+  }
+  var IMapActualCameraChangingEventArgs: abstract new (...args: any[]) => IMapActualCameraChangingEventArgs;
+
+  interface IMapActualCameraChangingEventArgs2 {
+    readonly ChangeReason: number;
+  }
+  var IMapActualCameraChangingEventArgs2: abstract new (...args: any[]) => IMapActualCameraChangingEventArgs2;
+
+  interface IMapBillboard {
+    CollisionBehaviorDesired: number;
+    Image: Windows.Storage.Streams.IRandomAccessStreamReference;
+    Location: Windows.Devices.Geolocation.Geopoint;
+    NormalizedAnchorPoint: Windows.Foundation.Point;
+    readonly ReferenceCamera: Windows.UI.Xaml.Controls.Maps.MapCamera;
+  }
+  var IMapBillboard: abstract new (...args: any[]) => IMapBillboard;
+
+  interface IMapBillboardFactory {
+    CreateInstanceFromCamera(camera: Windows.UI.Xaml.Controls.Maps.MapCamera): Windows.UI.Xaml.Controls.Maps.MapBillboard;
+  }
+  var IMapBillboardFactory: abstract new (...args: any[]) => IMapBillboardFactory;
+
+  interface IMapBillboardStatics {
+    readonly CollisionBehaviorDesiredProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LocationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly NormalizedAnchorPointProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapBillboardStatics: abstract new (...args: any[]) => IMapBillboardStatics;
+
+  interface IMapCamera {
+    FieldOfView: number;
+    Heading: number;
+    Location: Windows.Devices.Geolocation.Geopoint;
+    Pitch: number;
+    Roll: number;
+  }
+  var IMapCamera: abstract new (...args: any[]) => IMapCamera;
+
+  interface IMapCameraFactory {
+    CreateInstanceWithLocation(location: Windows.Devices.Geolocation.Geopoint): Windows.UI.Xaml.Controls.Maps.MapCamera;
+    CreateInstanceWithLocationAndHeading(location: Windows.Devices.Geolocation.Geopoint, headingInDegrees: number): Windows.UI.Xaml.Controls.Maps.MapCamera;
+    CreateInstanceWithLocationHeadingAndPitch(location: Windows.Devices.Geolocation.Geopoint, headingInDegrees: number, pitchInDegrees: number): Windows.UI.Xaml.Controls.Maps.MapCamera;
+    CreateInstanceWithLocationHeadingPitchRollAndFieldOfView(location: Windows.Devices.Geolocation.Geopoint, headingInDegrees: number, pitchInDegrees: number, rollInDegrees: number, fieldOfViewInDegrees: number): Windows.UI.Xaml.Controls.Maps.MapCamera;
+  }
+  var IMapCameraFactory: abstract new (...args: any[]) => IMapCameraFactory;
+
+  interface IMapContextRequestedEventArgs {
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly MapElements: Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Controls.Maps.MapElement> | Windows.UI.Xaml.Controls.Maps.MapElement[];
+    readonly Position: Windows.Foundation.Point;
+  }
+  var IMapContextRequestedEventArgs: abstract new (...args: any[]) => IMapContextRequestedEventArgs;
+
+  interface IMapControl {
+    FindMapElementsAtOffset(offset: Windows.Foundation.Point): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Controls.Maps.MapElement> | Windows.UI.Xaml.Controls.Maps.MapElement[];
+    GetLocationFromOffset(offset: Windows.Foundation.Point, location: Windows.Devices.Geolocation.Geopoint): void;
+    GetOffsetFromLocation(location: Windows.Devices.Geolocation.Geopoint, offset: Windows.Foundation.Point): void;
+    IsLocationInView(location: Windows.Devices.Geolocation.Geopoint, isInView: boolean): void;
+    TrySetViewAsync(center: Windows.Devices.Geolocation.Geopoint): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySetViewAsync(center: Windows.Devices.Geolocation.Geopoint, zoomLevel: number | null): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySetViewAsync(center: Windows.Devices.Geolocation.Geopoint, zoomLevel: number | null, heading: number | null, desiredPitch: number | null): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySetViewAsync(center: Windows.Devices.Geolocation.Geopoint, zoomLevel: number | null, heading: number | null, desiredPitch: number | null, animation: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySetViewBoundsAsync(bounds: Windows.Devices.Geolocation.GeoboundingBox, margin: Windows.UI.Xaml.Thickness | null, animation: number): Windows.Foundation.IAsyncOperation<boolean>;
+    Center: Windows.Devices.Geolocation.Geopoint;
+    readonly Children: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    ColorScheme: number;
+    DesiredPitch: number;
+    Heading: number;
+    LandmarksVisible: boolean;
+    readonly LoadingStatus: number;
+    readonly MapElements: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.Maps.MapElement> | Windows.UI.Xaml.Controls.Maps.MapElement[];
+    MapServiceToken: string;
+    readonly MaxZoomLevel: number;
+    readonly MinZoomLevel: number;
+    PedestrianFeaturesVisible: boolean;
+    readonly Pitch: number;
+    readonly Routes: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.Maps.MapRouteView> | Windows.UI.Xaml.Controls.Maps.MapRouteView[];
+    Style: number;
+    readonly TileSources: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.Maps.MapTileSource> | Windows.UI.Xaml.Controls.Maps.MapTileSource[];
+    TrafficFlowVisible: boolean;
+    TransformOrigin: Windows.Foundation.Point;
+    WatermarkMode: number;
+    ZoomLevel: number;
+    CenterChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Object> | null;
+    HeadingChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Object> | null;
+    LoadingStatusChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Object> | null;
+    MapDoubleTapped: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapInputEventArgs> | null;
+    MapHolding: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapInputEventArgs> | null;
+    MapTapped: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapInputEventArgs> | null;
+    PitchChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Object> | null;
+    TransformOriginChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Object> | null;
+    ZoomLevelChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Object> | null;
+  }
+  var IMapControl: abstract new (...args: any[]) => IMapControl;
+
+  interface IMapControl2 {
+    StartContinuousRotate(rateInDegreesPerSecond: number): void;
+    StartContinuousTilt(rateInDegreesPerSecond: number): void;
+    StartContinuousZoom(rateOfChangePerSecond: number): void;
+    StopContinuousRotate(): void;
+    StopContinuousTilt(): void;
+    StopContinuousZoom(): void;
+    TryRotateAsync(degrees: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryRotateToAsync(angleInDegrees: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySetSceneAsync(scene: Windows.UI.Xaml.Controls.Maps.MapScene): Windows.Foundation.IAsyncOperation<boolean>;
+    TrySetSceneAsync(scene: Windows.UI.Xaml.Controls.Maps.MapScene, animationKind: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryTiltAsync(degrees: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryTiltToAsync(angleInDegrees: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryZoomInAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryZoomOutAsync(): Windows.Foundation.IAsyncOperation<boolean>;
+    TryZoomToAsync(zoomLevel: number): Windows.Foundation.IAsyncOperation<boolean>;
+    readonly ActualCamera: Windows.UI.Xaml.Controls.Maps.MapCamera;
+    BusinessLandmarksVisible: boolean;
+    CustomExperience: Windows.UI.Xaml.Controls.Maps.MapCustomExperience;
+    readonly Is3DSupported: boolean;
+    readonly IsStreetsideSupported: boolean;
+    PanInteractionMode: number;
+    RotateInteractionMode: number;
+    Scene: Windows.UI.Xaml.Controls.Maps.MapScene;
+    readonly TargetCamera: Windows.UI.Xaml.Controls.Maps.MapCamera;
+    TiltInteractionMode: number;
+    TransitFeaturesVisible: boolean;
+    ZoomInteractionMode: number;
+    ActualCameraChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapActualCameraChangedEventArgs> | null;
+    ActualCameraChanging: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapActualCameraChangingEventArgs> | null;
+    CustomExperienceChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapCustomExperienceChangedEventArgs> | null;
+    MapElementClick: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapElementClickEventArgs> | null;
+    MapElementPointerEntered: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapElementPointerEnteredEventArgs> | null;
+    MapElementPointerExited: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapElementPointerExitedEventArgs> | null;
+    TargetCameraChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs> | null;
+  }
+  var IMapControl2: abstract new (...args: any[]) => IMapControl2;
+
+  interface IMapControl3 {
+    MapRightTapped: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapRightTappedEventArgs> | null;
+  }
+  var IMapControl3: abstract new (...args: any[]) => IMapControl3;
+
+  interface IMapControl4 {
+    GetVisibleRegion(region: number): Windows.Devices.Geolocation.Geopath;
+    BusinessLandmarksEnabled: boolean;
+    TransitFeaturesEnabled: boolean;
+  }
+  var IMapControl4: abstract new (...args: any[]) => IMapControl4;
+
+  interface IMapControl5 {
+    FindMapElementsAtOffset(offset: Windows.Foundation.Point, radius: number): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Controls.Maps.MapElement> | Windows.UI.Xaml.Controls.Maps.MapElement[];
+    GetLocationFromOffset(offset: Windows.Foundation.Point, desiredReferenceSystem: number, location: Windows.Devices.Geolocation.Geopoint): void;
+    StartContinuousPan(horizontalPixelsPerSecond: number, verticalPixelsPerSecond: number): void;
+    StopContinuousPan(): void;
+    TryPanAsync(horizontalPixels: number, verticalPixels: number): Windows.Foundation.IAsyncOperation<boolean>;
+    TryPanToAsync(location: Windows.Devices.Geolocation.Geopoint): Windows.Foundation.IAsyncOperation<boolean>;
+    MapProjection: number;
+    StyleSheet: Windows.UI.Xaml.Controls.Maps.MapStyleSheet;
+    ViewPadding: Windows.UI.Xaml.Thickness;
+    MapContextRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapContextRequestedEventArgs> | null;
+  }
+  var IMapControl5: abstract new (...args: any[]) => IMapControl5;
+
+  interface IMapControl6 {
+    TryGetLocationFromOffset(offset: Windows.Foundation.Point, location: Windows.Devices.Geolocation.Geopoint): boolean;
+    TryGetLocationFromOffset(offset: Windows.Foundation.Point, desiredReferenceSystem: number, location: Windows.Devices.Geolocation.Geopoint): boolean;
+    Layers: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.Maps.MapLayer> | Windows.UI.Xaml.Controls.Maps.MapLayer[];
+  }
+  var IMapControl6: abstract new (...args: any[]) => IMapControl6;
+
+  interface IMapControl7 {
+    Region: string;
+  }
+  var IMapControl7: abstract new (...args: any[]) => IMapControl7;
+
+  interface IMapControl8 {
+    readonly CanTiltDown: boolean;
+    readonly CanTiltUp: boolean;
+    readonly CanZoomIn: boolean;
+    readonly CanZoomOut: boolean;
+  }
+  var IMapControl8: abstract new (...args: any[]) => IMapControl8;
+
+  interface IMapControlBusinessLandmarkClickEventArgs {
+    readonly LocalLocations: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.LocalSearch.LocalLocation> | Windows.Services.Maps.LocalSearch.LocalLocation[];
+  }
+  var IMapControlBusinessLandmarkClickEventArgs: abstract new (...args: any[]) => IMapControlBusinessLandmarkClickEventArgs;
+
+  interface IMapControlBusinessLandmarkPointerEnteredEventArgs {
+    readonly LocalLocations: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.LocalSearch.LocalLocation> | Windows.Services.Maps.LocalSearch.LocalLocation[];
+  }
+  var IMapControlBusinessLandmarkPointerEnteredEventArgs: abstract new (...args: any[]) => IMapControlBusinessLandmarkPointerEnteredEventArgs;
+
+  interface IMapControlBusinessLandmarkPointerExitedEventArgs {
+    readonly LocalLocations: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.LocalSearch.LocalLocation> | Windows.Services.Maps.LocalSearch.LocalLocation[];
+  }
+  var IMapControlBusinessLandmarkPointerExitedEventArgs: abstract new (...args: any[]) => IMapControlBusinessLandmarkPointerExitedEventArgs;
+
+  interface IMapControlBusinessLandmarkRightTappedEventArgs {
+    readonly LocalLocations: Windows.Foundation.Collections.IVectorView<Windows.Services.Maps.LocalSearch.LocalLocation> | Windows.Services.Maps.LocalSearch.LocalLocation[];
+  }
+  var IMapControlBusinessLandmarkRightTappedEventArgs: abstract new (...args: any[]) => IMapControlBusinessLandmarkRightTappedEventArgs;
+
+  interface IMapControlDataHelper {
+    BusinessLandmarkClick: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkClickEventArgs> | null;
+    BusinessLandmarkRightTapped: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkRightTappedEventArgs> | null;
+    TransitFeatureClick: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureClickEventArgs> | null;
+    TransitFeatureRightTapped: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapControlTransitFeatureRightTappedEventArgs> | null;
+  }
+  var IMapControlDataHelper: abstract new (...args: any[]) => IMapControlDataHelper;
+
+  interface IMapControlDataHelper2 {
+    BusinessLandmarkPointerEntered: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerEnteredEventArgs> | null;
+    BusinessLandmarkPointerExited: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapControlBusinessLandmarkPointerExitedEventArgs> | null;
+    TransitFeaturePointerEntered: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerEnteredEventArgs> | null;
+    TransitFeaturePointerExited: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapControl, Windows.UI.Xaml.Controls.Maps.MapControlTransitFeaturePointerExitedEventArgs> | null;
+  }
+  var IMapControlDataHelper2: abstract new (...args: any[]) => IMapControlDataHelper2;
+
+  interface IMapControlDataHelperFactory {
+    CreateInstance(map: Windows.UI.Xaml.Controls.Maps.MapControl): Windows.UI.Xaml.Controls.Maps.MapControlDataHelper;
+  }
+  var IMapControlDataHelperFactory: abstract new (...args: any[]) => IMapControlDataHelperFactory;
+
+  interface IMapControlDataHelperStatics {
+    CreateMapControl(rasterRenderMode: boolean): Windows.UI.Xaml.Controls.Maps.MapControl;
+  }
+  var IMapControlDataHelperStatics: abstract new (...args: any[]) => IMapControlDataHelperStatics;
+
+  interface IMapControlStatics {
+    GetLocation(element: Windows.UI.Xaml.DependencyObject): Windows.Devices.Geolocation.Geopoint;
+    GetNormalizedAnchorPoint(element: Windows.UI.Xaml.DependencyObject): Windows.Foundation.Point;
+    SetLocation(element: Windows.UI.Xaml.DependencyObject, value: Windows.Devices.Geolocation.Geopoint): void;
+    SetNormalizedAnchorPoint(element: Windows.UI.Xaml.DependencyObject, value: Windows.Foundation.Point): void;
+    readonly CenterProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ChildrenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ColorSchemeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DesiredPitchProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HeadingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LandmarksVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LoadingStatusProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LocationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MapElementsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MapServiceTokenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly NormalizedAnchorPointProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PedestrianFeaturesVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PitchProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RoutesProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TileSourcesProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TrafficFlowVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TransformOriginProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly WatermarkModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ZoomLevelProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapControlStatics: abstract new (...args: any[]) => IMapControlStatics;
+
+  interface IMapControlStatics2 {
+    readonly BusinessLandmarksVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Is3DSupportedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsStreetsideSupportedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PanInteractionModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RotateInteractionModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SceneProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TiltInteractionModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TransitFeaturesVisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ZoomInteractionModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapControlStatics2: abstract new (...args: any[]) => IMapControlStatics2;
+
+  interface IMapControlStatics4 {
+    readonly BusinessLandmarksEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TransitFeaturesEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapControlStatics4: abstract new (...args: any[]) => IMapControlStatics4;
+
+  interface IMapControlStatics5 {
+    readonly MapProjectionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StyleSheetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ViewPaddingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapControlStatics5: abstract new (...args: any[]) => IMapControlStatics5;
+
+  interface IMapControlStatics6 {
+    readonly LayersProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapControlStatics6: abstract new (...args: any[]) => IMapControlStatics6;
+
+  interface IMapControlStatics7 {
+    readonly RegionProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapControlStatics7: abstract new (...args: any[]) => IMapControlStatics7;
+
+  interface IMapControlStatics8 {
+    readonly CanTiltDownProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanTiltUpProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanZoomInProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CanZoomOutProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapControlStatics8: abstract new (...args: any[]) => IMapControlStatics8;
+
+  interface IMapControlTransitFeatureClickEventArgs {
+    readonly DisplayName: string;
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly TransitProperties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+  var IMapControlTransitFeatureClickEventArgs: abstract new (...args: any[]) => IMapControlTransitFeatureClickEventArgs;
+
+  interface IMapControlTransitFeaturePointerEnteredEventArgs {
+    readonly DisplayName: string;
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly TransitProperties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+  var IMapControlTransitFeaturePointerEnteredEventArgs: abstract new (...args: any[]) => IMapControlTransitFeaturePointerEnteredEventArgs;
+
+  interface IMapControlTransitFeaturePointerExitedEventArgs {
+    readonly DisplayName: string;
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly TransitProperties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+  var IMapControlTransitFeaturePointerExitedEventArgs: abstract new (...args: any[]) => IMapControlTransitFeaturePointerExitedEventArgs;
+
+  interface IMapControlTransitFeatureRightTappedEventArgs {
+    readonly DisplayName: string;
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly TransitProperties: Windows.Foundation.Collections.IMapView<string, Object>;
+  }
+  var IMapControlTransitFeatureRightTappedEventArgs: abstract new (...args: any[]) => IMapControlTransitFeatureRightTappedEventArgs;
+
+  interface IMapCustomExperience {
+  }
+  var IMapCustomExperience: abstract new (...args: any[]) => IMapCustomExperience;
+
+  interface IMapCustomExperienceChangedEventArgs {
+  }
+  var IMapCustomExperienceChangedEventArgs: abstract new (...args: any[]) => IMapCustomExperienceChangedEventArgs;
+
+  interface IMapCustomExperienceFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Maps.MapCustomExperience;
+  }
+  var IMapCustomExperienceFactory: abstract new (...args: any[]) => IMapCustomExperienceFactory;
+
+  interface IMapElement {
+    Visible: boolean;
+    ZIndex: number;
+  }
+  var IMapElement: abstract new (...args: any[]) => IMapElement;
+
+  interface IMapElement2 {
+    MapTabIndex: number;
+  }
+  var IMapElement2: abstract new (...args: any[]) => IMapElement2;
+
+  interface IMapElement3 {
+    MapStyleSheetEntry: string;
+    MapStyleSheetEntryState: string;
+    Tag: Object;
+  }
+  var IMapElement3: abstract new (...args: any[]) => IMapElement3;
+
+  interface IMapElement3D {
+    Heading: number;
+    Location: Windows.Devices.Geolocation.Geopoint;
+    Model: Windows.UI.Xaml.Controls.Maps.MapModel3D;
+    Pitch: number;
+    Roll: number;
+    Scale: Windows.Foundation.Numerics.Vector3;
+  }
+  var IMapElement3D: abstract new (...args: any[]) => IMapElement3D;
+
+  interface IMapElement3DStatics {
+    readonly HeadingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LocationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PitchProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RollProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ScaleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapElement3DStatics: abstract new (...args: any[]) => IMapElement3DStatics;
+
+  interface IMapElement4 {
+    IsEnabled: boolean;
+  }
+  var IMapElement4: abstract new (...args: any[]) => IMapElement4;
+
+  interface IMapElementClickEventArgs {
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly MapElements: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.Maps.MapElement> | Windows.UI.Xaml.Controls.Maps.MapElement[];
+    readonly Position: Windows.Foundation.Point;
+  }
+  var IMapElementClickEventArgs: abstract new (...args: any[]) => IMapElementClickEventArgs;
+
+  interface IMapElementFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Maps.MapElement;
+  }
+  var IMapElementFactory: abstract new (...args: any[]) => IMapElementFactory;
+
+  interface IMapElementPointerEnteredEventArgs {
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly MapElement: Windows.UI.Xaml.Controls.Maps.MapElement;
+    readonly Position: Windows.Foundation.Point;
+  }
+  var IMapElementPointerEnteredEventArgs: abstract new (...args: any[]) => IMapElementPointerEnteredEventArgs;
+
+  interface IMapElementPointerExitedEventArgs {
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly MapElement: Windows.UI.Xaml.Controls.Maps.MapElement;
+    readonly Position: Windows.Foundation.Point;
+  }
+  var IMapElementPointerExitedEventArgs: abstract new (...args: any[]) => IMapElementPointerExitedEventArgs;
+
+  interface IMapElementStatics {
+    readonly VisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ZIndexProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapElementStatics: abstract new (...args: any[]) => IMapElementStatics;
+
+  interface IMapElementStatics2 {
+    readonly MapTabIndexProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapElementStatics2: abstract new (...args: any[]) => IMapElementStatics2;
+
+  interface IMapElementStatics3 {
+    readonly MapStyleSheetEntryProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MapStyleSheetEntryStateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TagProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapElementStatics3: abstract new (...args: any[]) => IMapElementStatics3;
+
+  interface IMapElementStatics4 {
+    readonly IsEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapElementStatics4: abstract new (...args: any[]) => IMapElementStatics4;
+
+  interface IMapElementsLayer {
+    MapElements: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.Maps.MapElement> | Windows.UI.Xaml.Controls.Maps.MapElement[];
+    MapContextRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapElementsLayer, Windows.UI.Xaml.Controls.Maps.MapElementsLayerContextRequestedEventArgs> | null;
+    MapElementClick: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapElementsLayer, Windows.UI.Xaml.Controls.Maps.MapElementsLayerClickEventArgs> | null;
+    MapElementPointerEntered: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapElementsLayer, Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerEnteredEventArgs> | null;
+    MapElementPointerExited: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapElementsLayer, Windows.UI.Xaml.Controls.Maps.MapElementsLayerPointerExitedEventArgs> | null;
+  }
+  var IMapElementsLayer: abstract new (...args: any[]) => IMapElementsLayer;
+
+  interface IMapElementsLayerClickEventArgs {
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly MapElements: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Controls.Maps.MapElement> | Windows.UI.Xaml.Controls.Maps.MapElement[];
+    readonly Position: Windows.Foundation.Point;
+  }
+  var IMapElementsLayerClickEventArgs: abstract new (...args: any[]) => IMapElementsLayerClickEventArgs;
+
+  interface IMapElementsLayerContextRequestedEventArgs {
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly MapElements: Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Controls.Maps.MapElement> | Windows.UI.Xaml.Controls.Maps.MapElement[];
+    readonly Position: Windows.Foundation.Point;
+  }
+  var IMapElementsLayerContextRequestedEventArgs: abstract new (...args: any[]) => IMapElementsLayerContextRequestedEventArgs;
+
+  interface IMapElementsLayerPointerEnteredEventArgs {
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly MapElement: Windows.UI.Xaml.Controls.Maps.MapElement;
+    readonly Position: Windows.Foundation.Point;
+  }
+  var IMapElementsLayerPointerEnteredEventArgs: abstract new (...args: any[]) => IMapElementsLayerPointerEnteredEventArgs;
+
+  interface IMapElementsLayerPointerExitedEventArgs {
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly MapElement: Windows.UI.Xaml.Controls.Maps.MapElement;
+    readonly Position: Windows.Foundation.Point;
+  }
+  var IMapElementsLayerPointerExitedEventArgs: abstract new (...args: any[]) => IMapElementsLayerPointerExitedEventArgs;
+
+  interface IMapElementsLayerStatics {
+    readonly MapElementsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapElementsLayerStatics: abstract new (...args: any[]) => IMapElementsLayerStatics;
+
+  interface IMapIcon {
+    Image: Windows.Storage.Streams.IRandomAccessStreamReference;
+    Location: Windows.Devices.Geolocation.Geopoint;
+    NormalizedAnchorPoint: Windows.Foundation.Point;
+    Title: string;
+  }
+  var IMapIcon: abstract new (...args: any[]) => IMapIcon;
+
+  interface IMapIcon2 {
+    CollisionBehaviorDesired: number;
+  }
+  var IMapIcon2: abstract new (...args: any[]) => IMapIcon2;
+
+  interface IMapIconStatics {
+    readonly LocationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly NormalizedAnchorPointProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TitleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapIconStatics: abstract new (...args: any[]) => IMapIconStatics;
+
+  interface IMapIconStatics2 {
+    readonly CollisionBehaviorDesiredProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapIconStatics2: abstract new (...args: any[]) => IMapIconStatics2;
+
+  interface IMapInputEventArgs {
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly Position: Windows.Foundation.Point;
+  }
+  var IMapInputEventArgs: abstract new (...args: any[]) => IMapInputEventArgs;
+
+  interface IMapItemsControl {
+    ItemTemplate: Windows.UI.Xaml.DataTemplate;
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    ItemsSource: Object;
+  }
+  var IMapItemsControl: abstract new (...args: any[]) => IMapItemsControl;
+
+  interface IMapItemsControlStatics {
+    readonly ItemTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemsSourceProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapItemsControlStatics: abstract new (...args: any[]) => IMapItemsControlStatics;
+
+  interface IMapLayer {
+    MapTabIndex: number;
+    Visible: boolean;
+    ZIndex: number;
+  }
+  var IMapLayer: abstract new (...args: any[]) => IMapLayer;
+
+  interface IMapLayerFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Maps.MapLayer;
+  }
+  var IMapLayerFactory: abstract new (...args: any[]) => IMapLayerFactory;
+
+  interface IMapLayerStatics {
+    readonly MapTabIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ZIndexProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapLayerStatics: abstract new (...args: any[]) => IMapLayerStatics;
+
+  interface IMapModel3D {
+  }
+  var IMapModel3D: abstract new (...args: any[]) => IMapModel3D;
+
+  interface IMapModel3DFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Maps.MapModel3D;
+  }
+  var IMapModel3DFactory: abstract new (...args: any[]) => IMapModel3DFactory;
+
+  interface IMapModel3DStatics {
+    CreateFrom3MFAsync(source: Windows.Storage.Streams.IRandomAccessStreamReference): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Controls.Maps.MapModel3D>;
+    CreateFrom3MFAsync(source: Windows.Storage.Streams.IRandomAccessStreamReference, shadingOption: number): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Controls.Maps.MapModel3D>;
+  }
+  var IMapModel3DStatics: abstract new (...args: any[]) => IMapModel3DStatics;
+
+  interface IMapPolygon {
+    FillColor: Windows.UI.Color;
+    Path: Windows.Devices.Geolocation.Geopath;
+    StrokeColor: Windows.UI.Color;
+    StrokeDashed: boolean;
+    StrokeThickness: number;
+  }
+  var IMapPolygon: abstract new (...args: any[]) => IMapPolygon;
+
+  interface IMapPolygon2 {
+    readonly Paths: Windows.Foundation.Collections.IVector<Windows.Devices.Geolocation.Geopath> | Windows.Devices.Geolocation.Geopath[];
+  }
+  var IMapPolygon2: abstract new (...args: any[]) => IMapPolygon2;
+
+  interface IMapPolygonStatics {
+    readonly PathProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StrokeDashedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StrokeThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapPolygonStatics: abstract new (...args: any[]) => IMapPolygonStatics;
+
+  interface IMapPolyline {
+    Path: Windows.Devices.Geolocation.Geopath;
+    StrokeColor: Windows.UI.Color;
+    StrokeDashed: boolean;
+    StrokeThickness: number;
+  }
+  var IMapPolyline: abstract new (...args: any[]) => IMapPolyline;
+
+  interface IMapPolylineStatics {
+    readonly PathProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StrokeDashedProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapPolylineStatics: abstract new (...args: any[]) => IMapPolylineStatics;
+
+  interface IMapRightTappedEventArgs {
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+    readonly Position: Windows.Foundation.Point;
+  }
+  var IMapRightTappedEventArgs: abstract new (...args: any[]) => IMapRightTappedEventArgs;
+
+  interface IMapRouteView {
+    OutlineColor: Windows.UI.Color;
+    readonly Route: Windows.Services.Maps.MapRoute;
+    RouteColor: Windows.UI.Color;
+  }
+  var IMapRouteView: abstract new (...args: any[]) => IMapRouteView;
+
+  interface IMapRouteViewFactory {
+    CreateInstanceWithMapRoute(route: Windows.Services.Maps.MapRoute, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Maps.MapRouteView;
+  }
+  var IMapRouteViewFactory: abstract new (...args: any[]) => IMapRouteViewFactory;
+
+  interface IMapScene {
+    readonly TargetCamera: Windows.UI.Xaml.Controls.Maps.MapCamera;
+    TargetCameraChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Maps.MapScene, Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs> | null;
+  }
+  var IMapScene: abstract new (...args: any[]) => IMapScene;
+
+  interface IMapSceneStatics {
+    CreateFromBoundingBox(bounds: Windows.Devices.Geolocation.GeoboundingBox): Windows.UI.Xaml.Controls.Maps.MapScene;
+    CreateFromBoundingBox(bounds: Windows.Devices.Geolocation.GeoboundingBox, headingInDegrees: number, pitchInDegrees: number): Windows.UI.Xaml.Controls.Maps.MapScene;
+    CreateFromCamera(camera: Windows.UI.Xaml.Controls.Maps.MapCamera): Windows.UI.Xaml.Controls.Maps.MapScene;
+    CreateFromLocation(location: Windows.Devices.Geolocation.Geopoint): Windows.UI.Xaml.Controls.Maps.MapScene;
+    CreateFromLocation(location: Windows.Devices.Geolocation.Geopoint, headingInDegrees: number, pitchInDegrees: number): Windows.UI.Xaml.Controls.Maps.MapScene;
+    CreateFromLocationAndRadius(location: Windows.Devices.Geolocation.Geopoint, radiusInMeters: number): Windows.UI.Xaml.Controls.Maps.MapScene;
+    CreateFromLocationAndRadius(location: Windows.Devices.Geolocation.Geopoint, radiusInMeters: number, headingInDegrees: number, pitchInDegrees: number): Windows.UI.Xaml.Controls.Maps.MapScene;
+    CreateFromLocations(locations: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.Geopoint> | Windows.Devices.Geolocation.Geopoint[]): Windows.UI.Xaml.Controls.Maps.MapScene;
+    CreateFromLocations(locations: Windows.Foundation.Collections.IIterable<Windows.Devices.Geolocation.Geopoint> | Windows.Devices.Geolocation.Geopoint[], headingInDegrees: number, pitchInDegrees: number): Windows.UI.Xaml.Controls.Maps.MapScene;
+  }
+  var IMapSceneStatics: abstract new (...args: any[]) => IMapSceneStatics;
+
+  interface IMapStyleSheet {
+  }
+  var IMapStyleSheet: abstract new (...args: any[]) => IMapStyleSheet;
+
+  interface IMapStyleSheetEntriesStatics {
+    readonly AdminDistrict: string;
+    readonly AdminDistrictCapital: string;
+    readonly Airport: string;
+    readonly Area: string;
+    readonly ArterialRoad: string;
+    readonly Building: string;
+    readonly Business: string;
+    readonly Capital: string;
+    readonly Cemetery: string;
+    readonly Continent: string;
+    readonly ControlledAccessHighway: string;
+    readonly CountryRegion: string;
+    readonly CountryRegionCapital: string;
+    readonly District: string;
+    readonly DrivingRoute: string;
+    readonly Education: string;
+    readonly EducationBuilding: string;
+    readonly FoodPoint: string;
+    readonly Forest: string;
+    readonly GolfCourse: string;
+    readonly HighSpeedRamp: string;
+    readonly Highway: string;
+    readonly IndigenousPeoplesReserve: string;
+    readonly Island: string;
+    readonly MajorRoad: string;
+    readonly Medical: string;
+    readonly MedicalBuilding: string;
+    readonly Military: string;
+    readonly NaturalPoint: string;
+    readonly Nautical: string;
+    readonly Neighborhood: string;
+    readonly Park: string;
+    readonly Peak: string;
+    readonly PlayingField: string;
+    readonly Point: string;
+    readonly PointOfInterest: string;
+    readonly Political: string;
+    readonly PopulatedPlace: string;
+    readonly Railway: string;
+    readonly Ramp: string;
+    readonly Reserve: string;
+    readonly River: string;
+    readonly Road: string;
+    readonly RoadExit: string;
+    readonly RoadShield: string;
+    readonly RouteLine: string;
+    readonly Runway: string;
+    readonly Sand: string;
+    readonly ShoppingCenter: string;
+    readonly Stadium: string;
+    readonly Street: string;
+    readonly Structure: string;
+    readonly TollRoad: string;
+    readonly Trail: string;
+    readonly Transit: string;
+    readonly TransitBuilding: string;
+    readonly Transportation: string;
+    readonly UnpavedStreet: string;
+    readonly Vegetation: string;
+    readonly VolcanicPeak: string;
+    readonly WalkingRoute: string;
+    readonly Water: string;
+    readonly WaterPoint: string;
+    readonly WaterRoute: string;
+  }
+  var IMapStyleSheetEntriesStatics: abstract new (...args: any[]) => IMapStyleSheetEntriesStatics;
+
+  interface IMapStyleSheetEntryStatesStatics {
+    readonly Disabled: string;
+    readonly Hover: string;
+    readonly Selected: string;
+  }
+  var IMapStyleSheetEntryStatesStatics: abstract new (...args: any[]) => IMapStyleSheetEntryStatesStatics;
+
+  interface IMapStyleSheetStatics {
+    Aerial(): Windows.UI.Xaml.Controls.Maps.MapStyleSheet;
+    AerialWithOverlay(): Windows.UI.Xaml.Controls.Maps.MapStyleSheet;
+    Combine(styleSheets: Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.Controls.Maps.MapStyleSheet> | Windows.UI.Xaml.Controls.Maps.MapStyleSheet[]): Windows.UI.Xaml.Controls.Maps.MapStyleSheet;
+    ParseFromJson(styleAsJson: string): Windows.UI.Xaml.Controls.Maps.MapStyleSheet;
+    RoadDark(): Windows.UI.Xaml.Controls.Maps.MapStyleSheet;
+    RoadHighContrastDark(): Windows.UI.Xaml.Controls.Maps.MapStyleSheet;
+    RoadHighContrastLight(): Windows.UI.Xaml.Controls.Maps.MapStyleSheet;
+    RoadLight(): Windows.UI.Xaml.Controls.Maps.MapStyleSheet;
+    TryParseFromJson(styleAsJson: string, styleSheet: Windows.UI.Xaml.Controls.Maps.MapStyleSheet): boolean;
+  }
+  var IMapStyleSheetStatics: abstract new (...args: any[]) => IMapStyleSheetStatics;
+
+  interface IMapTargetCameraChangedEventArgs {
+    readonly Camera: Windows.UI.Xaml.Controls.Maps.MapCamera;
+  }
+  var IMapTargetCameraChangedEventArgs: abstract new (...args: any[]) => IMapTargetCameraChangedEventArgs;
+
+  interface IMapTargetCameraChangedEventArgs2 {
+    readonly ChangeReason: number;
+  }
+  var IMapTargetCameraChangedEventArgs2: abstract new (...args: any[]) => IMapTargetCameraChangedEventArgs2;
+
+  interface IMapTileBitmapRequest {
+    GetDeferral(): Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequestDeferral;
+    PixelData: Windows.Storage.Streams.IRandomAccessStreamReference;
+  }
+  var IMapTileBitmapRequest: abstract new (...args: any[]) => IMapTileBitmapRequest;
+
+  interface IMapTileBitmapRequestDeferral {
+    Complete(): void;
+  }
+  var IMapTileBitmapRequestDeferral: abstract new (...args: any[]) => IMapTileBitmapRequestDeferral;
+
+  interface IMapTileBitmapRequestedEventArgs {
+    readonly Request: Windows.UI.Xaml.Controls.Maps.MapTileBitmapRequest;
+    readonly X: number;
+    readonly Y: number;
+    readonly ZoomLevel: number;
+  }
+  var IMapTileBitmapRequestedEventArgs: abstract new (...args: any[]) => IMapTileBitmapRequestedEventArgs;
+
+  interface IMapTileBitmapRequestedEventArgs2 {
+    readonly FrameIndex: number;
+  }
+  var IMapTileBitmapRequestedEventArgs2: abstract new (...args: any[]) => IMapTileBitmapRequestedEventArgs2;
+
+  interface IMapTileDataSource {
+  }
+  var IMapTileDataSource: abstract new (...args: any[]) => IMapTileDataSource;
+
+  interface IMapTileDataSourceFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Maps.MapTileDataSource;
+  }
+  var IMapTileDataSourceFactory: abstract new (...args: any[]) => IMapTileDataSourceFactory;
+
+  interface IMapTileSource {
+    AllowOverstretch: boolean;
+    Bounds: Windows.Devices.Geolocation.GeoboundingBox;
+    DataSource: Windows.UI.Xaml.Controls.Maps.MapTileDataSource;
+    IsFadingEnabled: boolean;
+    IsRetryEnabled: boolean;
+    IsTransparencyEnabled: boolean;
+    Layer: number;
+    TilePixelSize: number;
+    Visible: boolean;
+    ZIndex: number;
+    ZoomLevelRange: Windows.UI.Xaml.Controls.Maps.MapZoomLevelRange;
+  }
+  var IMapTileSource: abstract new (...args: any[]) => IMapTileSource;
+
+  interface IMapTileSource2 {
+    Pause(): void;
+    Play(): void;
+    Stop(): void;
+    readonly AnimationState: number;
+    AutoPlay: boolean;
+    FrameCount: number;
+    FrameDuration: Windows.Foundation.TimeSpan;
+  }
+  var IMapTileSource2: abstract new (...args: any[]) => IMapTileSource2;
+
+  interface IMapTileSourceFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Maps.MapTileSource;
+    CreateInstanceWithDataSource(dataSource: Windows.UI.Xaml.Controls.Maps.MapTileDataSource, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Maps.MapTileSource;
+    CreateInstanceWithDataSourceAndZoomRange(dataSource: Windows.UI.Xaml.Controls.Maps.MapTileDataSource, zoomLevelRange: Windows.UI.Xaml.Controls.Maps.MapZoomLevelRange, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Maps.MapTileSource;
+    CreateInstanceWithDataSourceZoomRangeAndBounds(dataSource: Windows.UI.Xaml.Controls.Maps.MapTileDataSource, zoomLevelRange: Windows.UI.Xaml.Controls.Maps.MapZoomLevelRange, bounds: Windows.Devices.Geolocation.GeoboundingBox, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Maps.MapTileSource;
+    CreateInstanceWithDataSourceZoomRangeBoundsAndTileSize(dataSource: Windows.UI.Xaml.Controls.Maps.MapTileDataSource, zoomLevelRange: Windows.UI.Xaml.Controls.Maps.MapZoomLevelRange, bounds: Windows.Devices.Geolocation.GeoboundingBox, tileSizeInPixels: number, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Maps.MapTileSource;
+  }
+  var IMapTileSourceFactory: abstract new (...args: any[]) => IMapTileSourceFactory;
+
+  interface IMapTileSourceStatics {
+    readonly AllowOverstretchProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BoundsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DataSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsFadingEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsRetryEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsTransparencyEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LayerProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TilePixelSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VisibleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ZIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ZoomLevelRangeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapTileSourceStatics: abstract new (...args: any[]) => IMapTileSourceStatics;
+
+  interface IMapTileSourceStatics2 {
+    readonly AnimationStateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AutoPlayProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FrameCountProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FrameDurationProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMapTileSourceStatics2: abstract new (...args: any[]) => IMapTileSourceStatics2;
+
+  interface IMapTileUriRequest {
+    GetDeferral(): Windows.UI.Xaml.Controls.Maps.MapTileUriRequestDeferral;
+    Uri: Windows.Foundation.Uri;
+  }
+  var IMapTileUriRequest: abstract new (...args: any[]) => IMapTileUriRequest;
+
+  interface IMapTileUriRequestDeferral {
+    Complete(): void;
+  }
+  var IMapTileUriRequestDeferral: abstract new (...args: any[]) => IMapTileUriRequestDeferral;
+
+  interface IMapTileUriRequestedEventArgs {
+    readonly Request: Windows.UI.Xaml.Controls.Maps.MapTileUriRequest;
+    readonly X: number;
+    readonly Y: number;
+    readonly ZoomLevel: number;
+  }
+  var IMapTileUriRequestedEventArgs: abstract new (...args: any[]) => IMapTileUriRequestedEventArgs;
+
+  interface IMapTileUriRequestedEventArgs2 {
+    readonly FrameIndex: number;
+  }
+  var IMapTileUriRequestedEventArgs2: abstract new (...args: any[]) => IMapTileUriRequestedEventArgs2;
+
+  interface IStreetsideExperience {
+    AddressTextVisible: boolean;
+    CursorVisible: boolean;
+    ExitButtonVisible: boolean;
+    OverviewMapVisible: boolean;
+    StreetLabelsVisible: boolean;
+    ZoomButtonsVisible: boolean;
+  }
+  var IStreetsideExperience: abstract new (...args: any[]) => IStreetsideExperience;
+
+  interface IStreetsideExperienceFactory {
+    CreateInstanceWithPanorama(panorama: Windows.UI.Xaml.Controls.Maps.StreetsidePanorama): Windows.UI.Xaml.Controls.Maps.StreetsideExperience;
+    CreateInstanceWithPanoramaHeadingPitchAndFieldOfView(panorama: Windows.UI.Xaml.Controls.Maps.StreetsidePanorama, headingInDegrees: number, pitchInDegrees: number, fieldOfViewInDegrees: number): Windows.UI.Xaml.Controls.Maps.StreetsideExperience;
+  }
+  var IStreetsideExperienceFactory: abstract new (...args: any[]) => IStreetsideExperienceFactory;
+
+  interface IStreetsidePanorama {
+    readonly Location: Windows.Devices.Geolocation.Geopoint;
+  }
+  var IStreetsidePanorama: abstract new (...args: any[]) => IStreetsidePanorama;
+
+  interface IStreetsidePanoramaStatics {
+    FindNearbyAsync(location: Windows.Devices.Geolocation.Geopoint): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Controls.Maps.StreetsidePanorama>;
+    FindNearbyAsync(location: Windows.Devices.Geolocation.Geopoint, radiusInMeters: number): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Controls.Maps.StreetsidePanorama>;
+  }
+  var IStreetsidePanoramaStatics: abstract new (...args: any[]) => IStreetsidePanoramaStatics;
+
+  interface MapZoomLevelRange {
+    Min: number;
+    Max: number;
+  }
+  var MapZoomLevelRange: {
+    new(min: number, max: number): MapZoomLevelRange;
+    new(fields: { Min?: number; Max?: number }): MapZoomLevelRange;
+  };
+
+}
+
+declare namespace Windows.UI.Xaml.Controls.Primitives {
+  class AppBarButtonTemplateSettings extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.IAppBarButtonTemplateSettings {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly KeyboardAcceleratorTextMinWidth: number;
+  }
+
+  class AppBarTemplateSettings extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.IAppBarTemplateSettings, Windows.UI.Xaml.Controls.Primitives.IAppBarTemplateSettings2 {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly ClipRect: Windows.Foundation.Rect;
+    readonly CompactRootMargin: Windows.UI.Xaml.Thickness;
+    readonly CompactVerticalDelta: number;
+    readonly HiddenRootMargin: Windows.UI.Xaml.Thickness;
+    readonly HiddenVerticalDelta: number;
+    readonly MinimalRootMargin: Windows.UI.Xaml.Thickness;
+    readonly MinimalVerticalDelta: number;
+    readonly NegativeCompactVerticalDelta: number;
+    readonly NegativeHiddenVerticalDelta: number;
+    readonly NegativeMinimalVerticalDelta: number;
+  }
+
+  class AppBarToggleButtonTemplateSettings extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.IAppBarToggleButtonTemplateSettings {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly KeyboardAcceleratorTextMinWidth: number;
+  }
+
+  class ButtonBase extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.Primitives.IButtonBase {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    ClickMode: number;
+    static readonly ClickModeProperty: Windows.UI.Xaml.DependencyProperty;
+    Command: Windows.UI.Xaml.Input.ICommand;
+    CommandParameter: Object;
+    static readonly CommandParameterProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly CommandProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsPointerOver: boolean;
+    static readonly IsPointerOverProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsPressed: boolean;
+    static readonly IsPressedProperty: Windows.UI.Xaml.DependencyProperty;
+    Click: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+
+  class CalendarPanel extends Windows.UI.Xaml.Controls.Panel implements Windows.UI.Xaml.Controls.Primitives.ICalendarPanel {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class CalendarViewTemplateSettings extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.ICalendarViewTemplateSettings {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly CenterX: number;
+    readonly CenterY: number;
+    readonly ClipRect: Windows.Foundation.Rect;
+    readonly HasMoreContentAfter: boolean;
+    readonly HasMoreContentBefore: boolean;
+    readonly HasMoreViews: boolean;
+    readonly HeaderText: string;
+    readonly MinViewWidth: number;
+    readonly WeekDay1: string;
+    readonly WeekDay2: string;
+    readonly WeekDay3: string;
+    readonly WeekDay4: string;
+    readonly WeekDay5: string;
+    readonly WeekDay6: string;
+    readonly WeekDay7: string;
+  }
+
+  class CarouselPanel extends Windows.UI.Xaml.Controls.VirtualizingPanel implements Windows.UI.Xaml.Controls.Primitives.ICarouselPanel, Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    AddInternalChild(child: Windows.UI.Xaml.UIElement): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    BringIndexIntoView(index: number): void;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetIrregularSnapPoints(orientation: number, alignment: number): Windows.Foundation.Collections.IVectorView<number> | number[];
+    GetRegularSnapPoints(orientation: number, alignment: number, offset: number): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InsertInternalChild(index: number, child: Windows.UI.Xaml.UIElement): void;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    LineDown(): void;
+    LineLeft(): void;
+    LineRight(): void;
+    LineUp(): void;
+    MakeVisible(visual: Windows.UI.Xaml.UIElement, rectangle: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    MouseWheelDown(): void;
+    MouseWheelLeft(): void;
+    MouseWheelRight(): void;
+    MouseWheelUp(): void;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnClearChildren(): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnItemsChanged(sender: Object, args: Windows.UI.Xaml.Controls.Primitives.ItemsChangedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PageDown(): void;
+    PageLeft(): void;
+    PageRight(): void;
+    PageUp(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    RemoveInternalChildRange(index: number, range: number): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetHorizontalOffset(offset: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    SetVerticalOffset(offset: number): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly AreHorizontalSnapPointsRegular: boolean;
+    readonly AreVerticalSnapPointsRegular: boolean;
+    CanHorizontallyScroll: boolean;
+    CanVerticallyScroll: boolean;
+    readonly ExtentHeight: number;
+    readonly ExtentWidth: number;
+    readonly HorizontalOffset: number;
+    ScrollOwner: Object;
+    readonly VerticalOffset: number;
+    readonly ViewportHeight: number;
+    readonly ViewportWidth: number;
+    HorizontalSnapPointsChanged: Windows.Foundation.EventHandler<Object> | null;
+    VerticalSnapPointsChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class ColorPickerSlider extends Windows.UI.Xaml.Controls.Slider implements Windows.UI.Xaml.Controls.Primitives.IColorPickerSlider {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnMaximumChanged(oldMaximum: number, newMaximum: number): void;
+    OnMinimumChanged(oldMinimum: number, newMinimum: number): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnValueChanged(oldValue: number, newValue: number): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    ColorChannel: number;
+    static readonly ColorChannelProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ColorSpectrum extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.Primitives.IColorSpectrum {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Color: Windows.UI.Color;
+    static readonly ColorProperty: Windows.UI.Xaml.DependencyProperty;
+    Components: number;
+    static readonly ComponentsProperty: Windows.UI.Xaml.DependencyProperty;
+    HsvColor: Windows.Foundation.Numerics.Vector4;
+    static readonly HsvColorProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxHue: number;
+    static readonly MaxHueProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxSaturation: number;
+    static readonly MaxSaturationProperty: Windows.UI.Xaml.DependencyProperty;
+    MaxValue: number;
+    static readonly MaxValueProperty: Windows.UI.Xaml.DependencyProperty;
+    MinHue: number;
+    static readonly MinHueProperty: Windows.UI.Xaml.DependencyProperty;
+    MinSaturation: number;
+    static readonly MinSaturationProperty: Windows.UI.Xaml.DependencyProperty;
+    MinValue: number;
+    static readonly MinValueProperty: Windows.UI.Xaml.DependencyProperty;
+    Shape: number;
+    static readonly ShapeProperty: Windows.UI.Xaml.DependencyProperty;
+    ColorChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Primitives.ColorSpectrum, Windows.UI.Xaml.Controls.ColorChangedEventArgs> | null;
+  }
+
+  class ComboBoxTemplateSettings extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.IComboBoxTemplateSettings, Windows.UI.Xaml.Controls.Primitives.IComboBoxTemplateSettings2 {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly DropDownClosedHeight: number;
+    readonly DropDownContentMinWidth: number;
+    readonly DropDownOffset: number;
+    readonly DropDownOpenedHeight: number;
+    readonly SelectedItemDirection: number;
+  }
+
+  class CommandBarFlyoutCommandBar extends Windows.UI.Xaml.Controls.CommandBar implements Windows.UI.Xaml.Controls.Primitives.ICommandBarFlyoutCommandBar {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnClosed(e: Object): void;
+    OnClosing(e: Object): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnOpened(e: Object): void;
+    OnOpening(e: Object): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly FlyoutTemplateSettings: Windows.UI.Xaml.Controls.Primitives.CommandBarFlyoutCommandBarTemplateSettings;
+  }
+
+  class CommandBarFlyoutCommandBarTemplateSettings extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.ICommandBarFlyoutCommandBarTemplateSettings {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly CloseAnimationEndPosition: number;
+    readonly ContentClipRect: Windows.Foundation.Rect;
+    readonly CurrentWidth: number;
+    readonly ExpandDownAnimationEndPosition: number;
+    readonly ExpandDownAnimationHoldPosition: number;
+    readonly ExpandDownAnimationStartPosition: number;
+    readonly ExpandDownOverflowVerticalPosition: number;
+    readonly ExpandUpAnimationEndPosition: number;
+    readonly ExpandUpAnimationHoldPosition: number;
+    readonly ExpandUpAnimationStartPosition: number;
+    readonly ExpandUpOverflowVerticalPosition: number;
+    readonly ExpandedWidth: number;
+    readonly OpenAnimationEndPosition: number;
+    readonly OpenAnimationStartPosition: number;
+    readonly OverflowContentClipRect: Windows.Foundation.Rect;
+    readonly WidthExpansionAnimationEndPosition: number;
+    readonly WidthExpansionAnimationStartPosition: number;
+    readonly WidthExpansionDelta: number;
+    readonly WidthExpansionMoreButtonAnimationEndPosition: number;
+    readonly WidthExpansionMoreButtonAnimationStartPosition: number;
+  }
+
+  class CommandBarTemplateSettings extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.ICommandBarTemplateSettings, Windows.UI.Xaml.Controls.Primitives.ICommandBarTemplateSettings2, Windows.UI.Xaml.Controls.Primitives.ICommandBarTemplateSettings3, Windows.UI.Xaml.Controls.Primitives.ICommandBarTemplateSettings4 {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly ContentHeight: number;
+    readonly EffectiveOverflowButtonVisibility: number;
+    readonly NegativeOverflowContentHeight: number;
+    readonly OverflowContentClipRect: Windows.Foundation.Rect;
+    readonly OverflowContentCompactYTranslation: number;
+    readonly OverflowContentHeight: number;
+    readonly OverflowContentHiddenYTranslation: number;
+    readonly OverflowContentHorizontalOffset: number;
+    readonly OverflowContentMaxHeight: number;
+    readonly OverflowContentMaxWidth: number;
+    readonly OverflowContentMinWidth: number;
+    readonly OverflowContentMinimalYTranslation: number;
+  }
+
+  class DragCompletedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Controls.Primitives.IDragCompletedEventArgs {
+    constructor(horizontalChange: number, verticalChange: number, canceled: boolean);
+    readonly Canceled: boolean;
+    readonly HorizontalChange: number;
+    readonly VerticalChange: number;
+  }
+
+  class DragDeltaEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Controls.Primitives.IDragDeltaEventArgs {
+    constructor(horizontalChange: number, verticalChange: number);
+    readonly HorizontalChange: number;
+    readonly VerticalChange: number;
+  }
+
+  class DragStartedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Controls.Primitives.IDragStartedEventArgs {
+    constructor(horizontalOffset: number, verticalOffset: number);
+    readonly HorizontalOffset: number;
+    readonly VerticalOffset: number;
+  }
+
+  class FlyoutBase extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.IFlyoutBase, Windows.UI.Xaml.Controls.Primitives.IFlyoutBase2, Windows.UI.Xaml.Controls.Primitives.IFlyoutBase3, Windows.UI.Xaml.Controls.Primitives.IFlyoutBase4, Windows.UI.Xaml.Controls.Primitives.IFlyoutBase5, Windows.UI.Xaml.Controls.Primitives.IFlyoutBase6, Windows.UI.Xaml.Controls.Primitives.IFlyoutBaseOverrides, Windows.UI.Xaml.Controls.Primitives.IFlyoutBaseOverrides4 {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreatePresenter(): Windows.UI.Xaml.Controls.Control;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement): Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Hide(): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static SetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement, value: Windows.UI.Xaml.Controls.Primitives.FlyoutBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShowAt(placementTarget: Windows.UI.Xaml.FrameworkElement): void;
+    ShowAt(placementTarget: Windows.UI.Xaml.DependencyObject, showOptions: Windows.UI.Xaml.Controls.Primitives.FlyoutShowOptions): void;
+    static ShowAttachedFlyout(flyoutOwner: Windows.UI.Xaml.FrameworkElement): void;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    AllowFocusOnInteraction: boolean;
+    static readonly AllowFocusOnInteractionProperty: Windows.UI.Xaml.DependencyProperty;
+    AllowFocusWhenDisabled: boolean;
+    static readonly AllowFocusWhenDisabledProperty: Windows.UI.Xaml.DependencyProperty;
+    AreOpenCloseAnimationsEnabled: boolean;
+    static readonly AreOpenCloseAnimationsEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly AttachedFlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+    ElementSoundMode: number;
+    static readonly ElementSoundModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly InputDevicePrefersPrimaryCommands: boolean;
+    static readonly InputDevicePrefersPrimaryCommandsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsConstrainedToRootBounds: boolean;
+    readonly IsOpen: boolean;
+    static readonly IsOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    LightDismissOverlayMode: number;
+    static readonly LightDismissOverlayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    OverlayInputPassThroughElement: Windows.UI.Xaml.DependencyObject;
+    static readonly OverlayInputPassThroughElementProperty: Windows.UI.Xaml.DependencyProperty;
+    Placement: number;
+    static readonly PlacementProperty: Windows.UI.Xaml.DependencyProperty;
+    ShouldConstrainToRootBounds: boolean;
+    static readonly ShouldConstrainToRootBoundsProperty: Windows.UI.Xaml.DependencyProperty;
+    ShowMode: number;
+    static readonly ShowModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Target: Windows.UI.Xaml.FrameworkElement;
+    static readonly TargetProperty: Windows.UI.Xaml.DependencyProperty;
+    XamlRoot: Windows.UI.Xaml.XamlRoot;
+    Closed: Windows.Foundation.EventHandler<Object> | null;
+    Opened: Windows.Foundation.EventHandler<Object> | null;
+    Opening: Windows.Foundation.EventHandler<Object> | null;
+    Closing: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Primitives.FlyoutBase, Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs> | null;
+  }
+
+  class FlyoutBaseClosingEventArgs implements Windows.UI.Xaml.Controls.Primitives.IFlyoutBaseClosingEventArgs {
+    Cancel: boolean;
+  }
+
+  class FlyoutShowOptions implements Windows.UI.Xaml.Controls.Primitives.IFlyoutShowOptions {
+    constructor();
+    ExclusionRect: Windows.Foundation.Rect | null;
+    Placement: number;
+    Position: Windows.Foundation.Point | null;
+    ShowMode: number;
+  }
+
+  class GeneratorPositionHelper implements Windows.UI.Xaml.Controls.Primitives.IGeneratorPositionHelper {
+    static FromIndexAndOffset(index: number, offset: number): Windows.UI.Xaml.Controls.Primitives.GeneratorPosition;
+  }
+
+  class GridViewItemPresenter extends Windows.UI.Xaml.Controls.ContentPresenter implements Windows.UI.Xaml.Controls.Primitives.IGridViewItemPresenter {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    CheckBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckHintBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckHintBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckSelectingBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckSelectingBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    ContentMargin: Windows.UI.Xaml.Thickness;
+    static readonly ContentMarginProperty: Windows.UI.Xaml.DependencyProperty;
+    DisabledOpacity: number;
+    static readonly DisabledOpacityProperty: Windows.UI.Xaml.DependencyProperty;
+    DragBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly DragBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    DragForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly DragForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    DragOpacity: number;
+    static readonly DragOpacityProperty: Windows.UI.Xaml.DependencyProperty;
+    FocusBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly FocusBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    GridViewItemPresenterHorizontalContentAlignment: number;
+    static readonly GridViewItemPresenterHorizontalContentAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    GridViewItemPresenterPadding: Windows.UI.Xaml.Thickness;
+    static readonly GridViewItemPresenterPaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    GridViewItemPresenterVerticalContentAlignment: number;
+    static readonly GridViewItemPresenterVerticalContentAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    PlaceholderBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly PlaceholderBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    PointerOverBackground: Windows.UI.Xaml.Media.Brush;
+    PointerOverBackgroundMargin: Windows.UI.Xaml.Thickness;
+    static readonly PointerOverBackgroundMarginProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly PointerOverBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    ReorderHintOffset: number;
+    static readonly ReorderHintOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedBorderThickness: Windows.UI.Xaml.Thickness;
+    static readonly SelectedBorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedPointerOverBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedPointerOverBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedPointerOverBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedPointerOverBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionCheckMarkVisualEnabled: boolean;
+    static readonly SelectionCheckMarkVisualEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class GridViewItemTemplateSettings extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.IGridViewItemTemplateSettings {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly DragItemsCount: number;
+  }
+
+  class ItemsChangedEventArgs implements Windows.UI.Xaml.Controls.Primitives.IItemsChangedEventArgs {
+    readonly Action: number;
+    readonly ItemCount: number;
+    readonly ItemUICount: number;
+    readonly OldPosition: Windows.UI.Xaml.Controls.Primitives.GeneratorPosition;
+    readonly Position: Windows.UI.Xaml.Controls.Primitives.GeneratorPosition;
+  }
+
+  class JumpListItemBackgroundConverter extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.IJumpListItemBackgroundConverter, Windows.UI.Xaml.Data.IValueConverter {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Convert(value: Object, targetType: Windows.UI.Xaml.Interop.TypeName, parameter: Object, language: string): Object;
+    ConvertBack(value: Object, targetType: Windows.UI.Xaml.Interop.TypeName, parameter: Object, language: string): Object;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Disabled: Windows.UI.Xaml.Media.Brush;
+    static readonly DisabledProperty: Windows.UI.Xaml.DependencyProperty;
+    Enabled: Windows.UI.Xaml.Media.Brush;
+    static readonly EnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class JumpListItemForegroundConverter extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.IJumpListItemForegroundConverter, Windows.UI.Xaml.Data.IValueConverter {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Convert(value: Object, targetType: Windows.UI.Xaml.Interop.TypeName, parameter: Object, language: string): Object;
+    ConvertBack(value: Object, targetType: Windows.UI.Xaml.Interop.TypeName, parameter: Object, language: string): Object;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Disabled: Windows.UI.Xaml.Media.Brush;
+    static readonly DisabledProperty: Windows.UI.Xaml.DependencyProperty;
+    Enabled: Windows.UI.Xaml.Media.Brush;
+    static readonly EnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class LayoutInformation implements Windows.UI.Xaml.Controls.Primitives.ILayoutInformation {
+    static GetAvailableSize(element: Windows.UI.Xaml.UIElement): Windows.Foundation.Size;
+    static GetLayoutExceptionElement(dispatcher: Object): Windows.UI.Xaml.UIElement;
+    static GetLayoutSlot(element: Windows.UI.Xaml.FrameworkElement): Windows.Foundation.Rect;
+  }
+
+  class ListViewItemPresenter extends Windows.UI.Xaml.Controls.ContentPresenter implements Windows.UI.Xaml.Controls.Primitives.IListViewItemPresenter, Windows.UI.Xaml.Controls.Primitives.IListViewItemPresenter2, Windows.UI.Xaml.Controls.Primitives.IListViewItemPresenter3, Windows.UI.Xaml.Controls.Primitives.IListViewItemPresenter4 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    CheckBoxBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckBoxBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckBoxBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckBoxBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckBoxCornerRadius: Windows.UI.Xaml.CornerRadius;
+    static readonly CheckBoxCornerRadiusProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckBoxDisabledBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckBoxDisabledBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckBoxDisabledBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckBoxDisabledBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckBoxPointerOverBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckBoxPointerOverBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckBoxPointerOverBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckBoxPointerOverBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckBoxPressedBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckBoxPressedBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckBoxPressedBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckBoxPressedBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckBoxSelectedBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckBoxSelectedBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckBoxSelectedDisabledBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckBoxSelectedDisabledBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckBoxSelectedPointerOverBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckBoxSelectedPointerOverBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckBoxSelectedPressedBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckBoxSelectedPressedBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckDisabledBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckDisabledBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckHintBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckHintBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckMode: number;
+    static readonly CheckModeProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckPressedBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckPressedBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    CheckSelectingBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly CheckSelectingBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    ContentMargin: Windows.UI.Xaml.Thickness;
+    static readonly ContentMarginProperty: Windows.UI.Xaml.DependencyProperty;
+    DisabledOpacity: number;
+    static readonly DisabledOpacityProperty: Windows.UI.Xaml.DependencyProperty;
+    DragBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly DragBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    DragForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly DragForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    DragOpacity: number;
+    static readonly DragOpacityProperty: Windows.UI.Xaml.DependencyProperty;
+    FocusBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly FocusBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    FocusSecondaryBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly FocusSecondaryBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    ListViewItemPresenterHorizontalContentAlignment: number;
+    static readonly ListViewItemPresenterHorizontalContentAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    ListViewItemPresenterPadding: Windows.UI.Xaml.Thickness;
+    static readonly ListViewItemPresenterPaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    ListViewItemPresenterVerticalContentAlignment: number;
+    static readonly ListViewItemPresenterVerticalContentAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    PlaceholderBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly PlaceholderBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    PointerOverBackground: Windows.UI.Xaml.Media.Brush;
+    PointerOverBackgroundMargin: Windows.UI.Xaml.Thickness;
+    static readonly PointerOverBackgroundMarginProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly PointerOverBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    PointerOverBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly PointerOverBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    PointerOverForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly PointerOverForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    PressedBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly PressedBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    ReorderHintOffset: number;
+    static readonly ReorderHintOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    RevealBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly RevealBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    RevealBackgroundShowsAboveContent: boolean;
+    static readonly RevealBackgroundShowsAboveContentProperty: Windows.UI.Xaml.DependencyProperty;
+    RevealBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly RevealBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    RevealBorderThickness: Windows.UI.Xaml.Thickness;
+    static readonly RevealBorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedBorderThickness: Windows.UI.Xaml.Thickness;
+    static readonly SelectedBorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedDisabledBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedDisabledBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedDisabledBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedDisabledBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedForeground: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedInnerBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedInnerBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedPointerOverBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedPointerOverBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedPointerOverBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedPointerOverBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedPressedBackground: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedPressedBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedPressedBorderBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectedPressedBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionCheckMarkVisualEnabled: boolean;
+    static readonly SelectionCheckMarkVisualEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionIndicatorBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectionIndicatorBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionIndicatorCornerRadius: Windows.UI.Xaml.CornerRadius;
+    static readonly SelectionIndicatorCornerRadiusProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionIndicatorDisabledBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectionIndicatorDisabledBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionIndicatorMode: number;
+    static readonly SelectionIndicatorModeProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionIndicatorPointerOverBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectionIndicatorPointerOverBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionIndicatorPressedBrush: Windows.UI.Xaml.Media.Brush;
+    static readonly SelectionIndicatorPressedBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionIndicatorVisualEnabled: boolean;
+    static readonly SelectionIndicatorVisualEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ListViewItemTemplateSettings extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.IListViewItemTemplateSettings {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly DragItemsCount: number;
+  }
+
+  class LoopingSelector extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.Primitives.ILoopingSelector {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    ItemHeight: number;
+    static readonly ItemHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemTemplate: Windows.UI.Xaml.DataTemplate;
+    static readonly ItemTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemWidth: number;
+    static readonly ItemWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    Items: Windows.Foundation.Collections.IVector<Object> | Object[];
+    static readonly ItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedIndex: number;
+    static readonly SelectedIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedItem: Object;
+    static readonly SelectedItemProperty: Windows.UI.Xaml.DependencyProperty;
+    ShouldLoop: boolean;
+    static readonly ShouldLoopProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionChanged: Windows.UI.Xaml.Controls.SelectionChangedEventHandler | null;
+  }
+
+  class LoopingSelectorItem extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.Primitives.ILoopingSelectorItem {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class LoopingSelectorPanel extends Windows.UI.Xaml.Controls.Canvas implements Windows.UI.Xaml.Controls.Primitives.ILoopingSelectorPanel, Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetIrregularSnapPoints(orientation: number, alignment: number): Windows.Foundation.Collections.IVectorView<number> | number[];
+    static GetLeft(element: Windows.UI.Xaml.UIElement): number;
+    GetRegularSnapPoints(orientation: number, alignment: number, offset: number): number;
+    static GetTop(element: Windows.UI.Xaml.UIElement): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetZIndex(element: Windows.UI.Xaml.UIElement): number;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetLeft(element: Windows.UI.Xaml.UIElement, length: number): void;
+    static SetTop(element: Windows.UI.Xaml.UIElement, length: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    static SetZIndex(element: Windows.UI.Xaml.UIElement, value: number): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly AreHorizontalSnapPointsRegular: boolean;
+    readonly AreVerticalSnapPointsRegular: boolean;
+    HorizontalSnapPointsChanged: Windows.Foundation.EventHandler<Object> | null;
+    VerticalSnapPointsChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class MenuFlyoutItemTemplateSettings extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.IMenuFlyoutItemTemplateSettings {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly KeyboardAcceleratorTextMinWidth: number;
+  }
+
+  class MenuFlyoutPresenterTemplateSettings extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.IMenuFlyoutPresenterTemplateSettings {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly FlyoutContentMinWidth: number;
+  }
+
+  class NavigationViewItemPresenter extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.Primitives.INavigationViewItemPresenter {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Icon: Windows.UI.Xaml.Controls.IconElement;
+    static readonly IconProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class OrientedVirtualizingPanel extends Windows.UI.Xaml.Controls.VirtualizingPanel implements Windows.UI.Xaml.Controls.IInsertionPanel, Windows.UI.Xaml.Controls.Primitives.IOrientedVirtualizingPanel, Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    AddInternalChild(child: Windows.UI.Xaml.UIElement): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    BringIndexIntoView(index: number): void;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetInsertionIndexes(position: Windows.Foundation.Point, first: number, second: number): void;
+    GetIrregularSnapPoints(orientation: number, alignment: number): Windows.Foundation.Collections.IVectorView<number> | number[];
+    GetRegularSnapPoints(orientation: number, alignment: number, offset: number): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InsertInternalChild(index: number, child: Windows.UI.Xaml.UIElement): void;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    LineDown(): void;
+    LineLeft(): void;
+    LineRight(): void;
+    LineUp(): void;
+    MakeVisible(visual: Windows.UI.Xaml.UIElement, rectangle: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    MouseWheelDown(): void;
+    MouseWheelLeft(): void;
+    MouseWheelRight(): void;
+    MouseWheelUp(): void;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnClearChildren(): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnItemsChanged(sender: Object, args: Windows.UI.Xaml.Controls.Primitives.ItemsChangedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PageDown(): void;
+    PageLeft(): void;
+    PageRight(): void;
+    PageUp(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    RemoveInternalChildRange(index: number, range: number): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetHorizontalOffset(offset: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    SetVerticalOffset(offset: number): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly AreHorizontalSnapPointsRegular: boolean;
+    readonly AreVerticalSnapPointsRegular: boolean;
+    CanHorizontallyScroll: boolean;
+    CanVerticallyScroll: boolean;
+    readonly ExtentHeight: number;
+    readonly ExtentWidth: number;
+    readonly HorizontalOffset: number;
+    ScrollOwner: Object;
+    readonly VerticalOffset: number;
+    readonly ViewportHeight: number;
+    readonly ViewportWidth: number;
+    HorizontalSnapPointsChanged: Windows.Foundation.EventHandler<Object> | null;
+    VerticalSnapPointsChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class PickerFlyoutBase extends Windows.UI.Xaml.Controls.Primitives.FlyoutBase implements Windows.UI.Xaml.Controls.Primitives.IPickerFlyoutBase, Windows.UI.Xaml.Controls.Primitives.IPickerFlyoutBaseOverrides {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    CreatePresenter(): Windows.UI.Xaml.Controls.Control;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement): Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    static GetTitle(element: Windows.UI.Xaml.DependencyObject): string;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Hide(): void;
+    OnConfirmed(): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static SetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement, value: Windows.UI.Xaml.Controls.Primitives.FlyoutBase): void;
+    static SetTitle(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    ShouldShowConfirmationButtons(): boolean;
+    ShowAt(placementTarget: Windows.UI.Xaml.FrameworkElement): void;
+    ShowAt(placementTarget: Windows.UI.Xaml.DependencyObject, showOptions: Windows.UI.Xaml.Controls.Primitives.FlyoutShowOptions): void;
+    static ShowAttachedFlyout(flyoutOwner: Windows.UI.Xaml.FrameworkElement): void;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    static readonly TitleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PivotHeaderItem extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.Primitives.IPivotHeaderItem {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class PivotHeaderPanel extends Windows.UI.Xaml.Controls.Canvas implements Windows.UI.Xaml.Controls.Primitives.IPivotHeaderPanel {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetLeft(element: Windows.UI.Xaml.UIElement): number;
+    static GetTop(element: Windows.UI.Xaml.UIElement): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetZIndex(element: Windows.UI.Xaml.UIElement): number;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetLeft(element: Windows.UI.Xaml.UIElement, length: number): void;
+    static SetTop(element: Windows.UI.Xaml.UIElement, length: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    static SetZIndex(element: Windows.UI.Xaml.UIElement, value: number): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class PivotPanel extends Windows.UI.Xaml.Controls.Panel implements Windows.UI.Xaml.Controls.Primitives.IPivotPanel, Windows.UI.Xaml.Controls.Primitives.IScrollSnapPointsInfo {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetIrregularSnapPoints(orientation: number, alignment: number): Windows.Foundation.Collections.IVectorView<number> | number[];
+    GetRegularSnapPoints(orientation: number, alignment: number, offset: number): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly AreHorizontalSnapPointsRegular: boolean;
+    readonly AreVerticalSnapPointsRegular: boolean;
+    HorizontalSnapPointsChanged: Windows.Foundation.EventHandler<Object> | null;
+    VerticalSnapPointsChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class Popup extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Controls.Primitives.IPopup, Windows.UI.Xaml.Controls.Primitives.IPopup2, Windows.UI.Xaml.Controls.Primitives.IPopup3, Windows.UI.Xaml.Controls.Primitives.IPopup4 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly ActualPlacement: number;
+    Child: Windows.UI.Xaml.UIElement;
+    static readonly ChildProperty: Windows.UI.Xaml.DependencyProperty;
+    ChildTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    static readonly ChildTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    DesiredPlacement: number;
+    static readonly DesiredPlacementProperty: Windows.UI.Xaml.DependencyProperty;
+    HorizontalOffset: number;
+    static readonly HorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsConstrainedToRootBounds: boolean;
+    IsLightDismissEnabled: boolean;
+    static readonly IsLightDismissEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    IsOpen: boolean;
+    static readonly IsOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    LightDismissOverlayMode: number;
+    static readonly LightDismissOverlayModeProperty: Windows.UI.Xaml.DependencyProperty;
+    PlacementTarget: Windows.UI.Xaml.FrameworkElement;
+    static readonly PlacementTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    ShouldConstrainToRootBounds: boolean;
+    static readonly ShouldConstrainToRootBoundsProperty: Windows.UI.Xaml.DependencyProperty;
+    VerticalOffset: number;
+    static readonly VerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    Closed: Windows.Foundation.EventHandler<Object> | null;
+    Opened: Windows.Foundation.EventHandler<Object> | null;
+    ActualPlacementChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class ProgressBarTemplateSettings extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.IProgressBarTemplateSettings {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly ContainerAnimationEndPosition: number;
+    readonly ContainerAnimationStartPosition: number;
+    readonly EllipseAnimationEndPosition: number;
+    readonly EllipseAnimationWellPosition: number;
+    readonly EllipseDiameter: number;
+    readonly EllipseOffset: number;
+    readonly IndicatorLengthDelta: number;
+  }
+
+  class ProgressRingTemplateSettings extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.IProgressRingTemplateSettings {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly EllipseDiameter: number;
+    readonly EllipseOffset: Windows.UI.Xaml.Thickness;
+    readonly MaxSideLength: number;
+  }
+
+  class RangeBase extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.Primitives.IRangeBase, Windows.UI.Xaml.Controls.Primitives.IRangeBaseOverrides {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnMaximumChanged(oldMaximum: number, newMaximum: number): void;
+    OnMinimumChanged(oldMinimum: number, newMinimum: number): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnValueChanged(oldValue: number, newValue: number): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    LargeChange: number;
+    static readonly LargeChangeProperty: Windows.UI.Xaml.DependencyProperty;
+    Maximum: number;
+    static readonly MaximumProperty: Windows.UI.Xaml.DependencyProperty;
+    Minimum: number;
+    static readonly MinimumProperty: Windows.UI.Xaml.DependencyProperty;
+    SmallChange: number;
+    static readonly SmallChangeProperty: Windows.UI.Xaml.DependencyProperty;
+    Value: number;
+    static readonly ValueProperty: Windows.UI.Xaml.DependencyProperty;
+    ValueChanged: Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler | null;
+  }
+
+  class RangeBaseValueChangedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Controls.Primitives.IRangeBaseValueChangedEventArgs {
+    readonly NewValue: number;
+    readonly OldValue: number;
+  }
+
+  class RepeatButton extends Windows.UI.Xaml.Controls.Primitives.ButtonBase implements Windows.UI.Xaml.Controls.Primitives.IRepeatButton {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Delay: number;
+    static readonly DelayProperty: Windows.UI.Xaml.DependencyProperty;
+    Interval: number;
+    static readonly IntervalProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ScrollBar extends Windows.UI.Xaml.Controls.Primitives.RangeBase implements Windows.UI.Xaml.Controls.Primitives.IScrollBar {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnMaximumChanged(oldMaximum: number, newMaximum: number): void;
+    OnMinimumChanged(oldMinimum: number, newMinimum: number): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnValueChanged(oldValue: number, newValue: number): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    IndicatorMode: number;
+    static readonly IndicatorModeProperty: Windows.UI.Xaml.DependencyProperty;
+    Orientation: number;
+    static readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    ViewportSize: number;
+    static readonly ViewportSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    Scroll: Windows.UI.Xaml.Controls.Primitives.ScrollEventHandler | null;
+  }
+
+  class ScrollEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Controls.Primitives.IScrollEventArgs {
+    constructor();
+    readonly NewValue: number;
+    readonly ScrollEventType: number;
+  }
+
+  class Selector extends Windows.UI.Xaml.Controls.ItemsControl implements Windows.UI.Xaml.Controls.Primitives.ISelector {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    ContainerFromIndex(index: number): Windows.UI.Xaml.DependencyObject;
+    ContainerFromItem(item: Object): Windows.UI.Xaml.DependencyObject;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetContainerForItemOverride(): Windows.UI.Xaml.DependencyObject;
+    static GetIsSelectionActive(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetItemsOwner(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    GroupHeaderContainerFromItemContainer(itemContainer: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+    IndexFromContainer(container: Windows.UI.Xaml.DependencyObject): number;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    IsItemItsOwnContainerOverride(item: Object): boolean;
+    ItemFromContainer(container: Windows.UI.Xaml.DependencyObject): Object;
+    static ItemsControlFromItemContainer(container: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Controls.ItemsControl;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnGroupStyleSelectorChanged(oldGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector, newGroupStyleSelector: Windows.UI.Xaml.Controls.GroupStyleSelector): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnItemContainerStyleChanged(oldItemContainerStyle: Windows.UI.Xaml.Style, newItemContainerStyle: Windows.UI.Xaml.Style): void;
+    OnItemContainerStyleSelectorChanged(oldItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector, newItemContainerStyleSelector: Windows.UI.Xaml.Controls.StyleSelector): void;
+    OnItemTemplateChanged(oldItemTemplate: Windows.UI.Xaml.DataTemplate, newItemTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnItemTemplateSelectorChanged(oldItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newItemTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnItemsChanged(e: Object): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PrepareContainerForItemOverride(element: Windows.UI.Xaml.DependencyObject, item: Object): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    IsSynchronizedWithCurrentItem: boolean | null;
+    static readonly IsSynchronizedWithCurrentItemProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedIndex: number;
+    static readonly SelectedIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedItem: Object;
+    static readonly SelectedItemProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectedValue: Object;
+    SelectedValuePath: string;
+    static readonly SelectedValuePathProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly SelectedValueProperty: Windows.UI.Xaml.DependencyProperty;
+    SelectionChanged: Windows.UI.Xaml.Controls.SelectionChangedEventHandler | null;
+  }
+
+  class SelectorItem extends Windows.UI.Xaml.Controls.ContentControl implements Windows.UI.Xaml.Controls.Primitives.ISelectorItem {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    IsSelected: boolean;
+    static readonly IsSelectedProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class SettingsFlyoutTemplateSettings extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.ISettingsFlyoutTemplateSettings {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly BorderBrush: Windows.UI.Xaml.Media.Brush;
+    readonly BorderThickness: Windows.UI.Xaml.Thickness;
+    readonly ContentTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    readonly HeaderBackground: Windows.UI.Xaml.Media.Brush;
+    readonly HeaderForeground: Windows.UI.Xaml.Media.Brush;
+    readonly IconSource: Windows.UI.Xaml.Media.ImageSource;
+  }
+
+  class SplitViewTemplateSettings extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.ISplitViewTemplateSettings {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly CompactPaneGridLength: Windows.UI.Xaml.GridLength;
+    readonly NegativeOpenPaneLength: number;
+    readonly NegativeOpenPaneLengthMinusCompactLength: number;
+    readonly OpenPaneGridLength: Windows.UI.Xaml.GridLength;
+    readonly OpenPaneLength: number;
+    readonly OpenPaneLengthMinusCompactLength: number;
+  }
+
+  class Thumb extends Windows.UI.Xaml.Controls.Control implements Windows.UI.Xaml.Controls.Primitives.IThumb {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CancelDrag(): void;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    readonly IsDragging: boolean;
+    static readonly IsDraggingProperty: Windows.UI.Xaml.DependencyProperty;
+    DragCompleted: Windows.UI.Xaml.Controls.Primitives.DragCompletedEventHandler | null;
+    DragDelta: Windows.UI.Xaml.Controls.Primitives.DragDeltaEventHandler | null;
+    DragStarted: Windows.UI.Xaml.Controls.Primitives.DragStartedEventHandler | null;
+  }
+
+  class TickBar extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Controls.Primitives.ITickBar {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Fill: Windows.UI.Xaml.Media.Brush;
+    static readonly FillProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ToggleButton extends Windows.UI.Xaml.Controls.Primitives.ButtonBase implements Windows.UI.Xaml.Controls.Primitives.IToggleButton, Windows.UI.Xaml.Controls.Primitives.IToggleButtonOverrides {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    ApplyTemplate(): boolean;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    static GetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement): boolean;
+    static GetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetTemplateChild(childName: string): Windows.UI.Xaml.DependencyObject;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCharacterReceived(e: Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs): void;
+    OnContentChanged(oldContent: Object, newContent: Object): void;
+    OnContentTemplateChanged(oldContentTemplate: Windows.UI.Xaml.DataTemplate, newContentTemplate: Windows.UI.Xaml.DataTemplate): void;
+    OnContentTemplateSelectorChanged(oldContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector, newContentTemplateSelector: Windows.UI.Xaml.Controls.DataTemplateSelector): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnDoubleTapped(e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+    OnDragEnter(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragLeave(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDragOver(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnDrop(e: Windows.UI.Xaml.DragEventArgs): void;
+    OnGotFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnHolding(e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+    OnKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnLostFocus(e: Windows.UI.Xaml.RoutedEventArgs): void;
+    OnManipulationCompleted(e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+    OnManipulationDelta(e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+    OnManipulationInertiaStarting(e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+    OnManipulationStarted(e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+    OnManipulationStarting(e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+    OnPointerCanceled(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerCaptureLost(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerEntered(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerExited(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerMoved(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerPressed(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerReleased(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPointerWheelChanged(e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+    OnPreviewKeyDown(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnPreviewKeyUp(e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    OnRightTapped(e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+    OnTapped(e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+    OnToggle(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveFocusEngagement(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    static SetIsTemplateFocusTarget(element: Windows.UI.Xaml.FrameworkElement, value: boolean): void;
+    static SetIsTemplateKeyTipTarget(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    IsChecked: boolean | null;
+    static readonly IsCheckedProperty: Windows.UI.Xaml.DependencyProperty;
+    IsThreeState: boolean;
+    static readonly IsThreeStateProperty: Windows.UI.Xaml.DependencyProperty;
+    Checked: Windows.UI.Xaml.RoutedEventHandler | null;
+    Indeterminate: Windows.UI.Xaml.RoutedEventHandler | null;
+    Unchecked: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+
+  class ToggleSwitchTemplateSettings extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.IToggleSwitchTemplateSettings {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly CurtainCurrentToOffOffset: number;
+    readonly CurtainCurrentToOnOffset: number;
+    readonly CurtainOffToOnOffset: number;
+    readonly CurtainOnToOffOffset: number;
+    readonly KnobCurrentToOffOffset: number;
+    readonly KnobCurrentToOnOffset: number;
+    readonly KnobOffToOnOffset: number;
+    readonly KnobOnToOffOffset: number;
+  }
+
+  class ToolTipTemplateSettings extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Controls.Primitives.IToolTipTemplateSettings {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly FromHorizontalOffset: number;
+    readonly FromVerticalOffset: number;
+  }
+
+  enum AnimationDirection {
+    Left = 0,
+    Top = 1,
+    Right = 2,
+    Bottom = 3,
+  }
+
+  enum ComponentResourceLocation {
+    Application = 0,
+    Nested = 1,
+  }
+
+  enum EdgeTransitionLocation {
+    Left = 0,
+    Top = 1,
+    Right = 2,
+    Bottom = 3,
+  }
+
+  enum FlyoutPlacementMode {
+    Top = 0,
+    Bottom = 1,
+    Left = 2,
+    Right = 3,
+    Full = 4,
+    TopEdgeAlignedLeft = 5,
+    TopEdgeAlignedRight = 6,
+    BottomEdgeAlignedLeft = 7,
+    BottomEdgeAlignedRight = 8,
+    LeftEdgeAlignedTop = 9,
+    LeftEdgeAlignedBottom = 10,
+    RightEdgeAlignedTop = 11,
+    RightEdgeAlignedBottom = 12,
+    Auto = 13,
+  }
+
+  enum FlyoutShowMode {
+    Auto = 0,
+    Standard = 1,
+    Transient = 2,
+    TransientWithDismissOnPointerMoveAway = 3,
+  }
+
+  enum GeneratorDirection {
+    Forward = 0,
+    Backward = 1,
+  }
+
+  enum GroupHeaderPlacement {
+    Top = 0,
+    Left = 1,
+  }
+
+  enum ListViewItemPresenterCheckMode {
+    Inline = 0,
+    Overlay = 1,
+  }
+
+  enum ListViewItemPresenterSelectionIndicatorMode {
+    Inline = 0,
+    Overlay = 1,
+  }
+
+  enum PlacementMode {
+    Bottom = 2,
+    Left = 9,
+    Mouse = 7,
+    Right = 4,
+    Top = 10,
+  }
+
+  enum PopupPlacementMode {
+    Auto = 0,
+    Top = 1,
+    Bottom = 2,
+    Left = 3,
+    Right = 4,
+    TopEdgeAlignedLeft = 5,
+    TopEdgeAlignedRight = 6,
+    BottomEdgeAlignedLeft = 7,
+    BottomEdgeAlignedRight = 8,
+    LeftEdgeAlignedTop = 9,
+    LeftEdgeAlignedBottom = 10,
+    RightEdgeAlignedTop = 11,
+    RightEdgeAlignedBottom = 12,
+  }
+
+  enum ScrollEventType {
+    SmallDecrement = 0,
+    SmallIncrement = 1,
+    LargeDecrement = 2,
+    LargeIncrement = 3,
+    ThumbPosition = 4,
+    ThumbTrack = 5,
+    First = 6,
+    Last = 7,
+    EndScroll = 8,
+  }
+
+  enum ScrollingIndicatorMode {
+    None = 0,
+    TouchIndicator = 1,
+    MouseIndicator = 2,
+  }
+
+  enum SliderSnapsTo {
+    StepValues = 0,
+    Ticks = 1,
+  }
+
+  enum SnapPointsAlignment {
+    Near = 0,
+    Center = 1,
+    Far = 2,
+  }
+
+  enum TickPlacement {
+    None = 0,
+    TopLeft = 1,
+    BottomRight = 2,
+    Outside = 3,
+    Inline = 4,
+  }
+
+  interface DragCompletedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Controls.Primitives.DragCompletedEventArgs): void;
+  }
+  var DragCompletedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Controls.Primitives.DragCompletedEventArgs) => void): DragCompletedEventHandler;
+  };
+
+  interface DragDeltaEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Controls.Primitives.DragDeltaEventArgs): void;
+  }
+  var DragDeltaEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Controls.Primitives.DragDeltaEventArgs) => void): DragDeltaEventHandler;
+  };
+
+  interface DragStartedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Controls.Primitives.DragStartedEventArgs): void;
+  }
+  var DragStartedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Controls.Primitives.DragStartedEventArgs) => void): DragStartedEventHandler;
+  };
+
+  interface GeneratorPosition {
+    Index: number;
+    Offset: number;
+  }
+  var GeneratorPosition: {
+    new(index: number, offset: number): GeneratorPosition;
+    new(fields: { Index?: number; Offset?: number }): GeneratorPosition;
+  };
+
+  interface IAppBarButtonTemplateSettings {
+    readonly KeyboardAcceleratorTextMinWidth: number;
+  }
+  var IAppBarButtonTemplateSettings: abstract new (...args: any[]) => IAppBarButtonTemplateSettings;
+
+  interface IAppBarTemplateSettings {
+    readonly ClipRect: Windows.Foundation.Rect;
+    readonly CompactRootMargin: Windows.UI.Xaml.Thickness;
+    readonly CompactVerticalDelta: number;
+    readonly HiddenRootMargin: Windows.UI.Xaml.Thickness;
+    readonly HiddenVerticalDelta: number;
+    readonly MinimalRootMargin: Windows.UI.Xaml.Thickness;
+    readonly MinimalVerticalDelta: number;
+  }
+  var IAppBarTemplateSettings: abstract new (...args: any[]) => IAppBarTemplateSettings;
+
+  interface IAppBarTemplateSettings2 {
+    readonly NegativeCompactVerticalDelta: number;
+    readonly NegativeHiddenVerticalDelta: number;
+    readonly NegativeMinimalVerticalDelta: number;
+  }
+  var IAppBarTemplateSettings2: abstract new (...args: any[]) => IAppBarTemplateSettings2;
+
+  interface IAppBarToggleButtonTemplateSettings {
+    readonly KeyboardAcceleratorTextMinWidth: number;
+  }
+  var IAppBarToggleButtonTemplateSettings: abstract new (...args: any[]) => IAppBarToggleButtonTemplateSettings;
+
+  interface IButtonBase {
+    ClickMode: number;
+    Command: Windows.UI.Xaml.Input.ICommand;
+    CommandParameter: Object;
+    readonly IsPointerOver: boolean;
+    readonly IsPressed: boolean;
+    Click: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+  var IButtonBase: abstract new (...args: any[]) => IButtonBase;
+
+  interface IButtonBaseFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Primitives.ButtonBase;
+  }
+  var IButtonBaseFactory: abstract new (...args: any[]) => IButtonBaseFactory;
+
+  interface IButtonBaseStatics {
+    readonly ClickModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CommandParameterProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CommandProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsPointerOverProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsPressedProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IButtonBaseStatics: abstract new (...args: any[]) => IButtonBaseStatics;
+
+  interface ICalendarPanel {
+  }
+  var ICalendarPanel: abstract new (...args: any[]) => ICalendarPanel;
+
+  interface ICalendarViewTemplateSettings {
+    readonly CenterX: number;
+    readonly CenterY: number;
+    readonly ClipRect: Windows.Foundation.Rect;
+    readonly HasMoreContentAfter: boolean;
+    readonly HasMoreContentBefore: boolean;
+    readonly HasMoreViews: boolean;
+    readonly HeaderText: string;
+    readonly MinViewWidth: number;
+    readonly WeekDay1: string;
+    readonly WeekDay2: string;
+    readonly WeekDay3: string;
+    readonly WeekDay4: string;
+    readonly WeekDay5: string;
+    readonly WeekDay6: string;
+    readonly WeekDay7: string;
+  }
+  var ICalendarViewTemplateSettings: abstract new (...args: any[]) => ICalendarViewTemplateSettings;
+
+  interface ICarouselPanel {
+    LineDown(): void;
+    LineLeft(): void;
+    LineRight(): void;
+    LineUp(): void;
+    MakeVisible(visual: Windows.UI.Xaml.UIElement, rectangle: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    MouseWheelDown(): void;
+    MouseWheelLeft(): void;
+    MouseWheelRight(): void;
+    MouseWheelUp(): void;
+    PageDown(): void;
+    PageLeft(): void;
+    PageRight(): void;
+    PageUp(): void;
+    SetHorizontalOffset(offset: number): void;
+    SetVerticalOffset(offset: number): void;
+    CanHorizontallyScroll: boolean;
+    CanVerticallyScroll: boolean;
+    readonly ExtentHeight: number;
+    readonly ExtentWidth: number;
+    readonly HorizontalOffset: number;
+    ScrollOwner: Object;
+    readonly VerticalOffset: number;
+    readonly ViewportHeight: number;
+    readonly ViewportWidth: number;
+  }
+  var ICarouselPanel: abstract new (...args: any[]) => ICarouselPanel;
+
+  interface ICarouselPanelFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Primitives.CarouselPanel;
+  }
+  var ICarouselPanelFactory: abstract new (...args: any[]) => ICarouselPanelFactory;
+
+  interface IColorPickerSlider {
+    ColorChannel: number;
+  }
+  var IColorPickerSlider: abstract new (...args: any[]) => IColorPickerSlider;
+
+  interface IColorPickerSliderFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Primitives.ColorPickerSlider;
+  }
+  var IColorPickerSliderFactory: abstract new (...args: any[]) => IColorPickerSliderFactory;
+
+  interface IColorPickerSliderStatics {
+    readonly ColorChannelProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IColorPickerSliderStatics: abstract new (...args: any[]) => IColorPickerSliderStatics;
+
+  interface IColorSpectrum {
+    Color: Windows.UI.Color;
+    Components: number;
+    HsvColor: Windows.Foundation.Numerics.Vector4;
+    MaxHue: number;
+    MaxSaturation: number;
+    MaxValue: number;
+    MinHue: number;
+    MinSaturation: number;
+    MinValue: number;
+    Shape: number;
+    ColorChanged: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Primitives.ColorSpectrum, Windows.UI.Xaml.Controls.ColorChangedEventArgs> | null;
+  }
+  var IColorSpectrum: abstract new (...args: any[]) => IColorSpectrum;
+
+  interface IColorSpectrumFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Primitives.ColorSpectrum;
+  }
+  var IColorSpectrumFactory: abstract new (...args: any[]) => IColorSpectrumFactory;
+
+  interface IColorSpectrumStatics {
+    readonly ColorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ComponentsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HsvColorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxHueProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxSaturationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaxValueProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinHueProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinSaturationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinValueProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ShapeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IColorSpectrumStatics: abstract new (...args: any[]) => IColorSpectrumStatics;
+
+  interface IComboBoxTemplateSettings {
+    readonly DropDownClosedHeight: number;
+    readonly DropDownOffset: number;
+    readonly DropDownOpenedHeight: number;
+    readonly SelectedItemDirection: number;
+  }
+  var IComboBoxTemplateSettings: abstract new (...args: any[]) => IComboBoxTemplateSettings;
+
+  interface IComboBoxTemplateSettings2 {
+    readonly DropDownContentMinWidth: number;
+  }
+  var IComboBoxTemplateSettings2: abstract new (...args: any[]) => IComboBoxTemplateSettings2;
+
+  interface ICommandBarFlyoutCommandBar {
+    readonly FlyoutTemplateSettings: Windows.UI.Xaml.Controls.Primitives.CommandBarFlyoutCommandBarTemplateSettings;
+  }
+  var ICommandBarFlyoutCommandBar: abstract new (...args: any[]) => ICommandBarFlyoutCommandBar;
+
+  interface ICommandBarFlyoutCommandBarFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Primitives.CommandBarFlyoutCommandBar;
+  }
+  var ICommandBarFlyoutCommandBarFactory: abstract new (...args: any[]) => ICommandBarFlyoutCommandBarFactory;
+
+  interface ICommandBarFlyoutCommandBarTemplateSettings {
+    readonly CloseAnimationEndPosition: number;
+    readonly ContentClipRect: Windows.Foundation.Rect;
+    readonly CurrentWidth: number;
+    readonly ExpandDownAnimationEndPosition: number;
+    readonly ExpandDownAnimationHoldPosition: number;
+    readonly ExpandDownAnimationStartPosition: number;
+    readonly ExpandDownOverflowVerticalPosition: number;
+    readonly ExpandUpAnimationEndPosition: number;
+    readonly ExpandUpAnimationHoldPosition: number;
+    readonly ExpandUpAnimationStartPosition: number;
+    readonly ExpandUpOverflowVerticalPosition: number;
+    readonly ExpandedWidth: number;
+    readonly OpenAnimationEndPosition: number;
+    readonly OpenAnimationStartPosition: number;
+    readonly OverflowContentClipRect: Windows.Foundation.Rect;
+    readonly WidthExpansionAnimationEndPosition: number;
+    readonly WidthExpansionAnimationStartPosition: number;
+    readonly WidthExpansionDelta: number;
+    readonly WidthExpansionMoreButtonAnimationEndPosition: number;
+    readonly WidthExpansionMoreButtonAnimationStartPosition: number;
+  }
+  var ICommandBarFlyoutCommandBarTemplateSettings: abstract new (...args: any[]) => ICommandBarFlyoutCommandBarTemplateSettings;
+
+  interface ICommandBarTemplateSettings {
+    readonly ContentHeight: number;
+    readonly NegativeOverflowContentHeight: number;
+    readonly OverflowContentClipRect: Windows.Foundation.Rect;
+    readonly OverflowContentHeight: number;
+    readonly OverflowContentHorizontalOffset: number;
+    readonly OverflowContentMaxHeight: number;
+    readonly OverflowContentMinWidth: number;
+  }
+  var ICommandBarTemplateSettings: abstract new (...args: any[]) => ICommandBarTemplateSettings;
+
+  interface ICommandBarTemplateSettings2 {
+    readonly OverflowContentMaxWidth: number;
+  }
+  var ICommandBarTemplateSettings2: abstract new (...args: any[]) => ICommandBarTemplateSettings2;
+
+  interface ICommandBarTemplateSettings3 {
+    readonly EffectiveOverflowButtonVisibility: number;
+  }
+  var ICommandBarTemplateSettings3: abstract new (...args: any[]) => ICommandBarTemplateSettings3;
+
+  interface ICommandBarTemplateSettings4 {
+    readonly OverflowContentCompactYTranslation: number;
+    readonly OverflowContentHiddenYTranslation: number;
+    readonly OverflowContentMinimalYTranslation: number;
+  }
+  var ICommandBarTemplateSettings4: abstract new (...args: any[]) => ICommandBarTemplateSettings4;
+
+  interface IDragCompletedEventArgs {
+    readonly Canceled: boolean;
+    readonly HorizontalChange: number;
+    readonly VerticalChange: number;
+  }
+  var IDragCompletedEventArgs: abstract new (...args: any[]) => IDragCompletedEventArgs;
+
+  interface IDragCompletedEventArgsFactory {
+    CreateInstanceWithHorizontalChangeVerticalChangeAndCanceled(horizontalChange: number, verticalChange: number, canceled: boolean, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Primitives.DragCompletedEventArgs;
+  }
+  var IDragCompletedEventArgsFactory: abstract new (...args: any[]) => IDragCompletedEventArgsFactory;
+
+  interface IDragDeltaEventArgs {
+    readonly HorizontalChange: number;
+    readonly VerticalChange: number;
+  }
+  var IDragDeltaEventArgs: abstract new (...args: any[]) => IDragDeltaEventArgs;
+
+  interface IDragDeltaEventArgsFactory {
+    CreateInstanceWithHorizontalChangeAndVerticalChange(horizontalChange: number, verticalChange: number, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Primitives.DragDeltaEventArgs;
+  }
+  var IDragDeltaEventArgsFactory: abstract new (...args: any[]) => IDragDeltaEventArgsFactory;
+
+  interface IDragStartedEventArgs {
+    readonly HorizontalOffset: number;
+    readonly VerticalOffset: number;
+  }
+  var IDragStartedEventArgs: abstract new (...args: any[]) => IDragStartedEventArgs;
+
+  interface IDragStartedEventArgsFactory {
+    CreateInstanceWithHorizontalOffsetAndVerticalOffset(horizontalOffset: number, verticalOffset: number, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Primitives.DragStartedEventArgs;
+  }
+  var IDragStartedEventArgsFactory: abstract new (...args: any[]) => IDragStartedEventArgsFactory;
+
+  interface IFlyoutBase {
+    Hide(): void;
+    ShowAt(placementTarget: Windows.UI.Xaml.FrameworkElement): void;
+    Placement: number;
+    Closed: Windows.Foundation.EventHandler<Object> | null;
+    Opened: Windows.Foundation.EventHandler<Object> | null;
+    Opening: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IFlyoutBase: abstract new (...args: any[]) => IFlyoutBase;
+
+  interface IFlyoutBase2 {
+    AllowFocusOnInteraction: boolean;
+    AllowFocusWhenDisabled: boolean;
+    ElementSoundMode: number;
+    LightDismissOverlayMode: number;
+    readonly Target: Windows.UI.Xaml.FrameworkElement;
+    Closing: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Controls.Primitives.FlyoutBase, Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs> | null;
+  }
+  var IFlyoutBase2: abstract new (...args: any[]) => IFlyoutBase2;
+
+  interface IFlyoutBase3 {
+    OverlayInputPassThroughElement: Windows.UI.Xaml.DependencyObject;
+  }
+  var IFlyoutBase3: abstract new (...args: any[]) => IFlyoutBase3;
+
+  interface IFlyoutBase4 {
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+  }
+  var IFlyoutBase4: abstract new (...args: any[]) => IFlyoutBase4;
+
+  interface IFlyoutBase5 {
+    ShowAt(placementTarget: Windows.UI.Xaml.DependencyObject, showOptions: Windows.UI.Xaml.Controls.Primitives.FlyoutShowOptions): void;
+    AreOpenCloseAnimationsEnabled: boolean;
+    readonly InputDevicePrefersPrimaryCommands: boolean;
+    readonly IsOpen: boolean;
+    ShowMode: number;
+  }
+  var IFlyoutBase5: abstract new (...args: any[]) => IFlyoutBase5;
+
+  interface IFlyoutBase6 {
+    readonly IsConstrainedToRootBounds: boolean;
+    ShouldConstrainToRootBounds: boolean;
+    XamlRoot: Windows.UI.Xaml.XamlRoot;
+  }
+  var IFlyoutBase6: abstract new (...args: any[]) => IFlyoutBase6;
+
+  interface IFlyoutBaseClosingEventArgs {
+    Cancel: boolean;
+  }
+  var IFlyoutBaseClosingEventArgs: abstract new (...args: any[]) => IFlyoutBaseClosingEventArgs;
+
+  interface IFlyoutBaseFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+  }
+  var IFlyoutBaseFactory: abstract new (...args: any[]) => IFlyoutBaseFactory;
+
+  interface IFlyoutBaseOverrides {
+    CreatePresenter(): Windows.UI.Xaml.Controls.Control;
+  }
+  var IFlyoutBaseOverrides: abstract new (...args: any[]) => IFlyoutBaseOverrides;
+
+  interface IFlyoutBaseOverrides4 {
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+  }
+  var IFlyoutBaseOverrides4: abstract new (...args: any[]) => IFlyoutBaseOverrides4;
+
+  interface IFlyoutBaseStatics {
+    GetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement): Windows.UI.Xaml.Controls.Primitives.FlyoutBase;
+    SetAttachedFlyout(element: Windows.UI.Xaml.FrameworkElement, value: Windows.UI.Xaml.Controls.Primitives.FlyoutBase): void;
+    ShowAttachedFlyout(flyoutOwner: Windows.UI.Xaml.FrameworkElement): void;
+    readonly AttachedFlyoutProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlacementProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFlyoutBaseStatics: abstract new (...args: any[]) => IFlyoutBaseStatics;
+
+  interface IFlyoutBaseStatics2 {
+    readonly AllowFocusOnInteractionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AllowFocusWhenDisabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ElementSoundModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LightDismissOverlayModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFlyoutBaseStatics2: abstract new (...args: any[]) => IFlyoutBaseStatics2;
+
+  interface IFlyoutBaseStatics3 {
+    readonly OverlayInputPassThroughElementProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFlyoutBaseStatics3: abstract new (...args: any[]) => IFlyoutBaseStatics3;
+
+  interface IFlyoutBaseStatics5 {
+    readonly AreOpenCloseAnimationsEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly InputDevicePrefersPrimaryCommandsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ShowModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TargetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFlyoutBaseStatics5: abstract new (...args: any[]) => IFlyoutBaseStatics5;
+
+  interface IFlyoutBaseStatics6 {
+    readonly ShouldConstrainToRootBoundsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFlyoutBaseStatics6: abstract new (...args: any[]) => IFlyoutBaseStatics6;
+
+  interface IFlyoutShowOptions {
+    ExclusionRect: Windows.Foundation.Rect | null;
+    Placement: number;
+    Position: Windows.Foundation.Point | null;
+    ShowMode: number;
+  }
+  var IFlyoutShowOptions: abstract new (...args: any[]) => IFlyoutShowOptions;
+
+  interface IFlyoutShowOptionsFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Primitives.FlyoutShowOptions;
+  }
+  var IFlyoutShowOptionsFactory: abstract new (...args: any[]) => IFlyoutShowOptionsFactory;
+
+  interface IGeneratorPositionHelper {
+  }
+  var IGeneratorPositionHelper: abstract new (...args: any[]) => IGeneratorPositionHelper;
+
+  interface IGeneratorPositionHelperStatics {
+    FromIndexAndOffset(index: number, offset: number): Windows.UI.Xaml.Controls.Primitives.GeneratorPosition;
+  }
+  var IGeneratorPositionHelperStatics: abstract new (...args: any[]) => IGeneratorPositionHelperStatics;
+
+  interface IGridViewItemPresenter {
+    CheckBrush: Windows.UI.Xaml.Media.Brush;
+    CheckHintBrush: Windows.UI.Xaml.Media.Brush;
+    CheckSelectingBrush: Windows.UI.Xaml.Media.Brush;
+    ContentMargin: Windows.UI.Xaml.Thickness;
+    DisabledOpacity: number;
+    DragBackground: Windows.UI.Xaml.Media.Brush;
+    DragForeground: Windows.UI.Xaml.Media.Brush;
+    DragOpacity: number;
+    FocusBorderBrush: Windows.UI.Xaml.Media.Brush;
+    GridViewItemPresenterHorizontalContentAlignment: number;
+    GridViewItemPresenterPadding: Windows.UI.Xaml.Thickness;
+    GridViewItemPresenterVerticalContentAlignment: number;
+    PlaceholderBackground: Windows.UI.Xaml.Media.Brush;
+    PointerOverBackground: Windows.UI.Xaml.Media.Brush;
+    PointerOverBackgroundMargin: Windows.UI.Xaml.Thickness;
+    ReorderHintOffset: number;
+    SelectedBackground: Windows.UI.Xaml.Media.Brush;
+    SelectedBorderThickness: Windows.UI.Xaml.Thickness;
+    SelectedForeground: Windows.UI.Xaml.Media.Brush;
+    SelectedPointerOverBackground: Windows.UI.Xaml.Media.Brush;
+    SelectedPointerOverBorderBrush: Windows.UI.Xaml.Media.Brush;
+    SelectionCheckMarkVisualEnabled: boolean;
+  }
+  var IGridViewItemPresenter: abstract new (...args: any[]) => IGridViewItemPresenter;
+
+  interface IGridViewItemPresenterFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Primitives.GridViewItemPresenter;
+  }
+  var IGridViewItemPresenterFactory: abstract new (...args: any[]) => IGridViewItemPresenterFactory;
+
+  interface IGridViewItemPresenterStatics {
+    readonly CheckBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CheckHintBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CheckSelectingBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentMarginProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DisabledOpacityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DragBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DragForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DragOpacityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FocusBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GridViewItemPresenterHorizontalContentAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GridViewItemPresenterPaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GridViewItemPresenterVerticalContentAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlaceholderBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PointerOverBackgroundMarginProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PointerOverBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ReorderHintOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedBorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedPointerOverBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedPointerOverBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionCheckMarkVisualEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IGridViewItemPresenterStatics: abstract new (...args: any[]) => IGridViewItemPresenterStatics;
+
+  interface IGridViewItemTemplateSettings {
+    readonly DragItemsCount: number;
+  }
+  var IGridViewItemTemplateSettings: abstract new (...args: any[]) => IGridViewItemTemplateSettings;
+
+  interface IItemsChangedEventArgs {
+    readonly Action: number;
+    readonly ItemCount: number;
+    readonly ItemUICount: number;
+    readonly OldPosition: Windows.UI.Xaml.Controls.Primitives.GeneratorPosition;
+    readonly Position: Windows.UI.Xaml.Controls.Primitives.GeneratorPosition;
+  }
+  var IItemsChangedEventArgs: abstract new (...args: any[]) => IItemsChangedEventArgs;
+
+  interface IJumpListItemBackgroundConverter {
+    Disabled: Windows.UI.Xaml.Media.Brush;
+    Enabled: Windows.UI.Xaml.Media.Brush;
+  }
+  var IJumpListItemBackgroundConverter: abstract new (...args: any[]) => IJumpListItemBackgroundConverter;
+
+  interface IJumpListItemBackgroundConverterStatics {
+    readonly DisabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly EnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IJumpListItemBackgroundConverterStatics: abstract new (...args: any[]) => IJumpListItemBackgroundConverterStatics;
+
+  interface IJumpListItemForegroundConverter {
+    Disabled: Windows.UI.Xaml.Media.Brush;
+    Enabled: Windows.UI.Xaml.Media.Brush;
+  }
+  var IJumpListItemForegroundConverter: abstract new (...args: any[]) => IJumpListItemForegroundConverter;
+
+  interface IJumpListItemForegroundConverterStatics {
+    readonly DisabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly EnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IJumpListItemForegroundConverterStatics: abstract new (...args: any[]) => IJumpListItemForegroundConverterStatics;
+
+  interface ILayoutInformation {
+  }
+  var ILayoutInformation: abstract new (...args: any[]) => ILayoutInformation;
+
+  interface ILayoutInformationStatics {
+    GetLayoutExceptionElement(dispatcher: Object): Windows.UI.Xaml.UIElement;
+    GetLayoutSlot(element: Windows.UI.Xaml.FrameworkElement): Windows.Foundation.Rect;
+  }
+  var ILayoutInformationStatics: abstract new (...args: any[]) => ILayoutInformationStatics;
+
+  interface ILayoutInformationStatics2 {
+    GetAvailableSize(element: Windows.UI.Xaml.UIElement): Windows.Foundation.Size;
+  }
+  var ILayoutInformationStatics2: abstract new (...args: any[]) => ILayoutInformationStatics2;
+
+  interface IListViewItemPresenter {
+    CheckBrush: Windows.UI.Xaml.Media.Brush;
+    CheckHintBrush: Windows.UI.Xaml.Media.Brush;
+    CheckSelectingBrush: Windows.UI.Xaml.Media.Brush;
+    ContentMargin: Windows.UI.Xaml.Thickness;
+    DisabledOpacity: number;
+    DragBackground: Windows.UI.Xaml.Media.Brush;
+    DragForeground: Windows.UI.Xaml.Media.Brush;
+    DragOpacity: number;
+    FocusBorderBrush: Windows.UI.Xaml.Media.Brush;
+    ListViewItemPresenterHorizontalContentAlignment: number;
+    ListViewItemPresenterPadding: Windows.UI.Xaml.Thickness;
+    ListViewItemPresenterVerticalContentAlignment: number;
+    PlaceholderBackground: Windows.UI.Xaml.Media.Brush;
+    PointerOverBackground: Windows.UI.Xaml.Media.Brush;
+    PointerOverBackgroundMargin: Windows.UI.Xaml.Thickness;
+    ReorderHintOffset: number;
+    SelectedBackground: Windows.UI.Xaml.Media.Brush;
+    SelectedBorderThickness: Windows.UI.Xaml.Thickness;
+    SelectedForeground: Windows.UI.Xaml.Media.Brush;
+    SelectedPointerOverBackground: Windows.UI.Xaml.Media.Brush;
+    SelectedPointerOverBorderBrush: Windows.UI.Xaml.Media.Brush;
+    SelectionCheckMarkVisualEnabled: boolean;
+  }
+  var IListViewItemPresenter: abstract new (...args: any[]) => IListViewItemPresenter;
+
+  interface IListViewItemPresenter2 {
+    CheckBoxBrush: Windows.UI.Xaml.Media.Brush;
+    CheckMode: number;
+    FocusSecondaryBorderBrush: Windows.UI.Xaml.Media.Brush;
+    PointerOverForeground: Windows.UI.Xaml.Media.Brush;
+    PressedBackground: Windows.UI.Xaml.Media.Brush;
+    SelectedPressedBackground: Windows.UI.Xaml.Media.Brush;
+  }
+  var IListViewItemPresenter2: abstract new (...args: any[]) => IListViewItemPresenter2;
+
+  interface IListViewItemPresenter3 {
+    RevealBackground: Windows.UI.Xaml.Media.Brush;
+    RevealBackgroundShowsAboveContent: boolean;
+    RevealBorderBrush: Windows.UI.Xaml.Media.Brush;
+    RevealBorderThickness: Windows.UI.Xaml.Thickness;
+  }
+  var IListViewItemPresenter3: abstract new (...args: any[]) => IListViewItemPresenter3;
+
+  interface IListViewItemPresenter4 {
+    CheckBoxBorderBrush: Windows.UI.Xaml.Media.Brush;
+    CheckBoxCornerRadius: Windows.UI.Xaml.CornerRadius;
+    CheckBoxDisabledBorderBrush: Windows.UI.Xaml.Media.Brush;
+    CheckBoxDisabledBrush: Windows.UI.Xaml.Media.Brush;
+    CheckBoxPointerOverBorderBrush: Windows.UI.Xaml.Media.Brush;
+    CheckBoxPointerOverBrush: Windows.UI.Xaml.Media.Brush;
+    CheckBoxPressedBorderBrush: Windows.UI.Xaml.Media.Brush;
+    CheckBoxPressedBrush: Windows.UI.Xaml.Media.Brush;
+    CheckBoxSelectedBrush: Windows.UI.Xaml.Media.Brush;
+    CheckBoxSelectedDisabledBrush: Windows.UI.Xaml.Media.Brush;
+    CheckBoxSelectedPointerOverBrush: Windows.UI.Xaml.Media.Brush;
+    CheckBoxSelectedPressedBrush: Windows.UI.Xaml.Media.Brush;
+    CheckDisabledBrush: Windows.UI.Xaml.Media.Brush;
+    CheckPressedBrush: Windows.UI.Xaml.Media.Brush;
+    PointerOverBorderBrush: Windows.UI.Xaml.Media.Brush;
+    SelectedBorderBrush: Windows.UI.Xaml.Media.Brush;
+    SelectedDisabledBackground: Windows.UI.Xaml.Media.Brush;
+    SelectedDisabledBorderBrush: Windows.UI.Xaml.Media.Brush;
+    SelectedInnerBorderBrush: Windows.UI.Xaml.Media.Brush;
+    SelectedPressedBorderBrush: Windows.UI.Xaml.Media.Brush;
+    SelectionIndicatorBrush: Windows.UI.Xaml.Media.Brush;
+    SelectionIndicatorCornerRadius: Windows.UI.Xaml.CornerRadius;
+    SelectionIndicatorDisabledBrush: Windows.UI.Xaml.Media.Brush;
+    SelectionIndicatorMode: number;
+    SelectionIndicatorPointerOverBrush: Windows.UI.Xaml.Media.Brush;
+    SelectionIndicatorPressedBrush: Windows.UI.Xaml.Media.Brush;
+    SelectionIndicatorVisualEnabled: boolean;
+  }
+  var IListViewItemPresenter4: abstract new (...args: any[]) => IListViewItemPresenter4;
+
+  interface IListViewItemPresenterFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Primitives.ListViewItemPresenter;
+  }
+  var IListViewItemPresenterFactory: abstract new (...args: any[]) => IListViewItemPresenterFactory;
+
+  interface IListViewItemPresenterStatics {
+    readonly CheckBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CheckHintBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CheckSelectingBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentMarginProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DisabledOpacityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DragBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DragForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DragOpacityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FocusBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ListViewItemPresenterHorizontalContentAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ListViewItemPresenterPaddingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ListViewItemPresenterVerticalContentAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlaceholderBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PointerOverBackgroundMarginProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PointerOverBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ReorderHintOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedBorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedPointerOverBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedPointerOverBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionCheckMarkVisualEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IListViewItemPresenterStatics: abstract new (...args: any[]) => IListViewItemPresenterStatics;
+
+  interface IListViewItemPresenterStatics2 {
+    readonly CheckBoxBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CheckModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FocusSecondaryBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PointerOverForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PressedBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedPressedBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IListViewItemPresenterStatics2: abstract new (...args: any[]) => IListViewItemPresenterStatics2;
+
+  interface IListViewItemPresenterStatics3 {
+    readonly RevealBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RevealBackgroundShowsAboveContentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RevealBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RevealBorderThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IListViewItemPresenterStatics3: abstract new (...args: any[]) => IListViewItemPresenterStatics3;
+
+  interface IListViewItemPresenterStatics4 {
+    readonly CheckBoxBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CheckBoxCornerRadiusProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CheckBoxDisabledBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CheckBoxDisabledBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CheckBoxPointerOverBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CheckBoxPointerOverBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CheckBoxPressedBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CheckBoxPressedBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CheckBoxSelectedBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CheckBoxSelectedDisabledBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CheckBoxSelectedPointerOverBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CheckBoxSelectedPressedBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CheckDisabledBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CheckPressedBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PointerOverBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedDisabledBackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedDisabledBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedInnerBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedPressedBorderBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionIndicatorBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionIndicatorCornerRadiusProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionIndicatorDisabledBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionIndicatorModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionIndicatorPointerOverBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionIndicatorPressedBrushProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectionIndicatorVisualEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IListViewItemPresenterStatics4: abstract new (...args: any[]) => IListViewItemPresenterStatics4;
+
+  interface IListViewItemTemplateSettings {
+    readonly DragItemsCount: number;
+  }
+  var IListViewItemTemplateSettings: abstract new (...args: any[]) => IListViewItemTemplateSettings;
+
+  interface ILoopingSelector {
+    ItemHeight: number;
+    ItemTemplate: Windows.UI.Xaml.DataTemplate;
+    ItemWidth: number;
+    Items: Windows.Foundation.Collections.IVector<Object> | Object[];
+    SelectedIndex: number;
+    SelectedItem: Object;
+    ShouldLoop: boolean;
+    SelectionChanged: Windows.UI.Xaml.Controls.SelectionChangedEventHandler | null;
+  }
+  var ILoopingSelector: abstract new (...args: any[]) => ILoopingSelector;
+
+  interface ILoopingSelectorItem {
+  }
+  var ILoopingSelectorItem: abstract new (...args: any[]) => ILoopingSelectorItem;
+
+  interface ILoopingSelectorPanel {
+  }
+  var ILoopingSelectorPanel: abstract new (...args: any[]) => ILoopingSelectorPanel;
+
+  interface ILoopingSelectorStatics {
+    readonly ItemHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemTemplateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedItemProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ShouldLoopProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ILoopingSelectorStatics: abstract new (...args: any[]) => ILoopingSelectorStatics;
+
+  interface IMenuFlyoutItemTemplateSettings {
+    readonly KeyboardAcceleratorTextMinWidth: number;
+  }
+  var IMenuFlyoutItemTemplateSettings: abstract new (...args: any[]) => IMenuFlyoutItemTemplateSettings;
+
+  interface IMenuFlyoutPresenterTemplateSettings {
+    readonly FlyoutContentMinWidth: number;
+  }
+  var IMenuFlyoutPresenterTemplateSettings: abstract new (...args: any[]) => IMenuFlyoutPresenterTemplateSettings;
+
+  interface INavigationViewItemPresenter {
+    Icon: Windows.UI.Xaml.Controls.IconElement;
+  }
+  var INavigationViewItemPresenter: abstract new (...args: any[]) => INavigationViewItemPresenter;
+
+  interface INavigationViewItemPresenterFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Primitives.NavigationViewItemPresenter;
+  }
+  var INavigationViewItemPresenterFactory: abstract new (...args: any[]) => INavigationViewItemPresenterFactory;
+
+  interface INavigationViewItemPresenterStatics {
+    readonly IconProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var INavigationViewItemPresenterStatics: abstract new (...args: any[]) => INavigationViewItemPresenterStatics;
+
+  interface IOrientedVirtualizingPanel {
+    LineDown(): void;
+    LineLeft(): void;
+    LineRight(): void;
+    LineUp(): void;
+    MakeVisible(visual: Windows.UI.Xaml.UIElement, rectangle: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    MouseWheelDown(): void;
+    MouseWheelLeft(): void;
+    MouseWheelRight(): void;
+    MouseWheelUp(): void;
+    PageDown(): void;
+    PageLeft(): void;
+    PageRight(): void;
+    PageUp(): void;
+    SetHorizontalOffset(offset: number): void;
+    SetVerticalOffset(offset: number): void;
+    CanHorizontallyScroll: boolean;
+    CanVerticallyScroll: boolean;
+    readonly ExtentHeight: number;
+    readonly ExtentWidth: number;
+    readonly HorizontalOffset: number;
+    ScrollOwner: Object;
+    readonly VerticalOffset: number;
+    readonly ViewportHeight: number;
+    readonly ViewportWidth: number;
+  }
+  var IOrientedVirtualizingPanel: abstract new (...args: any[]) => IOrientedVirtualizingPanel;
+
+  interface IOrientedVirtualizingPanelFactory {
+  }
+  var IOrientedVirtualizingPanelFactory: abstract new (...args: any[]) => IOrientedVirtualizingPanelFactory;
+
+  interface IPickerFlyoutBase {
+  }
+  var IPickerFlyoutBase: abstract new (...args: any[]) => IPickerFlyoutBase;
+
+  interface IPickerFlyoutBaseFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Primitives.PickerFlyoutBase;
+  }
+  var IPickerFlyoutBaseFactory: abstract new (...args: any[]) => IPickerFlyoutBaseFactory;
+
+  interface IPickerFlyoutBaseOverrides {
+    OnConfirmed(): void;
+    ShouldShowConfirmationButtons(): boolean;
+  }
+  var IPickerFlyoutBaseOverrides: abstract new (...args: any[]) => IPickerFlyoutBaseOverrides;
+
+  interface IPickerFlyoutBaseStatics {
+    GetTitle(element: Windows.UI.Xaml.DependencyObject): string;
+    SetTitle(element: Windows.UI.Xaml.DependencyObject, value: string): void;
+    readonly TitleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPickerFlyoutBaseStatics: abstract new (...args: any[]) => IPickerFlyoutBaseStatics;
+
+  interface IPivotHeaderItem {
+  }
+  var IPivotHeaderItem: abstract new (...args: any[]) => IPivotHeaderItem;
+
+  interface IPivotHeaderItemFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Primitives.PivotHeaderItem;
+  }
+  var IPivotHeaderItemFactory: abstract new (...args: any[]) => IPivotHeaderItemFactory;
+
+  interface IPivotHeaderPanel {
+  }
+  var IPivotHeaderPanel: abstract new (...args: any[]) => IPivotHeaderPanel;
+
+  interface IPivotPanel {
+  }
+  var IPivotPanel: abstract new (...args: any[]) => IPivotPanel;
+
+  interface IPopup {
+    Child: Windows.UI.Xaml.UIElement;
+    ChildTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    HorizontalOffset: number;
+    IsLightDismissEnabled: boolean;
+    IsOpen: boolean;
+    VerticalOffset: number;
+    Closed: Windows.Foundation.EventHandler<Object> | null;
+    Opened: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IPopup: abstract new (...args: any[]) => IPopup;
+
+  interface IPopup2 {
+    LightDismissOverlayMode: number;
+  }
+  var IPopup2: abstract new (...args: any[]) => IPopup2;
+
+  interface IPopup3 {
+    readonly IsConstrainedToRootBounds: boolean;
+    ShouldConstrainToRootBounds: boolean;
+  }
+  var IPopup3: abstract new (...args: any[]) => IPopup3;
+
+  interface IPopup4 {
+    readonly ActualPlacement: number;
+    DesiredPlacement: number;
+    PlacementTarget: Windows.UI.Xaml.FrameworkElement;
+    ActualPlacementChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IPopup4: abstract new (...args: any[]) => IPopup4;
+
+  interface IPopupStatics {
+    readonly ChildProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ChildTransitionsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsLightDismissEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsOpenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPopupStatics: abstract new (...args: any[]) => IPopupStatics;
+
+  interface IPopupStatics2 {
+    readonly LightDismissOverlayModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPopupStatics2: abstract new (...args: any[]) => IPopupStatics2;
+
+  interface IPopupStatics3 {
+    readonly ShouldConstrainToRootBoundsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPopupStatics3: abstract new (...args: any[]) => IPopupStatics3;
+
+  interface IPopupStatics4 {
+    readonly DesiredPlacementProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PlacementTargetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPopupStatics4: abstract new (...args: any[]) => IPopupStatics4;
+
+  interface IProgressBarTemplateSettings {
+    readonly ContainerAnimationEndPosition: number;
+    readonly ContainerAnimationStartPosition: number;
+    readonly EllipseAnimationEndPosition: number;
+    readonly EllipseAnimationWellPosition: number;
+    readonly EllipseDiameter: number;
+    readonly EllipseOffset: number;
+    readonly IndicatorLengthDelta: number;
+  }
+  var IProgressBarTemplateSettings: abstract new (...args: any[]) => IProgressBarTemplateSettings;
+
+  interface IProgressRingTemplateSettings {
+    readonly EllipseDiameter: number;
+    readonly EllipseOffset: Windows.UI.Xaml.Thickness;
+    readonly MaxSideLength: number;
+  }
+  var IProgressRingTemplateSettings: abstract new (...args: any[]) => IProgressRingTemplateSettings;
+
+  interface IRangeBase {
+    LargeChange: number;
+    Maximum: number;
+    Minimum: number;
+    SmallChange: number;
+    Value: number;
+    ValueChanged: Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventHandler | null;
+  }
+  var IRangeBase: abstract new (...args: any[]) => IRangeBase;
+
+  interface IRangeBaseFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Primitives.RangeBase;
+  }
+  var IRangeBaseFactory: abstract new (...args: any[]) => IRangeBaseFactory;
+
+  interface IRangeBaseOverrides {
+    OnMaximumChanged(oldMaximum: number, newMaximum: number): void;
+    OnMinimumChanged(oldMinimum: number, newMinimum: number): void;
+    OnValueChanged(oldValue: number, newValue: number): void;
+  }
+  var IRangeBaseOverrides: abstract new (...args: any[]) => IRangeBaseOverrides;
+
+  interface IRangeBaseStatics {
+    readonly LargeChangeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MaximumProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MinimumProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SmallChangeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ValueProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRangeBaseStatics: abstract new (...args: any[]) => IRangeBaseStatics;
+
+  interface IRangeBaseValueChangedEventArgs {
+    readonly NewValue: number;
+    readonly OldValue: number;
+  }
+  var IRangeBaseValueChangedEventArgs: abstract new (...args: any[]) => IRangeBaseValueChangedEventArgs;
+
+  interface IRepeatButton {
+    Delay: number;
+    Interval: number;
+  }
+  var IRepeatButton: abstract new (...args: any[]) => IRepeatButton;
+
+  interface IRepeatButtonStatics {
+    readonly DelayProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IntervalProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRepeatButtonStatics: abstract new (...args: any[]) => IRepeatButtonStatics;
+
+  interface IScrollBar {
+    IndicatorMode: number;
+    Orientation: number;
+    ViewportSize: number;
+    Scroll: Windows.UI.Xaml.Controls.Primitives.ScrollEventHandler | null;
+  }
+  var IScrollBar: abstract new (...args: any[]) => IScrollBar;
+
+  interface IScrollBarStatics {
+    readonly IndicatorModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OrientationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ViewportSizeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IScrollBarStatics: abstract new (...args: any[]) => IScrollBarStatics;
+
+  interface IScrollEventArgs {
+    readonly NewValue: number;
+    readonly ScrollEventType: number;
+  }
+  var IScrollEventArgs: abstract new (...args: any[]) => IScrollEventArgs;
+
+  interface IScrollSnapPointsInfo {
+    GetIrregularSnapPoints(orientation: number, alignment: number): Windows.Foundation.Collections.IVectorView<number> | number[];
+    GetRegularSnapPoints(orientation: number, alignment: number, offset: number): number;
+    readonly AreHorizontalSnapPointsRegular: boolean;
+    readonly AreVerticalSnapPointsRegular: boolean;
+    HorizontalSnapPointsChanged: Windows.Foundation.EventHandler<Object> | null;
+    VerticalSnapPointsChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var IScrollSnapPointsInfo: abstract new (...args: any[]) => IScrollSnapPointsInfo;
+
+  interface ISelector {
+    IsSynchronizedWithCurrentItem: boolean | null;
+    SelectedIndex: number;
+    SelectedItem: Object;
+    SelectedValue: Object;
+    SelectedValuePath: string;
+    SelectionChanged: Windows.UI.Xaml.Controls.SelectionChangedEventHandler | null;
+  }
+  var ISelector: abstract new (...args: any[]) => ISelector;
+
+  interface ISelectorFactory {
+  }
+  var ISelectorFactory: abstract new (...args: any[]) => ISelectorFactory;
+
+  interface ISelectorItem {
+    IsSelected: boolean;
+  }
+  var ISelectorItem: abstract new (...args: any[]) => ISelectorItem;
+
+  interface ISelectorItemFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Primitives.SelectorItem;
+  }
+  var ISelectorItemFactory: abstract new (...args: any[]) => ISelectorItemFactory;
+
+  interface ISelectorItemStatics {
+    readonly IsSelectedProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISelectorItemStatics: abstract new (...args: any[]) => ISelectorItemStatics;
+
+  interface ISelectorStatics {
+    GetIsSelectionActive(element: Windows.UI.Xaml.DependencyObject): boolean;
+    readonly IsSynchronizedWithCurrentItemProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedItemProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedValuePathProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SelectedValueProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISelectorStatics: abstract new (...args: any[]) => ISelectorStatics;
+
+  interface ISettingsFlyoutTemplateSettings {
+    readonly BorderBrush: Windows.UI.Xaml.Media.Brush;
+    readonly BorderThickness: Windows.UI.Xaml.Thickness;
+    readonly ContentTransitions: Windows.UI.Xaml.Media.Animation.TransitionCollection;
+    readonly HeaderBackground: Windows.UI.Xaml.Media.Brush;
+    readonly HeaderForeground: Windows.UI.Xaml.Media.Brush;
+    readonly IconSource: Windows.UI.Xaml.Media.ImageSource;
+  }
+  var ISettingsFlyoutTemplateSettings: abstract new (...args: any[]) => ISettingsFlyoutTemplateSettings;
+
+  interface ISplitViewTemplateSettings {
+    readonly CompactPaneGridLength: Windows.UI.Xaml.GridLength;
+    readonly NegativeOpenPaneLength: number;
+    readonly NegativeOpenPaneLengthMinusCompactLength: number;
+    readonly OpenPaneGridLength: Windows.UI.Xaml.GridLength;
+    readonly OpenPaneLength: number;
+    readonly OpenPaneLengthMinusCompactLength: number;
+  }
+  var ISplitViewTemplateSettings: abstract new (...args: any[]) => ISplitViewTemplateSettings;
+
+  interface IThumb {
+    CancelDrag(): void;
+    readonly IsDragging: boolean;
+    DragCompleted: Windows.UI.Xaml.Controls.Primitives.DragCompletedEventHandler | null;
+    DragDelta: Windows.UI.Xaml.Controls.Primitives.DragDeltaEventHandler | null;
+    DragStarted: Windows.UI.Xaml.Controls.Primitives.DragStartedEventHandler | null;
+  }
+  var IThumb: abstract new (...args: any[]) => IThumb;
+
+  interface IThumbStatics {
+    readonly IsDraggingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IThumbStatics: abstract new (...args: any[]) => IThumbStatics;
+
+  interface ITickBar {
+    Fill: Windows.UI.Xaml.Media.Brush;
+  }
+  var ITickBar: abstract new (...args: any[]) => ITickBar;
+
+  interface ITickBarStatics {
+    readonly FillProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITickBarStatics: abstract new (...args: any[]) => ITickBarStatics;
+
+  interface IToggleButton {
+    IsChecked: boolean | null;
+    IsThreeState: boolean;
+    Checked: Windows.UI.Xaml.RoutedEventHandler | null;
+    Indeterminate: Windows.UI.Xaml.RoutedEventHandler | null;
+    Unchecked: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+  var IToggleButton: abstract new (...args: any[]) => IToggleButton;
+
+  interface IToggleButtonFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Controls.Primitives.ToggleButton;
+  }
+  var IToggleButtonFactory: abstract new (...args: any[]) => IToggleButtonFactory;
+
+  interface IToggleButtonOverrides {
+    OnToggle(): void;
+  }
+  var IToggleButtonOverrides: abstract new (...args: any[]) => IToggleButtonOverrides;
+
+  interface IToggleButtonStatics {
+    readonly IsCheckedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsThreeStateProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IToggleButtonStatics: abstract new (...args: any[]) => IToggleButtonStatics;
+
+  interface IToggleSwitchTemplateSettings {
+    readonly CurtainCurrentToOffOffset: number;
+    readonly CurtainCurrentToOnOffset: number;
+    readonly CurtainOffToOnOffset: number;
+    readonly CurtainOnToOffOffset: number;
+    readonly KnobCurrentToOffOffset: number;
+    readonly KnobCurrentToOnOffset: number;
+    readonly KnobOffToOnOffset: number;
+    readonly KnobOnToOffOffset: number;
+  }
+  var IToggleSwitchTemplateSettings: abstract new (...args: any[]) => IToggleSwitchTemplateSettings;
+
+  interface IToolTipTemplateSettings {
+    readonly FromHorizontalOffset: number;
+    readonly FromVerticalOffset: number;
+  }
+  var IToolTipTemplateSettings: abstract new (...args: any[]) => IToolTipTemplateSettings;
+
+  interface ItemsChangedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Controls.Primitives.ItemsChangedEventArgs): void;
+  }
+  var ItemsChangedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Controls.Primitives.ItemsChangedEventArgs) => void): ItemsChangedEventHandler;
+  };
+
+  interface RangeBaseValueChangedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventArgs): void;
+  }
+  var RangeBaseValueChangedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventArgs) => void): RangeBaseValueChangedEventHandler;
+  };
+
+  interface ScrollEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Controls.Primitives.ScrollEventArgs): void;
+  }
+  var ScrollEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Controls.Primitives.ScrollEventArgs) => void): ScrollEventHandler;
+  };
+
+}
+
+declare namespace Windows.UI.Xaml.Core.Direct {
+  class XamlDirect implements Windows.UI.Xaml.Core.Direct.IXamlDirect {
+    AddEventHandler(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, eventIndex: number, handler: Object): void;
+    AddEventHandler(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, eventIndex: number, handler: Object, handledEventsToo: boolean): void;
+    AddToCollection(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, value: Windows.UI.Xaml.Core.Direct.IXamlDirectObject): void;
+    ClearCollection(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject): void;
+    ClearProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): void;
+    CreateInstance(typeIndex: number): Windows.UI.Xaml.Core.Direct.IXamlDirectObject;
+    GetBooleanProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): boolean;
+    GetCollectionCount(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject): number;
+    GetColorProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.UI.Color;
+    GetCornerRadiusProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.UI.Xaml.CornerRadius;
+    GetDateTimeProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.Foundation.DateTime;
+    static GetDefault(): Windows.UI.Xaml.Core.Direct.XamlDirect;
+    GetDoubleProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): number;
+    GetDurationProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.UI.Xaml.Duration;
+    GetEnumProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): number;
+    GetGridLengthProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.UI.Xaml.GridLength;
+    GetInt32Property(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): number;
+    GetMatrix3DProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.UI.Xaml.Media.Media3D.Matrix3D;
+    GetMatrixProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.UI.Xaml.Media.Matrix;
+    GetObject(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject): Object;
+    GetObjectProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Object;
+    GetPointProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.Foundation.Point;
+    GetRectProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.Foundation.Rect;
+    GetSizeProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.Foundation.Size;
+    GetStringProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): string;
+    GetThicknessProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.UI.Xaml.Thickness;
+    GetTimeSpanProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.Foundation.TimeSpan;
+    GetXamlDirectObject(object: Object): Windows.UI.Xaml.Core.Direct.IXamlDirectObject;
+    GetXamlDirectObjectFromCollectionAt(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, index: number): Windows.UI.Xaml.Core.Direct.IXamlDirectObject;
+    GetXamlDirectObjectProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.UI.Xaml.Core.Direct.IXamlDirectObject;
+    InsertIntoCollectionAt(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, index: number, value: Windows.UI.Xaml.Core.Direct.IXamlDirectObject): void;
+    RemoveEventHandler(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, eventIndex: number, handler: Object): void;
+    RemoveFromCollection(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, value: Windows.UI.Xaml.Core.Direct.IXamlDirectObject): boolean;
+    RemoveFromCollectionAt(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, index: number): void;
+    SetBooleanProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: boolean): void;
+    SetColorProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.UI.Color): void;
+    SetCornerRadiusProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.UI.Xaml.CornerRadius): void;
+    SetDateTimeProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.Foundation.DateTime): void;
+    SetDoubleProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: number): void;
+    SetDurationProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.UI.Xaml.Duration): void;
+    SetEnumProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: number): void;
+    SetGridLengthProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.UI.Xaml.GridLength): void;
+    SetInt32Property(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: number): void;
+    SetMatrix3DProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.UI.Xaml.Media.Media3D.Matrix3D): void;
+    SetMatrixProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.UI.Xaml.Media.Matrix): void;
+    SetObjectProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Object): void;
+    SetPointProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.Foundation.Point): void;
+    SetRectProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.Foundation.Rect): void;
+    SetSizeProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.Foundation.Size): void;
+    SetStringProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: string): void;
+    SetThicknessProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.UI.Xaml.Thickness): void;
+    SetTimeSpanProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.Foundation.TimeSpan): void;
+    SetXamlDirectObjectProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.UI.Xaml.Core.Direct.IXamlDirectObject): void;
+  }
+
+  enum XamlEventIndex {
+    FrameworkElement_DataContextChanged = 16,
+    FrameworkElement_SizeChanged = 17,
+    FrameworkElement_LayoutUpdated = 18,
+    UIElement_KeyUp = 22,
+    UIElement_KeyDown = 23,
+    UIElement_GotFocus = 24,
+    UIElement_LostFocus = 25,
+    UIElement_DragStarting = 26,
+    UIElement_DropCompleted = 27,
+    UIElement_CharacterReceived = 28,
+    UIElement_DragEnter = 29,
+    UIElement_DragLeave = 30,
+    UIElement_DragOver = 31,
+    UIElement_Drop = 32,
+    UIElement_PointerPressed = 38,
+    UIElement_PointerMoved = 39,
+    UIElement_PointerReleased = 40,
+    UIElement_PointerEntered = 41,
+    UIElement_PointerExited = 42,
+    UIElement_PointerCaptureLost = 43,
+    UIElement_PointerCanceled = 44,
+    UIElement_PointerWheelChanged = 45,
+    UIElement_Tapped = 46,
+    UIElement_DoubleTapped = 47,
+    UIElement_Holding = 48,
+    UIElement_ContextRequested = 49,
+    UIElement_ContextCanceled = 50,
+    UIElement_RightTapped = 51,
+    UIElement_ManipulationStarting = 52,
+    UIElement_ManipulationInertiaStarting = 53,
+    UIElement_ManipulationStarted = 54,
+    UIElement_ManipulationDelta = 55,
+    UIElement_ManipulationCompleted = 56,
+    UIElement_ProcessKeyboardAccelerators = 60,
+    UIElement_GettingFocus = 61,
+    UIElement_LosingFocus = 62,
+    UIElement_NoFocusCandidateFound = 63,
+    UIElement_PreviewKeyDown = 64,
+    UIElement_PreviewKeyUp = 65,
+    UIElement_BringIntoViewRequested = 66,
+    AppBar_Opening = 109,
+    AppBar_Opened = 110,
+    AppBar_Closing = 111,
+    AppBar_Closed = 112,
+    AutoSuggestBox_SuggestionChosen = 113,
+    AutoSuggestBox_TextChanged = 114,
+    AutoSuggestBox_QuerySubmitted = 115,
+    CalendarDatePicker_CalendarViewDayItemChanging = 116,
+    CalendarDatePicker_DateChanged = 117,
+    CalendarDatePicker_Opened = 118,
+    CalendarDatePicker_Closed = 119,
+    CalendarView_CalendarViewDayItemChanging = 120,
+    CalendarView_SelectedDatesChanged = 121,
+    ComboBox_DropDownClosed = 122,
+    ComboBox_DropDownOpened = 123,
+    CommandBar_DynamicOverflowItemsChanging = 124,
+    ContentDialog_Closing = 126,
+    ContentDialog_Closed = 127,
+    ContentDialog_Opened = 128,
+    ContentDialog_PrimaryButtonClick = 129,
+    ContentDialog_SecondaryButtonClick = 130,
+    ContentDialog_CloseButtonClick = 131,
+    Control_FocusEngaged = 132,
+    Control_FocusDisengaged = 133,
+    DatePicker_DateChanged = 135,
+    Frame_Navigated = 136,
+    Frame_Navigating = 137,
+    Frame_NavigationFailed = 138,
+    Frame_NavigationStopped = 139,
+    Hub_SectionHeaderClick = 143,
+    Hub_SectionsInViewChanged = 144,
+    ItemsPresenter_HorizontalSnapPointsChanged = 148,
+    ItemsPresenter_VerticalSnapPointsChanged = 149,
+    ListViewBase_ItemClick = 150,
+    ListViewBase_DragItemsStarting = 151,
+    ListViewBase_DragItemsCompleted = 152,
+    ListViewBase_ContainerContentChanging = 153,
+    ListViewBase_ChoosingItemContainer = 154,
+    ListViewBase_ChoosingGroupHeaderContainer = 155,
+    MediaTransportControls_ThumbnailRequested = 167,
+    MenuFlyoutItem_Click = 168,
+    RichEditBox_TextChanging = 177,
+    ScrollViewer_ViewChanging = 192,
+    ScrollViewer_ViewChanged = 193,
+    ScrollViewer_DirectManipulationStarted = 194,
+    ScrollViewer_DirectManipulationCompleted = 195,
+    SearchBox_QueryChanged = 196,
+    SearchBox_SuggestionsRequested = 197,
+    SearchBox_QuerySubmitted = 198,
+    SearchBox_ResultSuggestionChosen = 199,
+    SearchBox_PrepareForFocusOnKeyboardInput = 200,
+    SemanticZoom_ViewChangeStarted = 201,
+    SemanticZoom_ViewChangeCompleted = 202,
+    SettingsFlyout_BackClick = 203,
+    StackPanel_HorizontalSnapPointsChanged = 208,
+    StackPanel_VerticalSnapPointsChanged = 209,
+    TimePicker_TimeChanged = 227,
+    ToggleSwitch_Toggled = 228,
+    ToolTip_Closed = 229,
+    ToolTip_Opened = 230,
+    VirtualizingStackPanel_CleanUpVirtualizedItemEvent = 231,
+    WebView_SeparateProcessLost = 232,
+    WebView_LoadCompleted = 233,
+    WebView_ScriptNotify = 234,
+    WebView_NavigationFailed = 235,
+    WebView_NavigationStarting = 236,
+    WebView_ContentLoading = 237,
+    WebView_DOMContentLoaded = 238,
+    WebView_NavigationCompleted = 239,
+    WebView_FrameNavigationStarting = 240,
+    WebView_FrameContentLoading = 241,
+    WebView_FrameDOMContentLoaded = 242,
+    WebView_FrameNavigationCompleted = 243,
+    WebView_LongRunningScriptDetected = 244,
+    WebView_UnsafeContentWarningDisplaying = 245,
+    WebView_UnviewableContentIdentified = 246,
+    WebView_ContainsFullScreenElementChanged = 247,
+    WebView_UnsupportedUriSchemeIdentified = 248,
+    WebView_NewWindowRequested = 249,
+    WebView_PermissionRequested = 250,
+    ButtonBase_Click = 256,
+    CarouselPanel_HorizontalSnapPointsChanged = 257,
+    CarouselPanel_VerticalSnapPointsChanged = 258,
+    OrientedVirtualizingPanel_HorizontalSnapPointsChanged = 263,
+    OrientedVirtualizingPanel_VerticalSnapPointsChanged = 264,
+    RangeBase_ValueChanged = 267,
+    ScrollBar_Scroll = 268,
+    Selector_SelectionChanged = 269,
+    Thumb_DragStarted = 270,
+    Thumb_DragDelta = 271,
+    Thumb_DragCompleted = 272,
+    ToggleButton_Checked = 273,
+    ToggleButton_Unchecked = 274,
+    ToggleButton_Indeterminate = 275,
+    WebView_WebResourceRequested = 283,
+    ScrollViewer_AnchorRequested = 291,
+    DatePicker_SelectedDateChanged = 322,
+    TimePicker_SelectedTimeChanged = 323,
+  }
+
+  enum XamlPropertyIndex {
+    AutomationProperties_AcceleratorKey = 5,
+    AutomationProperties_AccessibilityView = 6,
+    AutomationProperties_AccessKey = 7,
+    AutomationProperties_AutomationId = 8,
+    AutomationProperties_ControlledPeers = 9,
+    AutomationProperties_HelpText = 10,
+    AutomationProperties_IsRequiredForForm = 11,
+    AutomationProperties_ItemStatus = 12,
+    AutomationProperties_ItemType = 13,
+    AutomationProperties_LabeledBy = 14,
+    AutomationProperties_LiveSetting = 15,
+    AutomationProperties_Name = 16,
+    ToolTipService_Placement = 24,
+    ToolTipService_PlacementTarget = 25,
+    ToolTipService_ToolTip = 26,
+    Typography_AnnotationAlternates = 28,
+    Typography_Capitals = 29,
+    Typography_CapitalSpacing = 30,
+    Typography_CaseSensitiveForms = 31,
+    Typography_ContextualAlternates = 32,
+    Typography_ContextualLigatures = 33,
+    Typography_ContextualSwashes = 34,
+    Typography_DiscretionaryLigatures = 35,
+    Typography_EastAsianExpertForms = 36,
+    Typography_EastAsianLanguage = 37,
+    Typography_EastAsianWidths = 38,
+    Typography_Fraction = 39,
+    Typography_HistoricalForms = 40,
+    Typography_HistoricalLigatures = 41,
+    Typography_Kerning = 42,
+    Typography_MathematicalGreek = 43,
+    Typography_NumeralAlignment = 44,
+    Typography_NumeralStyle = 45,
+    Typography_SlashedZero = 46,
+    Typography_StandardLigatures = 47,
+    Typography_StandardSwashes = 48,
+    Typography_StylisticAlternates = 49,
+    Typography_StylisticSet1 = 50,
+    Typography_StylisticSet10 = 51,
+    Typography_StylisticSet11 = 52,
+    Typography_StylisticSet12 = 53,
+    Typography_StylisticSet13 = 54,
+    Typography_StylisticSet14 = 55,
+    Typography_StylisticSet15 = 56,
+    Typography_StylisticSet16 = 57,
+    Typography_StylisticSet17 = 58,
+    Typography_StylisticSet18 = 59,
+    Typography_StylisticSet19 = 60,
+    Typography_StylisticSet2 = 61,
+    Typography_StylisticSet20 = 62,
+    Typography_StylisticSet3 = 63,
+    Typography_StylisticSet4 = 64,
+    Typography_StylisticSet5 = 65,
+    Typography_StylisticSet6 = 66,
+    Typography_StylisticSet7 = 67,
+    Typography_StylisticSet8 = 68,
+    Typography_StylisticSet9 = 69,
+    Typography_Variants = 70,
+    AutomationPeer_EventsSource = 75,
+    AutoSuggestBoxSuggestionChosenEventArgs_SelectedItem = 76,
+    AutoSuggestBoxTextChangedEventArgs_Reason = 77,
+    Brush_Opacity = 78,
+    Brush_RelativeTransform = 79,
+    Brush_Transform = 80,
+    CollectionViewSource_IsSourceGrouped = 81,
+    CollectionViewSource_ItemsPath = 82,
+    CollectionViewSource_Source = 83,
+    CollectionViewSource_View = 84,
+    ColorKeyFrame_KeyTime = 90,
+    ColorKeyFrame_Value = 91,
+    ColumnDefinition_ActualWidth = 92,
+    ColumnDefinition_MaxWidth = 93,
+    ColumnDefinition_MinWidth = 94,
+    ColumnDefinition_Width = 95,
+    ComboBoxTemplateSettings_DropDownClosedHeight = 96,
+    ComboBoxTemplateSettings_DropDownOffset = 97,
+    ComboBoxTemplateSettings_DropDownOpenedHeight = 98,
+    ComboBoxTemplateSettings_SelectedItemDirection = 99,
+    DoubleKeyFrame_KeyTime = 107,
+    DoubleKeyFrame_Value = 108,
+    EasingFunctionBase_EasingMode = 111,
+    FlyoutBase_AttachedFlyout = 114,
+    FlyoutBase_Placement = 115,
+    Geometry_Bounds = 118,
+    Geometry_Transform = 119,
+    GradientStop_Color = 120,
+    GradientStop_Offset = 121,
+    GroupStyle_ContainerStyle = 124,
+    GroupStyle_ContainerStyleSelector = 125,
+    GroupStyle_HeaderContainerStyle = 126,
+    GroupStyle_HeaderTemplate = 127,
+    GroupStyle_HeaderTemplateSelector = 128,
+    GroupStyle_HidesIfEmpty = 129,
+    GroupStyle_Panel = 130,
+    InertiaExpansionBehavior_DesiredDeceleration = 144,
+    InertiaExpansionBehavior_DesiredExpansion = 145,
+    InertiaRotationBehavior_DesiredDeceleration = 146,
+    InertiaRotationBehavior_DesiredRotation = 147,
+    InertiaTranslationBehavior_DesiredDeceleration = 148,
+    InertiaTranslationBehavior_DesiredDisplacement = 149,
+    InputScope_Names = 150,
+    InputScopeName_NameValue = 151,
+    KeySpline_ControlPoint1 = 153,
+    KeySpline_ControlPoint2 = 154,
+    ManipulationPivot_Center = 159,
+    ManipulationPivot_Radius = 160,
+    ObjectKeyFrame_KeyTime = 183,
+    ObjectKeyFrame_Value = 184,
+    PageStackEntry_SourcePageType = 185,
+    PathFigure_IsClosed = 192,
+    PathFigure_IsFilled = 193,
+    PathFigure_Segments = 194,
+    PathFigure_StartPoint = 195,
+    Pointer_IsInContact = 199,
+    Pointer_IsInRange = 200,
+    Pointer_PointerDeviceType = 201,
+    Pointer_PointerId = 202,
+    PointKeyFrame_KeyTime = 205,
+    PointKeyFrame_Value = 206,
+    PrintDocument_DocumentSource = 209,
+    ProgressBarTemplateSettings_ContainerAnimationEndPosition = 211,
+    ProgressBarTemplateSettings_ContainerAnimationStartPosition = 212,
+    ProgressBarTemplateSettings_EllipseAnimationEndPosition = 213,
+    ProgressBarTemplateSettings_EllipseAnimationWellPosition = 214,
+    ProgressBarTemplateSettings_EllipseDiameter = 215,
+    ProgressBarTemplateSettings_EllipseOffset = 216,
+    ProgressBarTemplateSettings_IndicatorLengthDelta = 217,
+    ProgressRingTemplateSettings_EllipseDiameter = 218,
+    ProgressRingTemplateSettings_EllipseOffset = 219,
+    ProgressRingTemplateSettings_MaxSideLength = 220,
+    PropertyPath_Path = 221,
+    RowDefinition_ActualHeight = 226,
+    RowDefinition_Height = 227,
+    RowDefinition_MaxHeight = 228,
+    RowDefinition_MinHeight = 229,
+    SetterBase_IsSealed = 233,
+    SettingsFlyoutTemplateSettings_BorderBrush = 234,
+    SettingsFlyoutTemplateSettings_BorderThickness = 235,
+    SettingsFlyoutTemplateSettings_ContentTransitions = 236,
+    SettingsFlyoutTemplateSettings_HeaderBackground = 237,
+    SettingsFlyoutTemplateSettings_HeaderForeground = 238,
+    SettingsFlyoutTemplateSettings_IconSource = 239,
+    Style_BasedOn = 244,
+    Style_IsSealed = 245,
+    Style_Setters = 246,
+    Style_TargetType = 247,
+    TextElement_CharacterSpacing = 249,
+    TextElement_FontFamily = 250,
+    TextElement_FontSize = 251,
+    TextElement_FontStretch = 252,
+    TextElement_FontStyle = 253,
+    TextElement_FontWeight = 254,
+    TextElement_Foreground = 255,
+    TextElement_IsTextScaleFactorEnabled = 256,
+    TextElement_Language = 257,
+    Timeline_AutoReverse = 263,
+    Timeline_BeginTime = 264,
+    Timeline_Duration = 265,
+    Timeline_FillBehavior = 266,
+    Timeline_RepeatBehavior = 267,
+    Timeline_SpeedRatio = 268,
+    TimelineMarker_Text = 269,
+    TimelineMarker_Time = 270,
+    TimelineMarker_Type = 271,
+    ToggleSwitchTemplateSettings_CurtainCurrentToOffOffset = 273,
+    ToggleSwitchTemplateSettings_CurtainCurrentToOnOffset = 274,
+    ToggleSwitchTemplateSettings_CurtainOffToOnOffset = 275,
+    ToggleSwitchTemplateSettings_CurtainOnToOffOffset = 276,
+    ToggleSwitchTemplateSettings_KnobCurrentToOffOffset = 277,
+    ToggleSwitchTemplateSettings_KnobCurrentToOnOffset = 278,
+    ToggleSwitchTemplateSettings_KnobOffToOnOffset = 279,
+    ToggleSwitchTemplateSettings_KnobOnToOffOffset = 280,
+    ToolTipTemplateSettings_FromHorizontalOffset = 281,
+    ToolTipTemplateSettings_FromVerticalOffset = 282,
+    UIElement_AllowDrop = 292,
+    UIElement_CacheMode = 293,
+    UIElement_Clip = 295,
+    UIElement_CompositeMode = 296,
+    UIElement_IsDoubleTapEnabled = 297,
+    UIElement_IsHitTestVisible = 298,
+    UIElement_IsHoldingEnabled = 299,
+    UIElement_IsRightTapEnabled = 300,
+    UIElement_IsTapEnabled = 301,
+    UIElement_ManipulationMode = 302,
+    UIElement_Opacity = 303,
+    UIElement_PointerCaptures = 304,
+    UIElement_Projection = 305,
+    UIElement_RenderSize = 306,
+    UIElement_RenderTransform = 307,
+    UIElement_RenderTransformOrigin = 308,
+    UIElement_Transitions = 309,
+    UIElement_UseLayoutRounding = 311,
+    UIElement_Visibility = 312,
+    VisualState_Storyboard = 322,
+    VisualStateGroup_States = 323,
+    VisualStateGroup_Transitions = 324,
+    VisualStateManager_CustomVisualStateManager = 325,
+    VisualStateManager_VisualStateGroups = 326,
+    VisualTransition_From = 327,
+    VisualTransition_GeneratedDuration = 328,
+    VisualTransition_GeneratedEasingFunction = 329,
+    VisualTransition_Storyboard = 330,
+    VisualTransition_To = 331,
+    ArcSegment_IsLargeArc = 332,
+    ArcSegment_Point = 333,
+    ArcSegment_RotationAngle = 334,
+    ArcSegment_Size = 335,
+    ArcSegment_SweepDirection = 336,
+    BackEase_Amplitude = 337,
+    BeginStoryboard_Storyboard = 338,
+    BezierSegment_Point1 = 339,
+    BezierSegment_Point2 = 340,
+    BezierSegment_Point3 = 341,
+    BitmapSource_PixelHeight = 342,
+    BitmapSource_PixelWidth = 343,
+    Block_LineHeight = 344,
+    Block_LineStackingStrategy = 345,
+    Block_Margin = 346,
+    Block_TextAlignment = 347,
+    BounceEase_Bounces = 348,
+    BounceEase_Bounciness = 349,
+    ColorAnimation_By = 350,
+    ColorAnimation_EasingFunction = 351,
+    ColorAnimation_EnableDependentAnimation = 352,
+    ColorAnimation_From = 353,
+    ColorAnimation_To = 354,
+    ColorAnimationUsingKeyFrames_EnableDependentAnimation = 355,
+    ColorAnimationUsingKeyFrames_KeyFrames = 356,
+    ContentThemeTransition_HorizontalOffset = 357,
+    ContentThemeTransition_VerticalOffset = 358,
+    ControlTemplate_TargetType = 359,
+    DispatcherTimer_Interval = 362,
+    DoubleAnimation_By = 363,
+    DoubleAnimation_EasingFunction = 364,
+    DoubleAnimation_EnableDependentAnimation = 365,
+    DoubleAnimation_From = 366,
+    DoubleAnimation_To = 367,
+    DoubleAnimationUsingKeyFrames_EnableDependentAnimation = 368,
+    DoubleAnimationUsingKeyFrames_KeyFrames = 369,
+    EasingColorKeyFrame_EasingFunction = 372,
+    EasingDoubleKeyFrame_EasingFunction = 373,
+    EasingPointKeyFrame_EasingFunction = 374,
+    EdgeUIThemeTransition_Edge = 375,
+    ElasticEase_Oscillations = 376,
+    ElasticEase_Springiness = 377,
+    EllipseGeometry_Center = 378,
+    EllipseGeometry_RadiusX = 379,
+    EllipseGeometry_RadiusY = 380,
+    EntranceThemeTransition_FromHorizontalOffset = 381,
+    EntranceThemeTransition_FromVerticalOffset = 382,
+    EntranceThemeTransition_IsStaggeringEnabled = 383,
+    EventTrigger_Actions = 384,
+    EventTrigger_RoutedEvent = 385,
+    ExponentialEase_Exponent = 386,
+    Flyout_Content = 387,
+    Flyout_FlyoutPresenterStyle = 388,
+    FrameworkElement_ActualHeight = 389,
+    FrameworkElement_ActualWidth = 390,
+    FrameworkElement_DataContext = 391,
+    FrameworkElement_FlowDirection = 392,
+    FrameworkElement_Height = 393,
+    FrameworkElement_HorizontalAlignment = 394,
+    FrameworkElement_Language = 396,
+    FrameworkElement_Margin = 397,
+    FrameworkElement_MaxHeight = 398,
+    FrameworkElement_MaxWidth = 399,
+    FrameworkElement_MinHeight = 400,
+    FrameworkElement_MinWidth = 401,
+    FrameworkElement_Parent = 402,
+    FrameworkElement_RequestedTheme = 403,
+    FrameworkElement_Resources = 404,
+    FrameworkElement_Style = 405,
+    FrameworkElement_Tag = 406,
+    FrameworkElement_Triggers = 407,
+    FrameworkElement_VerticalAlignment = 408,
+    FrameworkElement_Width = 409,
+    FrameworkElementAutomationPeer_Owner = 410,
+    GeometryGroup_Children = 411,
+    GeometryGroup_FillRule = 412,
+    GradientBrush_ColorInterpolationMode = 413,
+    GradientBrush_GradientStops = 414,
+    GradientBrush_MappingMode = 415,
+    GradientBrush_SpreadMethod = 416,
+    GridViewItemTemplateSettings_DragItemsCount = 417,
+    ItemAutomationPeer_Item = 419,
+    ItemAutomationPeer_ItemsControlAutomationPeer = 420,
+    LineGeometry_EndPoint = 422,
+    LineGeometry_StartPoint = 423,
+    LineSegment_Point = 424,
+    ListViewItemTemplateSettings_DragItemsCount = 425,
+    Matrix3DProjection_ProjectionMatrix = 426,
+    MenuFlyout_Items = 427,
+    MenuFlyout_MenuFlyoutPresenterStyle = 428,
+    ObjectAnimationUsingKeyFrames_EnableDependentAnimation = 429,
+    ObjectAnimationUsingKeyFrames_KeyFrames = 430,
+    PaneThemeTransition_Edge = 431,
+    PathGeometry_Figures = 432,
+    PathGeometry_FillRule = 433,
+    PlaneProjection_CenterOfRotationX = 434,
+    PlaneProjection_CenterOfRotationY = 435,
+    PlaneProjection_CenterOfRotationZ = 436,
+    PlaneProjection_GlobalOffsetX = 437,
+    PlaneProjection_GlobalOffsetY = 438,
+    PlaneProjection_GlobalOffsetZ = 439,
+    PlaneProjection_LocalOffsetX = 440,
+    PlaneProjection_LocalOffsetY = 441,
+    PlaneProjection_LocalOffsetZ = 442,
+    PlaneProjection_ProjectionMatrix = 443,
+    PlaneProjection_RotationX = 444,
+    PlaneProjection_RotationY = 445,
+    PlaneProjection_RotationZ = 446,
+    PointAnimation_By = 447,
+    PointAnimation_EasingFunction = 448,
+    PointAnimation_EnableDependentAnimation = 449,
+    PointAnimation_From = 450,
+    PointAnimation_To = 451,
+    PointAnimationUsingKeyFrames_EnableDependentAnimation = 452,
+    PointAnimationUsingKeyFrames_KeyFrames = 453,
+    PolyBezierSegment_Points = 456,
+    PolyLineSegment_Points = 457,
+    PolyQuadraticBezierSegment_Points = 458,
+    PopupThemeTransition_FromHorizontalOffset = 459,
+    PopupThemeTransition_FromVerticalOffset = 460,
+    PowerEase_Power = 461,
+    QuadraticBezierSegment_Point1 = 466,
+    QuadraticBezierSegment_Point2 = 467,
+    RectangleGeometry_Rect = 470,
+    RelativeSource_Mode = 471,
+    RenderTargetBitmap_PixelHeight = 472,
+    RenderTargetBitmap_PixelWidth = 473,
+    Setter_Property = 474,
+    Setter_Value = 475,
+    SolidColorBrush_Color = 476,
+    SplineColorKeyFrame_KeySpline = 477,
+    SplineDoubleKeyFrame_KeySpline = 478,
+    SplinePointKeyFrame_KeySpline = 479,
+    TileBrush_AlignmentX = 483,
+    TileBrush_AlignmentY = 484,
+    TileBrush_Stretch = 485,
+    Binding_Converter = 487,
+    Binding_ConverterLanguage = 488,
+    Binding_ConverterParameter = 489,
+    Binding_ElementName = 490,
+    Binding_FallbackValue = 491,
+    Binding_Mode = 492,
+    Binding_Path = 493,
+    Binding_RelativeSource = 494,
+    Binding_Source = 495,
+    Binding_TargetNullValue = 496,
+    Binding_UpdateSourceTrigger = 497,
+    BitmapImage_CreateOptions = 498,
+    BitmapImage_DecodePixelHeight = 499,
+    BitmapImage_DecodePixelType = 500,
+    BitmapImage_DecodePixelWidth = 501,
+    BitmapImage_UriSource = 502,
+    Border_Background = 503,
+    Border_BorderBrush = 504,
+    Border_BorderThickness = 505,
+    Border_Child = 506,
+    Border_ChildTransitions = 507,
+    Border_CornerRadius = 508,
+    Border_Padding = 509,
+    CaptureElement_Source = 510,
+    CaptureElement_Stretch = 511,
+    CompositeTransform_CenterX = 514,
+    CompositeTransform_CenterY = 515,
+    CompositeTransform_Rotation = 516,
+    CompositeTransform_ScaleX = 517,
+    CompositeTransform_ScaleY = 518,
+    CompositeTransform_SkewX = 519,
+    CompositeTransform_SkewY = 520,
+    CompositeTransform_TranslateX = 521,
+    CompositeTransform_TranslateY = 522,
+    ContentPresenter_CharacterSpacing = 523,
+    ContentPresenter_Content = 524,
+    ContentPresenter_ContentTemplate = 525,
+    ContentPresenter_ContentTemplateSelector = 526,
+    ContentPresenter_ContentTransitions = 527,
+    ContentPresenter_FontFamily = 528,
+    ContentPresenter_FontSize = 529,
+    ContentPresenter_FontStretch = 530,
+    ContentPresenter_FontStyle = 531,
+    ContentPresenter_FontWeight = 532,
+    ContentPresenter_Foreground = 533,
+    ContentPresenter_IsTextScaleFactorEnabled = 534,
+    ContentPresenter_LineStackingStrategy = 535,
+    ContentPresenter_MaxLines = 536,
+    ContentPresenter_OpticalMarginAlignment = 537,
+    ContentPresenter_TextLineBounds = 539,
+    ContentPresenter_TextWrapping = 540,
+    Control_Background = 541,
+    Control_BorderBrush = 542,
+    Control_BorderThickness = 543,
+    Control_CharacterSpacing = 544,
+    Control_FocusState = 546,
+    Control_FontFamily = 547,
+    Control_FontSize = 548,
+    Control_FontStretch = 549,
+    Control_FontStyle = 550,
+    Control_FontWeight = 551,
+    Control_Foreground = 552,
+    Control_HorizontalContentAlignment = 553,
+    Control_IsEnabled = 554,
+    Control_IsTabStop = 555,
+    Control_IsTextScaleFactorEnabled = 556,
+    Control_Padding = 557,
+    Control_TabIndex = 558,
+    Control_TabNavigation = 559,
+    Control_Template = 560,
+    Control_VerticalContentAlignment = 561,
+    DragItemThemeAnimation_TargetName = 565,
+    DragOverThemeAnimation_Direction = 566,
+    DragOverThemeAnimation_TargetName = 567,
+    DragOverThemeAnimation_ToOffset = 568,
+    DropTargetItemThemeAnimation_TargetName = 569,
+    FadeInThemeAnimation_TargetName = 570,
+    FadeOutThemeAnimation_TargetName = 571,
+    Glyphs_Fill = 574,
+    Glyphs_FontRenderingEmSize = 575,
+    Glyphs_FontUri = 576,
+    Glyphs_Indices = 577,
+    Glyphs_OriginX = 578,
+    Glyphs_OriginY = 579,
+    Glyphs_StyleSimulations = 580,
+    Glyphs_UnicodeString = 581,
+    IconElement_Foreground = 584,
+    Image_NineGrid = 586,
+    Image_PlayToSource = 587,
+    Image_Source = 588,
+    Image_Stretch = 589,
+    ImageBrush_ImageSource = 591,
+    InlineUIContainer_Child = 592,
+    ItemsPresenter_Footer = 594,
+    ItemsPresenter_FooterTemplate = 595,
+    ItemsPresenter_FooterTransitions = 596,
+    ItemsPresenter_Header = 597,
+    ItemsPresenter_HeaderTemplate = 598,
+    ItemsPresenter_HeaderTransitions = 599,
+    ItemsPresenter_Padding = 601,
+    LinearGradientBrush_EndPoint = 602,
+    LinearGradientBrush_StartPoint = 603,
+    MatrixTransform_Matrix = 604,
+    MediaElement_ActualStereo3DVideoPackingMode = 605,
+    MediaElement_AreTransportControlsEnabled = 606,
+    MediaElement_AspectRatioHeight = 607,
+    MediaElement_AspectRatioWidth = 608,
+    MediaElement_AudioCategory = 609,
+    MediaElement_AudioDeviceType = 610,
+    MediaElement_AudioStreamCount = 611,
+    MediaElement_AudioStreamIndex = 612,
+    MediaElement_AutoPlay = 613,
+    MediaElement_Balance = 614,
+    MediaElement_BufferingProgress = 615,
+    MediaElement_CanPause = 616,
+    MediaElement_CanSeek = 617,
+    MediaElement_CurrentState = 618,
+    MediaElement_DefaultPlaybackRate = 619,
+    MediaElement_DownloadProgress = 620,
+    MediaElement_DownloadProgressOffset = 621,
+    MediaElement_IsAudioOnly = 623,
+    MediaElement_IsFullWindow = 624,
+    MediaElement_IsLooping = 625,
+    MediaElement_IsMuted = 626,
+    MediaElement_IsStereo3DVideo = 627,
+    MediaElement_Markers = 628,
+    MediaElement_NaturalDuration = 629,
+    MediaElement_NaturalVideoHeight = 630,
+    MediaElement_NaturalVideoWidth = 631,
+    MediaElement_PlaybackRate = 632,
+    MediaElement_PlayToPreferredSourceUri = 633,
+    MediaElement_PlayToSource = 634,
+    MediaElement_Position = 635,
+    MediaElement_PosterSource = 636,
+    MediaElement_ProtectionManager = 637,
+    MediaElement_RealTimePlayback = 638,
+    MediaElement_Source = 639,
+    MediaElement_Stereo3DVideoPackingMode = 640,
+    MediaElement_Stereo3DVideoRenderMode = 641,
+    MediaElement_Stretch = 642,
+    MediaElement_TransportControls = 643,
+    MediaElement_Volume = 644,
+    Panel_Background = 647,
+    Panel_Children = 648,
+    Panel_ChildrenTransitions = 649,
+    Panel_IsItemsHost = 651,
+    Paragraph_Inlines = 652,
+    Paragraph_TextIndent = 653,
+    PointerDownThemeAnimation_TargetName = 660,
+    PointerUpThemeAnimation_TargetName = 662,
+    PopInThemeAnimation_FromHorizontalOffset = 664,
+    PopInThemeAnimation_FromVerticalOffset = 665,
+    PopInThemeAnimation_TargetName = 666,
+    PopOutThemeAnimation_TargetName = 667,
+    Popup_Child = 668,
+    Popup_ChildTransitions = 669,
+    Popup_HorizontalOffset = 670,
+    Popup_IsLightDismissEnabled = 673,
+    Popup_IsOpen = 674,
+    Popup_VerticalOffset = 676,
+    RepositionThemeAnimation_FromHorizontalOffset = 683,
+    RepositionThemeAnimation_FromVerticalOffset = 684,
+    RepositionThemeAnimation_TargetName = 685,
+    ResourceDictionary_MergedDictionaries = 687,
+    ResourceDictionary_Source = 688,
+    ResourceDictionary_ThemeDictionaries = 689,
+    RichTextBlock_Blocks = 691,
+    RichTextBlock_CharacterSpacing = 692,
+    RichTextBlock_FontFamily = 693,
+    RichTextBlock_FontSize = 694,
+    RichTextBlock_FontStretch = 695,
+    RichTextBlock_FontStyle = 696,
+    RichTextBlock_FontWeight = 697,
+    RichTextBlock_Foreground = 698,
+    RichTextBlock_HasOverflowContent = 699,
+    RichTextBlock_IsColorFontEnabled = 700,
+    RichTextBlock_IsTextScaleFactorEnabled = 701,
+    RichTextBlock_IsTextSelectionEnabled = 702,
+    RichTextBlock_LineHeight = 703,
+    RichTextBlock_LineStackingStrategy = 704,
+    RichTextBlock_MaxLines = 705,
+    RichTextBlock_OpticalMarginAlignment = 706,
+    RichTextBlock_OverflowContentTarget = 707,
+    RichTextBlock_Padding = 708,
+    RichTextBlock_SelectedText = 709,
+    RichTextBlock_SelectionHighlightColor = 710,
+    RichTextBlock_TextAlignment = 711,
+    RichTextBlock_TextIndent = 712,
+    RichTextBlock_TextLineBounds = 713,
+    RichTextBlock_TextReadingOrder = 714,
+    RichTextBlock_TextTrimming = 715,
+    RichTextBlock_TextWrapping = 716,
+    RichTextBlockOverflow_HasOverflowContent = 717,
+    RichTextBlockOverflow_MaxLines = 718,
+    RichTextBlockOverflow_OverflowContentTarget = 719,
+    RichTextBlockOverflow_Padding = 720,
+    RotateTransform_Angle = 721,
+    RotateTransform_CenterX = 722,
+    RotateTransform_CenterY = 723,
+    Run_FlowDirection = 725,
+    Run_Text = 726,
+    ScaleTransform_CenterX = 727,
+    ScaleTransform_CenterY = 728,
+    ScaleTransform_ScaleX = 729,
+    ScaleTransform_ScaleY = 730,
+    SetterBaseCollection_IsSealed = 732,
+    Shape_Fill = 733,
+    Shape_GeometryTransform = 734,
+    Shape_Stretch = 735,
+    Shape_Stroke = 736,
+    Shape_StrokeDashArray = 737,
+    Shape_StrokeDashCap = 738,
+    Shape_StrokeDashOffset = 739,
+    Shape_StrokeEndLineCap = 740,
+    Shape_StrokeLineJoin = 741,
+    Shape_StrokeMiterLimit = 742,
+    Shape_StrokeStartLineCap = 743,
+    Shape_StrokeThickness = 744,
+    SkewTransform_AngleX = 745,
+    SkewTransform_AngleY = 746,
+    SkewTransform_CenterX = 747,
+    SkewTransform_CenterY = 748,
+    Span_Inlines = 749,
+    SplitCloseThemeAnimation_ClosedLength = 750,
+    SplitCloseThemeAnimation_ClosedTarget = 751,
+    SplitCloseThemeAnimation_ClosedTargetName = 752,
+    SplitCloseThemeAnimation_ContentTarget = 753,
+    SplitCloseThemeAnimation_ContentTargetName = 754,
+    SplitCloseThemeAnimation_ContentTranslationDirection = 755,
+    SplitCloseThemeAnimation_ContentTranslationOffset = 756,
+    SplitCloseThemeAnimation_OffsetFromCenter = 757,
+    SplitCloseThemeAnimation_OpenedLength = 758,
+    SplitCloseThemeAnimation_OpenedTarget = 759,
+    SplitCloseThemeAnimation_OpenedTargetName = 760,
+    SplitOpenThemeAnimation_ClosedLength = 761,
+    SplitOpenThemeAnimation_ClosedTarget = 762,
+    SplitOpenThemeAnimation_ClosedTargetName = 763,
+    SplitOpenThemeAnimation_ContentTarget = 764,
+    SplitOpenThemeAnimation_ContentTargetName = 765,
+    SplitOpenThemeAnimation_ContentTranslationDirection = 766,
+    SplitOpenThemeAnimation_ContentTranslationOffset = 767,
+    SplitOpenThemeAnimation_OffsetFromCenter = 768,
+    SplitOpenThemeAnimation_OpenedLength = 769,
+    SplitOpenThemeAnimation_OpenedTarget = 770,
+    SplitOpenThemeAnimation_OpenedTargetName = 771,
+    Storyboard_Children = 772,
+    Storyboard_TargetName = 774,
+    Storyboard_TargetProperty = 775,
+    SwipeBackThemeAnimation_FromHorizontalOffset = 776,
+    SwipeBackThemeAnimation_FromVerticalOffset = 777,
+    SwipeBackThemeAnimation_TargetName = 778,
+    SwipeHintThemeAnimation_TargetName = 779,
+    SwipeHintThemeAnimation_ToHorizontalOffset = 780,
+    SwipeHintThemeAnimation_ToVerticalOffset = 781,
+    TextBlock_CharacterSpacing = 782,
+    TextBlock_FontFamily = 783,
+    TextBlock_FontSize = 784,
+    TextBlock_FontStretch = 785,
+    TextBlock_FontStyle = 786,
+    TextBlock_FontWeight = 787,
+    TextBlock_Foreground = 788,
+    TextBlock_Inlines = 789,
+    TextBlock_IsColorFontEnabled = 790,
+    TextBlock_IsTextScaleFactorEnabled = 791,
+    TextBlock_IsTextSelectionEnabled = 792,
+    TextBlock_LineHeight = 793,
+    TextBlock_LineStackingStrategy = 794,
+    TextBlock_MaxLines = 795,
+    TextBlock_OpticalMarginAlignment = 796,
+    TextBlock_Padding = 797,
+    TextBlock_SelectedText = 798,
+    TextBlock_SelectionHighlightColor = 799,
+    TextBlock_Text = 800,
+    TextBlock_TextAlignment = 801,
+    TextBlock_TextDecorations = 802,
+    TextBlock_TextLineBounds = 803,
+    TextBlock_TextReadingOrder = 804,
+    TextBlock_TextTrimming = 805,
+    TextBlock_TextWrapping = 806,
+    TransformGroup_Children = 811,
+    TransformGroup_Value = 812,
+    TranslateTransform_X = 814,
+    TranslateTransform_Y = 815,
+    Viewbox_Child = 819,
+    Viewbox_Stretch = 820,
+    Viewbox_StretchDirection = 821,
+    WebViewBrush_SourceName = 825,
+    AppBarSeparator_IsCompact = 826,
+    BitmapIcon_UriSource = 827,
+    Canvas_Left = 828,
+    Canvas_Top = 829,
+    Canvas_ZIndex = 830,
+    ContentControl_Content = 832,
+    ContentControl_ContentTemplate = 833,
+    ContentControl_ContentTemplateSelector = 834,
+    ContentControl_ContentTransitions = 835,
+    DatePicker_CalendarIdentifier = 837,
+    DatePicker_Date = 838,
+    DatePicker_DayFormat = 839,
+    DatePicker_DayVisible = 840,
+    DatePicker_Header = 841,
+    DatePicker_HeaderTemplate = 842,
+    DatePicker_MaxYear = 843,
+    DatePicker_MinYear = 844,
+    DatePicker_MonthFormat = 845,
+    DatePicker_MonthVisible = 846,
+    DatePicker_Orientation = 847,
+    DatePicker_YearFormat = 848,
+    DatePicker_YearVisible = 849,
+    FontIcon_FontFamily = 851,
+    FontIcon_FontSize = 852,
+    FontIcon_FontStyle = 853,
+    FontIcon_FontWeight = 854,
+    FontIcon_Glyph = 855,
+    FontIcon_IsTextScaleFactorEnabled = 856,
+    Grid_Column = 857,
+    Grid_ColumnDefinitions = 858,
+    Grid_ColumnSpan = 859,
+    Grid_Row = 860,
+    Grid_RowDefinitions = 861,
+    Grid_RowSpan = 862,
+    Hub_DefaultSectionIndex = 863,
+    Hub_Header = 864,
+    Hub_HeaderTemplate = 865,
+    Hub_IsActiveView = 866,
+    Hub_IsZoomedInView = 867,
+    Hub_Orientation = 868,
+    Hub_SectionHeaders = 869,
+    Hub_Sections = 870,
+    Hub_SectionsInView = 871,
+    Hub_SemanticZoomOwner = 872,
+    HubSection_ContentTemplate = 873,
+    HubSection_Header = 874,
+    HubSection_HeaderTemplate = 875,
+    HubSection_IsHeaderInteractive = 876,
+    Hyperlink_NavigateUri = 877,
+    ItemsControl_DisplayMemberPath = 879,
+    ItemsControl_GroupStyle = 880,
+    ItemsControl_GroupStyleSelector = 881,
+    ItemsControl_IsGrouping = 882,
+    ItemsControl_ItemContainerStyle = 884,
+    ItemsControl_ItemContainerStyleSelector = 885,
+    ItemsControl_ItemContainerTransitions = 886,
+    ItemsControl_Items = 887,
+    ItemsControl_ItemsPanel = 889,
+    ItemsControl_ItemsSource = 890,
+    ItemsControl_ItemTemplate = 891,
+    ItemsControl_ItemTemplateSelector = 892,
+    Line_X1 = 893,
+    Line_X2 = 894,
+    Line_Y1 = 895,
+    Line_Y2 = 896,
+    MediaTransportControls_IsFastForwardButtonVisible = 898,
+    MediaTransportControls_IsFastRewindButtonVisible = 900,
+    MediaTransportControls_IsFullWindowButtonVisible = 902,
+    MediaTransportControls_IsPlaybackRateButtonVisible = 904,
+    MediaTransportControls_IsSeekBarVisible = 905,
+    MediaTransportControls_IsStopButtonVisible = 908,
+    MediaTransportControls_IsVolumeButtonVisible = 910,
+    MediaTransportControls_IsZoomButtonVisible = 912,
+    PasswordBox_Header = 913,
+    PasswordBox_HeaderTemplate = 914,
+    PasswordBox_IsPasswordRevealButtonEnabled = 915,
+    PasswordBox_MaxLength = 916,
+    PasswordBox_Password = 917,
+    PasswordBox_PasswordChar = 918,
+    PasswordBox_PlaceholderText = 919,
+    PasswordBox_PreventKeyboardDisplayOnProgrammaticFocus = 920,
+    PasswordBox_SelectionHighlightColor = 921,
+    Path_Data = 922,
+    PathIcon_Data = 923,
+    Polygon_FillRule = 924,
+    Polygon_Points = 925,
+    Polyline_FillRule = 926,
+    Polyline_Points = 927,
+    ProgressRing_IsActive = 928,
+    ProgressRing_TemplateSettings = 929,
+    RangeBase_LargeChange = 930,
+    RangeBase_Maximum = 931,
+    RangeBase_Minimum = 932,
+    RangeBase_SmallChange = 933,
+    RangeBase_Value = 934,
+    Rectangle_RadiusX = 935,
+    Rectangle_RadiusY = 936,
+    RichEditBox_AcceptsReturn = 937,
+    RichEditBox_Header = 938,
+    RichEditBox_HeaderTemplate = 939,
+    RichEditBox_InputScope = 940,
+    RichEditBox_IsColorFontEnabled = 941,
+    RichEditBox_IsReadOnly = 942,
+    RichEditBox_IsSpellCheckEnabled = 943,
+    RichEditBox_IsTextPredictionEnabled = 944,
+    RichEditBox_PlaceholderText = 945,
+    RichEditBox_PreventKeyboardDisplayOnProgrammaticFocus = 946,
+    RichEditBox_SelectionHighlightColor = 947,
+    RichEditBox_TextAlignment = 948,
+    RichEditBox_TextWrapping = 949,
+    SearchBox_ChooseSuggestionOnEnter = 950,
+    SearchBox_FocusOnKeyboardInput = 951,
+    SearchBox_PlaceholderText = 952,
+    SearchBox_QueryText = 953,
+    SearchBox_SearchHistoryContext = 954,
+    SearchBox_SearchHistoryEnabled = 955,
+    SemanticZoom_CanChangeViews = 956,
+    SemanticZoom_IsZoomedInViewActive = 957,
+    SemanticZoom_IsZoomOutButtonEnabled = 958,
+    SemanticZoom_ZoomedInView = 959,
+    SemanticZoom_ZoomedOutView = 960,
+    StackPanel_AreScrollSnapPointsRegular = 961,
+    StackPanel_Orientation = 962,
+    SymbolIcon_Symbol = 963,
+    TextBox_AcceptsReturn = 964,
+    TextBox_Header = 965,
+    TextBox_HeaderTemplate = 966,
+    TextBox_InputScope = 967,
+    TextBox_IsColorFontEnabled = 968,
+    TextBox_IsReadOnly = 971,
+    TextBox_IsSpellCheckEnabled = 972,
+    TextBox_IsTextPredictionEnabled = 973,
+    TextBox_MaxLength = 974,
+    TextBox_PlaceholderText = 975,
+    TextBox_PreventKeyboardDisplayOnProgrammaticFocus = 976,
+    TextBox_SelectedText = 977,
+    TextBox_SelectionHighlightColor = 978,
+    TextBox_SelectionLength = 979,
+    TextBox_SelectionStart = 980,
+    TextBox_Text = 981,
+    TextBox_TextAlignment = 982,
+    TextBox_TextWrapping = 983,
+    Thumb_IsDragging = 984,
+    TickBar_Fill = 985,
+    TimePicker_ClockIdentifier = 986,
+    TimePicker_Header = 987,
+    TimePicker_HeaderTemplate = 988,
+    TimePicker_MinuteIncrement = 989,
+    TimePicker_Time = 990,
+    ToggleSwitch_Header = 991,
+    ToggleSwitch_HeaderTemplate = 992,
+    ToggleSwitch_IsOn = 993,
+    ToggleSwitch_OffContent = 994,
+    ToggleSwitch_OffContentTemplate = 995,
+    ToggleSwitch_OnContent = 996,
+    ToggleSwitch_OnContentTemplate = 997,
+    ToggleSwitch_TemplateSettings = 998,
+    UserControl_Content = 999,
+    VariableSizedWrapGrid_ColumnSpan = 1000,
+    VariableSizedWrapGrid_HorizontalChildrenAlignment = 1001,
+    VariableSizedWrapGrid_ItemHeight = 1002,
+    VariableSizedWrapGrid_ItemWidth = 1003,
+    VariableSizedWrapGrid_MaximumRowsOrColumns = 1004,
+    VariableSizedWrapGrid_Orientation = 1005,
+    VariableSizedWrapGrid_RowSpan = 1006,
+    VariableSizedWrapGrid_VerticalChildrenAlignment = 1007,
+    WebView_AllowedScriptNotifyUris = 1008,
+    WebView_CanGoBack = 1009,
+    WebView_CanGoForward = 1010,
+    WebView_ContainsFullScreenElement = 1011,
+    WebView_DataTransferPackage = 1012,
+    WebView_DefaultBackgroundColor = 1013,
+    WebView_DocumentTitle = 1014,
+    WebView_Source = 1015,
+    AppBar_ClosedDisplayMode = 1016,
+    AppBar_IsOpen = 1017,
+    AppBar_IsSticky = 1018,
+    AutoSuggestBox_AutoMaximizeSuggestionArea = 1019,
+    AutoSuggestBox_Header = 1020,
+    AutoSuggestBox_IsSuggestionListOpen = 1021,
+    AutoSuggestBox_MaxSuggestionListHeight = 1022,
+    AutoSuggestBox_PlaceholderText = 1023,
+    AutoSuggestBox_Text = 1024,
+    AutoSuggestBox_TextBoxStyle = 1025,
+    AutoSuggestBox_TextMemberPath = 1026,
+    AutoSuggestBox_UpdateTextOnSelect = 1027,
+    ButtonBase_ClickMode = 1029,
+    ButtonBase_Command = 1030,
+    ButtonBase_CommandParameter = 1031,
+    ButtonBase_IsPointerOver = 1032,
+    ButtonBase_IsPressed = 1033,
+    ContentDialog_FullSizeDesired = 1034,
+    ContentDialog_IsPrimaryButtonEnabled = 1035,
+    ContentDialog_IsSecondaryButtonEnabled = 1036,
+    ContentDialog_PrimaryButtonCommand = 1037,
+    ContentDialog_PrimaryButtonCommandParameter = 1038,
+    ContentDialog_PrimaryButtonText = 1039,
+    ContentDialog_SecondaryButtonCommand = 1040,
+    ContentDialog_SecondaryButtonCommandParameter = 1041,
+    ContentDialog_SecondaryButtonText = 1042,
+    ContentDialog_Title = 1043,
+    ContentDialog_TitleTemplate = 1044,
+    Frame_BackStack = 1045,
+    Frame_BackStackDepth = 1046,
+    Frame_CacheSize = 1047,
+    Frame_CanGoBack = 1048,
+    Frame_CanGoForward = 1049,
+    Frame_CurrentSourcePageType = 1050,
+    Frame_ForwardStack = 1051,
+    Frame_SourcePageType = 1052,
+    GridViewItemPresenter_CheckBrush = 1053,
+    GridViewItemPresenter_CheckHintBrush = 1054,
+    GridViewItemPresenter_CheckSelectingBrush = 1055,
+    GridViewItemPresenter_ContentMargin = 1056,
+    GridViewItemPresenter_DisabledOpacity = 1057,
+    GridViewItemPresenter_DragBackground = 1058,
+    GridViewItemPresenter_DragForeground = 1059,
+    GridViewItemPresenter_DragOpacity = 1060,
+    GridViewItemPresenter_FocusBorderBrush = 1061,
+    GridViewItemPresenter_GridViewItemPresenterHorizontalContentAlignment = 1062,
+    GridViewItemPresenter_GridViewItemPresenterPadding = 1063,
+    GridViewItemPresenter_PlaceholderBackground = 1064,
+    GridViewItemPresenter_PointerOverBackground = 1065,
+    GridViewItemPresenter_PointerOverBackgroundMargin = 1066,
+    GridViewItemPresenter_ReorderHintOffset = 1067,
+    GridViewItemPresenter_SelectedBackground = 1068,
+    GridViewItemPresenter_SelectedBorderThickness = 1069,
+    GridViewItemPresenter_SelectedForeground = 1070,
+    GridViewItemPresenter_SelectedPointerOverBackground = 1071,
+    GridViewItemPresenter_SelectedPointerOverBorderBrush = 1072,
+    GridViewItemPresenter_SelectionCheckMarkVisualEnabled = 1073,
+    GridViewItemPresenter_GridViewItemPresenterVerticalContentAlignment = 1074,
+    ItemsStackPanel_CacheLength = 1076,
+    ItemsStackPanel_GroupHeaderPlacement = 1077,
+    ItemsStackPanel_GroupPadding = 1078,
+    ItemsStackPanel_ItemsUpdatingScrollMode = 1079,
+    ItemsStackPanel_Orientation = 1080,
+    ItemsWrapGrid_CacheLength = 1081,
+    ItemsWrapGrid_GroupHeaderPlacement = 1082,
+    ItemsWrapGrid_GroupPadding = 1083,
+    ItemsWrapGrid_ItemHeight = 1084,
+    ItemsWrapGrid_ItemWidth = 1085,
+    ItemsWrapGrid_MaximumRowsOrColumns = 1086,
+    ItemsWrapGrid_Orientation = 1087,
+    ListViewItemPresenter_CheckBrush = 1088,
+    ListViewItemPresenter_CheckHintBrush = 1089,
+    ListViewItemPresenter_CheckSelectingBrush = 1090,
+    ListViewItemPresenter_ContentMargin = 1091,
+    ListViewItemPresenter_DisabledOpacity = 1092,
+    ListViewItemPresenter_DragBackground = 1093,
+    ListViewItemPresenter_DragForeground = 1094,
+    ListViewItemPresenter_DragOpacity = 1095,
+    ListViewItemPresenter_FocusBorderBrush = 1096,
+    ListViewItemPresenter_ListViewItemPresenterHorizontalContentAlignment = 1097,
+    ListViewItemPresenter_ListViewItemPresenterPadding = 1098,
+    ListViewItemPresenter_PlaceholderBackground = 1099,
+    ListViewItemPresenter_PointerOverBackground = 1100,
+    ListViewItemPresenter_PointerOverBackgroundMargin = 1101,
+    ListViewItemPresenter_ReorderHintOffset = 1102,
+    ListViewItemPresenter_SelectedBackground = 1103,
+    ListViewItemPresenter_SelectedBorderThickness = 1104,
+    ListViewItemPresenter_SelectedForeground = 1105,
+    ListViewItemPresenter_SelectedPointerOverBackground = 1106,
+    ListViewItemPresenter_SelectedPointerOverBorderBrush = 1107,
+    ListViewItemPresenter_SelectionCheckMarkVisualEnabled = 1108,
+    ListViewItemPresenter_ListViewItemPresenterVerticalContentAlignment = 1109,
+    MenuFlyoutItem_Command = 1110,
+    MenuFlyoutItem_CommandParameter = 1111,
+    MenuFlyoutItem_Text = 1112,
+    Page_BottomAppBar = 1114,
+    Page_Frame = 1115,
+    Page_NavigationCacheMode = 1116,
+    Page_TopAppBar = 1117,
+    ProgressBar_IsIndeterminate = 1118,
+    ProgressBar_ShowError = 1119,
+    ProgressBar_ShowPaused = 1120,
+    ProgressBar_TemplateSettings = 1121,
+    ScrollBar_IndicatorMode = 1122,
+    ScrollBar_Orientation = 1123,
+    ScrollBar_ViewportSize = 1124,
+    Selector_IsSynchronizedWithCurrentItem = 1126,
+    Selector_SelectedIndex = 1127,
+    Selector_SelectedItem = 1128,
+    Selector_SelectedValue = 1129,
+    Selector_SelectedValuePath = 1130,
+    SelectorItem_IsSelected = 1131,
+    SettingsFlyout_HeaderBackground = 1132,
+    SettingsFlyout_HeaderForeground = 1133,
+    SettingsFlyout_IconSource = 1134,
+    SettingsFlyout_TemplateSettings = 1135,
+    SettingsFlyout_Title = 1136,
+    Slider_Header = 1137,
+    Slider_HeaderTemplate = 1138,
+    Slider_IntermediateValue = 1139,
+    Slider_IsDirectionReversed = 1140,
+    Slider_IsThumbToolTipEnabled = 1141,
+    Slider_Orientation = 1142,
+    Slider_SnapsTo = 1143,
+    Slider_StepFrequency = 1144,
+    Slider_ThumbToolTipValueConverter = 1145,
+    Slider_TickFrequency = 1146,
+    Slider_TickPlacement = 1147,
+    SwapChainPanel_CompositionScaleX = 1148,
+    SwapChainPanel_CompositionScaleY = 1149,
+    ToolTip_HorizontalOffset = 1150,
+    ToolTip_IsOpen = 1151,
+    ToolTip_Placement = 1152,
+    ToolTip_PlacementTarget = 1153,
+    ToolTip_TemplateSettings = 1154,
+    ToolTip_VerticalOffset = 1155,
+    Button_Flyout = 1156,
+    ComboBox_Header = 1157,
+    ComboBox_HeaderTemplate = 1158,
+    ComboBox_IsDropDownOpen = 1159,
+    ComboBox_IsEditable = 1160,
+    ComboBox_IsSelectionBoxHighlighted = 1161,
+    ComboBox_MaxDropDownHeight = 1162,
+    ComboBox_PlaceholderText = 1163,
+    ComboBox_SelectionBoxItem = 1164,
+    ComboBox_SelectionBoxItemTemplate = 1165,
+    ComboBox_TemplateSettings = 1166,
+    CommandBar_PrimaryCommands = 1167,
+    CommandBar_SecondaryCommands = 1168,
+    FlipView_UseTouchAnimationsForAllNavigation = 1169,
+    HyperlinkButton_NavigateUri = 1170,
+    ListBox_SelectedItems = 1171,
+    ListBox_SelectionMode = 1172,
+    ListViewBase_CanDragItems = 1173,
+    ListViewBase_CanReorderItems = 1174,
+    ListViewBase_DataFetchSize = 1175,
+    ListViewBase_Footer = 1176,
+    ListViewBase_FooterTemplate = 1177,
+    ListViewBase_FooterTransitions = 1178,
+    ListViewBase_Header = 1179,
+    ListViewBase_HeaderTemplate = 1180,
+    ListViewBase_HeaderTransitions = 1181,
+    ListViewBase_IncrementalLoadingThreshold = 1182,
+    ListViewBase_IncrementalLoadingTrigger = 1183,
+    ListViewBase_IsActiveView = 1184,
+    ListViewBase_IsItemClickEnabled = 1185,
+    ListViewBase_IsSwipeEnabled = 1186,
+    ListViewBase_IsZoomedInView = 1187,
+    ListViewBase_ReorderMode = 1188,
+    ListViewBase_SelectedItems = 1189,
+    ListViewBase_SelectionMode = 1190,
+    ListViewBase_SemanticZoomOwner = 1191,
+    ListViewBase_ShowsScrollingPlaceholders = 1192,
+    RepeatButton_Delay = 1193,
+    RepeatButton_Interval = 1194,
+    ScrollViewer_BringIntoViewOnFocusChange = 1195,
+    ScrollViewer_ComputedHorizontalScrollBarVisibility = 1196,
+    ScrollViewer_ComputedVerticalScrollBarVisibility = 1197,
+    ScrollViewer_ExtentHeight = 1198,
+    ScrollViewer_ExtentWidth = 1199,
+    ScrollViewer_HorizontalOffset = 1200,
+    ScrollViewer_HorizontalScrollBarVisibility = 1201,
+    ScrollViewer_HorizontalScrollMode = 1202,
+    ScrollViewer_HorizontalSnapPointsAlignment = 1203,
+    ScrollViewer_HorizontalSnapPointsType = 1204,
+    ScrollViewer_IsDeferredScrollingEnabled = 1205,
+    ScrollViewer_IsHorizontalRailEnabled = 1206,
+    ScrollViewer_IsHorizontalScrollChainingEnabled = 1207,
+    ScrollViewer_IsScrollInertiaEnabled = 1208,
+    ScrollViewer_IsVerticalRailEnabled = 1209,
+    ScrollViewer_IsVerticalScrollChainingEnabled = 1210,
+    ScrollViewer_IsZoomChainingEnabled = 1211,
+    ScrollViewer_IsZoomInertiaEnabled = 1212,
+    ScrollViewer_LeftHeader = 1213,
+    ScrollViewer_MaxZoomFactor = 1214,
+    ScrollViewer_MinZoomFactor = 1215,
+    ScrollViewer_ScrollableHeight = 1216,
+    ScrollViewer_ScrollableWidth = 1217,
+    ScrollViewer_TopHeader = 1218,
+    ScrollViewer_TopLeftHeader = 1219,
+    ScrollViewer_VerticalOffset = 1220,
+    ScrollViewer_VerticalScrollBarVisibility = 1221,
+    ScrollViewer_VerticalScrollMode = 1222,
+    ScrollViewer_VerticalSnapPointsAlignment = 1223,
+    ScrollViewer_VerticalSnapPointsType = 1224,
+    ScrollViewer_ViewportHeight = 1225,
+    ScrollViewer_ViewportWidth = 1226,
+    ScrollViewer_ZoomFactor = 1227,
+    ScrollViewer_ZoomMode = 1228,
+    ScrollViewer_ZoomSnapPoints = 1229,
+    ScrollViewer_ZoomSnapPointsType = 1230,
+    ToggleButton_IsChecked = 1231,
+    ToggleButton_IsThreeState = 1232,
+    ToggleMenuFlyoutItem_IsChecked = 1233,
+    VirtualizingStackPanel_AreScrollSnapPointsRegular = 1234,
+    VirtualizingStackPanel_IsVirtualizing = 1236,
+    VirtualizingStackPanel_Orientation = 1237,
+    VirtualizingStackPanel_VirtualizationMode = 1238,
+    WrapGrid_HorizontalChildrenAlignment = 1239,
+    WrapGrid_ItemHeight = 1240,
+    WrapGrid_ItemWidth = 1241,
+    WrapGrid_MaximumRowsOrColumns = 1242,
+    WrapGrid_Orientation = 1243,
+    WrapGrid_VerticalChildrenAlignment = 1244,
+    AppBarButton_Icon = 1245,
+    AppBarButton_IsCompact = 1246,
+    AppBarButton_Label = 1247,
+    AppBarToggleButton_Icon = 1248,
+    AppBarToggleButton_IsCompact = 1249,
+    AppBarToggleButton_Label = 1250,
+    GridViewItem_TemplateSettings = 1251,
+    ListViewItem_TemplateSettings = 1252,
+    RadioButton_GroupName = 1253,
+    Glyphs_ColorFontPaletteIndex = 1267,
+    Glyphs_IsColorFontEnabled = 1268,
+    CalendarViewTemplateSettings_HasMoreContentAfter = 1274,
+    CalendarViewTemplateSettings_HasMoreContentBefore = 1275,
+    CalendarViewTemplateSettings_HasMoreViews = 1276,
+    CalendarViewTemplateSettings_HeaderText = 1277,
+    CalendarViewTemplateSettings_WeekDay1 = 1280,
+    CalendarViewTemplateSettings_WeekDay2 = 1281,
+    CalendarViewTemplateSettings_WeekDay3 = 1282,
+    CalendarViewTemplateSettings_WeekDay4 = 1283,
+    CalendarViewTemplateSettings_WeekDay5 = 1284,
+    CalendarViewTemplateSettings_WeekDay6 = 1285,
+    CalendarViewTemplateSettings_WeekDay7 = 1286,
+    CalendarView_CalendarIdentifier = 1291,
+    CalendarView_DayOfWeekFormat = 1299,
+    CalendarView_DisplayMode = 1302,
+    CalendarView_FirstDayOfWeek = 1303,
+    CalendarView_IsOutOfScopeEnabled = 1317,
+    CalendarView_IsTodayHighlighted = 1318,
+    CalendarView_MaxDate = 1320,
+    CalendarView_MinDate = 1321,
+    CalendarView_NumberOfWeeksInView = 1327,
+    CalendarView_SelectedDates = 1333,
+    CalendarView_SelectionMode = 1335,
+    CalendarView_TemplateSettings = 1336,
+    CalendarViewDayItem_Date = 1339,
+    CalendarViewDayItem_IsBlackout = 1340,
+    MediaTransportControls_IsFastForwardEnabled = 1382,
+    MediaTransportControls_IsFastRewindEnabled = 1383,
+    MediaTransportControls_IsFullWindowEnabled = 1384,
+    MediaTransportControls_IsPlaybackRateEnabled = 1385,
+    MediaTransportControls_IsSeekEnabled = 1386,
+    MediaTransportControls_IsStopEnabled = 1387,
+    MediaTransportControls_IsVolumeEnabled = 1388,
+    MediaTransportControls_IsZoomEnabled = 1389,
+    ContentPresenter_LineHeight = 1425,
+    CalendarViewTemplateSettings_MinViewWidth = 1435,
+    ListViewBase_SelectedRanges = 1459,
+    SplitViewTemplateSettings_CompactPaneGridLength = 1462,
+    SplitViewTemplateSettings_NegativeOpenPaneLength = 1463,
+    SplitViewTemplateSettings_NegativeOpenPaneLengthMinusCompactLength = 1464,
+    SplitViewTemplateSettings_OpenPaneGridLength = 1465,
+    SplitViewTemplateSettings_OpenPaneLengthMinusCompactLength = 1466,
+    SplitView_CompactPaneLength = 1467,
+    SplitView_Content = 1468,
+    SplitView_DisplayMode = 1469,
+    SplitView_IsPaneOpen = 1470,
+    SplitView_OpenPaneLength = 1471,
+    SplitView_Pane = 1472,
+    SplitView_PanePlacement = 1473,
+    SplitView_TemplateSettings = 1474,
+    UIElement_Transform3D = 1475,
+    CompositeTransform3D_CenterX = 1476,
+    CompositeTransform3D_CenterY = 1478,
+    CompositeTransform3D_CenterZ = 1480,
+    CompositeTransform3D_RotationX = 1482,
+    CompositeTransform3D_RotationY = 1484,
+    CompositeTransform3D_RotationZ = 1486,
+    CompositeTransform3D_ScaleX = 1488,
+    CompositeTransform3D_ScaleY = 1490,
+    CompositeTransform3D_ScaleZ = 1492,
+    CompositeTransform3D_TranslateX = 1494,
+    CompositeTransform3D_TranslateY = 1496,
+    CompositeTransform3D_TranslateZ = 1498,
+    PerspectiveTransform3D_Depth = 1500,
+    PerspectiveTransform3D_OffsetX = 1501,
+    PerspectiveTransform3D_OffsetY = 1502,
+    RelativePanel_Above = 1508,
+    RelativePanel_AlignBottomWith = 1509,
+    RelativePanel_AlignLeftWith = 1510,
+    RelativePanel_AlignRightWith = 1515,
+    RelativePanel_AlignTopWith = 1516,
+    RelativePanel_Below = 1517,
+    RelativePanel_LeftOf = 1520,
+    RelativePanel_RightOf = 1521,
+    SplitViewTemplateSettings_OpenPaneLength = 1524,
+    PasswordBox_PasswordRevealMode = 1527,
+    SplitView_PaneBackground = 1528,
+    ItemsStackPanel_AreStickyGroupHeadersEnabled = 1529,
+    ItemsWrapGrid_AreStickyGroupHeadersEnabled = 1530,
+    MenuFlyoutSubItem_Items = 1531,
+    MenuFlyoutSubItem_Text = 1532,
+    UIElement_CanDrag = 1534,
+    DataTemplate_ExtensionInstance = 1535,
+    RelativePanel_AlignHorizontalCenterWith = 1552,
+    RelativePanel_AlignVerticalCenterWith = 1553,
+    TargetPropertyPath_Path = 1555,
+    TargetPropertyPath_Target = 1556,
+    VisualState_Setters = 1558,
+    VisualState_StateTriggers = 1559,
+    AdaptiveTrigger_MinWindowHeight = 1560,
+    AdaptiveTrigger_MinWindowWidth = 1561,
+    Setter_Target = 1562,
+    CalendarView_BlackoutForeground = 1565,
+    CalendarView_CalendarItemBackground = 1566,
+    CalendarView_CalendarItemBorderBrush = 1567,
+    CalendarView_CalendarItemBorderThickness = 1568,
+    CalendarView_CalendarItemForeground = 1569,
+    CalendarView_CalendarViewDayItemStyle = 1570,
+    CalendarView_DayItemFontFamily = 1571,
+    CalendarView_DayItemFontSize = 1572,
+    CalendarView_DayItemFontStyle = 1573,
+    CalendarView_DayItemFontWeight = 1574,
+    CalendarView_FirstOfMonthLabelFontFamily = 1575,
+    CalendarView_FirstOfMonthLabelFontSize = 1576,
+    CalendarView_FirstOfMonthLabelFontStyle = 1577,
+    CalendarView_FirstOfMonthLabelFontWeight = 1578,
+    CalendarView_FirstOfYearDecadeLabelFontFamily = 1579,
+    CalendarView_FirstOfYearDecadeLabelFontSize = 1580,
+    CalendarView_FirstOfYearDecadeLabelFontStyle = 1581,
+    CalendarView_FirstOfYearDecadeLabelFontWeight = 1582,
+    CalendarView_FocusBorderBrush = 1583,
+    CalendarView_HorizontalDayItemAlignment = 1584,
+    CalendarView_HorizontalFirstOfMonthLabelAlignment = 1585,
+    CalendarView_HoverBorderBrush = 1586,
+    CalendarView_MonthYearItemFontFamily = 1588,
+    CalendarView_MonthYearItemFontSize = 1589,
+    CalendarView_MonthYearItemFontStyle = 1590,
+    CalendarView_MonthYearItemFontWeight = 1591,
+    CalendarView_OutOfScopeBackground = 1592,
+    CalendarView_OutOfScopeForeground = 1593,
+    CalendarView_PressedBorderBrush = 1594,
+    CalendarView_PressedForeground = 1595,
+    CalendarView_SelectedBorderBrush = 1596,
+    CalendarView_SelectedForeground = 1597,
+    CalendarView_SelectedHoverBorderBrush = 1598,
+    CalendarView_SelectedPressedBorderBrush = 1599,
+    CalendarView_TodayFontWeight = 1600,
+    CalendarView_TodayForeground = 1601,
+    CalendarView_VerticalDayItemAlignment = 1602,
+    CalendarView_VerticalFirstOfMonthLabelAlignment = 1603,
+    MediaTransportControls_IsCompact = 1605,
+    RelativePanel_AlignBottomWithPanel = 1606,
+    RelativePanel_AlignHorizontalCenterWithPanel = 1607,
+    RelativePanel_AlignLeftWithPanel = 1608,
+    RelativePanel_AlignRightWithPanel = 1609,
+    RelativePanel_AlignTopWithPanel = 1610,
+    RelativePanel_AlignVerticalCenterWithPanel = 1611,
+    ListViewBase_IsMultiSelectCheckBoxEnabled = 1612,
+    AutomationProperties_Level = 1614,
+    AutomationProperties_PositionInSet = 1615,
+    AutomationProperties_SizeOfSet = 1616,
+    ListViewItemPresenter_CheckBoxBrush = 1617,
+    ListViewItemPresenter_CheckMode = 1618,
+    ListViewItemPresenter_PressedBackground = 1620,
+    ListViewItemPresenter_SelectedPressedBackground = 1621,
+    Control_IsTemplateFocusTarget = 1623,
+    Control_UseSystemFocusVisuals = 1624,
+    ListViewItemPresenter_FocusSecondaryBorderBrush = 1628,
+    ListViewItemPresenter_PointerOverForeground = 1630,
+    FontIcon_MirroredWhenRightToLeft = 1631,
+    CalendarViewTemplateSettings_CenterX = 1632,
+    CalendarViewTemplateSettings_CenterY = 1633,
+    CalendarViewTemplateSettings_ClipRect = 1634,
+    PasswordBox_TextReadingOrder = 1650,
+    RichEditBox_TextReadingOrder = 1651,
+    TextBox_TextReadingOrder = 1652,
+    WebView_ExecutionMode = 1653,
+    WebView_DeferredPermissionRequests = 1655,
+    WebView_Settings = 1656,
+    RichEditBox_DesiredCandidateWindowAlignment = 1660,
+    TextBox_DesiredCandidateWindowAlignment = 1662,
+    CalendarDatePicker_CalendarIdentifier = 1663,
+    CalendarDatePicker_CalendarViewStyle = 1664,
+    CalendarDatePicker_Date = 1665,
+    CalendarDatePicker_DateFormat = 1666,
+    CalendarDatePicker_DayOfWeekFormat = 1667,
+    CalendarDatePicker_DisplayMode = 1668,
+    CalendarDatePicker_FirstDayOfWeek = 1669,
+    CalendarDatePicker_Header = 1670,
+    CalendarDatePicker_HeaderTemplate = 1671,
+    CalendarDatePicker_IsCalendarOpen = 1672,
+    CalendarDatePicker_IsGroupLabelVisible = 1673,
+    CalendarDatePicker_IsOutOfScopeEnabled = 1674,
+    CalendarDatePicker_IsTodayHighlighted = 1675,
+    CalendarDatePicker_MaxDate = 1676,
+    CalendarDatePicker_MinDate = 1677,
+    CalendarDatePicker_PlaceholderText = 1678,
+    CalendarView_IsGroupLabelVisible = 1679,
+    ContentPresenter_Background = 1680,
+    ContentPresenter_BorderBrush = 1681,
+    ContentPresenter_BorderThickness = 1682,
+    ContentPresenter_CornerRadius = 1683,
+    ContentPresenter_Padding = 1684,
+    Grid_BorderBrush = 1685,
+    Grid_BorderThickness = 1686,
+    Grid_CornerRadius = 1687,
+    Grid_Padding = 1688,
+    RelativePanel_BorderBrush = 1689,
+    RelativePanel_BorderThickness = 1690,
+    RelativePanel_CornerRadius = 1691,
+    RelativePanel_Padding = 1692,
+    StackPanel_BorderBrush = 1693,
+    StackPanel_BorderThickness = 1694,
+    StackPanel_CornerRadius = 1695,
+    StackPanel_Padding = 1696,
+    PasswordBox_InputScope = 1697,
+    MediaTransportControlsHelper_DropoutOrder = 1698,
+    AutoSuggestBoxQuerySubmittedEventArgs_ChosenSuggestion = 1699,
+    AutoSuggestBoxQuerySubmittedEventArgs_QueryText = 1700,
+    AutoSuggestBox_QueryIcon = 1701,
+    StateTrigger_IsActive = 1702,
+    ContentPresenter_HorizontalContentAlignment = 1703,
+    ContentPresenter_VerticalContentAlignment = 1704,
+    AppBarTemplateSettings_ClipRect = 1705,
+    AppBarTemplateSettings_CompactRootMargin = 1706,
+    AppBarTemplateSettings_CompactVerticalDelta = 1707,
+    AppBarTemplateSettings_HiddenRootMargin = 1708,
+    AppBarTemplateSettings_HiddenVerticalDelta = 1709,
+    AppBarTemplateSettings_MinimalRootMargin = 1710,
+    AppBarTemplateSettings_MinimalVerticalDelta = 1711,
+    CommandBarTemplateSettings_ContentHeight = 1712,
+    CommandBarTemplateSettings_NegativeOverflowContentHeight = 1713,
+    CommandBarTemplateSettings_OverflowContentClipRect = 1714,
+    CommandBarTemplateSettings_OverflowContentHeight = 1715,
+    CommandBarTemplateSettings_OverflowContentHorizontalOffset = 1716,
+    CommandBarTemplateSettings_OverflowContentMaxHeight = 1717,
+    CommandBarTemplateSettings_OverflowContentMinWidth = 1718,
+    AppBar_TemplateSettings = 1719,
+    CommandBar_CommandBarOverflowPresenterStyle = 1720,
+    CommandBar_CommandBarTemplateSettings = 1721,
+    DrillInThemeAnimation_EntranceTarget = 1722,
+    DrillInThemeAnimation_EntranceTargetName = 1723,
+    DrillInThemeAnimation_ExitTarget = 1724,
+    DrillInThemeAnimation_ExitTargetName = 1725,
+    DrillOutThemeAnimation_EntranceTarget = 1726,
+    DrillOutThemeAnimation_EntranceTargetName = 1727,
+    DrillOutThemeAnimation_ExitTarget = 1728,
+    DrillOutThemeAnimation_ExitTargetName = 1729,
+    XamlBindingHelper_DataTemplateComponent = 1730,
+    AutomationProperties_Annotations = 1732,
+    AutomationAnnotation_Element = 1733,
+    AutomationAnnotation_Type = 1734,
+    AutomationPeerAnnotation_Peer = 1735,
+    AutomationPeerAnnotation_Type = 1736,
+    Hyperlink_UnderlineStyle = 1741,
+    CalendarView_DisabledForeground = 1742,
+    CalendarView_TodayBackground = 1743,
+    CalendarView_TodayBlackoutBackground = 1744,
+    CalendarView_TodaySelectedInnerBorderBrush = 1747,
+    Control_IsFocusEngaged = 1749,
+    Control_IsFocusEngagementEnabled = 1752,
+    RichEditBox_ClipboardCopyFormat = 1754,
+    CommandBarTemplateSettings_OverflowContentMaxWidth = 1757,
+    ComboBoxTemplateSettings_DropDownContentMinWidth = 1758,
+    MenuFlyoutPresenterTemplateSettings_FlyoutContentMinWidth = 1762,
+    MenuFlyoutPresenter_TemplateSettings = 1763,
+    AutomationProperties_LandmarkType = 1766,
+    AutomationProperties_LocalizedLandmarkType = 1767,
+    RepositionThemeTransition_IsStaggeringEnabled = 1769,
+    ListBox_SingleSelectionFollowsFocus = 1770,
+    ListViewBase_SingleSelectionFollowsFocus = 1771,
+    BitmapImage_AutoPlay = 1773,
+    BitmapImage_IsAnimatedBitmap = 1774,
+    BitmapImage_IsPlaying = 1775,
+    AutomationProperties_FullDescription = 1776,
+    AutomationProperties_IsDataValidForForm = 1777,
+    AutomationProperties_IsPeripheral = 1778,
+    AutomationProperties_LocalizedControlType = 1779,
+    FlyoutBase_AllowFocusOnInteraction = 1780,
+    TextElement_AllowFocusOnInteraction = 1781,
+    FrameworkElement_AllowFocusOnInteraction = 1782,
+    Control_RequiresPointer = 1783,
+    UIElement_ContextFlyout = 1785,
+    TextElement_AccessKey = 1786,
+    UIElement_AccessKeyScopeOwner = 1787,
+    UIElement_IsAccessKeyScope = 1788,
+    AutomationProperties_DescribedBy = 1790,
+    UIElement_AccessKey = 1803,
+    Control_XYFocusDown = 1804,
+    Control_XYFocusLeft = 1805,
+    Control_XYFocusRight = 1806,
+    Control_XYFocusUp = 1807,
+    Hyperlink_XYFocusDown = 1808,
+    Hyperlink_XYFocusLeft = 1809,
+    Hyperlink_XYFocusRight = 1810,
+    Hyperlink_XYFocusUp = 1811,
+    WebView_XYFocusDown = 1812,
+    WebView_XYFocusLeft = 1813,
+    WebView_XYFocusRight = 1814,
+    WebView_XYFocusUp = 1815,
+    CommandBarTemplateSettings_EffectiveOverflowButtonVisibility = 1816,
+    AppBarSeparator_IsInOverflow = 1817,
+    CommandBar_DefaultLabelPosition = 1818,
+    CommandBar_IsDynamicOverflowEnabled = 1819,
+    CommandBar_OverflowButtonVisibility = 1820,
+    AppBarButton_IsInOverflow = 1821,
+    AppBarButton_LabelPosition = 1822,
+    AppBarToggleButton_IsInOverflow = 1823,
+    AppBarToggleButton_LabelPosition = 1824,
+    FlyoutBase_LightDismissOverlayMode = 1825,
+    Popup_LightDismissOverlayMode = 1827,
+    CalendarDatePicker_LightDismissOverlayMode = 1829,
+    DatePicker_LightDismissOverlayMode = 1830,
+    SplitView_LightDismissOverlayMode = 1831,
+    TimePicker_LightDismissOverlayMode = 1832,
+    AppBar_LightDismissOverlayMode = 1833,
+    AutoSuggestBox_LightDismissOverlayMode = 1834,
+    ComboBox_LightDismissOverlayMode = 1835,
+    AppBarSeparator_DynamicOverflowOrder = 1836,
+    AppBarButton_DynamicOverflowOrder = 1837,
+    AppBarToggleButton_DynamicOverflowOrder = 1838,
+    FrameworkElement_FocusVisualMargin = 1839,
+    FrameworkElement_FocusVisualPrimaryBrush = 1840,
+    FrameworkElement_FocusVisualPrimaryThickness = 1841,
+    FrameworkElement_FocusVisualSecondaryBrush = 1842,
+    FrameworkElement_FocusVisualSecondaryThickness = 1843,
+    FlyoutBase_AllowFocusWhenDisabled = 1846,
+    FrameworkElement_AllowFocusWhenDisabled = 1847,
+    ComboBox_IsTextSearchEnabled = 1848,
+    TextElement_ExitDisplayModeOnAccessKeyInvoked = 1849,
+    UIElement_ExitDisplayModeOnAccessKeyInvoked = 1850,
+    MediaPlayerPresenter_IsFullWindow = 1851,
+    MediaPlayerPresenter_MediaPlayer = 1852,
+    MediaPlayerPresenter_Stretch = 1853,
+    MediaPlayerElement_AreTransportControlsEnabled = 1854,
+    MediaPlayerElement_AutoPlay = 1855,
+    MediaPlayerElement_IsFullWindow = 1856,
+    MediaPlayerElement_MediaPlayer = 1857,
+    MediaPlayerElement_PosterSource = 1858,
+    MediaPlayerElement_Source = 1859,
+    MediaPlayerElement_Stretch = 1860,
+    MediaPlayerElement_TransportControls = 1861,
+    MediaTransportControls_FastPlayFallbackBehaviour = 1862,
+    MediaTransportControls_IsNextTrackButtonVisible = 1863,
+    MediaTransportControls_IsPreviousTrackButtonVisible = 1864,
+    MediaTransportControls_IsSkipBackwardButtonVisible = 1865,
+    MediaTransportControls_IsSkipBackwardEnabled = 1866,
+    MediaTransportControls_IsSkipForwardButtonVisible = 1867,
+    MediaTransportControls_IsSkipForwardEnabled = 1868,
+    FlyoutBase_ElementSoundMode = 1869,
+    Control_ElementSoundMode = 1870,
+    Hyperlink_ElementSoundMode = 1871,
+    AutomationProperties_FlowsFrom = 1876,
+    AutomationProperties_FlowsTo = 1877,
+    TextElement_TextDecorations = 1879,
+    RichTextBlock_TextDecorations = 1881,
+    Control_DefaultStyleResourceUri = 1882,
+    ContentDialog_PrimaryButtonStyle = 1884,
+    ContentDialog_SecondaryButtonStyle = 1885,
+    TextElement_KeyTipHorizontalOffset = 1890,
+    TextElement_KeyTipPlacementMode = 1891,
+    TextElement_KeyTipVerticalOffset = 1892,
+    UIElement_KeyTipHorizontalOffset = 1893,
+    UIElement_KeyTipPlacementMode = 1894,
+    UIElement_KeyTipVerticalOffset = 1895,
+    FlyoutBase_OverlayInputPassThroughElement = 1896,
+    UIElement_XYFocusKeyboardNavigation = 1897,
+    AutomationProperties_Culture = 1898,
+    UIElement_XYFocusDownNavigationStrategy = 1918,
+    UIElement_XYFocusLeftNavigationStrategy = 1919,
+    UIElement_XYFocusRightNavigationStrategy = 1920,
+    UIElement_XYFocusUpNavigationStrategy = 1921,
+    Hyperlink_XYFocusDownNavigationStrategy = 1922,
+    Hyperlink_XYFocusLeftNavigationStrategy = 1923,
+    Hyperlink_XYFocusRightNavigationStrategy = 1924,
+    Hyperlink_XYFocusUpNavigationStrategy = 1925,
+    TextElement_AccessKeyScopeOwner = 1926,
+    TextElement_IsAccessKeyScope = 1927,
+    Hyperlink_FocusState = 1934,
+    ContentDialog_CloseButtonCommand = 1936,
+    ContentDialog_CloseButtonCommandParameter = 1937,
+    ContentDialog_CloseButtonStyle = 1938,
+    ContentDialog_CloseButtonText = 1939,
+    ContentDialog_DefaultButton = 1940,
+    RichEditBox_SelectionHighlightColorWhenNotFocused = 1941,
+    TextBox_SelectionHighlightColorWhenNotFocused = 1942,
+    SvgImageSource_RasterizePixelHeight = 1948,
+    SvgImageSource_RasterizePixelWidth = 1949,
+    SvgImageSource_UriSource = 1950,
+    LoadedImageSurface_DecodedPhysicalSize = 1955,
+    LoadedImageSurface_DecodedSize = 1956,
+    LoadedImageSurface_NaturalSize = 1957,
+    ComboBox_SelectionChangedTrigger = 1958,
+    XamlCompositionBrushBase_FallbackColor = 1960,
+    UIElement_Lights = 1962,
+    MenuFlyoutItem_Icon = 1963,
+    MenuFlyoutSubItem_Icon = 1964,
+    BitmapIcon_ShowAsMonochrome = 1965,
+    UIElement_HighContrastAdjustment = 1967,
+    RichEditBox_MaxLength = 1968,
+    UIElement_TabFocusNavigation = 1969,
+    Control_IsTemplateKeyTipTarget = 1970,
+    Hyperlink_IsTabStop = 1972,
+    Hyperlink_TabIndex = 1973,
+    MediaTransportControls_IsRepeatButtonVisible = 1974,
+    MediaTransportControls_IsRepeatEnabled = 1975,
+    MediaTransportControls_ShowAndHideAutomatically = 1976,
+    RichEditBox_DisabledFormattingAccelerators = 1977,
+    RichEditBox_CharacterCasing = 1978,
+    TextBox_CharacterCasing = 1979,
+    RichTextBlock_IsTextTrimmed = 1980,
+    RichTextBlockOverflow_IsTextTrimmed = 1981,
+    TextBlock_IsTextTrimmed = 1982,
+    TextHighlighter_Background = 1985,
+    TextHighlighter_Foreground = 1986,
+    TextHighlighter_Ranges = 1987,
+    RichTextBlock_TextHighlighters = 1988,
+    TextBlock_TextHighlighters = 1989,
+    FrameworkElement_ActualTheme = 1992,
+    Grid_ColumnSpacing = 1993,
+    Grid_RowSpacing = 1994,
+    StackPanel_Spacing = 1995,
+    Block_HorizontalTextAlignment = 1996,
+    RichTextBlock_HorizontalTextAlignment = 1997,
+    TextBlock_HorizontalTextAlignment = 1998,
+    RichEditBox_HorizontalTextAlignment = 1999,
+    TextBox_HorizontalTextAlignment = 2000,
+    TextBox_PlaceholderForeground = 2001,
+    ComboBox_PlaceholderForeground = 2002,
+    KeyboardAccelerator_IsEnabled = 2003,
+    KeyboardAccelerator_Key = 2004,
+    KeyboardAccelerator_Modifiers = 2005,
+    KeyboardAccelerator_ScopeOwner = 2006,
+    UIElement_KeyboardAccelerators = 2007,
+    ListViewItemPresenter_RevealBackground = 2009,
+    ListViewItemPresenter_RevealBackgroundShowsAboveContent = 2010,
+    ListViewItemPresenter_RevealBorderBrush = 2011,
+    ListViewItemPresenter_RevealBorderThickness = 2012,
+    UIElement_KeyTipTarget = 2014,
+    AppBarButtonTemplateSettings_KeyboardAcceleratorTextMinWidth = 2015,
+    AppBarToggleButtonTemplateSettings_KeyboardAcceleratorTextMinWidth = 2016,
+    MenuFlyoutItemTemplateSettings_KeyboardAcceleratorTextMinWidth = 2017,
+    MenuFlyoutItem_TemplateSettings = 2019,
+    AppBarButton_TemplateSettings = 2021,
+    AppBarToggleButton_TemplateSettings = 2023,
+    UIElement_KeyboardAcceleratorPlacementMode = 2028,
+    MediaTransportControls_IsCompactOverlayButtonVisible = 2032,
+    MediaTransportControls_IsCompactOverlayEnabled = 2033,
+    UIElement_KeyboardAcceleratorPlacementTarget = 2061,
+    UIElement_CenterPoint = 2062,
+    UIElement_Rotation = 2063,
+    UIElement_RotationAxis = 2064,
+    UIElement_Scale = 2065,
+    UIElement_TransformMatrix = 2066,
+    UIElement_Translation = 2067,
+    TextBox_HandwritingView = 2068,
+    AutomationProperties_HeadingLevel = 2069,
+    TextBox_IsHandwritingViewEnabled = 2076,
+    RichEditBox_ContentLinkProviders = 2078,
+    RichEditBox_ContentLinkBackgroundColor = 2079,
+    RichEditBox_ContentLinkForegroundColor = 2080,
+    HandwritingView_AreCandidatesEnabled = 2081,
+    HandwritingView_IsOpen = 2082,
+    HandwritingView_PlacementTarget = 2084,
+    HandwritingView_PlacementAlignment = 2085,
+    RichEditBox_HandwritingView = 2086,
+    RichEditBox_IsHandwritingViewEnabled = 2087,
+    MenuFlyoutItem_KeyboardAcceleratorTextOverride = 2090,
+    AppBarButton_KeyboardAcceleratorTextOverride = 2091,
+    AppBarToggleButton_KeyboardAcceleratorTextOverride = 2092,
+    ContentLink_Background = 2093,
+    ContentLink_Cursor = 2094,
+    ContentLink_ElementSoundMode = 2095,
+    ContentLink_FocusState = 2096,
+    ContentLink_IsTabStop = 2097,
+    ContentLink_TabIndex = 2098,
+    ContentLink_XYFocusDown = 2099,
+    ContentLink_XYFocusDownNavigationStrategy = 2100,
+    ContentLink_XYFocusLeft = 2101,
+    ContentLink_XYFocusLeftNavigationStrategy = 2102,
+    ContentLink_XYFocusRight = 2103,
+    ContentLink_XYFocusRightNavigationStrategy = 2104,
+    ContentLink_XYFocusUp = 2105,
+    ContentLink_XYFocusUpNavigationStrategy = 2106,
+    IconSource_Foreground = 2112,
+    BitmapIconSource_ShowAsMonochrome = 2113,
+    BitmapIconSource_UriSource = 2114,
+    FontIconSource_FontFamily = 2115,
+    FontIconSource_FontSize = 2116,
+    FontIconSource_FontStyle = 2117,
+    FontIconSource_FontWeight = 2118,
+    FontIconSource_Glyph = 2119,
+    FontIconSource_IsTextScaleFactorEnabled = 2120,
+    FontIconSource_MirroredWhenRightToLeft = 2121,
+    PathIconSource_Data = 2122,
+    SymbolIconSource_Symbol = 2123,
+    UIElement_Shadow = 2130,
+    IconSourceElement_IconSource = 2131,
+    PasswordBox_CanPasteClipboardContent = 2137,
+    TextBox_CanPasteClipboardContent = 2138,
+    TextBox_CanRedo = 2139,
+    TextBox_CanUndo = 2140,
+    FlyoutBase_ShowMode = 2141,
+    FlyoutBase_Target = 2142,
+    Control_CornerRadius = 2143,
+    AutomationProperties_IsDialog = 2149,
+    AppBarElementContainer_DynamicOverflowOrder = 2150,
+    AppBarElementContainer_IsCompact = 2151,
+    AppBarElementContainer_IsInOverflow = 2152,
+    ScrollContentPresenter_CanContentRenderOutsideBounds = 2157,
+    ScrollViewer_CanContentRenderOutsideBounds = 2158,
+    RichEditBox_SelectionFlyout = 2159,
+    TextBox_SelectionFlyout = 2160,
+    Border_BackgroundSizing = 2161,
+    ContentPresenter_BackgroundSizing = 2162,
+    Control_BackgroundSizing = 2163,
+    Grid_BackgroundSizing = 2164,
+    RelativePanel_BackgroundSizing = 2165,
+    StackPanel_BackgroundSizing = 2166,
+    ScrollViewer_HorizontalAnchorRatio = 2170,
+    ScrollViewer_VerticalAnchorRatio = 2171,
+    ComboBox_Text = 2208,
+    TextBox_Description = 2217,
+    ToolTip_PlacementRect = 2218,
+    RichTextBlock_SelectionFlyout = 2219,
+    TextBlock_SelectionFlyout = 2220,
+    PasswordBox_SelectionFlyout = 2221,
+    Border_BackgroundTransition = 2222,
+    ContentPresenter_BackgroundTransition = 2223,
+    Panel_BackgroundTransition = 2224,
+    ColorPaletteResources_Accent = 2227,
+    ColorPaletteResources_AltHigh = 2228,
+    ColorPaletteResources_AltLow = 2229,
+    ColorPaletteResources_AltMedium = 2230,
+    ColorPaletteResources_AltMediumHigh = 2231,
+    ColorPaletteResources_AltMediumLow = 2232,
+    ColorPaletteResources_BaseHigh = 2233,
+    ColorPaletteResources_BaseLow = 2234,
+    ColorPaletteResources_BaseMedium = 2235,
+    ColorPaletteResources_BaseMediumHigh = 2236,
+    ColorPaletteResources_BaseMediumLow = 2237,
+    ColorPaletteResources_ChromeAltLow = 2238,
+    ColorPaletteResources_ChromeBlackHigh = 2239,
+    ColorPaletteResources_ChromeBlackLow = 2240,
+    ColorPaletteResources_ChromeBlackMedium = 2241,
+    ColorPaletteResources_ChromeBlackMediumLow = 2242,
+    ColorPaletteResources_ChromeDisabledHigh = 2243,
+    ColorPaletteResources_ChromeDisabledLow = 2244,
+    ColorPaletteResources_ChromeGray = 2245,
+    ColorPaletteResources_ChromeHigh = 2246,
+    ColorPaletteResources_ChromeLow = 2247,
+    ColorPaletteResources_ChromeMedium = 2248,
+    ColorPaletteResources_ChromeMediumLow = 2249,
+    ColorPaletteResources_ChromeWhite = 2250,
+    ColorPaletteResources_ErrorText = 2252,
+    ColorPaletteResources_ListLow = 2253,
+    ColorPaletteResources_ListMedium = 2254,
+    UIElement_TranslationTransition = 2255,
+    UIElement_OpacityTransition = 2256,
+    UIElement_RotationTransition = 2257,
+    UIElement_ScaleTransition = 2258,
+    BrushTransition_Duration = 2261,
+    ScalarTransition_Duration = 2262,
+    Vector3Transition_Duration = 2263,
+    Vector3Transition_Components = 2266,
+    FlyoutBase_IsOpen = 2267,
+    StandardUICommand_Kind = 2275,
+    UIElement_CanBeScrollAnchor = 2276,
+    ThemeShadow_Receivers = 2279,
+    ScrollContentPresenter_SizesContentToTemplatedParent = 2280,
+    ComboBox_TextBoxStyle = 2281,
+    Frame_IsNavigationStackEnabled = 2282,
+    RichEditBox_ProofingMenuFlyout = 2283,
+    TextBox_ProofingMenuFlyout = 2284,
+    ScrollViewer_ReduceViewportForCoreInputViewOcclusions = 2295,
+    FlyoutBase_AreOpenCloseAnimationsEnabled = 2296,
+    FlyoutBase_InputDevicePrefersPrimaryCommands = 2297,
+    CalendarDatePicker_Description = 2300,
+    PasswordBox_Description = 2308,
+    RichEditBox_Description = 2316,
+    AutoSuggestBox_Description = 2331,
+    ComboBox_Description = 2339,
+    XamlUICommand_AccessKey = 2347,
+    XamlUICommand_Command = 2348,
+    XamlUICommand_Description = 2349,
+    XamlUICommand_IconSource = 2350,
+    XamlUICommand_KeyboardAccelerators = 2351,
+    XamlUICommand_Label = 2352,
+    DatePicker_SelectedDate = 2355,
+    TimePicker_SelectedTime = 2356,
+    AppBarTemplateSettings_NegativeCompactVerticalDelta = 2367,
+    AppBarTemplateSettings_NegativeHiddenVerticalDelta = 2368,
+    AppBarTemplateSettings_NegativeMinimalVerticalDelta = 2369,
+    FlyoutBase_ShouldConstrainToRootBounds = 2378,
+    Popup_ShouldConstrainToRootBounds = 2379,
+    FlyoutPresenter_IsDefaultShadowEnabled = 2380,
+    MenuFlyoutPresenter_IsDefaultShadowEnabled = 2381,
+    UIElement_ActualOffset = 2382,
+    UIElement_ActualSize = 2383,
+    CommandBarTemplateSettings_OverflowContentCompactYTranslation = 2384,
+    CommandBarTemplateSettings_OverflowContentHiddenYTranslation = 2385,
+    CommandBarTemplateSettings_OverflowContentMinimalYTranslation = 2386,
+    HandwritingView_IsCommandBarOpen = 2395,
+    HandwritingView_IsSwitchToKeyboardEnabled = 2396,
+    ListViewItemPresenter_SelectionIndicatorVisualEnabled = 2399,
+    ListViewItemPresenter_SelectionIndicatorBrush = 2400,
+    ListViewItemPresenter_SelectionIndicatorMode = 2401,
+    ListViewItemPresenter_SelectionIndicatorPointerOverBrush = 2402,
+    ListViewItemPresenter_SelectionIndicatorPressedBrush = 2403,
+    ListViewItemPresenter_SelectedBorderBrush = 2410,
+    ListViewItemPresenter_SelectedInnerBorderBrush = 2411,
+    ListViewItemPresenter_CheckBoxCornerRadius = 2412,
+    ListViewItemPresenter_SelectionIndicatorCornerRadius = 2413,
+    ListViewItemPresenter_SelectedDisabledBorderBrush = 2414,
+    ListViewItemPresenter_SelectedPressedBorderBrush = 2415,
+    ListViewItemPresenter_SelectedDisabledBackground = 2416,
+    ListViewItemPresenter_PointerOverBorderBrush = 2417,
+    ListViewItemPresenter_CheckBoxPointerOverBrush = 2418,
+    ListViewItemPresenter_CheckBoxPressedBrush = 2419,
+    ListViewItemPresenter_CheckDisabledBrush = 2420,
+    ListViewItemPresenter_CheckPressedBrush = 2421,
+    ListViewItemPresenter_CheckBoxBorderBrush = 2422,
+    ListViewItemPresenter_CheckBoxDisabledBorderBrush = 2423,
+    ListViewItemPresenter_CheckBoxPressedBorderBrush = 2424,
+    ListViewItemPresenter_CheckBoxDisabledBrush = 2425,
+    ListViewItemPresenter_CheckBoxSelectedBrush = 2426,
+    ListViewItemPresenter_CheckBoxSelectedDisabledBrush = 2427,
+    ListViewItemPresenter_CheckBoxSelectedPointerOverBrush = 2428,
+    ListViewItemPresenter_CheckBoxSelectedPressedBrush = 2429,
+    ListViewItemPresenter_CheckBoxPointerOverBorderBrush = 2430,
+    ListViewItemPresenter_SelectionIndicatorDisabledBrush = 2431,
+    CalendarView_BlackoutBackground = 2432,
+    CalendarView_BlackoutStrikethroughBrush = 2433,
+    CalendarView_CalendarItemCornerRadius = 2434,
+    CalendarView_CalendarItemDisabledBackground = 2435,
+    CalendarView_CalendarItemHoverBackground = 2436,
+    CalendarView_CalendarItemPressedBackground = 2437,
+    CalendarView_DayItemMargin = 2438,
+    CalendarView_FirstOfMonthLabelMargin = 2439,
+    CalendarView_FirstOfYearDecadeLabelMargin = 2440,
+    CalendarView_MonthYearItemMargin = 2441,
+    CalendarView_OutOfScopeHoverForeground = 2442,
+    CalendarView_OutOfScopePressedForeground = 2443,
+    CalendarView_SelectedDisabledBorderBrush = 2444,
+    CalendarView_SelectedDisabledForeground = 2445,
+    CalendarView_SelectedHoverForeground = 2446,
+    CalendarView_SelectedPressedForeground = 2447,
+    CalendarView_TodayBlackoutForeground = 2448,
+    CalendarView_TodayDisabledBackground = 2449,
+    CalendarView_TodayHoverBackground = 2450,
+    CalendarView_TodayPressedBackground = 2451,
+    Popup_ActualPlacement = 2452,
+    Popup_DesiredPlacement = 2453,
+    Popup_PlacementTarget = 2454,
+    AutomationProperties_AutomationControlType = 2455,
+  }
+
+  enum XamlTypeIndex {
+    AutoSuggestBoxSuggestionChosenEventArgs = 34,
+    AutoSuggestBoxTextChangedEventArgs = 35,
+    CollectionViewSource = 41,
+    ColumnDefinition = 44,
+    GradientStop = 64,
+    InputScope = 74,
+    InputScopeName = 75,
+    KeySpline = 78,
+    PathFigure = 93,
+    PrintDocument = 100,
+    RowDefinition = 106,
+    Style = 114,
+    TimelineMarker = 126,
+    VisualState = 137,
+    VisualStateGroup = 138,
+    VisualStateManager = 139,
+    VisualTransition = 140,
+    AddDeleteThemeTransition = 177,
+    ArcSegment = 178,
+    BackEase = 179,
+    BeginStoryboard = 180,
+    BezierSegment = 181,
+    BindingBase = 182,
+    BitmapCache = 183,
+    BounceEase = 186,
+    CircleEase = 187,
+    ColorAnimation = 188,
+    ColorAnimationUsingKeyFrames = 189,
+    ContentThemeTransition = 190,
+    ControlTemplate = 191,
+    CubicEase = 192,
+    DataTemplate = 194,
+    DiscreteColorKeyFrame = 195,
+    DiscreteDoubleKeyFrame = 196,
+    DiscreteObjectKeyFrame = 197,
+    DiscretePointKeyFrame = 198,
+    DoubleAnimation = 200,
+    DoubleAnimationUsingKeyFrames = 201,
+    EasingColorKeyFrame = 204,
+    EasingDoubleKeyFrame = 205,
+    EasingPointKeyFrame = 206,
+    EdgeUIThemeTransition = 207,
+    ElasticEase = 208,
+    EllipseGeometry = 209,
+    EntranceThemeTransition = 210,
+    EventTrigger = 211,
+    ExponentialEase = 212,
+    Flyout = 213,
+    GeometryGroup = 216,
+    ItemsPanelTemplate = 227,
+    LinearColorKeyFrame = 230,
+    LinearDoubleKeyFrame = 231,
+    LinearPointKeyFrame = 232,
+    LineGeometry = 233,
+    LineSegment = 234,
+    Matrix3DProjection = 236,
+    MenuFlyout = 238,
+    ObjectAnimationUsingKeyFrames = 240,
+    PaneThemeTransition = 241,
+    PathGeometry = 243,
+    PlaneProjection = 244,
+    PointAnimation = 245,
+    PointAnimationUsingKeyFrames = 246,
+    PolyBezierSegment = 248,
+    PolyLineSegment = 249,
+    PolyQuadraticBezierSegment = 250,
+    PopupThemeTransition = 251,
+    PowerEase = 252,
+    QuadraticBezierSegment = 254,
+    QuadraticEase = 255,
+    QuarticEase = 256,
+    QuinticEase = 257,
+    RectangleGeometry = 258,
+    RelativeSource = 259,
+    RenderTargetBitmap = 260,
+    ReorderThemeTransition = 261,
+    RepositionThemeTransition = 262,
+    Setter = 263,
+    SineEase = 264,
+    SolidColorBrush = 265,
+    SplineColorKeyFrame = 266,
+    SplineDoubleKeyFrame = 267,
+    SplinePointKeyFrame = 268,
+    BitmapImage = 285,
+    Border = 286,
+    CaptureElement = 288,
+    CompositeTransform = 295,
+    ContentPresenter = 296,
+    DragItemThemeAnimation = 302,
+    DragOverThemeAnimation = 303,
+    DropTargetItemThemeAnimation = 304,
+    FadeInThemeAnimation = 306,
+    FadeOutThemeAnimation = 307,
+    Glyphs = 312,
+    Image = 326,
+    ImageBrush = 328,
+    InlineUIContainer = 329,
+    ItemsPresenter = 332,
+    LinearGradientBrush = 334,
+    LineBreak = 335,
+    MatrixTransform = 340,
+    MediaElement = 342,
+    Paragraph = 349,
+    PointerDownThemeAnimation = 357,
+    PointerUpThemeAnimation = 359,
+    PopInThemeAnimation = 361,
+    PopOutThemeAnimation = 362,
+    Popup = 363,
+    RepositionThemeAnimation = 370,
+    ResourceDictionary = 371,
+    RichTextBlock = 374,
+    RichTextBlockOverflow = 376,
+    RotateTransform = 378,
+    Run = 380,
+    ScaleTransform = 381,
+    SkewTransform = 389,
+    Span = 390,
+    SplitCloseThemeAnimation = 391,
+    SplitOpenThemeAnimation = 392,
+    Storyboard = 393,
+    SwipeBackThemeAnimation = 394,
+    SwipeHintThemeAnimation = 395,
+    TextBlock = 396,
+    TransformGroup = 411,
+    TranslateTransform = 413,
+    Viewbox = 417,
+    WebViewBrush = 423,
+    AppBarSeparator = 427,
+    BitmapIcon = 429,
+    Bold = 430,
+    Canvas = 432,
+    ContentControl = 435,
+    DatePicker = 436,
+    DependencyObjectCollection = 437,
+    Ellipse = 438,
+    FontIcon = 440,
+    Grid = 442,
+    Hub = 445,
+    HubSection = 446,
+    Hyperlink = 447,
+    Italic = 449,
+    ItemsControl = 451,
+    Line = 452,
+    MediaTransportControls = 458,
+    PasswordBox = 462,
+    Path = 463,
+    PathIcon = 464,
+    Polygon = 465,
+    Polyline = 466,
+    ProgressRing = 468,
+    Rectangle = 470,
+    RichEditBox = 473,
+    ScrollContentPresenter = 476,
+    SearchBox = 477,
+    SemanticZoom = 479,
+    StackPanel = 481,
+    SymbolIcon = 482,
+    TextBox = 483,
+    Thumb = 485,
+    TickBar = 486,
+    TimePicker = 487,
+    ToggleSwitch = 489,
+    Underline = 490,
+    UserControl = 491,
+    VariableSizedWrapGrid = 492,
+    WebView = 494,
+    AppBar = 495,
+    AutoSuggestBox = 499,
+    CarouselPanel = 502,
+    ContentDialog = 506,
+    FlyoutPresenter = 508,
+    Frame = 509,
+    GridViewItemPresenter = 511,
+    GroupItem = 512,
+    ItemsStackPanel = 514,
+    ItemsWrapGrid = 515,
+    ListViewItemPresenter = 520,
+    MenuFlyoutItem = 521,
+    MenuFlyoutPresenter = 522,
+    MenuFlyoutSeparator = 523,
+    Page = 525,
+    ProgressBar = 528,
+    ScrollBar = 530,
+    SettingsFlyout = 533,
+    Slider = 534,
+    SwapChainBackgroundPanel = 535,
+    SwapChainPanel = 536,
+    ToolTip = 538,
+    Button = 540,
+    ComboBoxItem = 541,
+    CommandBar = 542,
+    FlipViewItem = 543,
+    GridViewHeaderItem = 545,
+    HyperlinkButton = 546,
+    ListBoxItem = 547,
+    ListViewHeaderItem = 550,
+    RepeatButton = 551,
+    ScrollViewer = 552,
+    ToggleButton = 553,
+    ToggleMenuFlyoutItem = 554,
+    VirtualizingStackPanel = 555,
+    WrapGrid = 556,
+    AppBarButton = 557,
+    AppBarToggleButton = 558,
+    CheckBox = 559,
+    GridViewItem = 560,
+    ListViewItem = 561,
+    RadioButton = 562,
+    Binding = 564,
+    ComboBox = 566,
+    FlipView = 567,
+    ListBox = 568,
+    GridView = 570,
+    ListView = 571,
+    CalendarView = 707,
+    CalendarViewDayItem = 709,
+    CalendarPanel = 723,
+    SplitView = 728,
+    CompositeTransform3D = 732,
+    PerspectiveTransform3D = 733,
+    RelativePanel = 744,
+    InkCanvas = 748,
+    MenuFlyoutSubItem = 749,
+    AdaptiveTrigger = 757,
+    SoftwareBitmapSource = 761,
+    StateTrigger = 767,
+    CalendarDatePicker = 774,
+    AutoSuggestBoxQuerySubmittedEventArgs = 778,
+    CommandBarOverflowPresenter = 781,
+    DrillInThemeAnimation = 782,
+    DrillOutThemeAnimation = 783,
+    AutomationAnnotation = 789,
+    AutomationPeerAnnotation = 790,
+    MediaPlayerPresenter = 828,
+    MediaPlayerElement = 829,
+    XamlLight = 855,
+    SvgImageSource = 860,
+    KeyboardAccelerator = 897,
+    HandwritingView = 920,
+    ContentLink = 925,
+    BitmapIconSource = 929,
+    FontIconSource = 930,
+    PathIconSource = 931,
+    SymbolIconSource = 933,
+    IconSourceElement = 939,
+    AppBarElementContainer = 945,
+    ColorPaletteResources = 952,
+    StandardUICommand = 961,
+    ThemeShadow = 964,
+    XamlUICommand = 969,
+  }
+
+  interface IXamlDirect {
+    AddEventHandler(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, eventIndex: number, handler: Object): void;
+    AddEventHandler(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, eventIndex: number, handler: Object, handledEventsToo: boolean): void;
+    AddToCollection(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, value: Windows.UI.Xaml.Core.Direct.IXamlDirectObject): void;
+    ClearCollection(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject): void;
+    ClearProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): void;
+    CreateInstance(typeIndex: number): Windows.UI.Xaml.Core.Direct.IXamlDirectObject;
+    GetBooleanProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): boolean;
+    GetCollectionCount(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject): number;
+    GetColorProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.UI.Color;
+    GetCornerRadiusProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.UI.Xaml.CornerRadius;
+    GetDateTimeProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.Foundation.DateTime;
+    GetDoubleProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): number;
+    GetDurationProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.UI.Xaml.Duration;
+    GetEnumProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): number;
+    GetGridLengthProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.UI.Xaml.GridLength;
+    GetInt32Property(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): number;
+    GetMatrix3DProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.UI.Xaml.Media.Media3D.Matrix3D;
+    GetMatrixProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.UI.Xaml.Media.Matrix;
+    GetObject(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject): Object;
+    GetObjectProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Object;
+    GetPointProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.Foundation.Point;
+    GetRectProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.Foundation.Rect;
+    GetSizeProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.Foundation.Size;
+    GetStringProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): string;
+    GetThicknessProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.UI.Xaml.Thickness;
+    GetTimeSpanProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.Foundation.TimeSpan;
+    GetXamlDirectObject(object: Object): Windows.UI.Xaml.Core.Direct.IXamlDirectObject;
+    GetXamlDirectObjectFromCollectionAt(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, index: number): Windows.UI.Xaml.Core.Direct.IXamlDirectObject;
+    GetXamlDirectObjectProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number): Windows.UI.Xaml.Core.Direct.IXamlDirectObject;
+    InsertIntoCollectionAt(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, index: number, value: Windows.UI.Xaml.Core.Direct.IXamlDirectObject): void;
+    RemoveEventHandler(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, eventIndex: number, handler: Object): void;
+    RemoveFromCollection(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, value: Windows.UI.Xaml.Core.Direct.IXamlDirectObject): boolean;
+    RemoveFromCollectionAt(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, index: number): void;
+    SetBooleanProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: boolean): void;
+    SetColorProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.UI.Color): void;
+    SetCornerRadiusProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.UI.Xaml.CornerRadius): void;
+    SetDateTimeProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.Foundation.DateTime): void;
+    SetDoubleProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: number): void;
+    SetDurationProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.UI.Xaml.Duration): void;
+    SetEnumProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: number): void;
+    SetGridLengthProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.UI.Xaml.GridLength): void;
+    SetInt32Property(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: number): void;
+    SetMatrix3DProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.UI.Xaml.Media.Media3D.Matrix3D): void;
+    SetMatrixProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.UI.Xaml.Media.Matrix): void;
+    SetObjectProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Object): void;
+    SetPointProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.Foundation.Point): void;
+    SetRectProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.Foundation.Rect): void;
+    SetSizeProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.Foundation.Size): void;
+    SetStringProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: string): void;
+    SetThicknessProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.UI.Xaml.Thickness): void;
+    SetTimeSpanProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.Foundation.TimeSpan): void;
+    SetXamlDirectObjectProperty(xamlDirectObject: Windows.UI.Xaml.Core.Direct.IXamlDirectObject, propertyIndex: number, value: Windows.UI.Xaml.Core.Direct.IXamlDirectObject): void;
+  }
+  var IXamlDirect: abstract new (...args: any[]) => IXamlDirect;
+
+  interface IXamlDirectObject {
+  }
+  var IXamlDirectObject: abstract new (...args: any[]) => IXamlDirectObject;
+
+  interface IXamlDirectStatics {
+    GetDefault(): Windows.UI.Xaml.Core.Direct.XamlDirect;
+  }
+  var IXamlDirectStatics: abstract new (...args: any[]) => IXamlDirectStatics;
+
+  interface XamlDirectContract {
+  }
+  var XamlDirectContract: {
+    new(fields: {  }): XamlDirectContract;
+  };
+
+}
+
+declare namespace Windows.UI.Xaml.Data {
+  class BindableAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class Binding extends Windows.UI.Xaml.Data.BindingBase implements Windows.UI.Xaml.Data.IBinding, Windows.UI.Xaml.Data.IBinding2 {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Converter: Windows.UI.Xaml.Data.IValueConverter;
+    ConverterLanguage: string;
+    ConverterParameter: Object;
+    ElementName: string;
+    FallbackValue: Object;
+    Mode: number;
+    Path: Windows.UI.Xaml.PropertyPath;
+    RelativeSource: Windows.UI.Xaml.Data.RelativeSource;
+    Source: Object;
+    TargetNullValue: Object;
+    UpdateSourceTrigger: number;
+  }
+
+  class BindingBase extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Data.IBindingBase {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class BindingExpression extends Windows.UI.Xaml.Data.BindingExpressionBase implements Windows.UI.Xaml.Data.IBindingExpression {
+    UpdateSource(): void;
+    readonly DataItem: Object;
+    readonly ParentBinding: Windows.UI.Xaml.Data.Binding;
+  }
+
+  class BindingExpressionBase implements Windows.UI.Xaml.Data.IBindingExpressionBase {
+  }
+
+  class BindingOperations implements Windows.UI.Xaml.Data.IBindingOperations {
+    static SetBinding(target: Windows.UI.Xaml.DependencyObject, dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+  }
+
+  class CollectionViewSource extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Data.ICollectionViewSource {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    IsSourceGrouped: boolean;
+    static readonly IsSourceGroupedProperty: Windows.UI.Xaml.DependencyProperty;
+    ItemsPath: Windows.UI.Xaml.PropertyPath;
+    static readonly ItemsPathProperty: Windows.UI.Xaml.DependencyProperty;
+    Source: Object;
+    static readonly SourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly View: Windows.UI.Xaml.Data.ICollectionView;
+    static readonly ViewProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class CurrentChangingEventArgs implements Windows.UI.Xaml.Data.ICurrentChangingEventArgs {
+    constructor();
+    constructor(isCancelable: boolean);
+    Cancel: boolean;
+    readonly IsCancelable: boolean;
+  }
+
+  class ItemIndexRange implements Windows.UI.Xaml.Data.IItemIndexRange {
+    constructor(firstIndex: number, length: number);
+    readonly FirstIndex: number;
+    readonly LastIndex: number;
+    readonly Length: number;
+  }
+
+  class PropertyChangedEventArgs implements Windows.UI.Xaml.Data.IPropertyChangedEventArgs {
+    constructor(name: string);
+    readonly PropertyName: string;
+  }
+
+  class RelativeSource extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Data.IRelativeSource {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Mode: number;
+  }
+
+  enum BindingMode {
+    OneWay = 1,
+    OneTime = 2,
+    TwoWay = 3,
+  }
+
+  enum RelativeSourceMode {
+    None = 0,
+    TemplatedParent = 1,
+    Self = 2,
+  }
+
+  enum UpdateSourceTrigger {
+    Default = 0,
+    PropertyChanged = 1,
+    Explicit = 2,
+    LostFocus = 3,
+  }
+
+  interface CurrentChangingEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Data.CurrentChangingEventArgs): void;
+  }
+  var CurrentChangingEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Data.CurrentChangingEventArgs) => void): CurrentChangingEventHandler;
+  };
+
+  interface IBinding {
+    Converter: Windows.UI.Xaml.Data.IValueConverter;
+    ConverterLanguage: string;
+    ConverterParameter: Object;
+    ElementName: string;
+    Mode: number;
+    Path: Windows.UI.Xaml.PropertyPath;
+    RelativeSource: Windows.UI.Xaml.Data.RelativeSource;
+    Source: Object;
+  }
+  var IBinding: abstract new (...args: any[]) => IBinding;
+
+  interface IBinding2 {
+    FallbackValue: Object;
+    TargetNullValue: Object;
+    UpdateSourceTrigger: number;
+  }
+  var IBinding2: abstract new (...args: any[]) => IBinding2;
+
+  interface IBindingBase {
+  }
+  var IBindingBase: abstract new (...args: any[]) => IBindingBase;
+
+  interface IBindingBaseFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Data.BindingBase;
+  }
+  var IBindingBaseFactory: abstract new (...args: any[]) => IBindingBaseFactory;
+
+  interface IBindingExpression {
+    UpdateSource(): void;
+    readonly DataItem: Object;
+    readonly ParentBinding: Windows.UI.Xaml.Data.Binding;
+  }
+  var IBindingExpression: abstract new (...args: any[]) => IBindingExpression;
+
+  interface IBindingExpressionBase {
+  }
+  var IBindingExpressionBase: abstract new (...args: any[]) => IBindingExpressionBase;
+
+  interface IBindingExpressionBaseFactory {
+  }
+  var IBindingExpressionBaseFactory: abstract new (...args: any[]) => IBindingExpressionBaseFactory;
+
+  interface IBindingExpressionFactory {
+  }
+  var IBindingExpressionFactory: abstract new (...args: any[]) => IBindingExpressionFactory;
+
+  interface IBindingFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Data.Binding;
+  }
+  var IBindingFactory: abstract new (...args: any[]) => IBindingFactory;
+
+  interface IBindingOperations {
+  }
+  var IBindingOperations: abstract new (...args: any[]) => IBindingOperations;
+
+  interface IBindingOperationsStatics {
+    SetBinding(target: Windows.UI.Xaml.DependencyObject, dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+  }
+  var IBindingOperationsStatics: abstract new (...args: any[]) => IBindingOperationsStatics;
+
+  interface ICollectionView {
+    LoadMoreItemsAsync(count: number): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Data.LoadMoreItemsResult>;
+    MoveCurrentTo(item: Object): boolean;
+    MoveCurrentToFirst(): boolean;
+    MoveCurrentToLast(): boolean;
+    MoveCurrentToNext(): boolean;
+    MoveCurrentToPosition(index: number): boolean;
+    MoveCurrentToPrevious(): boolean;
+    readonly CollectionGroups: Windows.Foundation.Collections.IObservableVector<Object>;
+    readonly CurrentItem: Object;
+    readonly CurrentPosition: number;
+    readonly HasMoreItems: boolean;
+    readonly IsCurrentAfterLast: boolean;
+    readonly IsCurrentBeforeFirst: boolean;
+    CurrentChanged: Windows.Foundation.EventHandler<Object> | null;
+    CurrentChanging: Windows.UI.Xaml.Data.CurrentChangingEventHandler | null;
+  }
+  var ICollectionView: abstract new (...args: any[]) => ICollectionView;
+
+  interface ICollectionViewFactory {
+    CreateView(): Windows.UI.Xaml.Data.ICollectionView;
+  }
+  var ICollectionViewFactory: abstract new (...args: any[]) => ICollectionViewFactory;
+
+  interface ICollectionViewGroup {
+    readonly Group: Object;
+    readonly GroupItems: Windows.Foundation.Collections.IObservableVector<Object>;
+  }
+  var ICollectionViewGroup: abstract new (...args: any[]) => ICollectionViewGroup;
+
+  interface ICollectionViewSource {
+    IsSourceGrouped: boolean;
+    ItemsPath: Windows.UI.Xaml.PropertyPath;
+    Source: Object;
+    readonly View: Windows.UI.Xaml.Data.ICollectionView;
+  }
+  var ICollectionViewSource: abstract new (...args: any[]) => ICollectionViewSource;
+
+  interface ICollectionViewSourceStatics {
+    readonly IsSourceGroupedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ItemsPathProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ViewProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ICollectionViewSourceStatics: abstract new (...args: any[]) => ICollectionViewSourceStatics;
+
+  interface ICurrentChangingEventArgs {
+    Cancel: boolean;
+    readonly IsCancelable: boolean;
+  }
+  var ICurrentChangingEventArgs: abstract new (...args: any[]) => ICurrentChangingEventArgs;
+
+  interface ICurrentChangingEventArgsFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Data.CurrentChangingEventArgs;
+    CreateWithCancelableParameter(isCancelable: boolean, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Data.CurrentChangingEventArgs;
+  }
+  var ICurrentChangingEventArgsFactory: abstract new (...args: any[]) => ICurrentChangingEventArgsFactory;
+
+  interface ICustomProperty {
+    GetIndexedValue(target: Object, index: Object): Object;
+    GetValue(target: Object): Object;
+    SetIndexedValue(target: Object, value: Object, index: Object): void;
+    SetValue(target: Object, value: Object): void;
+    readonly CanRead: boolean;
+    readonly CanWrite: boolean;
+    readonly Name: string;
+    readonly Type: Windows.UI.Xaml.Interop.TypeName;
+  }
+  var ICustomProperty: abstract new (...args: any[]) => ICustomProperty;
+
+  interface ICustomPropertyProvider {
+    GetCustomProperty(name: string): Windows.UI.Xaml.Data.ICustomProperty;
+    GetIndexedProperty(name: string, type: Windows.UI.Xaml.Interop.TypeName): Windows.UI.Xaml.Data.ICustomProperty;
+    GetStringRepresentation(): string;
+    readonly Type: Windows.UI.Xaml.Interop.TypeName;
+  }
+  var ICustomPropertyProvider: abstract new (...args: any[]) => ICustomPropertyProvider;
+
+  interface IItemIndexRange {
+    readonly FirstIndex: number;
+    readonly LastIndex: number;
+    readonly Length: number;
+  }
+  var IItemIndexRange: abstract new (...args: any[]) => IItemIndexRange;
+
+  interface IItemIndexRangeFactory {
+    CreateInstance(firstIndex: number, length: number, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Data.ItemIndexRange;
+  }
+  var IItemIndexRangeFactory: abstract new (...args: any[]) => IItemIndexRangeFactory;
+
+  interface IItemsRangeInfo extends Windows.Foundation.IClosable {
+    Close(): void;
+    RangesChanged(visibleRange: Windows.UI.Xaml.Data.ItemIndexRange, trackedItems: Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Data.ItemIndexRange> | Windows.UI.Xaml.Data.ItemIndexRange[]): void;
+  }
+  var IItemsRangeInfo: abstract new (...args: any[]) => IItemsRangeInfo;
+
+  interface INotifyPropertyChanged {
+    PropertyChanged: Windows.UI.Xaml.Data.PropertyChangedEventHandler | null;
+  }
+  var INotifyPropertyChanged: abstract new (...args: any[]) => INotifyPropertyChanged;
+
+  interface IPropertyChangedEventArgs {
+    readonly PropertyName: string;
+  }
+  var IPropertyChangedEventArgs: abstract new (...args: any[]) => IPropertyChangedEventArgs;
+
+  interface IPropertyChangedEventArgsFactory {
+    CreateInstance(name: string, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Data.PropertyChangedEventArgs;
+  }
+  var IPropertyChangedEventArgsFactory: abstract new (...args: any[]) => IPropertyChangedEventArgsFactory;
+
+  interface IRelativeSource {
+    Mode: number;
+  }
+  var IRelativeSource: abstract new (...args: any[]) => IRelativeSource;
+
+  interface IRelativeSourceFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Data.RelativeSource;
+  }
+  var IRelativeSourceFactory: abstract new (...args: any[]) => IRelativeSourceFactory;
+
+  interface ISelectionInfo {
+    DeselectRange(itemIndexRange: Windows.UI.Xaml.Data.ItemIndexRange): void;
+    GetSelectedRanges(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Data.ItemIndexRange> | Windows.UI.Xaml.Data.ItemIndexRange[];
+    IsSelected(index: number): boolean;
+    SelectRange(itemIndexRange: Windows.UI.Xaml.Data.ItemIndexRange): void;
+  }
+  var ISelectionInfo: abstract new (...args: any[]) => ISelectionInfo;
+
+  interface ISupportIncrementalLoading {
+    LoadMoreItemsAsync(count: number): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Data.LoadMoreItemsResult>;
+    readonly HasMoreItems: boolean;
+  }
+  var ISupportIncrementalLoading: abstract new (...args: any[]) => ISupportIncrementalLoading;
+
+  interface IValueConverter {
+    Convert(value: Object, targetType: Windows.UI.Xaml.Interop.TypeName, parameter: Object, language: string): Object;
+    ConvertBack(value: Object, targetType: Windows.UI.Xaml.Interop.TypeName, parameter: Object, language: string): Object;
+  }
+  var IValueConverter: abstract new (...args: any[]) => IValueConverter;
+
+  interface LoadMoreItemsResult {
+    Count: number;
+  }
+  var LoadMoreItemsResult: {
+    new(count: number): LoadMoreItemsResult;
+    new(fields: { Count?: number }): LoadMoreItemsResult;
+  };
+
+  interface PropertyChangedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Data.PropertyChangedEventArgs): void;
+  }
+  var PropertyChangedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Data.PropertyChangedEventArgs) => void): PropertyChangedEventHandler;
+  };
+
+}
+
+declare namespace Windows.UI.Xaml.Documents {
+  class Block extends Windows.UI.Xaml.Documents.TextElement implements Windows.UI.Xaml.Documents.IBlock, Windows.UI.Xaml.Documents.IBlock2 {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    FindName(name: string): Object;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    OnDisconnectVisualChildren(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    HorizontalTextAlignment: number;
+    static readonly HorizontalTextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    LineHeight: number;
+    static readonly LineHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    LineStackingStrategy: number;
+    static readonly LineStackingStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    Margin: Windows.UI.Xaml.Thickness;
+    static readonly MarginProperty: Windows.UI.Xaml.DependencyProperty;
+    TextAlignment: number;
+    static readonly TextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class BlockCollection {
+    Append(value: Windows.UI.Xaml.Documents.Block): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.Block>;
+    GetAt(index: number): Windows.UI.Xaml.Documents.Block;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Documents.Block[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Documents.Block> | Windows.UI.Xaml.Documents.Block[];
+    IndexOf(value: Windows.UI.Xaml.Documents.Block, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Documents.Block): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Documents.Block[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Documents.Block): void;
+    readonly Size: number;
+  }
+
+  class Bold extends Windows.UI.Xaml.Documents.Span implements Windows.UI.Xaml.Documents.IBold {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    FindName(name: string): Object;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    OnDisconnectVisualChildren(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ContactContentLinkProvider extends Windows.UI.Xaml.Documents.ContentLinkProvider implements Windows.UI.Xaml.Documents.IContactContentLinkProvider {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ContentLink extends Windows.UI.Xaml.Documents.Inline implements Windows.UI.Xaml.Documents.IContentLink {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    FindName(name: string): Object;
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    OnDisconnectVisualChildren(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Background: Windows.UI.Xaml.Media.Brush;
+    static readonly BackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    Cursor: number;
+    static readonly CursorProperty: Windows.UI.Xaml.DependencyProperty;
+    ElementSoundMode: number;
+    static readonly ElementSoundModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FocusState: number;
+    static readonly FocusStateProperty: Windows.UI.Xaml.DependencyProperty;
+    Info: Windows.UI.Text.ContentLinkInfo;
+    IsTabStop: boolean;
+    static readonly IsTabStopProperty: Windows.UI.Xaml.DependencyProperty;
+    TabIndex: number;
+    static readonly TabIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusDown: Windows.UI.Xaml.DependencyObject;
+    XYFocusDownNavigationStrategy: number;
+    static readonly XYFocusDownNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly XYFocusDownProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusLeft: Windows.UI.Xaml.DependencyObject;
+    XYFocusLeftNavigationStrategy: number;
+    static readonly XYFocusLeftNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly XYFocusLeftProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusRight: Windows.UI.Xaml.DependencyObject;
+    XYFocusRightNavigationStrategy: number;
+    static readonly XYFocusRightNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly XYFocusRightProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusUp: Windows.UI.Xaml.DependencyObject;
+    XYFocusUpNavigationStrategy: number;
+    static readonly XYFocusUpNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly XYFocusUpProperty: Windows.UI.Xaml.DependencyProperty;
+    GotFocus: Windows.UI.Xaml.RoutedEventHandler | null;
+    Invoked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Documents.ContentLink, Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs> | null;
+    LostFocus: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+
+  class ContentLinkInvokedEventArgs implements Windows.UI.Xaml.Documents.IContentLinkInvokedEventArgs {
+    readonly ContentLinkInfo: Windows.UI.Text.ContentLinkInfo;
+    Handled: boolean;
+  }
+
+  class ContentLinkProvider extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Documents.IContentLinkProvider {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ContentLinkProviderCollection implements Windows.UI.Xaml.Documents.IContentLinkProviderCollection {
+    constructor();
+    Append(value: Windows.UI.Xaml.Documents.ContentLinkProvider): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.ContentLinkProvider>;
+    GetAt(index: number): Windows.UI.Xaml.Documents.ContentLinkProvider;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Documents.ContentLinkProvider[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Documents.ContentLinkProvider> | Windows.UI.Xaml.Documents.ContentLinkProvider[];
+    IndexOf(value: Windows.UI.Xaml.Documents.ContentLinkProvider, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Documents.ContentLinkProvider): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Documents.ContentLinkProvider[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Documents.ContentLinkProvider): void;
+    readonly Size: number;
+  }
+
+  class Glyphs extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Documents.IGlyphs, Windows.UI.Xaml.Documents.IGlyphs2 {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    ColorFontPaletteIndex: number;
+    static readonly ColorFontPaletteIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    Fill: Windows.UI.Xaml.Media.Brush;
+    static readonly FillProperty: Windows.UI.Xaml.DependencyProperty;
+    FontRenderingEmSize: number;
+    static readonly FontRenderingEmSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    FontUri: Windows.Foundation.Uri;
+    static readonly FontUriProperty: Windows.UI.Xaml.DependencyProperty;
+    Indices: string;
+    static readonly IndicesProperty: Windows.UI.Xaml.DependencyProperty;
+    IsColorFontEnabled: boolean;
+    static readonly IsColorFontEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    OriginX: number;
+    static readonly OriginXProperty: Windows.UI.Xaml.DependencyProperty;
+    OriginY: number;
+    static readonly OriginYProperty: Windows.UI.Xaml.DependencyProperty;
+    StyleSimulations: number;
+    static readonly StyleSimulationsProperty: Windows.UI.Xaml.DependencyProperty;
+    UnicodeString: string;
+    static readonly UnicodeStringProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Hyperlink extends Windows.UI.Xaml.Documents.Span implements Windows.UI.Xaml.Documents.IHyperlink, Windows.UI.Xaml.Documents.IHyperlink2, Windows.UI.Xaml.Documents.IHyperlink3, Windows.UI.Xaml.Documents.IHyperlink4, Windows.UI.Xaml.Documents.IHyperlink5 {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    FindName(name: string): Object;
+    Focus(value: number): boolean;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    OnDisconnectVisualChildren(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    ElementSoundMode: number;
+    static readonly ElementSoundModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FocusState: number;
+    static readonly FocusStateProperty: Windows.UI.Xaml.DependencyProperty;
+    IsTabStop: boolean;
+    static readonly IsTabStopProperty: Windows.UI.Xaml.DependencyProperty;
+    NavigateUri: Windows.Foundation.Uri;
+    static readonly NavigateUriProperty: Windows.UI.Xaml.DependencyProperty;
+    TabIndex: number;
+    static readonly TabIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    UnderlineStyle: number;
+    static readonly UnderlineStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusDown: Windows.UI.Xaml.DependencyObject;
+    XYFocusDownNavigationStrategy: number;
+    static readonly XYFocusDownNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly XYFocusDownProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusLeft: Windows.UI.Xaml.DependencyObject;
+    XYFocusLeftNavigationStrategy: number;
+    static readonly XYFocusLeftNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly XYFocusLeftProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusRight: Windows.UI.Xaml.DependencyObject;
+    XYFocusRightNavigationStrategy: number;
+    static readonly XYFocusRightNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly XYFocusRightProperty: Windows.UI.Xaml.DependencyProperty;
+    XYFocusUp: Windows.UI.Xaml.DependencyObject;
+    XYFocusUpNavigationStrategy: number;
+    static readonly XYFocusUpNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly XYFocusUpProperty: Windows.UI.Xaml.DependencyProperty;
+    Click: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Documents.Hyperlink, Windows.UI.Xaml.Documents.HyperlinkClickEventArgs> | null;
+    GotFocus: Windows.UI.Xaml.RoutedEventHandler | null;
+    LostFocus: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+
+  class HyperlinkClickEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Documents.IHyperlinkClickEventArgs {
+  }
+
+  class Inline extends Windows.UI.Xaml.Documents.TextElement implements Windows.UI.Xaml.Documents.IInline {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    FindName(name: string): Object;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    OnDisconnectVisualChildren(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class InlineCollection {
+    Append(value: Windows.UI.Xaml.Documents.Inline): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Documents.Inline>;
+    GetAt(index: number): Windows.UI.Xaml.Documents.Inline;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Documents.Inline[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Documents.Inline> | Windows.UI.Xaml.Documents.Inline[];
+    IndexOf(value: Windows.UI.Xaml.Documents.Inline, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Documents.Inline): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Documents.Inline[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Documents.Inline): void;
+    readonly Size: number;
+  }
+
+  class InlineUIContainer extends Windows.UI.Xaml.Documents.Inline implements Windows.UI.Xaml.Documents.IInlineUIContainer {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    FindName(name: string): Object;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    OnDisconnectVisualChildren(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Child: Windows.UI.Xaml.UIElement;
+  }
+
+  class Italic extends Windows.UI.Xaml.Documents.Span implements Windows.UI.Xaml.Documents.IItalic {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    FindName(name: string): Object;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    OnDisconnectVisualChildren(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class LineBreak extends Windows.UI.Xaml.Documents.Inline implements Windows.UI.Xaml.Documents.ILineBreak {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    FindName(name: string): Object;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    OnDisconnectVisualChildren(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class Paragraph extends Windows.UI.Xaml.Documents.Block implements Windows.UI.Xaml.Documents.IParagraph {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    FindName(name: string): Object;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    OnDisconnectVisualChildren(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly Inlines: Windows.UI.Xaml.Documents.InlineCollection;
+    TextIndent: number;
+    static readonly TextIndentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PlaceContentLinkProvider extends Windows.UI.Xaml.Documents.ContentLinkProvider implements Windows.UI.Xaml.Documents.IPlaceContentLinkProvider {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class Run extends Windows.UI.Xaml.Documents.Inline implements Windows.UI.Xaml.Documents.IRun {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    FindName(name: string): Object;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    OnDisconnectVisualChildren(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    FlowDirection: number;
+    static readonly FlowDirectionProperty: Windows.UI.Xaml.DependencyProperty;
+    Text: string;
+  }
+
+  class Span extends Windows.UI.Xaml.Documents.Inline implements Windows.UI.Xaml.Documents.ISpan {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    FindName(name: string): Object;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    OnDisconnectVisualChildren(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Inlines: Windows.UI.Xaml.Documents.InlineCollection;
+  }
+
+  class TextElement extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Documents.ITextElement, Windows.UI.Xaml.Documents.ITextElement2, Windows.UI.Xaml.Documents.ITextElement3, Windows.UI.Xaml.Documents.ITextElement4, Windows.UI.Xaml.Documents.ITextElement5, Windows.UI.Xaml.Documents.ITextElementOverrides {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    FindName(name: string): Object;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    OnDisconnectVisualChildren(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    AccessKey: string;
+    static readonly AccessKeyProperty: Windows.UI.Xaml.DependencyProperty;
+    AccessKeyScopeOwner: Windows.UI.Xaml.DependencyObject;
+    static readonly AccessKeyScopeOwnerProperty: Windows.UI.Xaml.DependencyProperty;
+    AllowFocusOnInteraction: boolean;
+    static readonly AllowFocusOnInteractionProperty: Windows.UI.Xaml.DependencyProperty;
+    CharacterSpacing: number;
+    static readonly CharacterSpacingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentEnd: Windows.UI.Xaml.Documents.TextPointer;
+    readonly ContentStart: Windows.UI.Xaml.Documents.TextPointer;
+    readonly ElementEnd: Windows.UI.Xaml.Documents.TextPointer;
+    readonly ElementStart: Windows.UI.Xaml.Documents.TextPointer;
+    ExitDisplayModeOnAccessKeyInvoked: boolean;
+    static readonly ExitDisplayModeOnAccessKeyInvokedProperty: Windows.UI.Xaml.DependencyProperty;
+    FontFamily: Windows.UI.Xaml.Media.FontFamily;
+    static readonly FontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    FontSize: number;
+    static readonly FontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    FontStretch: number;
+    static readonly FontStretchProperty: Windows.UI.Xaml.DependencyProperty;
+    FontStyle: number;
+    static readonly FontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    FontWeight: Windows.UI.Text.FontWeight;
+    static readonly FontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    Foreground: Windows.UI.Xaml.Media.Brush;
+    static readonly ForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    IsAccessKeyScope: boolean;
+    static readonly IsAccessKeyScopeProperty: Windows.UI.Xaml.DependencyProperty;
+    IsTextScaleFactorEnabled: boolean;
+    static readonly IsTextScaleFactorEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    KeyTipHorizontalOffset: number;
+    static readonly KeyTipHorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    KeyTipPlacementMode: number;
+    static readonly KeyTipPlacementModeProperty: Windows.UI.Xaml.DependencyProperty;
+    KeyTipVerticalOffset: number;
+    static readonly KeyTipVerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    Language: string;
+    static readonly LanguageProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Name: string;
+    TextDecorations: number;
+    static readonly TextDecorationsProperty: Windows.UI.Xaml.DependencyProperty;
+    XamlRoot: Windows.UI.Xaml.XamlRoot;
+    AccessKeyDisplayDismissed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Documents.TextElement, Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs> | null;
+    AccessKeyDisplayRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Documents.TextElement, Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs> | null;
+    AccessKeyInvoked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Documents.TextElement, Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs> | null;
+  }
+
+  class TextHighlighter implements Windows.UI.Xaml.Documents.ITextHighlighter {
+    constructor();
+    Background: Windows.UI.Xaml.Media.Brush;
+    static readonly BackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    Foreground: Windows.UI.Xaml.Media.Brush;
+    static readonly ForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Ranges: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Documents.TextRange> | Windows.UI.Xaml.Documents.TextRange[];
+  }
+
+  class TextHighlighterBase extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Documents.ITextHighlighterBase {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class TextPointer implements Windows.UI.Xaml.Documents.ITextPointer {
+    GetCharacterRect(direction: number): Windows.Foundation.Rect;
+    GetPositionAtOffset(offset: number, direction: number): Windows.UI.Xaml.Documents.TextPointer;
+    readonly LogicalDirection: number;
+    readonly Offset: number;
+    readonly Parent: Windows.UI.Xaml.DependencyObject;
+    readonly VisualParent: Windows.UI.Xaml.FrameworkElement;
+  }
+
+  class Typography implements Windows.UI.Xaml.Documents.ITypography {
+    static GetAnnotationAlternates(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetCapitalSpacing(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetCapitals(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetCaseSensitiveForms(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetContextualAlternates(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetContextualLigatures(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetContextualSwashes(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetDiscretionaryLigatures(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetEastAsianExpertForms(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetEastAsianLanguage(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetEastAsianWidths(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetFraction(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetHistoricalForms(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetHistoricalLigatures(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetKerning(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetMathematicalGreek(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetNumeralAlignment(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetNumeralStyle(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetSlashedZero(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStandardLigatures(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStandardSwashes(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetStylisticAlternates(element: Windows.UI.Xaml.DependencyObject): number;
+    static GetStylisticSet1(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStylisticSet10(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStylisticSet11(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStylisticSet12(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStylisticSet13(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStylisticSet14(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStylisticSet15(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStylisticSet16(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStylisticSet17(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStylisticSet18(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStylisticSet19(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStylisticSet2(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStylisticSet20(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStylisticSet3(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStylisticSet4(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStylisticSet5(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStylisticSet6(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStylisticSet7(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStylisticSet8(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetStylisticSet9(element: Windows.UI.Xaml.DependencyObject): boolean;
+    static GetVariants(element: Windows.UI.Xaml.DependencyObject): number;
+    static SetAnnotationAlternates(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static SetCapitalSpacing(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetCapitals(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static SetCaseSensitiveForms(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetContextualAlternates(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetContextualLigatures(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetContextualSwashes(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static SetDiscretionaryLigatures(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetEastAsianExpertForms(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetEastAsianLanguage(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static SetEastAsianWidths(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static SetFraction(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static SetHistoricalForms(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetHistoricalLigatures(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetKerning(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetMathematicalGreek(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetNumeralAlignment(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static SetNumeralStyle(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static SetSlashedZero(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStandardLigatures(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStandardSwashes(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static SetStylisticAlternates(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static SetStylisticSet1(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStylisticSet10(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStylisticSet11(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStylisticSet12(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStylisticSet13(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStylisticSet14(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStylisticSet15(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStylisticSet16(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStylisticSet17(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStylisticSet18(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStylisticSet19(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStylisticSet2(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStylisticSet20(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStylisticSet3(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStylisticSet4(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStylisticSet5(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStylisticSet6(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStylisticSet7(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStylisticSet8(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetStylisticSet9(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    static SetVariants(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    static readonly AnnotationAlternatesProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly CapitalSpacingProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly CapitalsProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly CaseSensitiveFormsProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly ContextualAlternatesProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly ContextualLigaturesProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly ContextualSwashesProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly DiscretionaryLigaturesProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly EastAsianExpertFormsProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly EastAsianLanguageProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly EastAsianWidthsProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly FractionProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly HistoricalFormsProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly HistoricalLigaturesProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly KerningProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly MathematicalGreekProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly NumeralAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly NumeralStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly SlashedZeroProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly StandardLigaturesProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly StandardSwashesProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticAlternatesProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet10Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet11Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet12Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet13Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet14Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet15Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet16Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet17Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet18Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet19Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet1Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet20Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet2Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet3Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet4Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet5Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet6Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet7Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet8Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly StylisticSet9Property: Windows.UI.Xaml.DependencyProperty;
+    static readonly VariantsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Underline extends Windows.UI.Xaml.Documents.Span implements Windows.UI.Xaml.Documents.IUnderline {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    FindName(name: string): Object;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    OnDisconnectVisualChildren(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  enum LogicalDirection {
+    Backward = 0,
+    Forward = 1,
+  }
+
+  enum UnderlineStyle {
+    None = 0,
+    Single = 1,
+  }
+
+  interface IBlock {
+    LineHeight: number;
+    LineStackingStrategy: number;
+    Margin: Windows.UI.Xaml.Thickness;
+    TextAlignment: number;
+  }
+  var IBlock: abstract new (...args: any[]) => IBlock;
+
+  interface IBlock2 {
+    HorizontalTextAlignment: number;
+  }
+  var IBlock2: abstract new (...args: any[]) => IBlock2;
+
+  interface IBlockFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Documents.Block;
+  }
+  var IBlockFactory: abstract new (...args: any[]) => IBlockFactory;
+
+  interface IBlockStatics {
+    readonly LineHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LineStackingStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MarginProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IBlockStatics: abstract new (...args: any[]) => IBlockStatics;
+
+  interface IBlockStatics2 {
+    readonly HorizontalTextAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IBlockStatics2: abstract new (...args: any[]) => IBlockStatics2;
+
+  interface IBold {
+  }
+  var IBold: abstract new (...args: any[]) => IBold;
+
+  interface IContactContentLinkProvider {
+  }
+  var IContactContentLinkProvider: abstract new (...args: any[]) => IContactContentLinkProvider;
+
+  interface IContentLink {
+    Focus(value: number): boolean;
+    Background: Windows.UI.Xaml.Media.Brush;
+    Cursor: number;
+    ElementSoundMode: number;
+    readonly FocusState: number;
+    Info: Windows.UI.Text.ContentLinkInfo;
+    IsTabStop: boolean;
+    TabIndex: number;
+    XYFocusDown: Windows.UI.Xaml.DependencyObject;
+    XYFocusDownNavigationStrategy: number;
+    XYFocusLeft: Windows.UI.Xaml.DependencyObject;
+    XYFocusLeftNavigationStrategy: number;
+    XYFocusRight: Windows.UI.Xaml.DependencyObject;
+    XYFocusRightNavigationStrategy: number;
+    XYFocusUp: Windows.UI.Xaml.DependencyObject;
+    XYFocusUpNavigationStrategy: number;
+    GotFocus: Windows.UI.Xaml.RoutedEventHandler | null;
+    Invoked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Documents.ContentLink, Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs> | null;
+    LostFocus: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+  var IContentLink: abstract new (...args: any[]) => IContentLink;
+
+  interface IContentLinkInvokedEventArgs {
+    readonly ContentLinkInfo: Windows.UI.Text.ContentLinkInfo;
+    Handled: boolean;
+  }
+  var IContentLinkInvokedEventArgs: abstract new (...args: any[]) => IContentLinkInvokedEventArgs;
+
+  interface IContentLinkProvider {
+  }
+  var IContentLinkProvider: abstract new (...args: any[]) => IContentLinkProvider;
+
+  interface IContentLinkProviderCollection {
+  }
+  var IContentLinkProviderCollection: abstract new (...args: any[]) => IContentLinkProviderCollection;
+
+  interface IContentLinkProviderFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Documents.ContentLinkProvider;
+  }
+  var IContentLinkProviderFactory: abstract new (...args: any[]) => IContentLinkProviderFactory;
+
+  interface IContentLinkStatics {
+    readonly BackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CursorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ElementSoundModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FocusStateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsTabStopProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TabIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusDownNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusDownProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusLeftNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusLeftProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusRightNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusRightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusUpNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusUpProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IContentLinkStatics: abstract new (...args: any[]) => IContentLinkStatics;
+
+  interface IGlyphs {
+    Fill: Windows.UI.Xaml.Media.Brush;
+    FontRenderingEmSize: number;
+    FontUri: Windows.Foundation.Uri;
+    Indices: string;
+    OriginX: number;
+    OriginY: number;
+    StyleSimulations: number;
+    UnicodeString: string;
+  }
+  var IGlyphs: abstract new (...args: any[]) => IGlyphs;
+
+  interface IGlyphs2 {
+    ColorFontPaletteIndex: number;
+    IsColorFontEnabled: boolean;
+  }
+  var IGlyphs2: abstract new (...args: any[]) => IGlyphs2;
+
+  interface IGlyphsStatics {
+    readonly FillProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontRenderingEmSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontUriProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IndicesProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OriginXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OriginYProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StyleSimulationsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly UnicodeStringProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IGlyphsStatics: abstract new (...args: any[]) => IGlyphsStatics;
+
+  interface IGlyphsStatics2 {
+    readonly ColorFontPaletteIndexProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsColorFontEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IGlyphsStatics2: abstract new (...args: any[]) => IGlyphsStatics2;
+
+  interface IHyperlink {
+    NavigateUri: Windows.Foundation.Uri;
+    Click: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Documents.Hyperlink, Windows.UI.Xaml.Documents.HyperlinkClickEventArgs> | null;
+  }
+  var IHyperlink: abstract new (...args: any[]) => IHyperlink;
+
+  interface IHyperlink2 {
+    UnderlineStyle: number;
+  }
+  var IHyperlink2: abstract new (...args: any[]) => IHyperlink2;
+
+  interface IHyperlink3 {
+    ElementSoundMode: number;
+    XYFocusDown: Windows.UI.Xaml.DependencyObject;
+    XYFocusLeft: Windows.UI.Xaml.DependencyObject;
+    XYFocusRight: Windows.UI.Xaml.DependencyObject;
+    XYFocusUp: Windows.UI.Xaml.DependencyObject;
+  }
+  var IHyperlink3: abstract new (...args: any[]) => IHyperlink3;
+
+  interface IHyperlink4 {
+    Focus(value: number): boolean;
+    readonly FocusState: number;
+    XYFocusDownNavigationStrategy: number;
+    XYFocusLeftNavigationStrategy: number;
+    XYFocusRightNavigationStrategy: number;
+    XYFocusUpNavigationStrategy: number;
+    GotFocus: Windows.UI.Xaml.RoutedEventHandler | null;
+    LostFocus: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+  var IHyperlink4: abstract new (...args: any[]) => IHyperlink4;
+
+  interface IHyperlink5 {
+    IsTabStop: boolean;
+    TabIndex: number;
+  }
+  var IHyperlink5: abstract new (...args: any[]) => IHyperlink5;
+
+  interface IHyperlinkClickEventArgs {
+  }
+  var IHyperlinkClickEventArgs: abstract new (...args: any[]) => IHyperlinkClickEventArgs;
+
+  interface IHyperlinkStatics {
+    readonly NavigateUriProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IHyperlinkStatics: abstract new (...args: any[]) => IHyperlinkStatics;
+
+  interface IHyperlinkStatics2 {
+    readonly UnderlineStyleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IHyperlinkStatics2: abstract new (...args: any[]) => IHyperlinkStatics2;
+
+  interface IHyperlinkStatics3 {
+    readonly ElementSoundModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusDownProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusLeftProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusRightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusUpProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IHyperlinkStatics3: abstract new (...args: any[]) => IHyperlinkStatics3;
+
+  interface IHyperlinkStatics4 {
+    readonly FocusStateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusDownNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusLeftNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusRightNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly XYFocusUpNavigationStrategyProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IHyperlinkStatics4: abstract new (...args: any[]) => IHyperlinkStatics4;
+
+  interface IHyperlinkStatics5 {
+    readonly IsTabStopProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TabIndexProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IHyperlinkStatics5: abstract new (...args: any[]) => IHyperlinkStatics5;
+
+  interface IInline {
+  }
+  var IInline: abstract new (...args: any[]) => IInline;
+
+  interface IInlineFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Documents.Inline;
+  }
+  var IInlineFactory: abstract new (...args: any[]) => IInlineFactory;
+
+  interface IInlineUIContainer {
+    Child: Windows.UI.Xaml.UIElement;
+  }
+  var IInlineUIContainer: abstract new (...args: any[]) => IInlineUIContainer;
+
+  interface IItalic {
+  }
+  var IItalic: abstract new (...args: any[]) => IItalic;
+
+  interface ILineBreak {
+  }
+  var ILineBreak: abstract new (...args: any[]) => ILineBreak;
+
+  interface IParagraph {
+    readonly Inlines: Windows.UI.Xaml.Documents.InlineCollection;
+    TextIndent: number;
+  }
+  var IParagraph: abstract new (...args: any[]) => IParagraph;
+
+  interface IParagraphStatics {
+    readonly TextIndentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IParagraphStatics: abstract new (...args: any[]) => IParagraphStatics;
+
+  interface IPlaceContentLinkProvider {
+  }
+  var IPlaceContentLinkProvider: abstract new (...args: any[]) => IPlaceContentLinkProvider;
+
+  interface IRun {
+    FlowDirection: number;
+    Text: string;
+  }
+  var IRun: abstract new (...args: any[]) => IRun;
+
+  interface IRunStatics {
+    readonly FlowDirectionProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRunStatics: abstract new (...args: any[]) => IRunStatics;
+
+  interface ISpan {
+    Inlines: Windows.UI.Xaml.Documents.InlineCollection;
+  }
+  var ISpan: abstract new (...args: any[]) => ISpan;
+
+  interface ISpanFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Documents.Span;
+  }
+  var ISpanFactory: abstract new (...args: any[]) => ISpanFactory;
+
+  interface ITextElement {
+    FindName(name: string): Object;
+    CharacterSpacing: number;
+    readonly ContentEnd: Windows.UI.Xaml.Documents.TextPointer;
+    readonly ContentStart: Windows.UI.Xaml.Documents.TextPointer;
+    readonly ElementEnd: Windows.UI.Xaml.Documents.TextPointer;
+    readonly ElementStart: Windows.UI.Xaml.Documents.TextPointer;
+    FontFamily: Windows.UI.Xaml.Media.FontFamily;
+    FontSize: number;
+    FontStretch: number;
+    FontStyle: number;
+    FontWeight: Windows.UI.Text.FontWeight;
+    Foreground: Windows.UI.Xaml.Media.Brush;
+    Language: string;
+    readonly Name: string;
+  }
+  var ITextElement: abstract new (...args: any[]) => ITextElement;
+
+  interface ITextElement2 {
+    IsTextScaleFactorEnabled: boolean;
+  }
+  var ITextElement2: abstract new (...args: any[]) => ITextElement2;
+
+  interface ITextElement3 {
+    AccessKey: string;
+    AllowFocusOnInteraction: boolean;
+    ExitDisplayModeOnAccessKeyInvoked: boolean;
+  }
+  var ITextElement3: abstract new (...args: any[]) => ITextElement3;
+
+  interface ITextElement4 {
+    AccessKeyScopeOwner: Windows.UI.Xaml.DependencyObject;
+    IsAccessKeyScope: boolean;
+    KeyTipHorizontalOffset: number;
+    KeyTipPlacementMode: number;
+    KeyTipVerticalOffset: number;
+    TextDecorations: number;
+    AccessKeyDisplayDismissed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Documents.TextElement, Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs> | null;
+    AccessKeyDisplayRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Documents.TextElement, Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs> | null;
+    AccessKeyInvoked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Documents.TextElement, Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs> | null;
+  }
+  var ITextElement4: abstract new (...args: any[]) => ITextElement4;
+
+  interface ITextElement5 {
+    XamlRoot: Windows.UI.Xaml.XamlRoot;
+  }
+  var ITextElement5: abstract new (...args: any[]) => ITextElement5;
+
+  interface ITextElementFactory {
+  }
+  var ITextElementFactory: abstract new (...args: any[]) => ITextElementFactory;
+
+  interface ITextElementOverrides {
+    OnDisconnectVisualChildren(): void;
+  }
+  var ITextElementOverrides: abstract new (...args: any[]) => ITextElementOverrides;
+
+  interface ITextElementStatics {
+    readonly CharacterSpacingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontFamilyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontSizeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontStretchProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FontWeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LanguageProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITextElementStatics: abstract new (...args: any[]) => ITextElementStatics;
+
+  interface ITextElementStatics2 {
+    readonly IsTextScaleFactorEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITextElementStatics2: abstract new (...args: any[]) => ITextElementStatics2;
+
+  interface ITextElementStatics3 {
+    readonly AccessKeyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AllowFocusOnInteractionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ExitDisplayModeOnAccessKeyInvokedProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITextElementStatics3: abstract new (...args: any[]) => ITextElementStatics3;
+
+  interface ITextElementStatics4 {
+    readonly AccessKeyScopeOwnerProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsAccessKeyScopeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly KeyTipHorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly KeyTipPlacementModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly KeyTipVerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TextDecorationsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITextElementStatics4: abstract new (...args: any[]) => ITextElementStatics4;
+
+  interface ITextHighlighter {
+    Background: Windows.UI.Xaml.Media.Brush;
+    Foreground: Windows.UI.Xaml.Media.Brush;
+    readonly Ranges: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Documents.TextRange> | Windows.UI.Xaml.Documents.TextRange[];
+  }
+  var ITextHighlighter: abstract new (...args: any[]) => ITextHighlighter;
+
+  interface ITextHighlighterBase {
+  }
+  var ITextHighlighterBase: abstract new (...args: any[]) => ITextHighlighterBase;
+
+  interface ITextHighlighterBaseFactory {
+  }
+  var ITextHighlighterBaseFactory: abstract new (...args: any[]) => ITextHighlighterBaseFactory;
+
+  interface ITextHighlighterFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Documents.TextHighlighter;
+  }
+  var ITextHighlighterFactory: abstract new (...args: any[]) => ITextHighlighterFactory;
+
+  interface ITextHighlighterStatics {
+    readonly BackgroundProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ForegroundProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITextHighlighterStatics: abstract new (...args: any[]) => ITextHighlighterStatics;
+
+  interface ITextPointer {
+    GetCharacterRect(direction: number): Windows.Foundation.Rect;
+    GetPositionAtOffset(offset: number, direction: number): Windows.UI.Xaml.Documents.TextPointer;
+    readonly LogicalDirection: number;
+    readonly Offset: number;
+    readonly Parent: Windows.UI.Xaml.DependencyObject;
+    readonly VisualParent: Windows.UI.Xaml.FrameworkElement;
+  }
+  var ITextPointer: abstract new (...args: any[]) => ITextPointer;
+
+  interface ITypography {
+  }
+  var ITypography: abstract new (...args: any[]) => ITypography;
+
+  interface ITypographyStatics {
+    GetAnnotationAlternates(element: Windows.UI.Xaml.DependencyObject): number;
+    GetCapitalSpacing(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetCapitals(element: Windows.UI.Xaml.DependencyObject): number;
+    GetCaseSensitiveForms(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetContextualAlternates(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetContextualLigatures(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetContextualSwashes(element: Windows.UI.Xaml.DependencyObject): number;
+    GetDiscretionaryLigatures(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetEastAsianExpertForms(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetEastAsianLanguage(element: Windows.UI.Xaml.DependencyObject): number;
+    GetEastAsianWidths(element: Windows.UI.Xaml.DependencyObject): number;
+    GetFraction(element: Windows.UI.Xaml.DependencyObject): number;
+    GetHistoricalForms(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetHistoricalLigatures(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetKerning(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetMathematicalGreek(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetNumeralAlignment(element: Windows.UI.Xaml.DependencyObject): number;
+    GetNumeralStyle(element: Windows.UI.Xaml.DependencyObject): number;
+    GetSlashedZero(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStandardLigatures(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStandardSwashes(element: Windows.UI.Xaml.DependencyObject): number;
+    GetStylisticAlternates(element: Windows.UI.Xaml.DependencyObject): number;
+    GetStylisticSet1(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStylisticSet10(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStylisticSet11(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStylisticSet12(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStylisticSet13(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStylisticSet14(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStylisticSet15(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStylisticSet16(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStylisticSet17(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStylisticSet18(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStylisticSet19(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStylisticSet2(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStylisticSet20(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStylisticSet3(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStylisticSet4(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStylisticSet5(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStylisticSet6(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStylisticSet7(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStylisticSet8(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetStylisticSet9(element: Windows.UI.Xaml.DependencyObject): boolean;
+    GetVariants(element: Windows.UI.Xaml.DependencyObject): number;
+    SetAnnotationAlternates(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    SetCapitalSpacing(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetCapitals(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    SetCaseSensitiveForms(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetContextualAlternates(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetContextualLigatures(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetContextualSwashes(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    SetDiscretionaryLigatures(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetEastAsianExpertForms(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetEastAsianLanguage(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    SetEastAsianWidths(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    SetFraction(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    SetHistoricalForms(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetHistoricalLigatures(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetKerning(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetMathematicalGreek(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetNumeralAlignment(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    SetNumeralStyle(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    SetSlashedZero(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStandardLigatures(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStandardSwashes(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    SetStylisticAlternates(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    SetStylisticSet1(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStylisticSet10(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStylisticSet11(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStylisticSet12(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStylisticSet13(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStylisticSet14(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStylisticSet15(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStylisticSet16(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStylisticSet17(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStylisticSet18(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStylisticSet19(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStylisticSet2(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStylisticSet20(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStylisticSet3(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStylisticSet4(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStylisticSet5(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStylisticSet6(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStylisticSet7(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStylisticSet8(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetStylisticSet9(element: Windows.UI.Xaml.DependencyObject, value: boolean): void;
+    SetVariants(element: Windows.UI.Xaml.DependencyObject, value: number): void;
+    readonly AnnotationAlternatesProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CapitalSpacingProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CapitalsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CaseSensitiveFormsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContextualAlternatesProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContextualLigaturesProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContextualSwashesProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DiscretionaryLigaturesProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly EastAsianExpertFormsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly EastAsianLanguageProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly EastAsianWidthsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FractionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HistoricalFormsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly HistoricalLigaturesProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly KerningProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MathematicalGreekProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly NumeralAlignmentProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly NumeralStyleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SlashedZeroProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StandardLigaturesProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StandardSwashesProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticAlternatesProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet10Property: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet11Property: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet12Property: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet13Property: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet14Property: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet15Property: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet16Property: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet17Property: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet18Property: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet19Property: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet1Property: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet20Property: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet2Property: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet3Property: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet4Property: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet5Property: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet6Property: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet7Property: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet8Property: Windows.UI.Xaml.DependencyProperty;
+    readonly StylisticSet9Property: Windows.UI.Xaml.DependencyProperty;
+    readonly VariantsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITypographyStatics: abstract new (...args: any[]) => ITypographyStatics;
+
+  interface IUnderline {
+  }
+  var IUnderline: abstract new (...args: any[]) => IUnderline;
+
+  interface TextRange {
+    StartIndex: number;
+    Length: number;
+  }
+  var TextRange: {
+    new(startIndex: number, length: number): TextRange;
+    new(fields: { StartIndex?: number; Length?: number }): TextRange;
+  };
+
+}
+
+declare namespace Windows.UI.Xaml.Hosting {
+  class DesignerAppExitedEventArgs implements Windows.UI.Xaml.Hosting.IDesignerAppExitedEventArgs {
+    readonly ExitCode: number;
+  }
+
+  class DesignerAppManager implements Windows.Foundation.IClosable, Windows.UI.Xaml.Hosting.IDesignerAppManager {
+    constructor(appUserModelId: string);
+    Close(): void;
+    CreateNewViewAsync(initialViewState: number, initialViewSize: Windows.Foundation.Size): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Hosting.DesignerAppView>;
+    LoadObjectIntoAppAsync(dllName: string, classId: Guid, initializationData: string): Windows.Foundation.IAsyncAction;
+    readonly AppUserModelId: string;
+    DesignerAppExited: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Hosting.DesignerAppManager, Windows.UI.Xaml.Hosting.DesignerAppExitedEventArgs> | null;
+  }
+
+  class DesignerAppView implements Windows.Foundation.IClosable, Windows.UI.Xaml.Hosting.IDesignerAppView {
+    Close(): void;
+    UpdateViewAsync(viewState: number, viewSize: Windows.Foundation.Size): Windows.Foundation.IAsyncAction;
+    readonly AppUserModelId: string;
+    readonly ApplicationViewId: number;
+    readonly ViewSize: Windows.Foundation.Size;
+    readonly ViewState: number;
+  }
+
+  class DesktopWindowXamlSource implements Windows.Foundation.IClosable, Windows.UI.Xaml.Hosting.IDesktopWindowXamlSource {
+    constructor();
+    Close(): void;
+    NavigateFocus(request: Windows.UI.Xaml.Hosting.XamlSourceFocusNavigationRequest): Windows.UI.Xaml.Hosting.XamlSourceFocusNavigationResult;
+    Content: Windows.UI.Xaml.UIElement;
+    readonly HasFocus: boolean;
+    GotFocus: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Hosting.DesktopWindowXamlSource, Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceGotFocusEventArgs> | null;
+    TakeFocusRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Hosting.DesktopWindowXamlSource, Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceTakeFocusRequestedEventArgs> | null;
+  }
+
+  class DesktopWindowXamlSourceGotFocusEventArgs implements Windows.UI.Xaml.Hosting.IDesktopWindowXamlSourceGotFocusEventArgs {
+    readonly Request: Windows.UI.Xaml.Hosting.XamlSourceFocusNavigationRequest;
+  }
+
+  class DesktopWindowXamlSourceTakeFocusRequestedEventArgs implements Windows.UI.Xaml.Hosting.IDesktopWindowXamlSourceTakeFocusRequestedEventArgs {
+    readonly Request: Windows.UI.Xaml.Hosting.XamlSourceFocusNavigationRequest;
+  }
+
+  class ElementCompositionPreview implements Windows.UI.Xaml.Hosting.IElementCompositionPreview {
+    static GetAppWindowContent(appWindow: Windows.UI.WindowManagement.AppWindow): Windows.UI.Xaml.UIElement;
+    static GetElementChildVisual(element: Windows.UI.Xaml.UIElement): Windows.UI.Composition.Visual;
+    static GetElementVisual(element: Windows.UI.Xaml.UIElement): Windows.UI.Composition.Visual;
+    static GetPointerPositionPropertySet(targetElement: Windows.UI.Xaml.UIElement): Windows.UI.Composition.CompositionPropertySet;
+    static GetScrollViewerManipulationPropertySet(scrollViewer: Windows.UI.Xaml.Controls.ScrollViewer): Windows.UI.Composition.CompositionPropertySet;
+    static SetAppWindowContent(appWindow: Windows.UI.WindowManagement.AppWindow, xamlContent: Windows.UI.Xaml.UIElement): void;
+    static SetElementChildVisual(element: Windows.UI.Xaml.UIElement, visual: Windows.UI.Composition.Visual): void;
+    static SetImplicitHideAnimation(element: Windows.UI.Xaml.UIElement, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static SetImplicitShowAnimation(element: Windows.UI.Xaml.UIElement, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    static SetIsTranslationEnabled(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+  }
+
+  class WindowsXamlManager implements Windows.Foundation.IClosable, Windows.UI.Xaml.Hosting.IWindowsXamlManager {
+    Close(): void;
+    static InitializeForCurrentThread(): Windows.UI.Xaml.Hosting.WindowsXamlManager;
+  }
+
+  class XamlSourceFocusNavigationRequest implements Windows.UI.Xaml.Hosting.IXamlSourceFocusNavigationRequest {
+    constructor(reason: number);
+    constructor(reason: number, hintRect: Windows.Foundation.Rect);
+    constructor(reason: number, hintRect: Windows.Foundation.Rect, correlationId: Guid);
+    readonly CorrelationId: Guid;
+    readonly HintRect: Windows.Foundation.Rect;
+    readonly Reason: number;
+  }
+
+  class XamlSourceFocusNavigationResult implements Windows.UI.Xaml.Hosting.IXamlSourceFocusNavigationResult {
+    constructor(focusMoved: boolean);
+    readonly WasFocusMoved: boolean;
+  }
+
+  class XamlUIPresenter implements Windows.UI.Xaml.Hosting.IXamlUIPresenter {
+    static GetFlyoutPlacement(placementTargetBounds: Windows.Foundation.Rect, controlSize: Windows.Foundation.Size, minControlSize: Windows.Foundation.Size, containerRect: Windows.Foundation.Rect, targetPreferredPlacement: number, allowFallbacks: boolean, chosenPlacement: number): Windows.Foundation.Rect;
+    static GetFlyoutPlacementTargetInfo(placementTarget: Windows.UI.Xaml.FrameworkElement, preferredPlacement: number, targetPreferredPlacement: number, allowFallbacks: boolean): Windows.Foundation.Rect;
+    static NotifyWindowSizeChanged(): void;
+    Present(): void;
+    Render(): void;
+    static SetHost(host: Windows.UI.Xaml.Hosting.IXamlUIPresenterHost): void;
+    SetSize(width: number, height: number): void;
+    static CompleteTimelinesAutomatically: boolean;
+    RootElement: Windows.UI.Xaml.UIElement;
+    ThemeKey: string;
+    ThemeResourcesXaml: string;
+  }
+
+  enum DesignerAppViewState {
+    Visible = 0,
+    Hidden = 1,
+  }
+
+  enum XamlSourceFocusNavigationReason {
+    Programmatic = 0,
+    Restore = 1,
+    First = 3,
+    Last = 4,
+    Left = 7,
+    Up = 8,
+    Right = 9,
+    Down = 10,
+  }
+
+  interface HostingContract {
+  }
+  var HostingContract: {
+    new(fields: {  }): HostingContract;
+  };
+
+  interface IDesignerAppExitedEventArgs {
+    readonly ExitCode: number;
+  }
+  var IDesignerAppExitedEventArgs: abstract new (...args: any[]) => IDesignerAppExitedEventArgs;
+
+  interface IDesignerAppManager {
+    CreateNewViewAsync(initialViewState: number, initialViewSize: Windows.Foundation.Size): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Hosting.DesignerAppView>;
+    LoadObjectIntoAppAsync(dllName: string, classId: Guid, initializationData: string): Windows.Foundation.IAsyncAction;
+    readonly AppUserModelId: string;
+    DesignerAppExited: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Hosting.DesignerAppManager, Windows.UI.Xaml.Hosting.DesignerAppExitedEventArgs> | null;
+  }
+  var IDesignerAppManager: abstract new (...args: any[]) => IDesignerAppManager;
+
+  interface IDesignerAppManagerFactory {
+    Create(appUserModelId: string): Windows.UI.Xaml.Hosting.DesignerAppManager;
+  }
+  var IDesignerAppManagerFactory: abstract new (...args: any[]) => IDesignerAppManagerFactory;
+
+  interface IDesignerAppView {
+    UpdateViewAsync(viewState: number, viewSize: Windows.Foundation.Size): Windows.Foundation.IAsyncAction;
+    readonly AppUserModelId: string;
+    readonly ApplicationViewId: number;
+    readonly ViewSize: Windows.Foundation.Size;
+    readonly ViewState: number;
+  }
+  var IDesignerAppView: abstract new (...args: any[]) => IDesignerAppView;
+
+  interface IDesktopWindowXamlSource {
+    NavigateFocus(request: Windows.UI.Xaml.Hosting.XamlSourceFocusNavigationRequest): Windows.UI.Xaml.Hosting.XamlSourceFocusNavigationResult;
+    Content: Windows.UI.Xaml.UIElement;
+    readonly HasFocus: boolean;
+    GotFocus: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Hosting.DesktopWindowXamlSource, Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceGotFocusEventArgs> | null;
+    TakeFocusRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Hosting.DesktopWindowXamlSource, Windows.UI.Xaml.Hosting.DesktopWindowXamlSourceTakeFocusRequestedEventArgs> | null;
+  }
+  var IDesktopWindowXamlSource: abstract new (...args: any[]) => IDesktopWindowXamlSource;
+
+  interface IDesktopWindowXamlSourceFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Hosting.DesktopWindowXamlSource;
+  }
+  var IDesktopWindowXamlSourceFactory: abstract new (...args: any[]) => IDesktopWindowXamlSourceFactory;
+
+  interface IDesktopWindowXamlSourceGotFocusEventArgs {
+    readonly Request: Windows.UI.Xaml.Hosting.XamlSourceFocusNavigationRequest;
+  }
+  var IDesktopWindowXamlSourceGotFocusEventArgs: abstract new (...args: any[]) => IDesktopWindowXamlSourceGotFocusEventArgs;
+
+  interface IDesktopWindowXamlSourceTakeFocusRequestedEventArgs {
+    readonly Request: Windows.UI.Xaml.Hosting.XamlSourceFocusNavigationRequest;
+  }
+  var IDesktopWindowXamlSourceTakeFocusRequestedEventArgs: abstract new (...args: any[]) => IDesktopWindowXamlSourceTakeFocusRequestedEventArgs;
+
+  interface IElementCompositionPreview {
+  }
+  var IElementCompositionPreview: abstract new (...args: any[]) => IElementCompositionPreview;
+
+  interface IElementCompositionPreviewStatics {
+    GetElementChildVisual(element: Windows.UI.Xaml.UIElement): Windows.UI.Composition.Visual;
+    GetElementVisual(element: Windows.UI.Xaml.UIElement): Windows.UI.Composition.Visual;
+    GetScrollViewerManipulationPropertySet(scrollViewer: Windows.UI.Xaml.Controls.ScrollViewer): Windows.UI.Composition.CompositionPropertySet;
+    SetElementChildVisual(element: Windows.UI.Xaml.UIElement, visual: Windows.UI.Composition.Visual): void;
+  }
+  var IElementCompositionPreviewStatics: abstract new (...args: any[]) => IElementCompositionPreviewStatics;
+
+  interface IElementCompositionPreviewStatics2 {
+    GetPointerPositionPropertySet(targetElement: Windows.UI.Xaml.UIElement): Windows.UI.Composition.CompositionPropertySet;
+    SetImplicitHideAnimation(element: Windows.UI.Xaml.UIElement, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    SetImplicitShowAnimation(element: Windows.UI.Xaml.UIElement, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    SetIsTranslationEnabled(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+  }
+  var IElementCompositionPreviewStatics2: abstract new (...args: any[]) => IElementCompositionPreviewStatics2;
+
+  interface IElementCompositionPreviewStatics3 {
+    GetAppWindowContent(appWindow: Windows.UI.WindowManagement.AppWindow): Windows.UI.Xaml.UIElement;
+    SetAppWindowContent(appWindow: Windows.UI.WindowManagement.AppWindow, xamlContent: Windows.UI.Xaml.UIElement): void;
+  }
+  var IElementCompositionPreviewStatics3: abstract new (...args: any[]) => IElementCompositionPreviewStatics3;
+
+  interface IWindowsXamlManager {
+  }
+  var IWindowsXamlManager: abstract new (...args: any[]) => IWindowsXamlManager;
+
+  interface IWindowsXamlManagerStatics {
+    InitializeForCurrentThread(): Windows.UI.Xaml.Hosting.WindowsXamlManager;
+  }
+  var IWindowsXamlManagerStatics: abstract new (...args: any[]) => IWindowsXamlManagerStatics;
+
+  interface IXamlSourceFocusNavigationRequest {
+    readonly CorrelationId: Guid;
+    readonly HintRect: Windows.Foundation.Rect;
+    readonly Reason: number;
+  }
+  var IXamlSourceFocusNavigationRequest: abstract new (...args: any[]) => IXamlSourceFocusNavigationRequest;
+
+  interface IXamlSourceFocusNavigationRequestFactory {
+    CreateInstance(reason: number): Windows.UI.Xaml.Hosting.XamlSourceFocusNavigationRequest;
+    CreateInstanceWithHintRect(reason: number, hintRect: Windows.Foundation.Rect): Windows.UI.Xaml.Hosting.XamlSourceFocusNavigationRequest;
+    CreateInstanceWithHintRectAndCorrelationId(reason: number, hintRect: Windows.Foundation.Rect, correlationId: Guid): Windows.UI.Xaml.Hosting.XamlSourceFocusNavigationRequest;
+  }
+  var IXamlSourceFocusNavigationRequestFactory: abstract new (...args: any[]) => IXamlSourceFocusNavigationRequestFactory;
+
+  interface IXamlSourceFocusNavigationResult {
+    readonly WasFocusMoved: boolean;
+  }
+  var IXamlSourceFocusNavigationResult: abstract new (...args: any[]) => IXamlSourceFocusNavigationResult;
+
+  interface IXamlSourceFocusNavigationResultFactory {
+    CreateInstance(focusMoved: boolean): Windows.UI.Xaml.Hosting.XamlSourceFocusNavigationResult;
+  }
+  var IXamlSourceFocusNavigationResultFactory: abstract new (...args: any[]) => IXamlSourceFocusNavigationResultFactory;
+
+  interface IXamlUIPresenter {
+    Present(): void;
+    Render(): void;
+    SetSize(width: number, height: number): void;
+    RootElement: Windows.UI.Xaml.UIElement;
+    ThemeKey: string;
+    ThemeResourcesXaml: string;
+  }
+  var IXamlUIPresenter: abstract new (...args: any[]) => IXamlUIPresenter;
+
+  interface IXamlUIPresenterHost {
+    ResolveFileResource(path: string): string;
+  }
+  var IXamlUIPresenterHost: abstract new (...args: any[]) => IXamlUIPresenterHost;
+
+  interface IXamlUIPresenterHost2 {
+    GetGenericXamlFilePath(): string;
+  }
+  var IXamlUIPresenterHost2: abstract new (...args: any[]) => IXamlUIPresenterHost2;
+
+  interface IXamlUIPresenterHost3 {
+    ResolveDictionaryResource(dictionary: Windows.UI.Xaml.ResourceDictionary, dictionaryKey: Object, suggestedValue: Object): Object;
+  }
+  var IXamlUIPresenterHost3: abstract new (...args: any[]) => IXamlUIPresenterHost3;
+
+  interface IXamlUIPresenterStatics {
+    NotifyWindowSizeChanged(): void;
+    SetHost(host: Windows.UI.Xaml.Hosting.IXamlUIPresenterHost): void;
+    CompleteTimelinesAutomatically: boolean;
+  }
+  var IXamlUIPresenterStatics: abstract new (...args: any[]) => IXamlUIPresenterStatics;
+
+  interface IXamlUIPresenterStatics2 {
+    GetFlyoutPlacement(placementTargetBounds: Windows.Foundation.Rect, controlSize: Windows.Foundation.Size, minControlSize: Windows.Foundation.Size, containerRect: Windows.Foundation.Rect, targetPreferredPlacement: number, allowFallbacks: boolean, chosenPlacement: number): Windows.Foundation.Rect;
+    GetFlyoutPlacementTargetInfo(placementTarget: Windows.UI.Xaml.FrameworkElement, preferredPlacement: number, targetPreferredPlacement: number, allowFallbacks: boolean): Windows.Foundation.Rect;
+  }
+  var IXamlUIPresenterStatics2: abstract new (...args: any[]) => IXamlUIPresenterStatics2;
+
+}
+
+declare namespace Windows.UI.Xaml.Input {
+  class AccessKeyDisplayDismissedEventArgs implements Windows.UI.Xaml.Input.IAccessKeyDisplayDismissedEventArgs {
+    constructor();
+  }
+
+  class AccessKeyDisplayRequestedEventArgs implements Windows.UI.Xaml.Input.IAccessKeyDisplayRequestedEventArgs {
+    constructor();
+    readonly PressedKeys: string;
+  }
+
+  class AccessKeyInvokedEventArgs implements Windows.UI.Xaml.Input.IAccessKeyInvokedEventArgs {
+    constructor();
+    Handled: boolean;
+  }
+
+  class AccessKeyManager implements Windows.UI.Xaml.Input.IAccessKeyManager {
+    static ExitDisplayMode(): void;
+    static AreKeyTipsEnabled: boolean;
+    static readonly IsDisplayModeEnabled: boolean;
+    static IsDisplayModeEnabledChanged: Windows.Foundation.TypedEventHandler<Object, Object> | null;
+  }
+
+  class CanExecuteRequestedEventArgs implements Windows.UI.Xaml.Input.ICanExecuteRequestedEventArgs {
+    CanExecute: boolean;
+    readonly Parameter: Object;
+  }
+
+  class CharacterReceivedRoutedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Input.ICharacterReceivedRoutedEventArgs {
+    readonly Character: string;
+    Handled: boolean;
+    readonly KeyStatus: Windows.UI.Core.CorePhysicalKeyStatus;
+  }
+
+  class ContextRequestedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Input.IContextRequestedEventArgs {
+    constructor();
+    TryGetPosition(relativeTo: Windows.UI.Xaml.UIElement, point: Windows.Foundation.Point): boolean;
+    Handled: boolean;
+  }
+
+  class DoubleTappedRoutedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Input.IDoubleTappedRoutedEventArgs {
+    constructor();
+    GetPosition(relativeTo: Windows.UI.Xaml.UIElement): Windows.Foundation.Point;
+    Handled: boolean;
+    readonly PointerDeviceType: number;
+  }
+
+  class ExecuteRequestedEventArgs implements Windows.UI.Xaml.Input.IExecuteRequestedEventArgs {
+    readonly Parameter: Object;
+  }
+
+  class FindNextElementOptions implements Windows.UI.Xaml.Input.IFindNextElementOptions {
+    constructor();
+    ExclusionRect: Windows.Foundation.Rect;
+    HintRect: Windows.Foundation.Rect;
+    SearchRoot: Windows.UI.Xaml.DependencyObject;
+    XYFocusNavigationStrategyOverride: number;
+  }
+
+  class FocusManager implements Windows.UI.Xaml.Input.IFocusManager {
+    static FindFirstFocusableElement(searchScope: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+    static FindLastFocusableElement(searchScope: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+    static FindNextElement(focusNavigationDirection: number): Windows.UI.Xaml.DependencyObject;
+    static FindNextElement(focusNavigationDirection: number, focusNavigationOptions: Windows.UI.Xaml.Input.FindNextElementOptions): Windows.UI.Xaml.DependencyObject;
+    static FindNextFocusableElement(focusNavigationDirection: number): Windows.UI.Xaml.UIElement;
+    static FindNextFocusableElement(focusNavigationDirection: number, hintRect: Windows.Foundation.Rect): Windows.UI.Xaml.UIElement;
+    static GetFocusedElement(xamlRoot: Windows.UI.Xaml.XamlRoot): Object;
+    static GetFocusedElement(): Object;
+    static TryFocusAsync(element: Windows.UI.Xaml.DependencyObject, value: number): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Input.FocusMovementResult>;
+    static TryMoveFocus(focusNavigationDirection: number, focusNavigationOptions: Windows.UI.Xaml.Input.FindNextElementOptions): boolean;
+    static TryMoveFocus(focusNavigationDirection: number): boolean;
+    static TryMoveFocusAsync(focusNavigationDirection: number): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Input.FocusMovementResult>;
+    static TryMoveFocusAsync(focusNavigationDirection: number, focusNavigationOptions: Windows.UI.Xaml.Input.FindNextElementOptions): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Input.FocusMovementResult>;
+    static GettingFocus: Windows.Foundation.EventHandler<Windows.UI.Xaml.Input.GettingFocusEventArgs> | null;
+    static GotFocus: Windows.Foundation.EventHandler<Windows.UI.Xaml.Input.FocusManagerGotFocusEventArgs> | null;
+    static LosingFocus: Windows.Foundation.EventHandler<Windows.UI.Xaml.Input.LosingFocusEventArgs> | null;
+    static LostFocus: Windows.Foundation.EventHandler<Windows.UI.Xaml.Input.FocusManagerLostFocusEventArgs> | null;
+  }
+
+  class FocusManagerGotFocusEventArgs implements Windows.UI.Xaml.Input.IFocusManagerGotFocusEventArgs {
+    readonly CorrelationId: Guid;
+    readonly NewFocusedElement: Windows.UI.Xaml.DependencyObject;
+  }
+
+  class FocusManagerLostFocusEventArgs implements Windows.UI.Xaml.Input.IFocusManagerLostFocusEventArgs {
+    readonly CorrelationId: Guid;
+    readonly OldFocusedElement: Windows.UI.Xaml.DependencyObject;
+  }
+
+  class FocusMovementResult implements Windows.UI.Xaml.Input.IFocusMovementResult {
+    readonly Succeeded: boolean;
+  }
+
+  class GettingFocusEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Input.IGettingFocusEventArgs, Windows.UI.Xaml.Input.IGettingFocusEventArgs2, Windows.UI.Xaml.Input.IGettingFocusEventArgs3 {
+    TryCancel(): boolean;
+    TrySetNewFocusedElement(element: Windows.UI.Xaml.DependencyObject): boolean;
+    Cancel: boolean;
+    readonly CorrelationId: Guid;
+    readonly Direction: number;
+    readonly FocusState: number;
+    Handled: boolean;
+    readonly InputDevice: number;
+    NewFocusedElement: Windows.UI.Xaml.DependencyObject;
+    readonly OldFocusedElement: Windows.UI.Xaml.DependencyObject;
+  }
+
+  class HoldingRoutedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Input.IHoldingRoutedEventArgs {
+    constructor();
+    GetPosition(relativeTo: Windows.UI.Xaml.UIElement): Windows.Foundation.Point;
+    Handled: boolean;
+    readonly HoldingState: number;
+    readonly PointerDeviceType: number;
+  }
+
+  class InertiaExpansionBehavior implements Windows.UI.Xaml.Input.IInertiaExpansionBehavior {
+    DesiredDeceleration: number;
+    DesiredExpansion: number;
+  }
+
+  class InertiaRotationBehavior implements Windows.UI.Xaml.Input.IInertiaRotationBehavior {
+    DesiredDeceleration: number;
+    DesiredRotation: number;
+  }
+
+  class InertiaTranslationBehavior implements Windows.UI.Xaml.Input.IInertiaTranslationBehavior {
+    DesiredDeceleration: number;
+    DesiredDisplacement: number;
+  }
+
+  class InputScope extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Input.IInputScope {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly Names: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Input.InputScopeName> | Windows.UI.Xaml.Input.InputScopeName[];
+  }
+
+  class InputScopeName extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Input.IInputScopeName {
+    constructor(nameValue: number);
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    NameValue: number;
+  }
+
+  class KeyRoutedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Input.IKeyRoutedEventArgs, Windows.UI.Xaml.Input.IKeyRoutedEventArgs2, Windows.UI.Xaml.Input.IKeyRoutedEventArgs3 {
+    readonly DeviceId: string;
+    Handled: boolean;
+    readonly Key: number;
+    readonly KeyStatus: Windows.UI.Core.CorePhysicalKeyStatus;
+    readonly OriginalKey: number;
+  }
+
+  class KeyboardAccelerator extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Input.IKeyboardAccelerator {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    IsEnabled: boolean;
+    static readonly IsEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    Key: number;
+    static readonly KeyProperty: Windows.UI.Xaml.DependencyProperty;
+    Modifiers: number;
+    static readonly ModifiersProperty: Windows.UI.Xaml.DependencyProperty;
+    ScopeOwner: Windows.UI.Xaml.DependencyObject;
+    static readonly ScopeOwnerProperty: Windows.UI.Xaml.DependencyProperty;
+    Invoked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Input.KeyboardAccelerator, Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs> | null;
+  }
+
+  class KeyboardAcceleratorInvokedEventArgs implements Windows.UI.Xaml.Input.IKeyboardAcceleratorInvokedEventArgs, Windows.UI.Xaml.Input.IKeyboardAcceleratorInvokedEventArgs2 {
+    readonly Element: Windows.UI.Xaml.DependencyObject;
+    Handled: boolean;
+    readonly KeyboardAccelerator: Windows.UI.Xaml.Input.KeyboardAccelerator;
+  }
+
+  class LosingFocusEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Input.ILosingFocusEventArgs, Windows.UI.Xaml.Input.ILosingFocusEventArgs2, Windows.UI.Xaml.Input.ILosingFocusEventArgs3 {
+    TryCancel(): boolean;
+    TrySetNewFocusedElement(element: Windows.UI.Xaml.DependencyObject): boolean;
+    Cancel: boolean;
+    readonly CorrelationId: Guid;
+    readonly Direction: number;
+    readonly FocusState: number;
+    Handled: boolean;
+    readonly InputDevice: number;
+    NewFocusedElement: Windows.UI.Xaml.DependencyObject;
+    readonly OldFocusedElement: Windows.UI.Xaml.DependencyObject;
+  }
+
+  class ManipulationCompletedRoutedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Input.IManipulationCompletedRoutedEventArgs {
+    constructor();
+    readonly Container: Windows.UI.Xaml.UIElement;
+    readonly Cumulative: Windows.UI.Input.ManipulationDelta;
+    Handled: boolean;
+    readonly IsInertial: boolean;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+    readonly Velocities: Windows.UI.Input.ManipulationVelocities;
+  }
+
+  class ManipulationDeltaRoutedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Input.IManipulationDeltaRoutedEventArgs {
+    constructor();
+    Complete(): void;
+    readonly Container: Windows.UI.Xaml.UIElement;
+    readonly Cumulative: Windows.UI.Input.ManipulationDelta;
+    readonly Delta: Windows.UI.Input.ManipulationDelta;
+    Handled: boolean;
+    readonly IsInertial: boolean;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+    readonly Velocities: Windows.UI.Input.ManipulationVelocities;
+  }
+
+  class ManipulationInertiaStartingRoutedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Input.IManipulationInertiaStartingRoutedEventArgs {
+    constructor();
+    readonly Container: Windows.UI.Xaml.UIElement;
+    readonly Cumulative: Windows.UI.Input.ManipulationDelta;
+    readonly Delta: Windows.UI.Input.ManipulationDelta;
+    ExpansionBehavior: Windows.UI.Xaml.Input.InertiaExpansionBehavior;
+    Handled: boolean;
+    readonly PointerDeviceType: number;
+    RotationBehavior: Windows.UI.Xaml.Input.InertiaRotationBehavior;
+    TranslationBehavior: Windows.UI.Xaml.Input.InertiaTranslationBehavior;
+    readonly Velocities: Windows.UI.Input.ManipulationVelocities;
+  }
+
+  class ManipulationPivot implements Windows.UI.Xaml.Input.IManipulationPivot {
+    constructor(center: Windows.Foundation.Point, radius: number);
+    constructor();
+    Center: Windows.Foundation.Point;
+    Radius: number;
+  }
+
+  class ManipulationStartedRoutedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Input.IManipulationStartedRoutedEventArgs {
+    constructor();
+    Complete(): void;
+    readonly Container: Windows.UI.Xaml.UIElement;
+    readonly Cumulative: Windows.UI.Input.ManipulationDelta;
+    Handled: boolean;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+  }
+
+  class ManipulationStartingRoutedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Input.IManipulationStartingRoutedEventArgs {
+    constructor();
+    Container: Windows.UI.Xaml.UIElement;
+    Handled: boolean;
+    Mode: number;
+    Pivot: Windows.UI.Xaml.Input.ManipulationPivot;
+  }
+
+  class NoFocusCandidateFoundEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Input.INoFocusCandidateFoundEventArgs {
+    readonly Direction: number;
+    Handled: boolean;
+    readonly InputDevice: number;
+  }
+
+  class Pointer implements Windows.UI.Xaml.Input.IPointer {
+    readonly IsInContact: boolean;
+    readonly IsInRange: boolean;
+    readonly PointerDeviceType: number;
+    readonly PointerId: number;
+  }
+
+  class PointerRoutedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Input.IPointerRoutedEventArgs, Windows.UI.Xaml.Input.IPointerRoutedEventArgs2 {
+    GetCurrentPoint(relativeTo: Windows.UI.Xaml.UIElement): Windows.UI.Input.PointerPoint;
+    GetIntermediatePoints(relativeTo: Windows.UI.Xaml.UIElement): Windows.Foundation.Collections.IVector<Windows.UI.Input.PointerPoint> | Windows.UI.Input.PointerPoint[];
+    Handled: boolean;
+    readonly IsGenerated: boolean;
+    readonly KeyModifiers: number;
+    readonly Pointer: Windows.UI.Xaml.Input.Pointer;
+  }
+
+  class ProcessKeyboardAcceleratorEventArgs implements Windows.UI.Xaml.Input.IProcessKeyboardAcceleratorEventArgs {
+    Handled: boolean;
+    readonly Key: number;
+    readonly Modifiers: number;
+  }
+
+  class RightTappedRoutedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Input.IRightTappedRoutedEventArgs {
+    constructor();
+    GetPosition(relativeTo: Windows.UI.Xaml.UIElement): Windows.Foundation.Point;
+    Handled: boolean;
+    readonly PointerDeviceType: number;
+  }
+
+  class StandardUICommand extends Windows.UI.Xaml.Input.XamlUICommand implements Windows.UI.Xaml.Input.IStandardUICommand, Windows.UI.Xaml.Input.IStandardUICommand2 {
+    constructor();
+    constructor(kind: number);
+    CanExecute(parameter: Object): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Execute(parameter: Object): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    NotifyCanExecuteChanged(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Kind: number;
+    static readonly KindProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class TappedRoutedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Input.ITappedRoutedEventArgs {
+    constructor();
+    GetPosition(relativeTo: Windows.UI.Xaml.UIElement): Windows.Foundation.Point;
+    Handled: boolean;
+    readonly PointerDeviceType: number;
+  }
+
+  class XamlUICommand extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Input.ICommand, Windows.UI.Xaml.Input.IXamlUICommand {
+    constructor();
+    CanExecute(parameter: Object): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Execute(parameter: Object): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    NotifyCanExecuteChanged(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    AccessKey: string;
+    static readonly AccessKeyProperty: Windows.UI.Xaml.DependencyProperty;
+    Command: Windows.UI.Xaml.Input.ICommand;
+    static readonly CommandProperty: Windows.UI.Xaml.DependencyProperty;
+    Description: string;
+    static readonly DescriptionProperty: Windows.UI.Xaml.DependencyProperty;
+    IconSource: Windows.UI.Xaml.Controls.IconSource;
+    static readonly IconSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly KeyboardAccelerators: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Input.KeyboardAccelerator> | Windows.UI.Xaml.Input.KeyboardAccelerator[];
+    static readonly KeyboardAcceleratorsProperty: Windows.UI.Xaml.DependencyProperty;
+    Label: string;
+    static readonly LabelProperty: Windows.UI.Xaml.DependencyProperty;
+    CanExecuteRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Input.XamlUICommand, Windows.UI.Xaml.Input.CanExecuteRequestedEventArgs> | null;
+    ExecuteRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Input.XamlUICommand, Windows.UI.Xaml.Input.ExecuteRequestedEventArgs> | null;
+    CanExecuteChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  enum FocusInputDeviceKind {
+    None = 0,
+    Mouse = 1,
+    Touch = 2,
+    Pen = 3,
+    Keyboard = 4,
+    GameController = 5,
+  }
+
+  enum FocusNavigationDirection {
+    Next = 0,
+    Previous = 1,
+    Up = 2,
+    Down = 3,
+    Left = 4,
+    Right = 5,
+    None = 6,
+  }
+
+  enum InputScopeNameValue {
+    Default = 0,
+    Url = 1,
+    EmailSmtpAddress = 5,
+    PersonalFullName = 7,
+    CurrencyAmountAndSymbol = 20,
+    CurrencyAmount = 21,
+    DateMonthNumber = 23,
+    DateDayNumber = 24,
+    DateYear = 25,
+    Digits = 28,
+    Number = 29,
+    Password = 31,
+    TelephoneNumber = 32,
+    TelephoneCountryCode = 33,
+    TelephoneAreaCode = 34,
+    TelephoneLocalNumber = 35,
+    TimeHour = 37,
+    TimeMinutesOrSeconds = 38,
+    NumberFullWidth = 39,
+    AlphanumericHalfWidth = 40,
+    AlphanumericFullWidth = 41,
+    Hiragana = 44,
+    KatakanaHalfWidth = 45,
+    KatakanaFullWidth = 46,
+    Hanja = 47,
+    HangulHalfWidth = 48,
+    HangulFullWidth = 49,
+    Search = 50,
+    Formula = 51,
+    SearchIncremental = 52,
+    ChineseHalfWidth = 53,
+    ChineseFullWidth = 54,
+    NativeScript = 55,
+    Text = 57,
+    Chat = 58,
+    NameOrPhoneNumber = 59,
+    EmailNameOrAddress = 60,
+    Private = 61,
+    Maps = 62,
+    NumericPassword = 63,
+    NumericPin = 64,
+    AlphanumericPin = 65,
+    FormulaNumber = 67,
+    ChatWithoutEmoji = 68,
+  }
+
+  enum KeyTipPlacementMode {
+    Auto = 0,
+    Bottom = 1,
+    Top = 2,
+    Left = 3,
+    Right = 4,
+    Center = 5,
+    Hidden = 6,
+  }
+
+  enum KeyboardAcceleratorPlacementMode {
+    Auto = 0,
+    Hidden = 1,
+  }
+
+  enum KeyboardNavigationMode {
+    Local = 0,
+    Cycle = 1,
+    Once = 2,
+  }
+
+  enum ManipulationModes {
+    None = 0,
+    TranslateX = 1,
+    TranslateY = 2,
+    TranslateRailsX = 4,
+    TranslateRailsY = 8,
+    Rotate = 16,
+    Scale = 32,
+    TranslateInertia = 64,
+    RotateInertia = 128,
+    ScaleInertia = 256,
+    All = 65535,
+    System = 65536,
+  }
+
+  enum StandardUICommandKind {
+    None = 0,
+    Cut = 1,
+    Copy = 2,
+    Paste = 3,
+    SelectAll = 4,
+    Delete = 5,
+    Share = 6,
+    Save = 7,
+    Open = 8,
+    Close = 9,
+    Pause = 10,
+    Play = 11,
+    Stop = 12,
+    Forward = 13,
+    Backward = 14,
+    Undo = 15,
+    Redo = 16,
+  }
+
+  enum XYFocusKeyboardNavigationMode {
+    Auto = 0,
+    Enabled = 1,
+    Disabled = 2,
+  }
+
+  enum XYFocusNavigationStrategy {
+    Auto = 0,
+    Projection = 1,
+    NavigationDirectionDistance = 2,
+    RectilinearDistance = 3,
+  }
+
+  enum XYFocusNavigationStrategyOverride {
+    None = 0,
+    Auto = 1,
+    Projection = 2,
+    NavigationDirectionDistance = 3,
+    RectilinearDistance = 4,
+  }
+
+  interface DoubleTappedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs): void;
+  }
+  var DoubleTappedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs) => void): DoubleTappedEventHandler;
+  };
+
+  interface HoldingEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs): void;
+  }
+  var HoldingEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Input.HoldingRoutedEventArgs) => void): HoldingEventHandler;
+  };
+
+  interface IAccessKeyDisplayDismissedEventArgs {
+  }
+  var IAccessKeyDisplayDismissedEventArgs: abstract new (...args: any[]) => IAccessKeyDisplayDismissedEventArgs;
+
+  interface IAccessKeyDisplayRequestedEventArgs {
+    readonly PressedKeys: string;
+  }
+  var IAccessKeyDisplayRequestedEventArgs: abstract new (...args: any[]) => IAccessKeyDisplayRequestedEventArgs;
+
+  interface IAccessKeyInvokedEventArgs {
+    Handled: boolean;
+  }
+  var IAccessKeyInvokedEventArgs: abstract new (...args: any[]) => IAccessKeyInvokedEventArgs;
+
+  interface IAccessKeyManager {
+  }
+  var IAccessKeyManager: abstract new (...args: any[]) => IAccessKeyManager;
+
+  interface IAccessKeyManagerStatics {
+    ExitDisplayMode(): void;
+    readonly IsDisplayModeEnabled: boolean;
+    IsDisplayModeEnabledChanged: Windows.Foundation.TypedEventHandler<Object, Object> | null;
+  }
+  var IAccessKeyManagerStatics: abstract new (...args: any[]) => IAccessKeyManagerStatics;
+
+  interface IAccessKeyManagerStatics2 {
+    AreKeyTipsEnabled: boolean;
+  }
+  var IAccessKeyManagerStatics2: abstract new (...args: any[]) => IAccessKeyManagerStatics2;
+
+  interface ICanExecuteRequestedEventArgs {
+    CanExecute: boolean;
+    readonly Parameter: Object;
+  }
+  var ICanExecuteRequestedEventArgs: abstract new (...args: any[]) => ICanExecuteRequestedEventArgs;
+
+  interface ICharacterReceivedRoutedEventArgs {
+    readonly Character: string;
+    Handled: boolean;
+    readonly KeyStatus: Windows.UI.Core.CorePhysicalKeyStatus;
+  }
+  var ICharacterReceivedRoutedEventArgs: abstract new (...args: any[]) => ICharacterReceivedRoutedEventArgs;
+
+  interface ICommand {
+    CanExecute(parameter: Object): boolean;
+    Execute(parameter: Object): void;
+    CanExecuteChanged: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var ICommand: abstract new (...args: any[]) => ICommand;
+
+  interface IContextRequestedEventArgs {
+    TryGetPosition(relativeTo: Windows.UI.Xaml.UIElement, point: Windows.Foundation.Point): boolean;
+    Handled: boolean;
+  }
+  var IContextRequestedEventArgs: abstract new (...args: any[]) => IContextRequestedEventArgs;
+
+  interface IDoubleTappedRoutedEventArgs {
+    GetPosition(relativeTo: Windows.UI.Xaml.UIElement): Windows.Foundation.Point;
+    Handled: boolean;
+    readonly PointerDeviceType: number;
+  }
+  var IDoubleTappedRoutedEventArgs: abstract new (...args: any[]) => IDoubleTappedRoutedEventArgs;
+
+  interface IExecuteRequestedEventArgs {
+    readonly Parameter: Object;
+  }
+  var IExecuteRequestedEventArgs: abstract new (...args: any[]) => IExecuteRequestedEventArgs;
+
+  interface IFindNextElementOptions {
+    ExclusionRect: Windows.Foundation.Rect;
+    HintRect: Windows.Foundation.Rect;
+    SearchRoot: Windows.UI.Xaml.DependencyObject;
+    XYFocusNavigationStrategyOverride: number;
+  }
+  var IFindNextElementOptions: abstract new (...args: any[]) => IFindNextElementOptions;
+
+  interface IFocusManager {
+  }
+  var IFocusManager: abstract new (...args: any[]) => IFocusManager;
+
+  interface IFocusManagerGotFocusEventArgs {
+    readonly CorrelationId: Guid;
+    readonly NewFocusedElement: Windows.UI.Xaml.DependencyObject;
+  }
+  var IFocusManagerGotFocusEventArgs: abstract new (...args: any[]) => IFocusManagerGotFocusEventArgs;
+
+  interface IFocusManagerLostFocusEventArgs {
+    readonly CorrelationId: Guid;
+    readonly OldFocusedElement: Windows.UI.Xaml.DependencyObject;
+  }
+  var IFocusManagerLostFocusEventArgs: abstract new (...args: any[]) => IFocusManagerLostFocusEventArgs;
+
+  interface IFocusManagerStatics {
+    GetFocusedElement(): Object;
+  }
+  var IFocusManagerStatics: abstract new (...args: any[]) => IFocusManagerStatics;
+
+  interface IFocusManagerStatics2 {
+    TryMoveFocus(focusNavigationDirection: number): boolean;
+  }
+  var IFocusManagerStatics2: abstract new (...args: any[]) => IFocusManagerStatics2;
+
+  interface IFocusManagerStatics3 {
+    FindNextFocusableElement(focusNavigationDirection: number): Windows.UI.Xaml.UIElement;
+    FindNextFocusableElement(focusNavigationDirection: number, hintRect: Windows.Foundation.Rect): Windows.UI.Xaml.UIElement;
+  }
+  var IFocusManagerStatics3: abstract new (...args: any[]) => IFocusManagerStatics3;
+
+  interface IFocusManagerStatics4 {
+    FindFirstFocusableElement(searchScope: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+    FindLastFocusableElement(searchScope: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+    FindNextElement(focusNavigationDirection: number): Windows.UI.Xaml.DependencyObject;
+    FindNextElement(focusNavigationDirection: number, focusNavigationOptions: Windows.UI.Xaml.Input.FindNextElementOptions): Windows.UI.Xaml.DependencyObject;
+    TryMoveFocus(focusNavigationDirection: number, focusNavigationOptions: Windows.UI.Xaml.Input.FindNextElementOptions): boolean;
+  }
+  var IFocusManagerStatics4: abstract new (...args: any[]) => IFocusManagerStatics4;
+
+  interface IFocusManagerStatics5 {
+    TryFocusAsync(element: Windows.UI.Xaml.DependencyObject, value: number): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Input.FocusMovementResult>;
+    TryMoveFocusAsync(focusNavigationDirection: number): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Input.FocusMovementResult>;
+    TryMoveFocusAsync(focusNavigationDirection: number, focusNavigationOptions: Windows.UI.Xaml.Input.FindNextElementOptions): Windows.Foundation.IAsyncOperation<Windows.UI.Xaml.Input.FocusMovementResult>;
+  }
+  var IFocusManagerStatics5: abstract new (...args: any[]) => IFocusManagerStatics5;
+
+  interface IFocusManagerStatics6 {
+    GettingFocus: Windows.Foundation.EventHandler<Windows.UI.Xaml.Input.GettingFocusEventArgs> | null;
+    GotFocus: Windows.Foundation.EventHandler<Windows.UI.Xaml.Input.FocusManagerGotFocusEventArgs> | null;
+    LosingFocus: Windows.Foundation.EventHandler<Windows.UI.Xaml.Input.LosingFocusEventArgs> | null;
+    LostFocus: Windows.Foundation.EventHandler<Windows.UI.Xaml.Input.FocusManagerLostFocusEventArgs> | null;
+  }
+  var IFocusManagerStatics6: abstract new (...args: any[]) => IFocusManagerStatics6;
+
+  interface IFocusManagerStatics7 {
+    GetFocusedElement(xamlRoot: Windows.UI.Xaml.XamlRoot): Object;
+  }
+  var IFocusManagerStatics7: abstract new (...args: any[]) => IFocusManagerStatics7;
+
+  interface IFocusMovementResult {
+    readonly Succeeded: boolean;
+  }
+  var IFocusMovementResult: abstract new (...args: any[]) => IFocusMovementResult;
+
+  interface IGettingFocusEventArgs {
+    Cancel: boolean;
+    readonly Direction: number;
+    readonly FocusState: number;
+    Handled: boolean;
+    readonly InputDevice: number;
+    NewFocusedElement: Windows.UI.Xaml.DependencyObject;
+    readonly OldFocusedElement: Windows.UI.Xaml.DependencyObject;
+  }
+  var IGettingFocusEventArgs: abstract new (...args: any[]) => IGettingFocusEventArgs;
+
+  interface IGettingFocusEventArgs2 {
+    TryCancel(): boolean;
+    TrySetNewFocusedElement(element: Windows.UI.Xaml.DependencyObject): boolean;
+  }
+  var IGettingFocusEventArgs2: abstract new (...args: any[]) => IGettingFocusEventArgs2;
+
+  interface IGettingFocusEventArgs3 {
+    readonly CorrelationId: Guid;
+  }
+  var IGettingFocusEventArgs3: abstract new (...args: any[]) => IGettingFocusEventArgs3;
+
+  interface IHoldingRoutedEventArgs {
+    GetPosition(relativeTo: Windows.UI.Xaml.UIElement): Windows.Foundation.Point;
+    Handled: boolean;
+    readonly HoldingState: number;
+    readonly PointerDeviceType: number;
+  }
+  var IHoldingRoutedEventArgs: abstract new (...args: any[]) => IHoldingRoutedEventArgs;
+
+  interface IInertiaExpansionBehavior {
+    DesiredDeceleration: number;
+    DesiredExpansion: number;
+  }
+  var IInertiaExpansionBehavior: abstract new (...args: any[]) => IInertiaExpansionBehavior;
+
+  interface IInertiaRotationBehavior {
+    DesiredDeceleration: number;
+    DesiredRotation: number;
+  }
+  var IInertiaRotationBehavior: abstract new (...args: any[]) => IInertiaRotationBehavior;
+
+  interface IInertiaTranslationBehavior {
+    DesiredDeceleration: number;
+    DesiredDisplacement: number;
+  }
+  var IInertiaTranslationBehavior: abstract new (...args: any[]) => IInertiaTranslationBehavior;
+
+  interface IInputScope {
+    readonly Names: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Input.InputScopeName> | Windows.UI.Xaml.Input.InputScopeName[];
+  }
+  var IInputScope: abstract new (...args: any[]) => IInputScope;
+
+  interface IInputScopeName {
+    NameValue: number;
+  }
+  var IInputScopeName: abstract new (...args: any[]) => IInputScopeName;
+
+  interface IInputScopeNameFactory {
+    CreateInstance(nameValue: number): Windows.UI.Xaml.Input.InputScopeName;
+  }
+  var IInputScopeNameFactory: abstract new (...args: any[]) => IInputScopeNameFactory;
+
+  interface IKeyRoutedEventArgs {
+    Handled: boolean;
+    readonly Key: number;
+    readonly KeyStatus: Windows.UI.Core.CorePhysicalKeyStatus;
+  }
+  var IKeyRoutedEventArgs: abstract new (...args: any[]) => IKeyRoutedEventArgs;
+
+  interface IKeyRoutedEventArgs2 {
+    readonly OriginalKey: number;
+  }
+  var IKeyRoutedEventArgs2: abstract new (...args: any[]) => IKeyRoutedEventArgs2;
+
+  interface IKeyRoutedEventArgs3 {
+    readonly DeviceId: string;
+  }
+  var IKeyRoutedEventArgs3: abstract new (...args: any[]) => IKeyRoutedEventArgs3;
+
+  interface IKeyboardAccelerator {
+    IsEnabled: boolean;
+    Key: number;
+    Modifiers: number;
+    ScopeOwner: Windows.UI.Xaml.DependencyObject;
+    Invoked: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Input.KeyboardAccelerator, Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs> | null;
+  }
+  var IKeyboardAccelerator: abstract new (...args: any[]) => IKeyboardAccelerator;
+
+  interface IKeyboardAcceleratorFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Input.KeyboardAccelerator;
+  }
+  var IKeyboardAcceleratorFactory: abstract new (...args: any[]) => IKeyboardAcceleratorFactory;
+
+  interface IKeyboardAcceleratorInvokedEventArgs {
+    readonly Element: Windows.UI.Xaml.DependencyObject;
+    Handled: boolean;
+  }
+  var IKeyboardAcceleratorInvokedEventArgs: abstract new (...args: any[]) => IKeyboardAcceleratorInvokedEventArgs;
+
+  interface IKeyboardAcceleratorInvokedEventArgs2 {
+    readonly KeyboardAccelerator: Windows.UI.Xaml.Input.KeyboardAccelerator;
+  }
+  var IKeyboardAcceleratorInvokedEventArgs2: abstract new (...args: any[]) => IKeyboardAcceleratorInvokedEventArgs2;
+
+  interface IKeyboardAcceleratorStatics {
+    readonly IsEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly KeyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ModifiersProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ScopeOwnerProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IKeyboardAcceleratorStatics: abstract new (...args: any[]) => IKeyboardAcceleratorStatics;
+
+  interface ILosingFocusEventArgs {
+    Cancel: boolean;
+    readonly Direction: number;
+    readonly FocusState: number;
+    Handled: boolean;
+    readonly InputDevice: number;
+    NewFocusedElement: Windows.UI.Xaml.DependencyObject;
+    readonly OldFocusedElement: Windows.UI.Xaml.DependencyObject;
+  }
+  var ILosingFocusEventArgs: abstract new (...args: any[]) => ILosingFocusEventArgs;
+
+  interface ILosingFocusEventArgs2 {
+    TryCancel(): boolean;
+    TrySetNewFocusedElement(element: Windows.UI.Xaml.DependencyObject): boolean;
+  }
+  var ILosingFocusEventArgs2: abstract new (...args: any[]) => ILosingFocusEventArgs2;
+
+  interface ILosingFocusEventArgs3 {
+    readonly CorrelationId: Guid;
+  }
+  var ILosingFocusEventArgs3: abstract new (...args: any[]) => ILosingFocusEventArgs3;
+
+  interface IManipulationCompletedRoutedEventArgs {
+    readonly Container: Windows.UI.Xaml.UIElement;
+    readonly Cumulative: Windows.UI.Input.ManipulationDelta;
+    Handled: boolean;
+    readonly IsInertial: boolean;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+    readonly Velocities: Windows.UI.Input.ManipulationVelocities;
+  }
+  var IManipulationCompletedRoutedEventArgs: abstract new (...args: any[]) => IManipulationCompletedRoutedEventArgs;
+
+  interface IManipulationDeltaRoutedEventArgs {
+    Complete(): void;
+    readonly Container: Windows.UI.Xaml.UIElement;
+    readonly Cumulative: Windows.UI.Input.ManipulationDelta;
+    readonly Delta: Windows.UI.Input.ManipulationDelta;
+    Handled: boolean;
+    readonly IsInertial: boolean;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+    readonly Velocities: Windows.UI.Input.ManipulationVelocities;
+  }
+  var IManipulationDeltaRoutedEventArgs: abstract new (...args: any[]) => IManipulationDeltaRoutedEventArgs;
+
+  interface IManipulationInertiaStartingRoutedEventArgs {
+    readonly Container: Windows.UI.Xaml.UIElement;
+    readonly Cumulative: Windows.UI.Input.ManipulationDelta;
+    readonly Delta: Windows.UI.Input.ManipulationDelta;
+    ExpansionBehavior: Windows.UI.Xaml.Input.InertiaExpansionBehavior;
+    Handled: boolean;
+    readonly PointerDeviceType: number;
+    RotationBehavior: Windows.UI.Xaml.Input.InertiaRotationBehavior;
+    TranslationBehavior: Windows.UI.Xaml.Input.InertiaTranslationBehavior;
+    readonly Velocities: Windows.UI.Input.ManipulationVelocities;
+  }
+  var IManipulationInertiaStartingRoutedEventArgs: abstract new (...args: any[]) => IManipulationInertiaStartingRoutedEventArgs;
+
+  interface IManipulationPivot {
+    Center: Windows.Foundation.Point;
+    Radius: number;
+  }
+  var IManipulationPivot: abstract new (...args: any[]) => IManipulationPivot;
+
+  interface IManipulationPivotFactory {
+    CreateInstanceWithCenterAndRadius(center: Windows.Foundation.Point, radius: number): Windows.UI.Xaml.Input.ManipulationPivot;
+  }
+  var IManipulationPivotFactory: abstract new (...args: any[]) => IManipulationPivotFactory;
+
+  interface IManipulationStartedRoutedEventArgs {
+    Complete(): void;
+    readonly Container: Windows.UI.Xaml.UIElement;
+    readonly Cumulative: Windows.UI.Input.ManipulationDelta;
+    Handled: boolean;
+    readonly PointerDeviceType: number;
+    readonly Position: Windows.Foundation.Point;
+  }
+  var IManipulationStartedRoutedEventArgs: abstract new (...args: any[]) => IManipulationStartedRoutedEventArgs;
+
+  interface IManipulationStartedRoutedEventArgsFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs;
+  }
+  var IManipulationStartedRoutedEventArgsFactory: abstract new (...args: any[]) => IManipulationStartedRoutedEventArgsFactory;
+
+  interface IManipulationStartingRoutedEventArgs {
+    Container: Windows.UI.Xaml.UIElement;
+    Handled: boolean;
+    Mode: number;
+    Pivot: Windows.UI.Xaml.Input.ManipulationPivot;
+  }
+  var IManipulationStartingRoutedEventArgs: abstract new (...args: any[]) => IManipulationStartingRoutedEventArgs;
+
+  interface INoFocusCandidateFoundEventArgs {
+    readonly Direction: number;
+    Handled: boolean;
+    readonly InputDevice: number;
+  }
+  var INoFocusCandidateFoundEventArgs: abstract new (...args: any[]) => INoFocusCandidateFoundEventArgs;
+
+  interface IPointer {
+    readonly IsInContact: boolean;
+    readonly IsInRange: boolean;
+    readonly PointerDeviceType: number;
+    readonly PointerId: number;
+  }
+  var IPointer: abstract new (...args: any[]) => IPointer;
+
+  interface IPointerRoutedEventArgs {
+    GetCurrentPoint(relativeTo: Windows.UI.Xaml.UIElement): Windows.UI.Input.PointerPoint;
+    GetIntermediatePoints(relativeTo: Windows.UI.Xaml.UIElement): Windows.Foundation.Collections.IVector<Windows.UI.Input.PointerPoint> | Windows.UI.Input.PointerPoint[];
+    Handled: boolean;
+    readonly KeyModifiers: number;
+    readonly Pointer: Windows.UI.Xaml.Input.Pointer;
+  }
+  var IPointerRoutedEventArgs: abstract new (...args: any[]) => IPointerRoutedEventArgs;
+
+  interface IPointerRoutedEventArgs2 {
+    readonly IsGenerated: boolean;
+  }
+  var IPointerRoutedEventArgs2: abstract new (...args: any[]) => IPointerRoutedEventArgs2;
+
+  interface IProcessKeyboardAcceleratorEventArgs {
+    Handled: boolean;
+    readonly Key: number;
+    readonly Modifiers: number;
+  }
+  var IProcessKeyboardAcceleratorEventArgs: abstract new (...args: any[]) => IProcessKeyboardAcceleratorEventArgs;
+
+  interface IRightTappedRoutedEventArgs {
+    GetPosition(relativeTo: Windows.UI.Xaml.UIElement): Windows.Foundation.Point;
+    Handled: boolean;
+    readonly PointerDeviceType: number;
+  }
+  var IRightTappedRoutedEventArgs: abstract new (...args: any[]) => IRightTappedRoutedEventArgs;
+
+  interface IStandardUICommand {
+    readonly Kind: number;
+  }
+  var IStandardUICommand: abstract new (...args: any[]) => IStandardUICommand;
+
+  interface IStandardUICommand2 {
+    Kind: Object;
+  }
+  var IStandardUICommand2: abstract new (...args: any[]) => IStandardUICommand2;
+
+  interface IStandardUICommandFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Input.StandardUICommand;
+    CreateInstanceWithKind(kind: number, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Input.StandardUICommand;
+  }
+  var IStandardUICommandFactory: abstract new (...args: any[]) => IStandardUICommandFactory;
+
+  interface IStandardUICommandStatics {
+    readonly KindProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IStandardUICommandStatics: abstract new (...args: any[]) => IStandardUICommandStatics;
+
+  interface ITappedRoutedEventArgs {
+    GetPosition(relativeTo: Windows.UI.Xaml.UIElement): Windows.Foundation.Point;
+    Handled: boolean;
+    readonly PointerDeviceType: number;
+  }
+  var ITappedRoutedEventArgs: abstract new (...args: any[]) => ITappedRoutedEventArgs;
+
+  interface IXamlUICommand {
+    NotifyCanExecuteChanged(): void;
+    AccessKey: string;
+    Command: Windows.UI.Xaml.Input.ICommand;
+    Description: string;
+    IconSource: Windows.UI.Xaml.Controls.IconSource;
+    readonly KeyboardAccelerators: Windows.Foundation.Collections.IVector<Windows.UI.Xaml.Input.KeyboardAccelerator> | Windows.UI.Xaml.Input.KeyboardAccelerator[];
+    Label: string;
+    CanExecuteRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Input.XamlUICommand, Windows.UI.Xaml.Input.CanExecuteRequestedEventArgs> | null;
+    ExecuteRequested: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Input.XamlUICommand, Windows.UI.Xaml.Input.ExecuteRequestedEventArgs> | null;
+  }
+  var IXamlUICommand: abstract new (...args: any[]) => IXamlUICommand;
+
+  interface IXamlUICommandFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Input.XamlUICommand;
+  }
+  var IXamlUICommandFactory: abstract new (...args: any[]) => IXamlUICommandFactory;
+
+  interface IXamlUICommandStatics {
+    readonly AccessKeyProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CommandProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DescriptionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IconSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly KeyboardAcceleratorsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LabelProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IXamlUICommandStatics: abstract new (...args: any[]) => IXamlUICommandStatics;
+
+  interface KeyEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Input.KeyRoutedEventArgs): void;
+  }
+  var KeyEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Input.KeyRoutedEventArgs) => void): KeyEventHandler;
+  };
+
+  interface ManipulationCompletedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs): void;
+  }
+  var ManipulationCompletedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs) => void): ManipulationCompletedEventHandler;
+  };
+
+  interface ManipulationDeltaEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs): void;
+  }
+  var ManipulationDeltaEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs) => void): ManipulationDeltaEventHandler;
+  };
+
+  interface ManipulationInertiaStartingEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs): void;
+  }
+  var ManipulationInertiaStartingEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs) => void): ManipulationInertiaStartingEventHandler;
+  };
+
+  interface ManipulationStartedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs): void;
+  }
+  var ManipulationStartedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs) => void): ManipulationStartedEventHandler;
+  };
+
+  interface ManipulationStartingEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs): void;
+  }
+  var ManipulationStartingEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs) => void): ManipulationStartingEventHandler;
+  };
+
+  interface PointerEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Input.PointerRoutedEventArgs): void;
+  }
+  var PointerEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Input.PointerRoutedEventArgs) => void): PointerEventHandler;
+  };
+
+  interface RightTappedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs): void;
+  }
+  var RightTappedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Input.RightTappedRoutedEventArgs) => void): RightTappedEventHandler;
+  };
+
+  interface TappedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Input.TappedRoutedEventArgs): void;
+  }
+  var TappedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Input.TappedRoutedEventArgs) => void): TappedEventHandler;
+  };
+
+}
+
+declare namespace Windows.UI.Xaml.Interop {
+  class NotifyCollectionChangedEventArgs implements Windows.UI.Xaml.Interop.INotifyCollectionChangedEventArgs {
+    constructor(action: number, newItems: Windows.UI.Xaml.Interop.IBindableVector, oldItems: Windows.UI.Xaml.Interop.IBindableVector, newIndex: number, oldIndex: number);
+    readonly Action: number;
+    readonly NewItems: Windows.UI.Xaml.Interop.IBindableVector;
+    readonly NewStartingIndex: number;
+    readonly OldItems: Windows.UI.Xaml.Interop.IBindableVector;
+    readonly OldStartingIndex: number;
+  }
+
+  enum NotifyCollectionChangedAction {
+    Add = 0,
+    Remove = 1,
+    Replace = 2,
+    Move = 3,
+    Reset = 4,
+  }
+
+  enum TypeKind {
+    Primitive = 0,
+    Metadata = 1,
+    Custom = 2,
+  }
+
+  interface BindableVectorChangedEventHandler {
+    (vector: Windows.UI.Xaml.Interop.IBindableObservableVector, e: Object): void;
+  }
+  var BindableVectorChangedEventHandler: {
+    new(callback: (vector: Windows.UI.Xaml.Interop.IBindableObservableVector, e: Object) => void): BindableVectorChangedEventHandler;
+  };
+
+  interface IBindableIterable {
+    First(): Windows.UI.Xaml.Interop.IBindableIterator;
+  }
+  var IBindableIterable: abstract new (...args: any[]) => IBindableIterable;
+
+  interface IBindableIterator {
+    MoveNext(): boolean;
+    readonly Current: Object;
+    readonly HasCurrent: boolean;
+  }
+  var IBindableIterator: abstract new (...args: any[]) => IBindableIterator;
+
+  interface IBindableObservableVector extends Windows.UI.Xaml.Interop.IBindableIterable, Windows.UI.Xaml.Interop.IBindableVector {
+    Append(value: Object): void;
+    Clear(): void;
+    First(): Windows.UI.Xaml.Interop.IBindableIterator;
+    GetAt(index: number): Object;
+    GetView(): Windows.UI.Xaml.Interop.IBindableVectorView;
+    IndexOf(value: Object, index: number): boolean;
+    InsertAt(index: number, value: Object): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    SetAt(index: number, value: Object): void;
+    VectorChanged: Windows.UI.Xaml.Interop.BindableVectorChangedEventHandler | null;
+  }
+  var IBindableObservableVector: abstract new (...args: any[]) => IBindableObservableVector;
+
+  interface IBindableVector extends Windows.UI.Xaml.Interop.IBindableIterable {
+    Append(value: Object): void;
+    Clear(): void;
+    First(): Windows.UI.Xaml.Interop.IBindableIterator;
+    GetAt(index: number): Object;
+    GetView(): Windows.UI.Xaml.Interop.IBindableVectorView;
+    IndexOf(value: Object, index: number): boolean;
+    InsertAt(index: number, value: Object): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    SetAt(index: number, value: Object): void;
+    readonly Size: number;
+  }
+  var IBindableVector: abstract new (...args: any[]) => IBindableVector;
+
+  interface IBindableVectorView extends Windows.UI.Xaml.Interop.IBindableIterable {
+    First(): Windows.UI.Xaml.Interop.IBindableIterator;
+    GetAt(index: number): Object;
+    IndexOf(value: Object, index: number): boolean;
+    readonly Size: number;
+  }
+  var IBindableVectorView: abstract new (...args: any[]) => IBindableVectorView;
+
+  interface INotifyCollectionChanged {
+    CollectionChanged: Windows.UI.Xaml.Interop.NotifyCollectionChangedEventHandler | null;
+  }
+  var INotifyCollectionChanged: abstract new (...args: any[]) => INotifyCollectionChanged;
+
+  interface INotifyCollectionChangedEventArgs {
+    readonly Action: number;
+    readonly NewItems: Windows.UI.Xaml.Interop.IBindableVector;
+    readonly NewStartingIndex: number;
+    readonly OldItems: Windows.UI.Xaml.Interop.IBindableVector;
+    readonly OldStartingIndex: number;
+  }
+  var INotifyCollectionChangedEventArgs: abstract new (...args: any[]) => INotifyCollectionChangedEventArgs;
+
+  interface INotifyCollectionChangedEventArgsFactory {
+    CreateInstanceWithAllParameters(action: number, newItems: Windows.UI.Xaml.Interop.IBindableVector, oldItems: Windows.UI.Xaml.Interop.IBindableVector, newIndex: number, oldIndex: number, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Interop.NotifyCollectionChangedEventArgs;
+  }
+  var INotifyCollectionChangedEventArgsFactory: abstract new (...args: any[]) => INotifyCollectionChangedEventArgsFactory;
+
+  interface NotifyCollectionChangedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Interop.NotifyCollectionChangedEventArgs): void;
+  }
+  var NotifyCollectionChangedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Interop.NotifyCollectionChangedEventArgs) => void): NotifyCollectionChangedEventHandler;
+  };
+
+  interface TypeName {
+    Name: string;
+    Kind: number;
+  }
+  var TypeName: {
+    new(name: string, kind: number): TypeName;
+    new(fields: { Name?: string; Kind?: number }): TypeName;
+  };
+
+}
+
+declare namespace Windows.UI.Xaml.Markup {
+  class ContentPropertyAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class FullXamlMetadataProviderAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class MarkupExtension implements Windows.UI.Xaml.Markup.IMarkupExtension, Windows.UI.Xaml.Markup.IMarkupExtensionOverrides {
+    constructor();
+    ProvideValue(): Object;
+  }
+
+  class MarkupExtensionReturnTypeAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class XamlBinaryWriter implements Windows.UI.Xaml.Markup.IXamlBinaryWriter {
+    static Write(inputStreams: Windows.Foundation.Collections.IVector<Windows.Storage.Streams.IRandomAccessStream> | Windows.Storage.Streams.IRandomAccessStream[], outputStreams: Windows.Foundation.Collections.IVector<Windows.Storage.Streams.IRandomAccessStream> | Windows.Storage.Streams.IRandomAccessStream[], xamlMetadataProvider: Windows.UI.Xaml.Markup.IXamlMetadataProvider): Windows.UI.Xaml.Markup.XamlBinaryWriterErrorInformation;
+  }
+
+  class XamlBindingHelper implements Windows.UI.Xaml.Markup.IXamlBindingHelper {
+    static ConvertValue(type: Windows.UI.Xaml.Interop.TypeName, value: Object): Object;
+    static GetDataTemplateComponent(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Markup.IDataTemplateComponent;
+    static ResumeRendering(target: Windows.UI.Xaml.UIElement): void;
+    static SetDataTemplateComponent(element: Windows.UI.Xaml.DependencyObject, value: Windows.UI.Xaml.Markup.IDataTemplateComponent): void;
+    static SetPropertyFromBoolean(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: boolean): void;
+    static SetPropertyFromByte(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: number): void;
+    static SetPropertyFromChar16(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: string): void;
+    static SetPropertyFromDateTime(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: Windows.Foundation.DateTime): void;
+    static SetPropertyFromDouble(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: number): void;
+    static SetPropertyFromInt32(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: number): void;
+    static SetPropertyFromInt64(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: number | bigint): void;
+    static SetPropertyFromObject(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    static SetPropertyFromPoint(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: Windows.Foundation.Point): void;
+    static SetPropertyFromRect(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: Windows.Foundation.Rect): void;
+    static SetPropertyFromSingle(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: number): void;
+    static SetPropertyFromSize(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: Windows.Foundation.Size): void;
+    static SetPropertyFromString(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: string): void;
+    static SetPropertyFromTimeSpan(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: Windows.Foundation.TimeSpan): void;
+    static SetPropertyFromUInt32(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: number): void;
+    static SetPropertyFromUInt64(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: number | bigint): void;
+    static SetPropertyFromUri(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: Windows.Foundation.Uri): void;
+    static SuspendRendering(target: Windows.UI.Xaml.UIElement): void;
+    static readonly DataTemplateComponentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class XamlMarkupHelper implements Windows.UI.Xaml.Markup.IXamlMarkupHelper {
+    static UnloadObject(element: Windows.UI.Xaml.DependencyObject): void;
+  }
+
+  class XamlReader implements Windows.UI.Xaml.Markup.IXamlReader {
+    static Load(xaml: string): Object;
+    static LoadWithInitialTemplateValidation(xaml: string): Object;
+  }
+
+  interface IComponentConnector {
+    Connect(connectionId: number, target: Object): void;
+  }
+  var IComponentConnector: abstract new (...args: any[]) => IComponentConnector;
+
+  interface IComponentConnector2 {
+    GetBindingConnector(connectionId: number, target: Object): Windows.UI.Xaml.Markup.IComponentConnector;
+  }
+  var IComponentConnector2: abstract new (...args: any[]) => IComponentConnector2;
+
+  interface IDataTemplateComponent {
+    ProcessBindings(item: Object, itemIndex: number, phase: number, nextPhase: number): void;
+    Recycle(): void;
+  }
+  var IDataTemplateComponent: abstract new (...args: any[]) => IDataTemplateComponent;
+
+  interface IMarkupExtension {
+  }
+  var IMarkupExtension: abstract new (...args: any[]) => IMarkupExtension;
+
+  interface IMarkupExtensionFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Markup.MarkupExtension;
+  }
+  var IMarkupExtensionFactory: abstract new (...args: any[]) => IMarkupExtensionFactory;
+
+  interface IMarkupExtensionOverrides {
+    ProvideValue(): Object;
+  }
+  var IMarkupExtensionOverrides: abstract new (...args: any[]) => IMarkupExtensionOverrides;
+
+  interface IXamlBinaryWriter {
+  }
+  var IXamlBinaryWriter: abstract new (...args: any[]) => IXamlBinaryWriter;
+
+  interface IXamlBinaryWriterStatics {
+    Write(inputStreams: Windows.Foundation.Collections.IVector<Windows.Storage.Streams.IRandomAccessStream> | Windows.Storage.Streams.IRandomAccessStream[], outputStreams: Windows.Foundation.Collections.IVector<Windows.Storage.Streams.IRandomAccessStream> | Windows.Storage.Streams.IRandomAccessStream[], xamlMetadataProvider: Windows.UI.Xaml.Markup.IXamlMetadataProvider): Windows.UI.Xaml.Markup.XamlBinaryWriterErrorInformation;
+  }
+  var IXamlBinaryWriterStatics: abstract new (...args: any[]) => IXamlBinaryWriterStatics;
+
+  interface IXamlBindScopeDiagnostics {
+    Disable(lineNumber: number, columnNumber: number): void;
+  }
+  var IXamlBindScopeDiagnostics: abstract new (...args: any[]) => IXamlBindScopeDiagnostics;
+
+  interface IXamlBindingHelper {
+  }
+  var IXamlBindingHelper: abstract new (...args: any[]) => IXamlBindingHelper;
+
+  interface IXamlBindingHelperStatics {
+    ConvertValue(type: Windows.UI.Xaml.Interop.TypeName, value: Object): Object;
+    GetDataTemplateComponent(element: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.Markup.IDataTemplateComponent;
+    ResumeRendering(target: Windows.UI.Xaml.UIElement): void;
+    SetDataTemplateComponent(element: Windows.UI.Xaml.DependencyObject, value: Windows.UI.Xaml.Markup.IDataTemplateComponent): void;
+    SetPropertyFromBoolean(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: boolean): void;
+    SetPropertyFromByte(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: number): void;
+    SetPropertyFromChar16(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: string): void;
+    SetPropertyFromDateTime(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: Windows.Foundation.DateTime): void;
+    SetPropertyFromDouble(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: number): void;
+    SetPropertyFromInt32(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: number): void;
+    SetPropertyFromInt64(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: number | bigint): void;
+    SetPropertyFromObject(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    SetPropertyFromPoint(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: Windows.Foundation.Point): void;
+    SetPropertyFromRect(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: Windows.Foundation.Rect): void;
+    SetPropertyFromSingle(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: number): void;
+    SetPropertyFromSize(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: Windows.Foundation.Size): void;
+    SetPropertyFromString(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: string): void;
+    SetPropertyFromTimeSpan(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: Windows.Foundation.TimeSpan): void;
+    SetPropertyFromUInt32(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: number): void;
+    SetPropertyFromUInt64(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: number | bigint): void;
+    SetPropertyFromUri(dependencyObject: Object, propertyToSet: Windows.UI.Xaml.DependencyProperty, value: Windows.Foundation.Uri): void;
+    SuspendRendering(target: Windows.UI.Xaml.UIElement): void;
+    readonly DataTemplateComponentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IXamlBindingHelperStatics: abstract new (...args: any[]) => IXamlBindingHelperStatics;
+
+  interface IXamlMarkupHelper {
+  }
+  var IXamlMarkupHelper: abstract new (...args: any[]) => IXamlMarkupHelper;
+
+  interface IXamlMarkupHelperStatics {
+    UnloadObject(element: Windows.UI.Xaml.DependencyObject): void;
+  }
+  var IXamlMarkupHelperStatics: abstract new (...args: any[]) => IXamlMarkupHelperStatics;
+
+  interface IXamlMember {
+    GetValue(instance: Object): Object;
+    SetValue(instance: Object, value: Object): void;
+    readonly IsAttachable: boolean;
+    readonly IsDependencyProperty: boolean;
+    readonly IsReadOnly: boolean;
+    readonly Name: string;
+    readonly TargetType: Windows.UI.Xaml.Markup.IXamlType;
+    readonly Type: Windows.UI.Xaml.Markup.IXamlType;
+  }
+  var IXamlMember: abstract new (...args: any[]) => IXamlMember;
+
+  interface IXamlMetadataProvider {
+    GetXamlType(type: Windows.UI.Xaml.Interop.TypeName): Windows.UI.Xaml.Markup.IXamlType;
+    GetXmlnsDefinitions(): Windows.UI.Xaml.Markup.XmlnsDefinition[];
+  }
+  var IXamlMetadataProvider: abstract new (...args: any[]) => IXamlMetadataProvider;
+
+  interface IXamlReader {
+  }
+  var IXamlReader: abstract new (...args: any[]) => IXamlReader;
+
+  interface IXamlReaderStatics {
+    Load(xaml: string): Object;
+    LoadWithInitialTemplateValidation(xaml: string): Object;
+  }
+  var IXamlReaderStatics: abstract new (...args: any[]) => IXamlReaderStatics;
+
+  interface IXamlType {
+    ActivateInstance(): Object;
+    AddToMap(instance: Object, key: Object, value: Object): void;
+    AddToVector(instance: Object, value: Object): void;
+    CreateFromString(value: string): Object;
+    GetMember(name: string): Windows.UI.Xaml.Markup.IXamlMember;
+    RunInitializer(): void;
+    readonly BaseType: Windows.UI.Xaml.Markup.IXamlType;
+    readonly ContentProperty: Windows.UI.Xaml.Markup.IXamlMember;
+    readonly FullName: string;
+    readonly IsArray: boolean;
+    readonly IsBindable: boolean;
+    readonly IsCollection: boolean;
+    readonly IsConstructible: boolean;
+    readonly IsDictionary: boolean;
+    readonly IsMarkupExtension: boolean;
+    readonly ItemType: Windows.UI.Xaml.Markup.IXamlType;
+    readonly KeyType: Windows.UI.Xaml.Markup.IXamlType;
+    readonly UnderlyingType: Windows.UI.Xaml.Interop.TypeName;
+  }
+  var IXamlType: abstract new (...args: any[]) => IXamlType;
+
+  interface IXamlType2 extends Windows.UI.Xaml.Markup.IXamlType {
+    ActivateInstance(): Object;
+    AddToMap(instance: Object, key: Object, value: Object): void;
+    AddToVector(instance: Object, value: Object): void;
+    CreateFromString(value: string): Object;
+    GetMember(name: string): Windows.UI.Xaml.Markup.IXamlMember;
+    RunInitializer(): void;
+    readonly BoxedType: Windows.UI.Xaml.Markup.IXamlType;
+  }
+  var IXamlType2: abstract new (...args: any[]) => IXamlType2;
+
+  interface XamlBinaryWriterErrorInformation {
+    InputStreamIndex: number;
+    LineNumber: number;
+    LinePosition: number;
+  }
+  var XamlBinaryWriterErrorInformation: {
+    new(inputStreamIndex: number, lineNumber: number, linePosition: number): XamlBinaryWriterErrorInformation;
+    new(fields: { InputStreamIndex?: number; LineNumber?: number; LinePosition?: number }): XamlBinaryWriterErrorInformation;
+  };
+
+  interface XmlnsDefinition {
+    XmlNamespace: string;
+    Namespace: string;
+  }
+  var XmlnsDefinition: {
+    new(xmlNamespace: string, namespace: string): XmlnsDefinition;
+    new(fields: { XmlNamespace?: string; Namespace?: string }): XmlnsDefinition;
+  };
+
+}
+
+declare namespace Windows.UI.Xaml.Media {
+  class AcrylicBrush extends Windows.UI.Xaml.Media.XamlCompositionBrushBase implements Windows.UI.Xaml.Media.IAcrylicBrush, Windows.UI.Xaml.Media.IAcrylicBrush2 {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    OnConnected(): void;
+    OnDisconnected(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    AlwaysUseFallback: boolean;
+    static readonly AlwaysUseFallbackProperty: Windows.UI.Xaml.DependencyProperty;
+    BackgroundSource: number;
+    static readonly BackgroundSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    TintColor: Windows.UI.Color;
+    static readonly TintColorProperty: Windows.UI.Xaml.DependencyProperty;
+    TintLuminosityOpacity: number | null;
+    static readonly TintLuminosityOpacityProperty: Windows.UI.Xaml.DependencyProperty;
+    TintOpacity: number;
+    static readonly TintOpacityProperty: Windows.UI.Xaml.DependencyProperty;
+    TintTransitionDuration: Windows.Foundation.TimeSpan;
+    static readonly TintTransitionDurationProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ArcSegment extends Windows.UI.Xaml.Media.PathSegment implements Windows.UI.Xaml.Media.IArcSegment {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    IsLargeArc: boolean;
+    static readonly IsLargeArcProperty: Windows.UI.Xaml.DependencyProperty;
+    Point: Windows.Foundation.Point;
+    static readonly PointProperty: Windows.UI.Xaml.DependencyProperty;
+    RotationAngle: number;
+    static readonly RotationAngleProperty: Windows.UI.Xaml.DependencyProperty;
+    Size: Windows.Foundation.Size;
+    static readonly SizeProperty: Windows.UI.Xaml.DependencyProperty;
+    SweepDirection: number;
+    static readonly SweepDirectionProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class BezierSegment extends Windows.UI.Xaml.Media.PathSegment implements Windows.UI.Xaml.Media.IBezierSegment {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Point1: Windows.Foundation.Point;
+    static readonly Point1Property: Windows.UI.Xaml.DependencyProperty;
+    Point2: Windows.Foundation.Point;
+    static readonly Point2Property: Windows.UI.Xaml.DependencyProperty;
+    Point3: Windows.Foundation.Point;
+    static readonly Point3Property: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class BitmapCache extends Windows.UI.Xaml.Media.CacheMode implements Windows.UI.Xaml.Media.IBitmapCache {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class Brush extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Composition.IAnimationObject, Windows.UI.Xaml.Media.IBrush, Windows.UI.Xaml.Media.IBrushOverrides2 {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Opacity: number;
+    static readonly OpacityProperty: Windows.UI.Xaml.DependencyProperty;
+    RelativeTransform: Windows.UI.Xaml.Media.Transform;
+    static readonly RelativeTransformProperty: Windows.UI.Xaml.DependencyProperty;
+    Transform: Windows.UI.Xaml.Media.Transform;
+    static readonly TransformProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class BrushCollection {
+    constructor();
+    Append(value: Windows.UI.Xaml.Media.Brush): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Media.Brush>;
+    GetAt(index: number): Windows.UI.Xaml.Media.Brush;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Media.Brush[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Media.Brush> | Windows.UI.Xaml.Media.Brush[];
+    IndexOf(value: Windows.UI.Xaml.Media.Brush, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Media.Brush): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Media.Brush[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Media.Brush): void;
+    readonly Size: number;
+  }
+
+  class CacheMode extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.ICacheMode {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class CompositeTransform extends Windows.UI.Xaml.Media.Transform implements Windows.UI.Xaml.Media.ICompositeTransform {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    TransformBounds(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TransformBoundsCore(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TransformPoint(point: Windows.Foundation.Point): Windows.Foundation.Point;
+    TryTransform(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    TryTransformCore(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    CenterX: number;
+    static readonly CenterXProperty: Windows.UI.Xaml.DependencyProperty;
+    CenterY: number;
+    static readonly CenterYProperty: Windows.UI.Xaml.DependencyProperty;
+    Rotation: number;
+    static readonly RotationProperty: Windows.UI.Xaml.DependencyProperty;
+    ScaleX: number;
+    static readonly ScaleXProperty: Windows.UI.Xaml.DependencyProperty;
+    ScaleY: number;
+    static readonly ScaleYProperty: Windows.UI.Xaml.DependencyProperty;
+    SkewX: number;
+    static readonly SkewXProperty: Windows.UI.Xaml.DependencyProperty;
+    SkewY: number;
+    static readonly SkewYProperty: Windows.UI.Xaml.DependencyProperty;
+    TranslateX: number;
+    static readonly TranslateXProperty: Windows.UI.Xaml.DependencyProperty;
+    TranslateY: number;
+    static readonly TranslateYProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class CompositionTarget implements Windows.UI.Xaml.Media.ICompositionTarget {
+    static Rendered: Windows.Foundation.EventHandler<Windows.UI.Xaml.Media.RenderedEventArgs> | null;
+    static Rendering: Windows.Foundation.EventHandler<Object> | null;
+    static SurfaceContentsLost: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class DoubleCollection {
+    constructor();
+    Append(value: number): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<number>;
+    GetAt(index: number): number;
+    GetMany(startIndex: number, items: number[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<number> | number[];
+    IndexOf(value: number, index: number): boolean;
+    InsertAt(index: number, value: number): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: number[]): void;
+    SetAt(index: number, value: number): void;
+    readonly Size: number;
+  }
+
+  class EllipseGeometry extends Windows.UI.Xaml.Media.Geometry implements Windows.UI.Xaml.Media.IEllipseGeometry {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Center: Windows.Foundation.Point;
+    static readonly CenterProperty: Windows.UI.Xaml.DependencyProperty;
+    RadiusX: number;
+    static readonly RadiusXProperty: Windows.UI.Xaml.DependencyProperty;
+    RadiusY: number;
+    static readonly RadiusYProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class FontFamily implements Windows.UI.Xaml.Media.IFontFamily {
+    constructor(familyName: string);
+    readonly Source: string;
+    static readonly XamlAutoFontFamily: Windows.UI.Xaml.Media.FontFamily;
+  }
+
+  class GeneralTransform extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.IGeneralTransform, Windows.UI.Xaml.Media.IGeneralTransformOverrides {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    TransformBounds(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TransformBoundsCore(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TransformPoint(point: Windows.Foundation.Point): Windows.Foundation.Point;
+    TryTransform(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    TryTransformCore(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly Inverse: Windows.UI.Xaml.Media.GeneralTransform;
+    readonly InverseCore: Windows.UI.Xaml.Media.GeneralTransform;
+  }
+
+  class Geometry extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.IGeometry {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly Bounds: Windows.Foundation.Rect;
+    static readonly Empty: Windows.UI.Xaml.Media.Geometry;
+    static readonly StandardFlatteningTolerance: number;
+    Transform: Windows.UI.Xaml.Media.Transform;
+    static readonly TransformProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class GeometryCollection {
+    constructor();
+    Append(value: Windows.UI.Xaml.Media.Geometry): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Media.Geometry>;
+    GetAt(index: number): Windows.UI.Xaml.Media.Geometry;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Media.Geometry[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Media.Geometry> | Windows.UI.Xaml.Media.Geometry[];
+    IndexOf(value: Windows.UI.Xaml.Media.Geometry, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Media.Geometry): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Media.Geometry[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Media.Geometry): void;
+    readonly Size: number;
+  }
+
+  class GeometryGroup extends Windows.UI.Xaml.Media.Geometry implements Windows.UI.Xaml.Media.IGeometryGroup {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Children: Windows.UI.Xaml.Media.GeometryCollection;
+    static readonly ChildrenProperty: Windows.UI.Xaml.DependencyProperty;
+    FillRule: number;
+    static readonly FillRuleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class GradientBrush extends Windows.UI.Xaml.Media.Brush implements Windows.UI.Xaml.Media.IGradientBrush {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    ColorInterpolationMode: number;
+    static readonly ColorInterpolationModeProperty: Windows.UI.Xaml.DependencyProperty;
+    GradientStops: Windows.UI.Xaml.Media.GradientStopCollection;
+    static readonly GradientStopsProperty: Windows.UI.Xaml.DependencyProperty;
+    MappingMode: number;
+    static readonly MappingModeProperty: Windows.UI.Xaml.DependencyProperty;
+    SpreadMethod: number;
+    static readonly SpreadMethodProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class GradientStop extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.IGradientStop {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Color: Windows.UI.Color;
+    static readonly ColorProperty: Windows.UI.Xaml.DependencyProperty;
+    Offset: number;
+    static readonly OffsetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class GradientStopCollection {
+    constructor();
+    Append(value: Windows.UI.Xaml.Media.GradientStop): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Media.GradientStop>;
+    GetAt(index: number): Windows.UI.Xaml.Media.GradientStop;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Media.GradientStop[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Media.GradientStop> | Windows.UI.Xaml.Media.GradientStop[];
+    IndexOf(value: Windows.UI.Xaml.Media.GradientStop, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Media.GradientStop): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Media.GradientStop[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Media.GradientStop): void;
+    readonly Size: number;
+  }
+
+  class ImageBrush extends Windows.UI.Xaml.Media.TileBrush implements Windows.UI.Xaml.Media.IImageBrush {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    ImageSource: Windows.UI.Xaml.Media.ImageSource;
+    static readonly ImageSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    ImageFailed: Windows.UI.Xaml.ExceptionRoutedEventHandler | null;
+    ImageOpened: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+
+  class ImageSource extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.IImageSource {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class LineGeometry extends Windows.UI.Xaml.Media.Geometry implements Windows.UI.Xaml.Media.ILineGeometry {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    EndPoint: Windows.Foundation.Point;
+    static readonly EndPointProperty: Windows.UI.Xaml.DependencyProperty;
+    StartPoint: Windows.Foundation.Point;
+    static readonly StartPointProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class LineSegment extends Windows.UI.Xaml.Media.PathSegment implements Windows.UI.Xaml.Media.ILineSegment {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Point: Windows.Foundation.Point;
+    static readonly PointProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class LinearGradientBrush extends Windows.UI.Xaml.Media.GradientBrush implements Windows.UI.Xaml.Media.ILinearGradientBrush {
+    constructor(gradientStopCollection: Windows.UI.Xaml.Media.GradientStopCollection, angle: number);
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    EndPoint: Windows.Foundation.Point;
+    static readonly EndPointProperty: Windows.UI.Xaml.DependencyProperty;
+    StartPoint: Windows.Foundation.Point;
+    static readonly StartPointProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class LoadedImageSourceLoadCompletedEventArgs implements Windows.UI.Xaml.Media.ILoadedImageSourceLoadCompletedEventArgs {
+    readonly Status: number;
+  }
+
+  class LoadedImageSurface implements Windows.Foundation.IClosable, Windows.UI.Composition.ICompositionSurface, Windows.UI.Xaml.Media.ILoadedImageSurface {
+    Close(): void;
+    static StartLoadFromStream(stream: Windows.Storage.Streams.IRandomAccessStream, desiredMaxSize: Windows.Foundation.Size): Windows.UI.Xaml.Media.LoadedImageSurface;
+    static StartLoadFromStream(stream: Windows.Storage.Streams.IRandomAccessStream): Windows.UI.Xaml.Media.LoadedImageSurface;
+    static StartLoadFromUri(uri: Windows.Foundation.Uri, desiredMaxSize: Windows.Foundation.Size): Windows.UI.Xaml.Media.LoadedImageSurface;
+    static StartLoadFromUri(uri: Windows.Foundation.Uri): Windows.UI.Xaml.Media.LoadedImageSurface;
+    readonly DecodedPhysicalSize: Windows.Foundation.Size;
+    readonly DecodedSize: Windows.Foundation.Size;
+    readonly NaturalSize: Windows.Foundation.Size;
+    LoadCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Media.LoadedImageSurface, Windows.UI.Xaml.Media.LoadedImageSourceLoadCompletedEventArgs> | null;
+  }
+
+  class Matrix3DProjection extends Windows.UI.Xaml.Media.Projection implements Windows.UI.Xaml.Media.IMatrix3DProjection {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    ProjectionMatrix: Windows.UI.Xaml.Media.Media3D.Matrix3D;
+    static readonly ProjectionMatrixProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class MatrixHelper implements Windows.UI.Xaml.Media.IMatrixHelper {
+    static FromElements(m11: number, m12: number, m21: number, m22: number, offsetX: number, offsetY: number): Windows.UI.Xaml.Media.Matrix;
+    static GetIsIdentity(target: Windows.UI.Xaml.Media.Matrix): boolean;
+    static Transform(target: Windows.UI.Xaml.Media.Matrix, point: Windows.Foundation.Point): Windows.Foundation.Point;
+    static readonly Identity: Windows.UI.Xaml.Media.Matrix;
+  }
+
+  class MatrixTransform extends Windows.UI.Xaml.Media.Transform implements Windows.UI.Xaml.Media.IMatrixTransform {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    TransformBounds(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TransformBoundsCore(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TransformPoint(point: Windows.Foundation.Point): Windows.Foundation.Point;
+    TryTransform(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    TryTransformCore(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Matrix: Windows.UI.Xaml.Media.Matrix;
+    static readonly MatrixProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class MediaTransportControlsThumbnailRequestedEventArgs implements Windows.UI.Xaml.Media.IMediaTransportControlsThumbnailRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    SetThumbnailImage(source: Windows.Storage.Streams.IInputStream): void;
+  }
+
+  class PartialMediaFailureDetectedEventArgs implements Windows.UI.Xaml.Media.IPartialMediaFailureDetectedEventArgs, Windows.UI.Xaml.Media.IPartialMediaFailureDetectedEventArgs2 {
+    constructor();
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly StreamKind: number;
+  }
+
+  class PathFigure extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.IPathFigure {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    IsClosed: boolean;
+    static readonly IsClosedProperty: Windows.UI.Xaml.DependencyProperty;
+    IsFilled: boolean;
+    static readonly IsFilledProperty: Windows.UI.Xaml.DependencyProperty;
+    Segments: Windows.UI.Xaml.Media.PathSegmentCollection;
+    static readonly SegmentsProperty: Windows.UI.Xaml.DependencyProperty;
+    StartPoint: Windows.Foundation.Point;
+    static readonly StartPointProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PathFigureCollection {
+    constructor();
+    Append(value: Windows.UI.Xaml.Media.PathFigure): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Media.PathFigure>;
+    GetAt(index: number): Windows.UI.Xaml.Media.PathFigure;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Media.PathFigure[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Media.PathFigure> | Windows.UI.Xaml.Media.PathFigure[];
+    IndexOf(value: Windows.UI.Xaml.Media.PathFigure, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Media.PathFigure): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Media.PathFigure[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Media.PathFigure): void;
+    readonly Size: number;
+  }
+
+  class PathGeometry extends Windows.UI.Xaml.Media.Geometry implements Windows.UI.Xaml.Media.IPathGeometry {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Figures: Windows.UI.Xaml.Media.PathFigureCollection;
+    static readonly FiguresProperty: Windows.UI.Xaml.DependencyProperty;
+    FillRule: number;
+    static readonly FillRuleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PathSegment extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.IPathSegment {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class PathSegmentCollection {
+    constructor();
+    Append(value: Windows.UI.Xaml.Media.PathSegment): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Media.PathSegment>;
+    GetAt(index: number): Windows.UI.Xaml.Media.PathSegment;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Media.PathSegment[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Media.PathSegment> | Windows.UI.Xaml.Media.PathSegment[];
+    IndexOf(value: Windows.UI.Xaml.Media.PathSegment, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Media.PathSegment): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Media.PathSegment[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Media.PathSegment): void;
+    readonly Size: number;
+  }
+
+  class PlaneProjection extends Windows.UI.Xaml.Media.Projection implements Windows.UI.Xaml.Media.IPlaneProjection {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    CenterOfRotationX: number;
+    static readonly CenterOfRotationXProperty: Windows.UI.Xaml.DependencyProperty;
+    CenterOfRotationY: number;
+    static readonly CenterOfRotationYProperty: Windows.UI.Xaml.DependencyProperty;
+    CenterOfRotationZ: number;
+    static readonly CenterOfRotationZProperty: Windows.UI.Xaml.DependencyProperty;
+    GlobalOffsetX: number;
+    static readonly GlobalOffsetXProperty: Windows.UI.Xaml.DependencyProperty;
+    GlobalOffsetY: number;
+    static readonly GlobalOffsetYProperty: Windows.UI.Xaml.DependencyProperty;
+    GlobalOffsetZ: number;
+    static readonly GlobalOffsetZProperty: Windows.UI.Xaml.DependencyProperty;
+    LocalOffsetX: number;
+    static readonly LocalOffsetXProperty: Windows.UI.Xaml.DependencyProperty;
+    LocalOffsetY: number;
+    static readonly LocalOffsetYProperty: Windows.UI.Xaml.DependencyProperty;
+    LocalOffsetZ: number;
+    static readonly LocalOffsetZProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ProjectionMatrix: Windows.UI.Xaml.Media.Media3D.Matrix3D;
+    static readonly ProjectionMatrixProperty: Windows.UI.Xaml.DependencyProperty;
+    RotationX: number;
+    static readonly RotationXProperty: Windows.UI.Xaml.DependencyProperty;
+    RotationY: number;
+    static readonly RotationYProperty: Windows.UI.Xaml.DependencyProperty;
+    RotationZ: number;
+    static readonly RotationZProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PointCollection {
+    constructor();
+    Append(value: Windows.Foundation.Point): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Point>;
+    GetAt(index: number): Windows.Foundation.Point;
+    GetMany(startIndex: number, items: Windows.Foundation.Point[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.Foundation.Point> | Windows.Foundation.Point[];
+    IndexOf(value: Windows.Foundation.Point, index: number): boolean;
+    InsertAt(index: number, value: Windows.Foundation.Point): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.Foundation.Point[]): void;
+    SetAt(index: number, value: Windows.Foundation.Point): void;
+    readonly Size: number;
+  }
+
+  class PolyBezierSegment extends Windows.UI.Xaml.Media.PathSegment implements Windows.UI.Xaml.Media.IPolyBezierSegment {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Points: Windows.UI.Xaml.Media.PointCollection;
+    static readonly PointsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PolyLineSegment extends Windows.UI.Xaml.Media.PathSegment implements Windows.UI.Xaml.Media.IPolyLineSegment {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Points: Windows.UI.Xaml.Media.PointCollection;
+    static readonly PointsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PolyQuadraticBezierSegment extends Windows.UI.Xaml.Media.PathSegment implements Windows.UI.Xaml.Media.IPolyQuadraticBezierSegment {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Points: Windows.UI.Xaml.Media.PointCollection;
+    static readonly PointsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Projection extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.IProjection {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class QuadraticBezierSegment extends Windows.UI.Xaml.Media.PathSegment implements Windows.UI.Xaml.Media.IQuadraticBezierSegment {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Point1: Windows.Foundation.Point;
+    static readonly Point1Property: Windows.UI.Xaml.DependencyProperty;
+    Point2: Windows.Foundation.Point;
+    static readonly Point2Property: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class RateChangedRoutedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Media.IRateChangedRoutedEventArgs {
+    constructor();
+  }
+
+  class RectangleGeometry extends Windows.UI.Xaml.Media.Geometry implements Windows.UI.Xaml.Media.IRectangleGeometry {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Rect: Windows.Foundation.Rect;
+    static readonly RectProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class RenderedEventArgs implements Windows.UI.Xaml.Media.IRenderedEventArgs {
+    readonly FrameDuration: Windows.Foundation.TimeSpan;
+  }
+
+  class RenderingEventArgs implements Windows.UI.Xaml.Media.IRenderingEventArgs {
+    readonly RenderingTime: Windows.Foundation.TimeSpan;
+  }
+
+  class RevealBackgroundBrush extends Windows.UI.Xaml.Media.RevealBrush implements Windows.UI.Xaml.Media.IRevealBackgroundBrush {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetState(element: Windows.UI.Xaml.UIElement): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    OnConnected(): void;
+    OnDisconnected(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static SetState(element: Windows.UI.Xaml.UIElement, value: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class RevealBorderBrush extends Windows.UI.Xaml.Media.RevealBrush implements Windows.UI.Xaml.Media.IRevealBorderBrush {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetState(element: Windows.UI.Xaml.UIElement): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    OnConnected(): void;
+    OnDisconnected(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static SetState(element: Windows.UI.Xaml.UIElement, value: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class RevealBrush extends Windows.UI.Xaml.Media.XamlCompositionBrushBase implements Windows.UI.Xaml.Media.IRevealBrush {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetState(element: Windows.UI.Xaml.UIElement): number;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    OnConnected(): void;
+    OnDisconnected(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static SetState(element: Windows.UI.Xaml.UIElement, value: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    AlwaysUseFallback: boolean;
+    static readonly AlwaysUseFallbackProperty: Windows.UI.Xaml.DependencyProperty;
+    Color: Windows.UI.Color;
+    static readonly ColorProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly StateProperty: Windows.UI.Xaml.DependencyProperty;
+    TargetTheme: number;
+    static readonly TargetThemeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class RotateTransform extends Windows.UI.Xaml.Media.Transform implements Windows.UI.Xaml.Media.IRotateTransform {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    TransformBounds(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TransformBoundsCore(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TransformPoint(point: Windows.Foundation.Point): Windows.Foundation.Point;
+    TryTransform(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    TryTransformCore(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Angle: number;
+    static readonly AngleProperty: Windows.UI.Xaml.DependencyProperty;
+    CenterX: number;
+    static readonly CenterXProperty: Windows.UI.Xaml.DependencyProperty;
+    CenterY: number;
+    static readonly CenterYProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ScaleTransform extends Windows.UI.Xaml.Media.Transform implements Windows.UI.Xaml.Media.IScaleTransform {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    TransformBounds(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TransformBoundsCore(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TransformPoint(point: Windows.Foundation.Point): Windows.Foundation.Point;
+    TryTransform(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    TryTransformCore(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    CenterX: number;
+    static readonly CenterXProperty: Windows.UI.Xaml.DependencyProperty;
+    CenterY: number;
+    static readonly CenterYProperty: Windows.UI.Xaml.DependencyProperty;
+    ScaleX: number;
+    static readonly ScaleXProperty: Windows.UI.Xaml.DependencyProperty;
+    ScaleY: number;
+    static readonly ScaleYProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Shadow extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.IShadow {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class SkewTransform extends Windows.UI.Xaml.Media.Transform implements Windows.UI.Xaml.Media.ISkewTransform {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    TransformBounds(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TransformBoundsCore(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TransformPoint(point: Windows.Foundation.Point): Windows.Foundation.Point;
+    TryTransform(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    TryTransformCore(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    AngleX: number;
+    static readonly AngleXProperty: Windows.UI.Xaml.DependencyProperty;
+    AngleY: number;
+    static readonly AngleYProperty: Windows.UI.Xaml.DependencyProperty;
+    CenterX: number;
+    static readonly CenterXProperty: Windows.UI.Xaml.DependencyProperty;
+    CenterY: number;
+    static readonly CenterYProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class SolidColorBrush extends Windows.UI.Xaml.Media.Brush implements Windows.UI.Xaml.Media.ISolidColorBrush {
+    constructor(color: Windows.UI.Color);
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Color: Windows.UI.Color;
+    static readonly ColorProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ThemeShadow extends Windows.UI.Xaml.Media.Shadow implements Windows.UI.Xaml.Media.IThemeShadow {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly Receivers: Windows.UI.Xaml.UIElementWeakCollection;
+  }
+
+  class TileBrush extends Windows.UI.Xaml.Media.Brush implements Windows.UI.Xaml.Media.ITileBrush {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    AlignmentX: number;
+    static readonly AlignmentXProperty: Windows.UI.Xaml.DependencyProperty;
+    AlignmentY: number;
+    static readonly AlignmentYProperty: Windows.UI.Xaml.DependencyProperty;
+    Stretch: number;
+    static readonly StretchProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class TimelineMarker extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.ITimelineMarker {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Text: string;
+    static readonly TextProperty: Windows.UI.Xaml.DependencyProperty;
+    Time: Windows.Foundation.TimeSpan;
+    static readonly TimeProperty: Windows.UI.Xaml.DependencyProperty;
+    Type: string;
+    static readonly TypeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class TimelineMarkerCollection {
+    constructor();
+    Append(value: Windows.UI.Xaml.Media.TimelineMarker): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Media.TimelineMarker>;
+    GetAt(index: number): Windows.UI.Xaml.Media.TimelineMarker;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Media.TimelineMarker[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Media.TimelineMarker> | Windows.UI.Xaml.Media.TimelineMarker[];
+    IndexOf(value: Windows.UI.Xaml.Media.TimelineMarker, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Media.TimelineMarker): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Media.TimelineMarker[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Media.TimelineMarker): void;
+    readonly Size: number;
+  }
+
+  class TimelineMarkerRoutedEventArgs extends Windows.UI.Xaml.RoutedEventArgs implements Windows.UI.Xaml.Media.ITimelineMarkerRoutedEventArgs {
+    constructor();
+    Marker: Windows.UI.Xaml.Media.TimelineMarker;
+  }
+
+  class Transform extends Windows.UI.Xaml.Media.GeneralTransform implements Windows.UI.Xaml.Media.ITransform {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    TransformBounds(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TransformBoundsCore(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TransformPoint(point: Windows.Foundation.Point): Windows.Foundation.Point;
+    TryTransform(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    TryTransformCore(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class TransformCollection {
+    constructor();
+    Append(value: Windows.UI.Xaml.Media.Transform): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Media.Transform>;
+    GetAt(index: number): Windows.UI.Xaml.Media.Transform;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Media.Transform[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Media.Transform> | Windows.UI.Xaml.Media.Transform[];
+    IndexOf(value: Windows.UI.Xaml.Media.Transform, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Media.Transform): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Media.Transform[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Media.Transform): void;
+    readonly Size: number;
+  }
+
+  class TransformGroup extends Windows.UI.Xaml.Media.Transform implements Windows.UI.Xaml.Media.ITransformGroup {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    TransformBounds(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TransformBoundsCore(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TransformPoint(point: Windows.Foundation.Point): Windows.Foundation.Point;
+    TryTransform(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    TryTransformCore(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Children: Windows.UI.Xaml.Media.TransformCollection;
+    static readonly ChildrenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly Value: Windows.UI.Xaml.Media.Matrix;
+  }
+
+  class TranslateTransform extends Windows.UI.Xaml.Media.Transform implements Windows.UI.Xaml.Media.ITranslateTransform {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    TransformBounds(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TransformBoundsCore(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TransformPoint(point: Windows.Foundation.Point): Windows.Foundation.Point;
+    TryTransform(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    TryTransformCore(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    X: number;
+    static readonly XProperty: Windows.UI.Xaml.DependencyProperty;
+    Y: number;
+    static readonly YProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class VisualTreeHelper implements Windows.UI.Xaml.Media.IVisualTreeHelper {
+    static DisconnectChildrenRecursive(element: Windows.UI.Xaml.UIElement): void;
+    static FindElementsInHostCoordinates(intersectingPoint: Windows.Foundation.Point, subtree: Windows.UI.Xaml.UIElement): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.UIElement> | Windows.UI.Xaml.UIElement[];
+    static FindElementsInHostCoordinates(intersectingPoint: Windows.Foundation.Point, subtree: Windows.UI.Xaml.UIElement, includeAllElements: boolean): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.UIElement> | Windows.UI.Xaml.UIElement[];
+    static GetChild(reference: Windows.UI.Xaml.DependencyObject, childIndex: number): Windows.UI.Xaml.DependencyObject;
+    static GetChildrenCount(reference: Windows.UI.Xaml.DependencyObject): number;
+    static GetOpenPopups(window: Windows.UI.Xaml.Window): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Controls.Primitives.Popup> | Windows.UI.Xaml.Controls.Primitives.Popup[];
+    static GetOpenPopupsForXamlRoot(xamlRoot: Windows.UI.Xaml.XamlRoot): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Controls.Primitives.Popup> | Windows.UI.Xaml.Controls.Primitives.Popup[];
+    static GetParent(reference: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+  }
+
+  class XamlCompositionBrushBase extends Windows.UI.Xaml.Media.Brush implements Windows.UI.Xaml.Media.IXamlCompositionBrushBase, Windows.UI.Xaml.Media.IXamlCompositionBrushBaseOverrides, Windows.UI.Xaml.Media.IXamlCompositionBrushBaseProtected {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    OnConnected(): void;
+    OnDisconnected(): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    CompositionBrush: Windows.UI.Composition.CompositionBrush;
+    FallbackColor: Windows.UI.Color;
+    static readonly FallbackColorProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class XamlLight extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.IXamlLight, Windows.UI.Xaml.Media.IXamlLightOverrides, Windows.UI.Xaml.Media.IXamlLightProtected {
+    constructor();
+    static AddTargetBrush(lightId: string, brush: Windows.UI.Xaml.Media.Brush): void;
+    static AddTargetElement(lightId: string, element: Windows.UI.Xaml.UIElement): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetId(): string;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    OnConnected(newElement: Windows.UI.Xaml.UIElement): void;
+    OnDisconnected(oldElement: Windows.UI.Xaml.UIElement): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static RemoveTargetBrush(lightId: string, brush: Windows.UI.Xaml.Media.Brush): void;
+    static RemoveTargetElement(lightId: string, element: Windows.UI.Xaml.UIElement): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    CompositionLight: Windows.UI.Composition.CompositionLight;
+  }
+
+  enum AcrylicBackgroundSource {
+    HostBackdrop = 0,
+    Backdrop = 1,
+  }
+
+  enum AlignmentX {
+    Left = 0,
+    Center = 1,
+    Right = 2,
+  }
+
+  enum AlignmentY {
+    Top = 0,
+    Center = 1,
+    Bottom = 2,
+  }
+
+  enum AudioCategory {
+    Other = 0,
+    ForegroundOnlyMedia = 1,
+    BackgroundCapableMedia = 2,
+    Communications = 3,
+    Alerts = 4,
+    SoundEffects = 5,
+    GameEffects = 6,
+    GameMedia = 7,
+    GameChat = 8,
+    Speech = 9,
+    Movie = 10,
+    Media = 11,
+  }
+
+  enum AudioDeviceType {
+    Console = 0,
+    Multimedia = 1,
+    Communications = 2,
+  }
+
+  enum BrushMappingMode {
+    Absolute = 0,
+    RelativeToBoundingBox = 1,
+  }
+
+  enum ColorInterpolationMode {
+    ScRgbLinearInterpolation = 0,
+    SRgbLinearInterpolation = 1,
+  }
+
+  enum ElementCompositeMode {
+    Inherit = 0,
+    SourceOver = 1,
+    MinBlend = 2,
+  }
+
+  enum FastPlayFallbackBehaviour {
+    Skip = 0,
+    Hide = 1,
+    Disable = 2,
+  }
+
+  enum FillRule {
+    EvenOdd = 0,
+    Nonzero = 1,
+  }
+
+  enum GradientSpreadMethod {
+    Pad = 0,
+    Reflect = 1,
+    Repeat = 2,
+  }
+
+  enum LoadedImageSourceLoadStatus {
+    Success = 0,
+    NetworkError = 1,
+    InvalidFormat = 2,
+    Other = 3,
+  }
+
+  enum MediaCanPlayResponse {
+    NotSupported = 0,
+    Maybe = 1,
+    Probably = 2,
+  }
+
+  enum MediaElementState {
+    Closed = 0,
+    Opening = 1,
+    Buffering = 2,
+    Playing = 3,
+    Paused = 4,
+    Stopped = 5,
+  }
+
+  enum PenLineCap {
+    Flat = 0,
+    Square = 1,
+    Round = 2,
+    Triangle = 3,
+  }
+
+  enum PenLineJoin {
+    Miter = 0,
+    Bevel = 1,
+    Round = 2,
+  }
+
+  enum RevealBrushState {
+    Normal = 0,
+    PointerOver = 1,
+    Pressed = 2,
+  }
+
+  enum Stereo3DVideoPackingMode {
+    None = 0,
+    SideBySide = 1,
+    TopBottom = 2,
+  }
+
+  enum Stereo3DVideoRenderMode {
+    Mono = 0,
+    Stereo = 1,
+  }
+
+  enum Stretch {
+    None = 0,
+    Fill = 1,
+    Uniform = 2,
+    UniformToFill = 3,
+  }
+
+  enum StyleSimulations {
+    None = 0,
+    BoldSimulation = 1,
+    ItalicSimulation = 2,
+    BoldItalicSimulation = 3,
+  }
+
+  enum SweepDirection {
+    Counterclockwise = 0,
+    Clockwise = 1,
+  }
+
+  interface IAcrylicBrush {
+    AlwaysUseFallback: boolean;
+    BackgroundSource: number;
+    TintColor: Windows.UI.Color;
+    TintOpacity: number;
+    TintTransitionDuration: Windows.Foundation.TimeSpan;
+  }
+  var IAcrylicBrush: abstract new (...args: any[]) => IAcrylicBrush;
+
+  interface IAcrylicBrush2 {
+    TintLuminosityOpacity: number | null;
+  }
+  var IAcrylicBrush2: abstract new (...args: any[]) => IAcrylicBrush2;
+
+  interface IAcrylicBrushFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.AcrylicBrush;
+  }
+  var IAcrylicBrushFactory: abstract new (...args: any[]) => IAcrylicBrushFactory;
+
+  interface IAcrylicBrushStatics {
+    readonly AlwaysUseFallbackProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BackgroundSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TintColorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TintOpacityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TintTransitionDurationProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAcrylicBrushStatics: abstract new (...args: any[]) => IAcrylicBrushStatics;
+
+  interface IAcrylicBrushStatics2 {
+    readonly TintLuminosityOpacityProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IAcrylicBrushStatics2: abstract new (...args: any[]) => IAcrylicBrushStatics2;
+
+  interface IArcSegment {
+    IsLargeArc: boolean;
+    Point: Windows.Foundation.Point;
+    RotationAngle: number;
+    Size: Windows.Foundation.Size;
+    SweepDirection: number;
+  }
+  var IArcSegment: abstract new (...args: any[]) => IArcSegment;
+
+  interface IArcSegmentStatics {
+    readonly IsLargeArcProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PointProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RotationAngleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SizeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SweepDirectionProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IArcSegmentStatics: abstract new (...args: any[]) => IArcSegmentStatics;
+
+  interface IBezierSegment {
+    Point1: Windows.Foundation.Point;
+    Point2: Windows.Foundation.Point;
+    Point3: Windows.Foundation.Point;
+  }
+  var IBezierSegment: abstract new (...args: any[]) => IBezierSegment;
+
+  interface IBezierSegmentStatics {
+    readonly Point1Property: Windows.UI.Xaml.DependencyProperty;
+    readonly Point2Property: Windows.UI.Xaml.DependencyProperty;
+    readonly Point3Property: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IBezierSegmentStatics: abstract new (...args: any[]) => IBezierSegmentStatics;
+
+  interface IBitmapCache {
+  }
+  var IBitmapCache: abstract new (...args: any[]) => IBitmapCache;
+
+  interface IBrush {
+    Opacity: number;
+    RelativeTransform: Windows.UI.Xaml.Media.Transform;
+    Transform: Windows.UI.Xaml.Media.Transform;
+  }
+  var IBrush: abstract new (...args: any[]) => IBrush;
+
+  interface IBrushFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.Brush;
+  }
+  var IBrushFactory: abstract new (...args: any[]) => IBrushFactory;
+
+  interface IBrushOverrides2 {
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+  }
+  var IBrushOverrides2: abstract new (...args: any[]) => IBrushOverrides2;
+
+  interface IBrushStatics {
+    readonly OpacityProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RelativeTransformProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TransformProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IBrushStatics: abstract new (...args: any[]) => IBrushStatics;
+
+  interface ICacheMode {
+  }
+  var ICacheMode: abstract new (...args: any[]) => ICacheMode;
+
+  interface ICacheModeFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.CacheMode;
+  }
+  var ICacheModeFactory: abstract new (...args: any[]) => ICacheModeFactory;
+
+  interface ICompositeTransform {
+    CenterX: number;
+    CenterY: number;
+    Rotation: number;
+    ScaleX: number;
+    ScaleY: number;
+    SkewX: number;
+    SkewY: number;
+    TranslateX: number;
+    TranslateY: number;
+  }
+  var ICompositeTransform: abstract new (...args: any[]) => ICompositeTransform;
+
+  interface ICompositeTransformStatics {
+    readonly CenterXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CenterYProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RotationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ScaleXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ScaleYProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SkewXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SkewYProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TranslateXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TranslateYProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ICompositeTransformStatics: abstract new (...args: any[]) => ICompositeTransformStatics;
+
+  interface ICompositionTarget {
+  }
+  var ICompositionTarget: abstract new (...args: any[]) => ICompositionTarget;
+
+  interface ICompositionTargetStatics {
+    Rendering: Windows.Foundation.EventHandler<Object> | null;
+    SurfaceContentsLost: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var ICompositionTargetStatics: abstract new (...args: any[]) => ICompositionTargetStatics;
+
+  interface ICompositionTargetStatics3 {
+    Rendered: Windows.Foundation.EventHandler<Windows.UI.Xaml.Media.RenderedEventArgs> | null;
+  }
+  var ICompositionTargetStatics3: abstract new (...args: any[]) => ICompositionTargetStatics3;
+
+  interface IEllipseGeometry {
+    Center: Windows.Foundation.Point;
+    RadiusX: number;
+    RadiusY: number;
+  }
+  var IEllipseGeometry: abstract new (...args: any[]) => IEllipseGeometry;
+
+  interface IEllipseGeometryStatics {
+    readonly CenterProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RadiusXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RadiusYProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IEllipseGeometryStatics: abstract new (...args: any[]) => IEllipseGeometryStatics;
+
+  interface IFontFamily {
+    readonly Source: string;
+  }
+  var IFontFamily: abstract new (...args: any[]) => IFontFamily;
+
+  interface IFontFamilyFactory {
+    CreateInstanceWithName(familyName: string, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.FontFamily;
+  }
+  var IFontFamilyFactory: abstract new (...args: any[]) => IFontFamilyFactory;
+
+  interface IFontFamilyStatics2 {
+    readonly XamlAutoFontFamily: Windows.UI.Xaml.Media.FontFamily;
+  }
+  var IFontFamilyStatics2: abstract new (...args: any[]) => IFontFamilyStatics2;
+
+  interface IGeneralTransform {
+    TransformBounds(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TransformPoint(point: Windows.Foundation.Point): Windows.Foundation.Point;
+    TryTransform(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    readonly Inverse: Windows.UI.Xaml.Media.GeneralTransform;
+  }
+  var IGeneralTransform: abstract new (...args: any[]) => IGeneralTransform;
+
+  interface IGeneralTransformFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.GeneralTransform;
+  }
+  var IGeneralTransformFactory: abstract new (...args: any[]) => IGeneralTransformFactory;
+
+  interface IGeneralTransformOverrides {
+    TransformBoundsCore(rect: Windows.Foundation.Rect): Windows.Foundation.Rect;
+    TryTransformCore(inPoint: Windows.Foundation.Point, outPoint: Windows.Foundation.Point): boolean;
+    readonly InverseCore: Windows.UI.Xaml.Media.GeneralTransform;
+  }
+  var IGeneralTransformOverrides: abstract new (...args: any[]) => IGeneralTransformOverrides;
+
+  interface IGeometry {
+    readonly Bounds: Windows.Foundation.Rect;
+    Transform: Windows.UI.Xaml.Media.Transform;
+  }
+  var IGeometry: abstract new (...args: any[]) => IGeometry;
+
+  interface IGeometryFactory {
+  }
+  var IGeometryFactory: abstract new (...args: any[]) => IGeometryFactory;
+
+  interface IGeometryGroup {
+    Children: Windows.UI.Xaml.Media.GeometryCollection;
+    FillRule: number;
+  }
+  var IGeometryGroup: abstract new (...args: any[]) => IGeometryGroup;
+
+  interface IGeometryGroupStatics {
+    readonly ChildrenProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FillRuleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IGeometryGroupStatics: abstract new (...args: any[]) => IGeometryGroupStatics;
+
+  interface IGeometryStatics {
+    readonly Empty: Windows.UI.Xaml.Media.Geometry;
+    readonly StandardFlatteningTolerance: number;
+    readonly TransformProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IGeometryStatics: abstract new (...args: any[]) => IGeometryStatics;
+
+  interface IGradientBrush {
+    ColorInterpolationMode: number;
+    GradientStops: Windows.UI.Xaml.Media.GradientStopCollection;
+    MappingMode: number;
+    SpreadMethod: number;
+  }
+  var IGradientBrush: abstract new (...args: any[]) => IGradientBrush;
+
+  interface IGradientBrushFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.GradientBrush;
+  }
+  var IGradientBrushFactory: abstract new (...args: any[]) => IGradientBrushFactory;
+
+  interface IGradientBrushStatics {
+    readonly ColorInterpolationModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GradientStopsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly MappingModeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SpreadMethodProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IGradientBrushStatics: abstract new (...args: any[]) => IGradientBrushStatics;
+
+  interface IGradientStop {
+    Color: Windows.UI.Color;
+    Offset: number;
+  }
+  var IGradientStop: abstract new (...args: any[]) => IGradientStop;
+
+  interface IGradientStopStatics {
+    readonly ColorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OffsetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IGradientStopStatics: abstract new (...args: any[]) => IGradientStopStatics;
+
+  interface IImageBrush {
+    ImageSource: Windows.UI.Xaml.Media.ImageSource;
+    ImageFailed: Windows.UI.Xaml.ExceptionRoutedEventHandler | null;
+    ImageOpened: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+  var IImageBrush: abstract new (...args: any[]) => IImageBrush;
+
+  interface IImageBrushStatics {
+    readonly ImageSourceProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IImageBrushStatics: abstract new (...args: any[]) => IImageBrushStatics;
+
+  interface IImageSource {
+  }
+  var IImageSource: abstract new (...args: any[]) => IImageSource;
+
+  interface IImageSourceFactory {
+  }
+  var IImageSourceFactory: abstract new (...args: any[]) => IImageSourceFactory;
+
+  interface ILineGeometry {
+    EndPoint: Windows.Foundation.Point;
+    StartPoint: Windows.Foundation.Point;
+  }
+  var ILineGeometry: abstract new (...args: any[]) => ILineGeometry;
+
+  interface ILineGeometryStatics {
+    readonly EndPointProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StartPointProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ILineGeometryStatics: abstract new (...args: any[]) => ILineGeometryStatics;
+
+  interface ILineSegment {
+    Point: Windows.Foundation.Point;
+  }
+  var ILineSegment: abstract new (...args: any[]) => ILineSegment;
+
+  interface ILineSegmentStatics {
+    readonly PointProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ILineSegmentStatics: abstract new (...args: any[]) => ILineSegmentStatics;
+
+  interface ILinearGradientBrush {
+    EndPoint: Windows.Foundation.Point;
+    StartPoint: Windows.Foundation.Point;
+  }
+  var ILinearGradientBrush: abstract new (...args: any[]) => ILinearGradientBrush;
+
+  interface ILinearGradientBrushFactory {
+    CreateInstanceWithGradientStopCollectionAndAngle(gradientStopCollection: Windows.UI.Xaml.Media.GradientStopCollection, angle: number): Windows.UI.Xaml.Media.LinearGradientBrush;
+  }
+  var ILinearGradientBrushFactory: abstract new (...args: any[]) => ILinearGradientBrushFactory;
+
+  interface ILinearGradientBrushStatics {
+    readonly EndPointProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StartPointProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ILinearGradientBrushStatics: abstract new (...args: any[]) => ILinearGradientBrushStatics;
+
+  interface ILoadedImageSourceLoadCompletedEventArgs {
+    readonly Status: number;
+  }
+  var ILoadedImageSourceLoadCompletedEventArgs: abstract new (...args: any[]) => ILoadedImageSourceLoadCompletedEventArgs;
+
+  interface ILoadedImageSurface {
+    readonly DecodedPhysicalSize: Windows.Foundation.Size;
+    readonly DecodedSize: Windows.Foundation.Size;
+    readonly NaturalSize: Windows.Foundation.Size;
+    LoadCompleted: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Media.LoadedImageSurface, Windows.UI.Xaml.Media.LoadedImageSourceLoadCompletedEventArgs> | null;
+  }
+  var ILoadedImageSurface: abstract new (...args: any[]) => ILoadedImageSurface;
+
+  interface ILoadedImageSurfaceStatics {
+    StartLoadFromStream(stream: Windows.Storage.Streams.IRandomAccessStream, desiredMaxSize: Windows.Foundation.Size): Windows.UI.Xaml.Media.LoadedImageSurface;
+    StartLoadFromStream(stream: Windows.Storage.Streams.IRandomAccessStream): Windows.UI.Xaml.Media.LoadedImageSurface;
+    StartLoadFromUri(uri: Windows.Foundation.Uri, desiredMaxSize: Windows.Foundation.Size): Windows.UI.Xaml.Media.LoadedImageSurface;
+    StartLoadFromUri(uri: Windows.Foundation.Uri): Windows.UI.Xaml.Media.LoadedImageSurface;
+  }
+  var ILoadedImageSurfaceStatics: abstract new (...args: any[]) => ILoadedImageSurfaceStatics;
+
+  interface IMatrix3DProjection {
+    ProjectionMatrix: Windows.UI.Xaml.Media.Media3D.Matrix3D;
+  }
+  var IMatrix3DProjection: abstract new (...args: any[]) => IMatrix3DProjection;
+
+  interface IMatrix3DProjectionStatics {
+    readonly ProjectionMatrixProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMatrix3DProjectionStatics: abstract new (...args: any[]) => IMatrix3DProjectionStatics;
+
+  interface IMatrixHelper {
+  }
+  var IMatrixHelper: abstract new (...args: any[]) => IMatrixHelper;
+
+  interface IMatrixHelperStatics {
+    FromElements(m11: number, m12: number, m21: number, m22: number, offsetX: number, offsetY: number): Windows.UI.Xaml.Media.Matrix;
+    GetIsIdentity(target: Windows.UI.Xaml.Media.Matrix): boolean;
+    Transform(target: Windows.UI.Xaml.Media.Matrix, point: Windows.Foundation.Point): Windows.Foundation.Point;
+    readonly Identity: Windows.UI.Xaml.Media.Matrix;
+  }
+  var IMatrixHelperStatics: abstract new (...args: any[]) => IMatrixHelperStatics;
+
+  interface IMatrixTransform {
+    Matrix: Windows.UI.Xaml.Media.Matrix;
+  }
+  var IMatrixTransform: abstract new (...args: any[]) => IMatrixTransform;
+
+  interface IMatrixTransformStatics {
+    readonly MatrixProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IMatrixTransformStatics: abstract new (...args: any[]) => IMatrixTransformStatics;
+
+  interface IMediaTransportControlsThumbnailRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    SetThumbnailImage(source: Windows.Storage.Streams.IInputStream): void;
+  }
+  var IMediaTransportControlsThumbnailRequestedEventArgs: abstract new (...args: any[]) => IMediaTransportControlsThumbnailRequestedEventArgs;
+
+  interface IPartialMediaFailureDetectedEventArgs {
+    readonly StreamKind: number;
+  }
+  var IPartialMediaFailureDetectedEventArgs: abstract new (...args: any[]) => IPartialMediaFailureDetectedEventArgs;
+
+  interface IPartialMediaFailureDetectedEventArgs2 {
+    readonly ExtendedError: Windows.Foundation.HResult;
+  }
+  var IPartialMediaFailureDetectedEventArgs2: abstract new (...args: any[]) => IPartialMediaFailureDetectedEventArgs2;
+
+  interface IPathFigure {
+    IsClosed: boolean;
+    IsFilled: boolean;
+    Segments: Windows.UI.Xaml.Media.PathSegmentCollection;
+    StartPoint: Windows.Foundation.Point;
+  }
+  var IPathFigure: abstract new (...args: any[]) => IPathFigure;
+
+  interface IPathFigureStatics {
+    readonly IsClosedProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsFilledProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SegmentsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StartPointProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPathFigureStatics: abstract new (...args: any[]) => IPathFigureStatics;
+
+  interface IPathGeometry {
+    Figures: Windows.UI.Xaml.Media.PathFigureCollection;
+    FillRule: number;
+  }
+  var IPathGeometry: abstract new (...args: any[]) => IPathGeometry;
+
+  interface IPathGeometryStatics {
+    readonly FiguresProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FillRuleProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPathGeometryStatics: abstract new (...args: any[]) => IPathGeometryStatics;
+
+  interface IPathSegment {
+  }
+  var IPathSegment: abstract new (...args: any[]) => IPathSegment;
+
+  interface IPathSegmentFactory {
+  }
+  var IPathSegmentFactory: abstract new (...args: any[]) => IPathSegmentFactory;
+
+  interface IPlaneProjection {
+    CenterOfRotationX: number;
+    CenterOfRotationY: number;
+    CenterOfRotationZ: number;
+    GlobalOffsetX: number;
+    GlobalOffsetY: number;
+    GlobalOffsetZ: number;
+    LocalOffsetX: number;
+    LocalOffsetY: number;
+    LocalOffsetZ: number;
+    readonly ProjectionMatrix: Windows.UI.Xaml.Media.Media3D.Matrix3D;
+    RotationX: number;
+    RotationY: number;
+    RotationZ: number;
+  }
+  var IPlaneProjection: abstract new (...args: any[]) => IPlaneProjection;
+
+  interface IPlaneProjectionStatics {
+    readonly CenterOfRotationXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CenterOfRotationYProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CenterOfRotationZProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GlobalOffsetXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GlobalOffsetYProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GlobalOffsetZProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LocalOffsetXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LocalOffsetYProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly LocalOffsetZProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ProjectionMatrixProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RotationXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RotationYProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RotationZProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPlaneProjectionStatics: abstract new (...args: any[]) => IPlaneProjectionStatics;
+
+  interface IPolyBezierSegment {
+    Points: Windows.UI.Xaml.Media.PointCollection;
+  }
+  var IPolyBezierSegment: abstract new (...args: any[]) => IPolyBezierSegment;
+
+  interface IPolyBezierSegmentStatics {
+    readonly PointsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPolyBezierSegmentStatics: abstract new (...args: any[]) => IPolyBezierSegmentStatics;
+
+  interface IPolyLineSegment {
+    Points: Windows.UI.Xaml.Media.PointCollection;
+  }
+  var IPolyLineSegment: abstract new (...args: any[]) => IPolyLineSegment;
+
+  interface IPolyLineSegmentStatics {
+    readonly PointsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPolyLineSegmentStatics: abstract new (...args: any[]) => IPolyLineSegmentStatics;
+
+  interface IPolyQuadraticBezierSegment {
+    Points: Windows.UI.Xaml.Media.PointCollection;
+  }
+  var IPolyQuadraticBezierSegment: abstract new (...args: any[]) => IPolyQuadraticBezierSegment;
+
+  interface IPolyQuadraticBezierSegmentStatics {
+    readonly PointsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPolyQuadraticBezierSegmentStatics: abstract new (...args: any[]) => IPolyQuadraticBezierSegmentStatics;
+
+  interface IProjection {
+  }
+  var IProjection: abstract new (...args: any[]) => IProjection;
+
+  interface IProjectionFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.Projection;
+  }
+  var IProjectionFactory: abstract new (...args: any[]) => IProjectionFactory;
+
+  interface IQuadraticBezierSegment {
+    Point1: Windows.Foundation.Point;
+    Point2: Windows.Foundation.Point;
+  }
+  var IQuadraticBezierSegment: abstract new (...args: any[]) => IQuadraticBezierSegment;
+
+  interface IQuadraticBezierSegmentStatics {
+    readonly Point1Property: Windows.UI.Xaml.DependencyProperty;
+    readonly Point2Property: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IQuadraticBezierSegmentStatics: abstract new (...args: any[]) => IQuadraticBezierSegmentStatics;
+
+  interface IRateChangedRoutedEventArgs {
+  }
+  var IRateChangedRoutedEventArgs: abstract new (...args: any[]) => IRateChangedRoutedEventArgs;
+
+  interface IRectangleGeometry {
+    Rect: Windows.Foundation.Rect;
+  }
+  var IRectangleGeometry: abstract new (...args: any[]) => IRectangleGeometry;
+
+  interface IRectangleGeometryStatics {
+    readonly RectProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRectangleGeometryStatics: abstract new (...args: any[]) => IRectangleGeometryStatics;
+
+  interface IRenderedEventArgs {
+    readonly FrameDuration: Windows.Foundation.TimeSpan;
+  }
+  var IRenderedEventArgs: abstract new (...args: any[]) => IRenderedEventArgs;
+
+  interface IRenderingEventArgs {
+    readonly RenderingTime: Windows.Foundation.TimeSpan;
+  }
+  var IRenderingEventArgs: abstract new (...args: any[]) => IRenderingEventArgs;
+
+  interface IRevealBackgroundBrush {
+  }
+  var IRevealBackgroundBrush: abstract new (...args: any[]) => IRevealBackgroundBrush;
+
+  interface IRevealBackgroundBrushFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.RevealBackgroundBrush;
+  }
+  var IRevealBackgroundBrushFactory: abstract new (...args: any[]) => IRevealBackgroundBrushFactory;
+
+  interface IRevealBorderBrush {
+  }
+  var IRevealBorderBrush: abstract new (...args: any[]) => IRevealBorderBrush;
+
+  interface IRevealBorderBrushFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.RevealBorderBrush;
+  }
+  var IRevealBorderBrushFactory: abstract new (...args: any[]) => IRevealBorderBrushFactory;
+
+  interface IRevealBrush {
+    AlwaysUseFallback: boolean;
+    Color: Windows.UI.Color;
+    TargetTheme: number;
+  }
+  var IRevealBrush: abstract new (...args: any[]) => IRevealBrush;
+
+  interface IRevealBrushFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.RevealBrush;
+  }
+  var IRevealBrushFactory: abstract new (...args: any[]) => IRevealBrushFactory;
+
+  interface IRevealBrushStatics {
+    GetState(element: Windows.UI.Xaml.UIElement): number;
+    SetState(element: Windows.UI.Xaml.UIElement, value: number): void;
+    readonly AlwaysUseFallbackProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ColorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StateProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TargetThemeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRevealBrushStatics: abstract new (...args: any[]) => IRevealBrushStatics;
+
+  interface IRotateTransform {
+    Angle: number;
+    CenterX: number;
+    CenterY: number;
+  }
+  var IRotateTransform: abstract new (...args: any[]) => IRotateTransform;
+
+  interface IRotateTransformStatics {
+    readonly AngleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CenterXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CenterYProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRotateTransformStatics: abstract new (...args: any[]) => IRotateTransformStatics;
+
+  interface IScaleTransform {
+    CenterX: number;
+    CenterY: number;
+    ScaleX: number;
+    ScaleY: number;
+  }
+  var IScaleTransform: abstract new (...args: any[]) => IScaleTransform;
+
+  interface IScaleTransformStatics {
+    readonly CenterXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CenterYProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ScaleXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ScaleYProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IScaleTransformStatics: abstract new (...args: any[]) => IScaleTransformStatics;
+
+  interface IShadow {
+  }
+  var IShadow: abstract new (...args: any[]) => IShadow;
+
+  interface IShadowFactory {
+  }
+  var IShadowFactory: abstract new (...args: any[]) => IShadowFactory;
+
+  interface ISkewTransform {
+    AngleX: number;
+    AngleY: number;
+    CenterX: number;
+    CenterY: number;
+  }
+  var ISkewTransform: abstract new (...args: any[]) => ISkewTransform;
+
+  interface ISkewTransformStatics {
+    readonly AngleXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AngleYProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CenterXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CenterYProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISkewTransformStatics: abstract new (...args: any[]) => ISkewTransformStatics;
+
+  interface ISolidColorBrush {
+    Color: Windows.UI.Color;
+  }
+  var ISolidColorBrush: abstract new (...args: any[]) => ISolidColorBrush;
+
+  interface ISolidColorBrushFactory {
+    CreateInstanceWithColor(color: Windows.UI.Color): Windows.UI.Xaml.Media.SolidColorBrush;
+  }
+  var ISolidColorBrushFactory: abstract new (...args: any[]) => ISolidColorBrushFactory;
+
+  interface ISolidColorBrushStatics {
+    readonly ColorProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISolidColorBrushStatics: abstract new (...args: any[]) => ISolidColorBrushStatics;
+
+  interface IThemeShadow {
+    readonly Receivers: Windows.UI.Xaml.UIElementWeakCollection;
+  }
+  var IThemeShadow: abstract new (...args: any[]) => IThemeShadow;
+
+  interface IThemeShadowFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.ThemeShadow;
+  }
+  var IThemeShadowFactory: abstract new (...args: any[]) => IThemeShadowFactory;
+
+  interface ITileBrush {
+    AlignmentX: number;
+    AlignmentY: number;
+    Stretch: number;
+  }
+  var ITileBrush: abstract new (...args: any[]) => ITileBrush;
+
+  interface ITileBrushFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.TileBrush;
+  }
+  var ITileBrushFactory: abstract new (...args: any[]) => ITileBrushFactory;
+
+  interface ITileBrushStatics {
+    readonly AlignmentXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly AlignmentYProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StretchProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITileBrushStatics: abstract new (...args: any[]) => ITileBrushStatics;
+
+  interface ITimelineMarker {
+    Text: string;
+    Time: Windows.Foundation.TimeSpan;
+    Type: string;
+  }
+  var ITimelineMarker: abstract new (...args: any[]) => ITimelineMarker;
+
+  interface ITimelineMarkerRoutedEventArgs {
+    Marker: Windows.UI.Xaml.Media.TimelineMarker;
+  }
+  var ITimelineMarkerRoutedEventArgs: abstract new (...args: any[]) => ITimelineMarkerRoutedEventArgs;
+
+  interface ITimelineMarkerStatics {
+    readonly TextProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TimeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TypeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITimelineMarkerStatics: abstract new (...args: any[]) => ITimelineMarkerStatics;
+
+  interface ITransform {
+  }
+  var ITransform: abstract new (...args: any[]) => ITransform;
+
+  interface ITransformFactory {
+  }
+  var ITransformFactory: abstract new (...args: any[]) => ITransformFactory;
+
+  interface ITransformGroup {
+    Children: Windows.UI.Xaml.Media.TransformCollection;
+    readonly Value: Windows.UI.Xaml.Media.Matrix;
+  }
+  var ITransformGroup: abstract new (...args: any[]) => ITransformGroup;
+
+  interface ITransformGroupStatics {
+    readonly ChildrenProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITransformGroupStatics: abstract new (...args: any[]) => ITransformGroupStatics;
+
+  interface ITranslateTransform {
+    X: number;
+    Y: number;
+  }
+  var ITranslateTransform: abstract new (...args: any[]) => ITranslateTransform;
+
+  interface ITranslateTransformStatics {
+    readonly XProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly YProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITranslateTransformStatics: abstract new (...args: any[]) => ITranslateTransformStatics;
+
+  interface IVisualTreeHelper {
+  }
+  var IVisualTreeHelper: abstract new (...args: any[]) => IVisualTreeHelper;
+
+  interface IVisualTreeHelperStatics {
+    DisconnectChildrenRecursive(element: Windows.UI.Xaml.UIElement): void;
+    FindElementsInHostCoordinates(intersectingPoint: Windows.Foundation.Point, subtree: Windows.UI.Xaml.UIElement): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.UIElement> | Windows.UI.Xaml.UIElement[];
+    FindElementsInHostCoordinates(intersectingPoint: Windows.Foundation.Point, subtree: Windows.UI.Xaml.UIElement, includeAllElements: boolean): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.UIElement> | Windows.UI.Xaml.UIElement[];
+    GetChild(reference: Windows.UI.Xaml.DependencyObject, childIndex: number): Windows.UI.Xaml.DependencyObject;
+    GetChildrenCount(reference: Windows.UI.Xaml.DependencyObject): number;
+    GetParent(reference: Windows.UI.Xaml.DependencyObject): Windows.UI.Xaml.DependencyObject;
+  }
+  var IVisualTreeHelperStatics: abstract new (...args: any[]) => IVisualTreeHelperStatics;
+
+  interface IVisualTreeHelperStatics2 {
+    GetOpenPopups(window: Windows.UI.Xaml.Window): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Controls.Primitives.Popup> | Windows.UI.Xaml.Controls.Primitives.Popup[];
+  }
+  var IVisualTreeHelperStatics2: abstract new (...args: any[]) => IVisualTreeHelperStatics2;
+
+  interface IVisualTreeHelperStatics3 {
+    GetOpenPopupsForXamlRoot(xamlRoot: Windows.UI.Xaml.XamlRoot): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Controls.Primitives.Popup> | Windows.UI.Xaml.Controls.Primitives.Popup[];
+  }
+  var IVisualTreeHelperStatics3: abstract new (...args: any[]) => IVisualTreeHelperStatics3;
+
+  interface IXamlCompositionBrushBase {
+    FallbackColor: Windows.UI.Color;
+  }
+  var IXamlCompositionBrushBase: abstract new (...args: any[]) => IXamlCompositionBrushBase;
+
+  interface IXamlCompositionBrushBaseFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.XamlCompositionBrushBase;
+  }
+  var IXamlCompositionBrushBaseFactory: abstract new (...args: any[]) => IXamlCompositionBrushBaseFactory;
+
+  interface IXamlCompositionBrushBaseOverrides {
+    OnConnected(): void;
+    OnDisconnected(): void;
+  }
+  var IXamlCompositionBrushBaseOverrides: abstract new (...args: any[]) => IXamlCompositionBrushBaseOverrides;
+
+  interface IXamlCompositionBrushBaseProtected {
+    CompositionBrush: Windows.UI.Composition.CompositionBrush;
+  }
+  var IXamlCompositionBrushBaseProtected: abstract new (...args: any[]) => IXamlCompositionBrushBaseProtected;
+
+  interface IXamlCompositionBrushBaseStatics {
+    readonly FallbackColorProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IXamlCompositionBrushBaseStatics: abstract new (...args: any[]) => IXamlCompositionBrushBaseStatics;
+
+  interface IXamlLight {
+  }
+  var IXamlLight: abstract new (...args: any[]) => IXamlLight;
+
+  interface IXamlLightFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.XamlLight;
+  }
+  var IXamlLightFactory: abstract new (...args: any[]) => IXamlLightFactory;
+
+  interface IXamlLightOverrides {
+    GetId(): string;
+    OnConnected(newElement: Windows.UI.Xaml.UIElement): void;
+    OnDisconnected(oldElement: Windows.UI.Xaml.UIElement): void;
+  }
+  var IXamlLightOverrides: abstract new (...args: any[]) => IXamlLightOverrides;
+
+  interface IXamlLightProtected {
+    CompositionLight: Windows.UI.Composition.CompositionLight;
+  }
+  var IXamlLightProtected: abstract new (...args: any[]) => IXamlLightProtected;
+
+  interface IXamlLightStatics {
+    AddTargetBrush(lightId: string, brush: Windows.UI.Xaml.Media.Brush): void;
+    AddTargetElement(lightId: string, element: Windows.UI.Xaml.UIElement): void;
+    RemoveTargetBrush(lightId: string, brush: Windows.UI.Xaml.Media.Brush): void;
+    RemoveTargetElement(lightId: string, element: Windows.UI.Xaml.UIElement): void;
+  }
+  var IXamlLightStatics: abstract new (...args: any[]) => IXamlLightStatics;
+
+  interface Matrix {
+    M11: number;
+    M12: number;
+    M21: number;
+    M22: number;
+    OffsetX: number;
+    OffsetY: number;
+  }
+  var Matrix: {
+    new(m11: number, m12: number, m21: number, m22: number, offsetX: number, offsetY: number): Matrix;
+    new(fields: { M11?: number; M12?: number; M21?: number; M22?: number; OffsetX?: number; OffsetY?: number }): Matrix;
+  };
+
+  interface RateChangedRoutedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Media.RateChangedRoutedEventArgs): void;
+  }
+  var RateChangedRoutedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Media.RateChangedRoutedEventArgs) => void): RateChangedRoutedEventHandler;
+  };
+
+  interface TimelineMarkerRoutedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Media.TimelineMarkerRoutedEventArgs): void;
+  }
+  var TimelineMarkerRoutedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Media.TimelineMarkerRoutedEventArgs) => void): TimelineMarkerRoutedEventHandler;
+  };
+
+}
+
+declare namespace Windows.UI.Xaml.Media.Animation {
+  class AddDeleteThemeTransition extends Windows.UI.Xaml.Media.Animation.Transition implements Windows.UI.Xaml.Media.Animation.IAddDeleteThemeTransition {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class BackEase extends Windows.UI.Xaml.Media.Animation.EasingFunctionBase implements Windows.UI.Xaml.Media.Animation.IBackEase {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Ease(normalizedTime: number): number;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Amplitude: number;
+    static readonly AmplitudeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class BasicConnectedAnimationConfiguration extends Windows.UI.Xaml.Media.Animation.ConnectedAnimationConfiguration implements Windows.UI.Xaml.Media.Animation.IBasicConnectedAnimationConfiguration {
+    constructor();
+  }
+
+  class BeginStoryboard extends Windows.UI.Xaml.TriggerAction implements Windows.UI.Xaml.Media.Animation.IBeginStoryboard {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Storyboard: Windows.UI.Xaml.Media.Animation.Storyboard;
+    static readonly StoryboardProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class BounceEase extends Windows.UI.Xaml.Media.Animation.EasingFunctionBase implements Windows.UI.Xaml.Media.Animation.IBounceEase {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Ease(normalizedTime: number): number;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Bounces: number;
+    static readonly BouncesProperty: Windows.UI.Xaml.DependencyProperty;
+    Bounciness: number;
+    static readonly BouncinessProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class CircleEase extends Windows.UI.Xaml.Media.Animation.EasingFunctionBase implements Windows.UI.Xaml.Media.Animation.ICircleEase {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Ease(normalizedTime: number): number;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ColorAnimation extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IColorAnimation {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    By: Windows.UI.Color | null;
+    static readonly ByProperty: Windows.UI.Xaml.DependencyProperty;
+    EasingFunction: Windows.UI.Xaml.Media.Animation.EasingFunctionBase;
+    static readonly EasingFunctionProperty: Windows.UI.Xaml.DependencyProperty;
+    EnableDependentAnimation: boolean;
+    static readonly EnableDependentAnimationProperty: Windows.UI.Xaml.DependencyProperty;
+    From: Windows.UI.Color | null;
+    static readonly FromProperty: Windows.UI.Xaml.DependencyProperty;
+    To: Windows.UI.Color | null;
+    static readonly ToProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ColorAnimationUsingKeyFrames extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IColorAnimationUsingKeyFrames {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    EnableDependentAnimation: boolean;
+    static readonly EnableDependentAnimationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly KeyFrames: Windows.UI.Xaml.Media.Animation.ColorKeyFrameCollection;
+  }
+
+  class ColorKeyFrame extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.Animation.IColorKeyFrame {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    KeyTime: Windows.UI.Xaml.Media.Animation.KeyTime;
+    static readonly KeyTimeProperty: Windows.UI.Xaml.DependencyProperty;
+    Value: Windows.UI.Color;
+    static readonly ValueProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ColorKeyFrameCollection {
+    constructor();
+    Append(value: Windows.UI.Xaml.Media.Animation.ColorKeyFrame): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Media.Animation.ColorKeyFrame>;
+    GetAt(index: number): Windows.UI.Xaml.Media.Animation.ColorKeyFrame;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Media.Animation.ColorKeyFrame[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Media.Animation.ColorKeyFrame> | Windows.UI.Xaml.Media.Animation.ColorKeyFrame[];
+    IndexOf(value: Windows.UI.Xaml.Media.Animation.ColorKeyFrame, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Media.Animation.ColorKeyFrame): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Media.Animation.ColorKeyFrame[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Media.Animation.ColorKeyFrame): void;
+    readonly Size: number;
+  }
+
+  class CommonNavigationTransitionInfo extends Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo implements Windows.UI.Xaml.Media.Animation.ICommonNavigationTransitionInfo {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetIsStaggerElement(element: Windows.UI.Xaml.UIElement): boolean;
+    GetNavigationStateCore(): string;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static SetIsStaggerElement(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    SetNavigationStateCore(navigationState: string): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    static readonly IsStaggerElementProperty: Windows.UI.Xaml.DependencyProperty;
+    IsStaggeringEnabled: boolean;
+    static readonly IsStaggeringEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ConditionallyIndependentlyAnimatableAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class ConnectedAnimation implements Windows.UI.Xaml.Media.Animation.IConnectedAnimation, Windows.UI.Xaml.Media.Animation.IConnectedAnimation2, Windows.UI.Xaml.Media.Animation.IConnectedAnimation3 {
+    Cancel(): void;
+    SetAnimationComponent(component: number, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryStart(destination: Windows.UI.Xaml.UIElement): boolean;
+    TryStart(destination: Windows.UI.Xaml.UIElement, coordinatedElements: Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.UIElement> | Windows.UI.Xaml.UIElement[]): boolean;
+    Configuration: Windows.UI.Xaml.Media.Animation.ConnectedAnimationConfiguration;
+    IsScaleAnimationEnabled: boolean;
+    Completed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Media.Animation.ConnectedAnimation, Object> | null;
+  }
+
+  class ConnectedAnimationConfiguration implements Windows.UI.Xaml.Media.Animation.IConnectedAnimationConfiguration {
+  }
+
+  class ConnectedAnimationService implements Windows.UI.Xaml.Media.Animation.IConnectedAnimationService {
+    GetAnimation(key: string): Windows.UI.Xaml.Media.Animation.ConnectedAnimation;
+    static GetForCurrentView(): Windows.UI.Xaml.Media.Animation.ConnectedAnimationService;
+    PrepareToAnimate(key: string, source: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.Animation.ConnectedAnimation;
+    DefaultDuration: Windows.Foundation.TimeSpan;
+    DefaultEasingFunction: Windows.UI.Composition.CompositionEasingFunction;
+  }
+
+  class ContentThemeTransition extends Windows.UI.Xaml.Media.Animation.Transition implements Windows.UI.Xaml.Media.Animation.IContentThemeTransition {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    HorizontalOffset: number;
+    static readonly HorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    VerticalOffset: number;
+    static readonly VerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ContinuumNavigationTransitionInfo extends Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo implements Windows.UI.Xaml.Media.Animation.IContinuumNavigationTransitionInfo {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetExitElementContainer(element: Windows.UI.Xaml.Controls.ListViewBase): boolean;
+    static GetIsEntranceElement(element: Windows.UI.Xaml.UIElement): boolean;
+    static GetIsExitElement(element: Windows.UI.Xaml.UIElement): boolean;
+    GetNavigationStateCore(): string;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static SetExitElementContainer(element: Windows.UI.Xaml.Controls.ListViewBase, value: boolean): void;
+    static SetIsEntranceElement(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    static SetIsExitElement(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    SetNavigationStateCore(navigationState: string): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    ExitElement: Windows.UI.Xaml.UIElement;
+    static readonly ExitElementContainerProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly ExitElementProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly IsEntranceElementProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly IsExitElementProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class CubicEase extends Windows.UI.Xaml.Media.Animation.EasingFunctionBase implements Windows.UI.Xaml.Media.Animation.ICubicEase {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Ease(normalizedTime: number): number;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class DirectConnectedAnimationConfiguration extends Windows.UI.Xaml.Media.Animation.ConnectedAnimationConfiguration implements Windows.UI.Xaml.Media.Animation.IDirectConnectedAnimationConfiguration {
+    constructor();
+  }
+
+  class DiscreteColorKeyFrame extends Windows.UI.Xaml.Media.Animation.ColorKeyFrame implements Windows.UI.Xaml.Media.Animation.IDiscreteColorKeyFrame {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class DiscreteDoubleKeyFrame extends Windows.UI.Xaml.Media.Animation.DoubleKeyFrame implements Windows.UI.Xaml.Media.Animation.IDiscreteDoubleKeyFrame {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class DiscreteObjectKeyFrame extends Windows.UI.Xaml.Media.Animation.ObjectKeyFrame implements Windows.UI.Xaml.Media.Animation.IDiscreteObjectKeyFrame {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class DiscretePointKeyFrame extends Windows.UI.Xaml.Media.Animation.PointKeyFrame implements Windows.UI.Xaml.Media.Animation.IDiscretePointKeyFrame {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class DoubleAnimation extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IDoubleAnimation {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    By: number | null;
+    static readonly ByProperty: Windows.UI.Xaml.DependencyProperty;
+    EasingFunction: Windows.UI.Xaml.Media.Animation.EasingFunctionBase;
+    static readonly EasingFunctionProperty: Windows.UI.Xaml.DependencyProperty;
+    EnableDependentAnimation: boolean;
+    static readonly EnableDependentAnimationProperty: Windows.UI.Xaml.DependencyProperty;
+    From: number | null;
+    static readonly FromProperty: Windows.UI.Xaml.DependencyProperty;
+    To: number | null;
+    static readonly ToProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class DoubleAnimationUsingKeyFrames extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IDoubleAnimationUsingKeyFrames {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    EnableDependentAnimation: boolean;
+    static readonly EnableDependentAnimationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly KeyFrames: Windows.UI.Xaml.Media.Animation.DoubleKeyFrameCollection;
+  }
+
+  class DoubleKeyFrame extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.Animation.IDoubleKeyFrame {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    KeyTime: Windows.UI.Xaml.Media.Animation.KeyTime;
+    static readonly KeyTimeProperty: Windows.UI.Xaml.DependencyProperty;
+    Value: number;
+    static readonly ValueProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class DoubleKeyFrameCollection {
+    constructor();
+    Append(value: Windows.UI.Xaml.Media.Animation.DoubleKeyFrame): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Media.Animation.DoubleKeyFrame>;
+    GetAt(index: number): Windows.UI.Xaml.Media.Animation.DoubleKeyFrame;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Media.Animation.DoubleKeyFrame[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Media.Animation.DoubleKeyFrame> | Windows.UI.Xaml.Media.Animation.DoubleKeyFrame[];
+    IndexOf(value: Windows.UI.Xaml.Media.Animation.DoubleKeyFrame, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Media.Animation.DoubleKeyFrame): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Media.Animation.DoubleKeyFrame[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Media.Animation.DoubleKeyFrame): void;
+    readonly Size: number;
+  }
+
+  class DragItemThemeAnimation extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IDragItemThemeAnimation {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    TargetName: string;
+    static readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class DragOverThemeAnimation extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IDragOverThemeAnimation {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Direction: number;
+    static readonly DirectionProperty: Windows.UI.Xaml.DependencyProperty;
+    TargetName: string;
+    static readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    ToOffset: number;
+    static readonly ToOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class DrillInNavigationTransitionInfo extends Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo implements Windows.UI.Xaml.Media.Animation.IDrillInNavigationTransitionInfo {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetNavigationStateCore(): string;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetNavigationStateCore(navigationState: string): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class DrillInThemeAnimation extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IDrillInThemeAnimation {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    EntranceTarget: Windows.UI.Xaml.DependencyObject;
+    EntranceTargetName: string;
+    static readonly EntranceTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly EntranceTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    ExitTarget: Windows.UI.Xaml.DependencyObject;
+    ExitTargetName: string;
+    static readonly ExitTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly ExitTargetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class DrillOutThemeAnimation extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IDrillOutThemeAnimation {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    EntranceTarget: Windows.UI.Xaml.DependencyObject;
+    EntranceTargetName: string;
+    static readonly EntranceTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly EntranceTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    ExitTarget: Windows.UI.Xaml.DependencyObject;
+    ExitTargetName: string;
+    static readonly ExitTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly ExitTargetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class DropTargetItemThemeAnimation extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IDropTargetItemThemeAnimation {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    TargetName: string;
+    static readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class EasingColorKeyFrame extends Windows.UI.Xaml.Media.Animation.ColorKeyFrame implements Windows.UI.Xaml.Media.Animation.IEasingColorKeyFrame {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    EasingFunction: Windows.UI.Xaml.Media.Animation.EasingFunctionBase;
+    static readonly EasingFunctionProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class EasingDoubleKeyFrame extends Windows.UI.Xaml.Media.Animation.DoubleKeyFrame implements Windows.UI.Xaml.Media.Animation.IEasingDoubleKeyFrame {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    EasingFunction: Windows.UI.Xaml.Media.Animation.EasingFunctionBase;
+    static readonly EasingFunctionProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class EasingFunctionBase extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.Animation.IEasingFunctionBase {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Ease(normalizedTime: number): number;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    EasingMode: number;
+    static readonly EasingModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class EasingPointKeyFrame extends Windows.UI.Xaml.Media.Animation.PointKeyFrame implements Windows.UI.Xaml.Media.Animation.IEasingPointKeyFrame {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    EasingFunction: Windows.UI.Xaml.Media.Animation.EasingFunctionBase;
+    static readonly EasingFunctionProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class EdgeUIThemeTransition extends Windows.UI.Xaml.Media.Animation.Transition implements Windows.UI.Xaml.Media.Animation.IEdgeUIThemeTransition {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Edge: number;
+    static readonly EdgeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ElasticEase extends Windows.UI.Xaml.Media.Animation.EasingFunctionBase implements Windows.UI.Xaml.Media.Animation.IElasticEase {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Ease(normalizedTime: number): number;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Oscillations: number;
+    static readonly OscillationsProperty: Windows.UI.Xaml.DependencyProperty;
+    Springiness: number;
+    static readonly SpringinessProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class EntranceNavigationTransitionInfo extends Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo implements Windows.UI.Xaml.Media.Animation.IEntranceNavigationTransitionInfo {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static GetIsTargetElement(element: Windows.UI.Xaml.UIElement): boolean;
+    GetNavigationStateCore(): string;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    static SetIsTargetElement(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    SetNavigationStateCore(navigationState: string): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    static readonly IsTargetElementProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class EntranceThemeTransition extends Windows.UI.Xaml.Media.Animation.Transition implements Windows.UI.Xaml.Media.Animation.IEntranceThemeTransition {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    FromHorizontalOffset: number;
+    static readonly FromHorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    FromVerticalOffset: number;
+    static readonly FromVerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    IsStaggeringEnabled: boolean;
+    static readonly IsStaggeringEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ExponentialEase extends Windows.UI.Xaml.Media.Animation.EasingFunctionBase implements Windows.UI.Xaml.Media.Animation.IExponentialEase {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Ease(normalizedTime: number): number;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Exponent: number;
+    static readonly ExponentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class FadeInThemeAnimation extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IFadeInThemeAnimation {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    TargetName: string;
+    static readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class FadeOutThemeAnimation extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IFadeOutThemeAnimation {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    TargetName: string;
+    static readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class GravityConnectedAnimationConfiguration extends Windows.UI.Xaml.Media.Animation.ConnectedAnimationConfiguration implements Windows.UI.Xaml.Media.Animation.IGravityConnectedAnimationConfiguration, Windows.UI.Xaml.Media.Animation.IGravityConnectedAnimationConfiguration2 {
+    constructor();
+    IsShadowEnabled: boolean;
+  }
+
+  class IndependentlyAnimatableAttribute extends System.Attribute {
+    constructor();
+  }
+
+  class KeySpline extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.Animation.IKeySpline {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    ControlPoint1: Windows.Foundation.Point;
+    ControlPoint2: Windows.Foundation.Point;
+  }
+
+  class KeyTimeHelper implements Windows.UI.Xaml.Media.Animation.IKeyTimeHelper {
+    static FromTimeSpan(timeSpan: Windows.Foundation.TimeSpan): Windows.UI.Xaml.Media.Animation.KeyTime;
+  }
+
+  class LinearColorKeyFrame extends Windows.UI.Xaml.Media.Animation.ColorKeyFrame implements Windows.UI.Xaml.Media.Animation.ILinearColorKeyFrame {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class LinearDoubleKeyFrame extends Windows.UI.Xaml.Media.Animation.DoubleKeyFrame implements Windows.UI.Xaml.Media.Animation.ILinearDoubleKeyFrame {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class LinearPointKeyFrame extends Windows.UI.Xaml.Media.Animation.PointKeyFrame implements Windows.UI.Xaml.Media.Animation.ILinearPointKeyFrame {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class NavigationThemeTransition extends Windows.UI.Xaml.Media.Animation.Transition implements Windows.UI.Xaml.Media.Animation.INavigationThemeTransition {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    DefaultNavigationTransitionInfo: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+    static readonly DefaultNavigationTransitionInfoProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class NavigationTransitionInfo extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.Animation.INavigationTransitionInfo, Windows.UI.Xaml.Media.Animation.INavigationTransitionInfoOverrides {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetNavigationStateCore(): string;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetNavigationStateCore(navigationState: string): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ObjectAnimationUsingKeyFrames extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IObjectAnimationUsingKeyFrames {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    EnableDependentAnimation: boolean;
+    static readonly EnableDependentAnimationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly KeyFrames: Windows.UI.Xaml.Media.Animation.ObjectKeyFrameCollection;
+  }
+
+  class ObjectKeyFrame extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.Animation.IObjectKeyFrame {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    KeyTime: Windows.UI.Xaml.Media.Animation.KeyTime;
+    static readonly KeyTimeProperty: Windows.UI.Xaml.DependencyProperty;
+    Value: Object;
+    static readonly ValueProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class ObjectKeyFrameCollection {
+    constructor();
+    Append(value: Windows.UI.Xaml.Media.Animation.ObjectKeyFrame): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Media.Animation.ObjectKeyFrame>;
+    GetAt(index: number): Windows.UI.Xaml.Media.Animation.ObjectKeyFrame;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Media.Animation.ObjectKeyFrame[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Media.Animation.ObjectKeyFrame> | Windows.UI.Xaml.Media.Animation.ObjectKeyFrame[];
+    IndexOf(value: Windows.UI.Xaml.Media.Animation.ObjectKeyFrame, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Media.Animation.ObjectKeyFrame): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Media.Animation.ObjectKeyFrame[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Media.Animation.ObjectKeyFrame): void;
+    readonly Size: number;
+  }
+
+  class PaneThemeTransition extends Windows.UI.Xaml.Media.Animation.Transition implements Windows.UI.Xaml.Media.Animation.IPaneThemeTransition {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Edge: number;
+    static readonly EdgeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PointAnimation extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IPointAnimation {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    By: Windows.Foundation.Point | null;
+    static readonly ByProperty: Windows.UI.Xaml.DependencyProperty;
+    EasingFunction: Windows.UI.Xaml.Media.Animation.EasingFunctionBase;
+    static readonly EasingFunctionProperty: Windows.UI.Xaml.DependencyProperty;
+    EnableDependentAnimation: boolean;
+    static readonly EnableDependentAnimationProperty: Windows.UI.Xaml.DependencyProperty;
+    From: Windows.Foundation.Point | null;
+    static readonly FromProperty: Windows.UI.Xaml.DependencyProperty;
+    To: Windows.Foundation.Point | null;
+    static readonly ToProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PointAnimationUsingKeyFrames extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IPointAnimationUsingKeyFrames {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    EnableDependentAnimation: boolean;
+    static readonly EnableDependentAnimationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly KeyFrames: Windows.UI.Xaml.Media.Animation.PointKeyFrameCollection;
+  }
+
+  class PointKeyFrame extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.Animation.IPointKeyFrame {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    KeyTime: Windows.UI.Xaml.Media.Animation.KeyTime;
+    static readonly KeyTimeProperty: Windows.UI.Xaml.DependencyProperty;
+    Value: Windows.Foundation.Point;
+    static readonly ValueProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PointKeyFrameCollection {
+    constructor();
+    Append(value: Windows.UI.Xaml.Media.Animation.PointKeyFrame): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Media.Animation.PointKeyFrame>;
+    GetAt(index: number): Windows.UI.Xaml.Media.Animation.PointKeyFrame;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Media.Animation.PointKeyFrame[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Media.Animation.PointKeyFrame> | Windows.UI.Xaml.Media.Animation.PointKeyFrame[];
+    IndexOf(value: Windows.UI.Xaml.Media.Animation.PointKeyFrame, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Media.Animation.PointKeyFrame): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Media.Animation.PointKeyFrame[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Media.Animation.PointKeyFrame): void;
+    readonly Size: number;
+  }
+
+  class PointerDownThemeAnimation extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IPointerDownThemeAnimation {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    TargetName: string;
+    static readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PointerUpThemeAnimation extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IPointerUpThemeAnimation {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    TargetName: string;
+    static readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PopInThemeAnimation extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IPopInThemeAnimation {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    FromHorizontalOffset: number;
+    static readonly FromHorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    FromVerticalOffset: number;
+    static readonly FromVerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    TargetName: string;
+    static readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PopOutThemeAnimation extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IPopOutThemeAnimation {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    TargetName: string;
+    static readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PopupThemeTransition extends Windows.UI.Xaml.Media.Animation.Transition implements Windows.UI.Xaml.Media.Animation.IPopupThemeTransition {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    FromHorizontalOffset: number;
+    static readonly FromHorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    FromVerticalOffset: number;
+    static readonly FromVerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class PowerEase extends Windows.UI.Xaml.Media.Animation.EasingFunctionBase implements Windows.UI.Xaml.Media.Animation.IPowerEase {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Ease(normalizedTime: number): number;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Power: number;
+    static readonly PowerProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class QuadraticEase extends Windows.UI.Xaml.Media.Animation.EasingFunctionBase implements Windows.UI.Xaml.Media.Animation.IQuadraticEase {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Ease(normalizedTime: number): number;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class QuarticEase extends Windows.UI.Xaml.Media.Animation.EasingFunctionBase implements Windows.UI.Xaml.Media.Animation.IQuarticEase {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Ease(normalizedTime: number): number;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class QuinticEase extends Windows.UI.Xaml.Media.Animation.EasingFunctionBase implements Windows.UI.Xaml.Media.Animation.IQuinticEase {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Ease(normalizedTime: number): number;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class ReorderThemeTransition extends Windows.UI.Xaml.Media.Animation.Transition implements Windows.UI.Xaml.Media.Animation.IReorderThemeTransition {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class RepeatBehaviorHelper implements Windows.UI.Xaml.Media.Animation.IRepeatBehaviorHelper {
+    static Equals(target: Windows.UI.Xaml.Media.Animation.RepeatBehavior, value: Windows.UI.Xaml.Media.Animation.RepeatBehavior): boolean;
+    static FromCount(count: number): Windows.UI.Xaml.Media.Animation.RepeatBehavior;
+    static FromDuration(duration: Windows.Foundation.TimeSpan): Windows.UI.Xaml.Media.Animation.RepeatBehavior;
+    static GetHasCount(target: Windows.UI.Xaml.Media.Animation.RepeatBehavior): boolean;
+    static GetHasDuration(target: Windows.UI.Xaml.Media.Animation.RepeatBehavior): boolean;
+    static readonly Forever: Windows.UI.Xaml.Media.Animation.RepeatBehavior;
+  }
+
+  class RepositionThemeAnimation extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IRepositionThemeAnimation {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    FromHorizontalOffset: number;
+    static readonly FromHorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    FromVerticalOffset: number;
+    static readonly FromVerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    TargetName: string;
+    static readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class RepositionThemeTransition extends Windows.UI.Xaml.Media.Animation.Transition implements Windows.UI.Xaml.Media.Animation.IRepositionThemeTransition, Windows.UI.Xaml.Media.Animation.IRepositionThemeTransition2 {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    IsStaggeringEnabled: boolean;
+    static readonly IsStaggeringEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class SineEase extends Windows.UI.Xaml.Media.Animation.EasingFunctionBase implements Windows.UI.Xaml.Media.Animation.ISineEase {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Ease(normalizedTime: number): number;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class SlideNavigationTransitionInfo extends Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo implements Windows.UI.Xaml.Media.Animation.ISlideNavigationTransitionInfo, Windows.UI.Xaml.Media.Animation.ISlideNavigationTransitionInfo2 {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetNavigationStateCore(): string;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetNavigationStateCore(navigationState: string): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Effect: number;
+    static readonly EffectProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class SplineColorKeyFrame extends Windows.UI.Xaml.Media.Animation.ColorKeyFrame implements Windows.UI.Xaml.Media.Animation.ISplineColorKeyFrame {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    KeySpline: Windows.UI.Xaml.Media.Animation.KeySpline;
+    static readonly KeySplineProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class SplineDoubleKeyFrame extends Windows.UI.Xaml.Media.Animation.DoubleKeyFrame implements Windows.UI.Xaml.Media.Animation.ISplineDoubleKeyFrame {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    KeySpline: Windows.UI.Xaml.Media.Animation.KeySpline;
+    static readonly KeySplineProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class SplinePointKeyFrame extends Windows.UI.Xaml.Media.Animation.PointKeyFrame implements Windows.UI.Xaml.Media.Animation.ISplinePointKeyFrame {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    KeySpline: Windows.UI.Xaml.Media.Animation.KeySpline;
+    static readonly KeySplineProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class SplitCloseThemeAnimation extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.ISplitCloseThemeAnimation {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    ClosedLength: number;
+    static readonly ClosedLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    ClosedTarget: Windows.UI.Xaml.DependencyObject;
+    ClosedTargetName: string;
+    static readonly ClosedTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly ClosedTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    ContentTarget: Windows.UI.Xaml.DependencyObject;
+    ContentTargetName: string;
+    static readonly ContentTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly ContentTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    ContentTranslationDirection: number;
+    static readonly ContentTranslationDirectionProperty: Windows.UI.Xaml.DependencyProperty;
+    ContentTranslationOffset: number;
+    static readonly ContentTranslationOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    OffsetFromCenter: number;
+    static readonly OffsetFromCenterProperty: Windows.UI.Xaml.DependencyProperty;
+    OpenedLength: number;
+    static readonly OpenedLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    OpenedTarget: Windows.UI.Xaml.DependencyObject;
+    OpenedTargetName: string;
+    static readonly OpenedTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly OpenedTargetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class SplitOpenThemeAnimation extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.ISplitOpenThemeAnimation {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    ClosedLength: number;
+    static readonly ClosedLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    ClosedTarget: Windows.UI.Xaml.DependencyObject;
+    ClosedTargetName: string;
+    static readonly ClosedTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly ClosedTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    ContentTarget: Windows.UI.Xaml.DependencyObject;
+    ContentTargetName: string;
+    static readonly ContentTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly ContentTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    ContentTranslationDirection: number;
+    static readonly ContentTranslationDirectionProperty: Windows.UI.Xaml.DependencyProperty;
+    ContentTranslationOffset: number;
+    static readonly ContentTranslationOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    OffsetFromCenter: number;
+    static readonly OffsetFromCenterProperty: Windows.UI.Xaml.DependencyProperty;
+    OpenedLength: number;
+    static readonly OpenedLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    OpenedTarget: Windows.UI.Xaml.DependencyObject;
+    OpenedTargetName: string;
+    static readonly OpenedTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly OpenedTargetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Storyboard extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.IStoryboard {
+    constructor();
+    Begin(): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetCurrentState(): number;
+    GetCurrentTime(): Windows.Foundation.TimeSpan;
+    static GetTargetName(element: Windows.UI.Xaml.Media.Animation.Timeline): string;
+    static GetTargetProperty(element: Windows.UI.Xaml.Media.Animation.Timeline): string;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Pause(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    Resume(): void;
+    Seek(offset: Windows.Foundation.TimeSpan): void;
+    SeekAlignedToLastTick(offset: Windows.Foundation.TimeSpan): void;
+    static SetTarget(timeline: Windows.UI.Xaml.Media.Animation.Timeline, target: Windows.UI.Xaml.DependencyObject): void;
+    static SetTargetName(element: Windows.UI.Xaml.Media.Animation.Timeline, name: string): void;
+    static SetTargetProperty(element: Windows.UI.Xaml.Media.Animation.Timeline, path: string): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    SkipToFill(): void;
+    Stop(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly Children: Windows.UI.Xaml.Media.Animation.TimelineCollection;
+    static readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly TargetPropertyProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class SuppressNavigationTransitionInfo extends Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo implements Windows.UI.Xaml.Media.Animation.ISuppressNavigationTransitionInfo {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetNavigationStateCore(): string;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetNavigationStateCore(navigationState: string): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class SwipeBackThemeAnimation extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.ISwipeBackThemeAnimation {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    FromHorizontalOffset: number;
+    static readonly FromHorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    FromVerticalOffset: number;
+    static readonly FromVerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    TargetName: string;
+    static readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class SwipeHintThemeAnimation extends Windows.UI.Xaml.Media.Animation.Timeline implements Windows.UI.Xaml.Media.Animation.ISwipeHintThemeAnimation {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    TargetName: string;
+    static readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    ToHorizontalOffset: number;
+    static readonly ToHorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    ToVerticalOffset: number;
+    static readonly ToVerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Timeline extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.Animation.ITimeline {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    static AllowDependentAnimations: boolean;
+    AutoReverse: boolean;
+    static readonly AutoReverseProperty: Windows.UI.Xaml.DependencyProperty;
+    BeginTime: Windows.Foundation.TimeSpan | null;
+    static readonly BeginTimeProperty: Windows.UI.Xaml.DependencyProperty;
+    Duration: Windows.UI.Xaml.Duration;
+    static readonly DurationProperty: Windows.UI.Xaml.DependencyProperty;
+    FillBehavior: number;
+    static readonly FillBehaviorProperty: Windows.UI.Xaml.DependencyProperty;
+    RepeatBehavior: Windows.UI.Xaml.Media.Animation.RepeatBehavior;
+    static readonly RepeatBehaviorProperty: Windows.UI.Xaml.DependencyProperty;
+    SpeedRatio: number;
+    static readonly SpeedRatioProperty: Windows.UI.Xaml.DependencyProperty;
+    Completed: Windows.Foundation.EventHandler<Object> | null;
+  }
+
+  class TimelineCollection {
+    constructor();
+    Append(value: Windows.UI.Xaml.Media.Animation.Timeline): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Media.Animation.Timeline>;
+    GetAt(index: number): Windows.UI.Xaml.Media.Animation.Timeline;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Media.Animation.Timeline[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Media.Animation.Timeline> | Windows.UI.Xaml.Media.Animation.Timeline[];
+    IndexOf(value: Windows.UI.Xaml.Media.Animation.Timeline, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Media.Animation.Timeline): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Media.Animation.Timeline[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Media.Animation.Timeline): void;
+    readonly Size: number;
+  }
+
+  class Transition extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.Animation.ITransition {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class TransitionCollection {
+    constructor();
+    Append(value: Windows.UI.Xaml.Media.Animation.Transition): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.UI.Xaml.Media.Animation.Transition>;
+    GetAt(index: number): Windows.UI.Xaml.Media.Animation.Transition;
+    GetMany(startIndex: number, items: Windows.UI.Xaml.Media.Animation.Transition[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.UI.Xaml.Media.Animation.Transition> | Windows.UI.Xaml.Media.Animation.Transition[];
+    IndexOf(value: Windows.UI.Xaml.Media.Animation.Transition, index: number): boolean;
+    InsertAt(index: number, value: Windows.UI.Xaml.Media.Animation.Transition): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.UI.Xaml.Media.Animation.Transition[]): void;
+    SetAt(index: number, value: Windows.UI.Xaml.Media.Animation.Transition): void;
+    readonly Size: number;
+  }
+
+  enum ClockState {
+    Active = 0,
+    Filling = 1,
+    Stopped = 2,
+  }
+
+  enum ConnectedAnimationComponent {
+    OffsetX = 0,
+    OffsetY = 1,
+    CrossFade = 2,
+    Scale = 3,
+  }
+
+  enum EasingMode {
+    EaseOut = 0,
+    EaseIn = 1,
+    EaseInOut = 2,
+  }
+
+  enum FillBehavior {
+    HoldEnd = 0,
+    Stop = 1,
+  }
+
+  enum RepeatBehaviorType {
+    Count = 0,
+    Duration = 1,
+    Forever = 2,
+  }
+
+  enum SlideNavigationTransitionEffect {
+    FromBottom = 0,
+    FromLeft = 1,
+    FromRight = 2,
+  }
+
+  interface IAddDeleteThemeTransition {
+  }
+  var IAddDeleteThemeTransition: abstract new (...args: any[]) => IAddDeleteThemeTransition;
+
+  interface IBackEase {
+    Amplitude: number;
+  }
+  var IBackEase: abstract new (...args: any[]) => IBackEase;
+
+  interface IBackEaseStatics {
+    readonly AmplitudeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IBackEaseStatics: abstract new (...args: any[]) => IBackEaseStatics;
+
+  interface IBasicConnectedAnimationConfiguration {
+  }
+  var IBasicConnectedAnimationConfiguration: abstract new (...args: any[]) => IBasicConnectedAnimationConfiguration;
+
+  interface IBasicConnectedAnimationConfigurationFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.Animation.BasicConnectedAnimationConfiguration;
+  }
+  var IBasicConnectedAnimationConfigurationFactory: abstract new (...args: any[]) => IBasicConnectedAnimationConfigurationFactory;
+
+  interface IBeginStoryboard {
+    Storyboard: Windows.UI.Xaml.Media.Animation.Storyboard;
+  }
+  var IBeginStoryboard: abstract new (...args: any[]) => IBeginStoryboard;
+
+  interface IBeginStoryboardStatics {
+    readonly StoryboardProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IBeginStoryboardStatics: abstract new (...args: any[]) => IBeginStoryboardStatics;
+
+  interface IBounceEase {
+    Bounces: number;
+    Bounciness: number;
+  }
+  var IBounceEase: abstract new (...args: any[]) => IBounceEase;
+
+  interface IBounceEaseStatics {
+    readonly BouncesProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BouncinessProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IBounceEaseStatics: abstract new (...args: any[]) => IBounceEaseStatics;
+
+  interface ICircleEase {
+  }
+  var ICircleEase: abstract new (...args: any[]) => ICircleEase;
+
+  interface IColorAnimation {
+    By: Windows.UI.Color | null;
+    EasingFunction: Windows.UI.Xaml.Media.Animation.EasingFunctionBase;
+    EnableDependentAnimation: boolean;
+    From: Windows.UI.Color | null;
+    To: Windows.UI.Color | null;
+  }
+  var IColorAnimation: abstract new (...args: any[]) => IColorAnimation;
+
+  interface IColorAnimationStatics {
+    readonly ByProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly EasingFunctionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly EnableDependentAnimationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FromProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ToProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IColorAnimationStatics: abstract new (...args: any[]) => IColorAnimationStatics;
+
+  interface IColorAnimationUsingKeyFrames {
+    EnableDependentAnimation: boolean;
+    readonly KeyFrames: Windows.UI.Xaml.Media.Animation.ColorKeyFrameCollection;
+  }
+  var IColorAnimationUsingKeyFrames: abstract new (...args: any[]) => IColorAnimationUsingKeyFrames;
+
+  interface IColorAnimationUsingKeyFramesStatics {
+    readonly EnableDependentAnimationProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IColorAnimationUsingKeyFramesStatics: abstract new (...args: any[]) => IColorAnimationUsingKeyFramesStatics;
+
+  interface IColorKeyFrame {
+    KeyTime: Windows.UI.Xaml.Media.Animation.KeyTime;
+    Value: Windows.UI.Color;
+  }
+  var IColorKeyFrame: abstract new (...args: any[]) => IColorKeyFrame;
+
+  interface IColorKeyFrameFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.Animation.ColorKeyFrame;
+  }
+  var IColorKeyFrameFactory: abstract new (...args: any[]) => IColorKeyFrameFactory;
+
+  interface IColorKeyFrameStatics {
+    readonly KeyTimeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ValueProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IColorKeyFrameStatics: abstract new (...args: any[]) => IColorKeyFrameStatics;
+
+  interface ICommonNavigationTransitionInfo {
+    IsStaggeringEnabled: boolean;
+  }
+  var ICommonNavigationTransitionInfo: abstract new (...args: any[]) => ICommonNavigationTransitionInfo;
+
+  interface ICommonNavigationTransitionInfoStatics {
+    GetIsStaggerElement(element: Windows.UI.Xaml.UIElement): boolean;
+    SetIsStaggerElement(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    readonly IsStaggerElementProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsStaggeringEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ICommonNavigationTransitionInfoStatics: abstract new (...args: any[]) => ICommonNavigationTransitionInfoStatics;
+
+  interface IConnectedAnimation {
+    Cancel(): void;
+    TryStart(destination: Windows.UI.Xaml.UIElement): boolean;
+    Completed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Media.Animation.ConnectedAnimation, Object> | null;
+  }
+  var IConnectedAnimation: abstract new (...args: any[]) => IConnectedAnimation;
+
+  interface IConnectedAnimation2 {
+    SetAnimationComponent(component: number, animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TryStart(destination: Windows.UI.Xaml.UIElement, coordinatedElements: Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.UIElement> | Windows.UI.Xaml.UIElement[]): boolean;
+    IsScaleAnimationEnabled: boolean;
+  }
+  var IConnectedAnimation2: abstract new (...args: any[]) => IConnectedAnimation2;
+
+  interface IConnectedAnimation3 {
+    Configuration: Windows.UI.Xaml.Media.Animation.ConnectedAnimationConfiguration;
+  }
+  var IConnectedAnimation3: abstract new (...args: any[]) => IConnectedAnimation3;
+
+  interface IConnectedAnimationConfiguration {
+  }
+  var IConnectedAnimationConfiguration: abstract new (...args: any[]) => IConnectedAnimationConfiguration;
+
+  interface IConnectedAnimationConfigurationFactory {
+  }
+  var IConnectedAnimationConfigurationFactory: abstract new (...args: any[]) => IConnectedAnimationConfigurationFactory;
+
+  interface IConnectedAnimationService {
+    GetAnimation(key: string): Windows.UI.Xaml.Media.Animation.ConnectedAnimation;
+    PrepareToAnimate(key: string, source: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.Animation.ConnectedAnimation;
+    DefaultDuration: Windows.Foundation.TimeSpan;
+    DefaultEasingFunction: Windows.UI.Composition.CompositionEasingFunction;
+  }
+  var IConnectedAnimationService: abstract new (...args: any[]) => IConnectedAnimationService;
+
+  interface IConnectedAnimationServiceStatics {
+    GetForCurrentView(): Windows.UI.Xaml.Media.Animation.ConnectedAnimationService;
+  }
+  var IConnectedAnimationServiceStatics: abstract new (...args: any[]) => IConnectedAnimationServiceStatics;
+
+  interface IContentThemeTransition {
+    HorizontalOffset: number;
+    VerticalOffset: number;
+  }
+  var IContentThemeTransition: abstract new (...args: any[]) => IContentThemeTransition;
+
+  interface IContentThemeTransitionStatics {
+    readonly HorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly VerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IContentThemeTransitionStatics: abstract new (...args: any[]) => IContentThemeTransitionStatics;
+
+  interface IContinuumNavigationTransitionInfo {
+    ExitElement: Windows.UI.Xaml.UIElement;
+  }
+  var IContinuumNavigationTransitionInfo: abstract new (...args: any[]) => IContinuumNavigationTransitionInfo;
+
+  interface IContinuumNavigationTransitionInfoStatics {
+    GetExitElementContainer(element: Windows.UI.Xaml.Controls.ListViewBase): boolean;
+    GetIsEntranceElement(element: Windows.UI.Xaml.UIElement): boolean;
+    GetIsExitElement(element: Windows.UI.Xaml.UIElement): boolean;
+    SetExitElementContainer(element: Windows.UI.Xaml.Controls.ListViewBase, value: boolean): void;
+    SetIsEntranceElement(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    SetIsExitElement(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    readonly ExitElementContainerProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ExitElementProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsEntranceElementProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsExitElementProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IContinuumNavigationTransitionInfoStatics: abstract new (...args: any[]) => IContinuumNavigationTransitionInfoStatics;
+
+  interface ICubicEase {
+  }
+  var ICubicEase: abstract new (...args: any[]) => ICubicEase;
+
+  interface IDirectConnectedAnimationConfiguration {
+  }
+  var IDirectConnectedAnimationConfiguration: abstract new (...args: any[]) => IDirectConnectedAnimationConfiguration;
+
+  interface IDirectConnectedAnimationConfigurationFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.Animation.DirectConnectedAnimationConfiguration;
+  }
+  var IDirectConnectedAnimationConfigurationFactory: abstract new (...args: any[]) => IDirectConnectedAnimationConfigurationFactory;
+
+  interface IDiscreteColorKeyFrame {
+  }
+  var IDiscreteColorKeyFrame: abstract new (...args: any[]) => IDiscreteColorKeyFrame;
+
+  interface IDiscreteDoubleKeyFrame {
+  }
+  var IDiscreteDoubleKeyFrame: abstract new (...args: any[]) => IDiscreteDoubleKeyFrame;
+
+  interface IDiscreteObjectKeyFrame {
+  }
+  var IDiscreteObjectKeyFrame: abstract new (...args: any[]) => IDiscreteObjectKeyFrame;
+
+  interface IDiscretePointKeyFrame {
+  }
+  var IDiscretePointKeyFrame: abstract new (...args: any[]) => IDiscretePointKeyFrame;
+
+  interface IDoubleAnimation {
+    By: number | null;
+    EasingFunction: Windows.UI.Xaml.Media.Animation.EasingFunctionBase;
+    EnableDependentAnimation: boolean;
+    From: number | null;
+    To: number | null;
+  }
+  var IDoubleAnimation: abstract new (...args: any[]) => IDoubleAnimation;
+
+  interface IDoubleAnimationStatics {
+    readonly ByProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly EasingFunctionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly EnableDependentAnimationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FromProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ToProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IDoubleAnimationStatics: abstract new (...args: any[]) => IDoubleAnimationStatics;
+
+  interface IDoubleAnimationUsingKeyFrames {
+    EnableDependentAnimation: boolean;
+    readonly KeyFrames: Windows.UI.Xaml.Media.Animation.DoubleKeyFrameCollection;
+  }
+  var IDoubleAnimationUsingKeyFrames: abstract new (...args: any[]) => IDoubleAnimationUsingKeyFrames;
+
+  interface IDoubleAnimationUsingKeyFramesStatics {
+    readonly EnableDependentAnimationProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IDoubleAnimationUsingKeyFramesStatics: abstract new (...args: any[]) => IDoubleAnimationUsingKeyFramesStatics;
+
+  interface IDoubleKeyFrame {
+    KeyTime: Windows.UI.Xaml.Media.Animation.KeyTime;
+    Value: number;
+  }
+  var IDoubleKeyFrame: abstract new (...args: any[]) => IDoubleKeyFrame;
+
+  interface IDoubleKeyFrameFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.Animation.DoubleKeyFrame;
+  }
+  var IDoubleKeyFrameFactory: abstract new (...args: any[]) => IDoubleKeyFrameFactory;
+
+  interface IDoubleKeyFrameStatics {
+    readonly KeyTimeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ValueProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IDoubleKeyFrameStatics: abstract new (...args: any[]) => IDoubleKeyFrameStatics;
+
+  interface IDragItemThemeAnimation {
+    TargetName: string;
+  }
+  var IDragItemThemeAnimation: abstract new (...args: any[]) => IDragItemThemeAnimation;
+
+  interface IDragItemThemeAnimationStatics {
+    readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IDragItemThemeAnimationStatics: abstract new (...args: any[]) => IDragItemThemeAnimationStatics;
+
+  interface IDragOverThemeAnimation {
+    Direction: number;
+    TargetName: string;
+    ToOffset: number;
+  }
+  var IDragOverThemeAnimation: abstract new (...args: any[]) => IDragOverThemeAnimation;
+
+  interface IDragOverThemeAnimationStatics {
+    readonly DirectionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ToOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IDragOverThemeAnimationStatics: abstract new (...args: any[]) => IDragOverThemeAnimationStatics;
+
+  interface IDrillInNavigationTransitionInfo {
+  }
+  var IDrillInNavigationTransitionInfo: abstract new (...args: any[]) => IDrillInNavigationTransitionInfo;
+
+  interface IDrillInThemeAnimation {
+    EntranceTarget: Windows.UI.Xaml.DependencyObject;
+    EntranceTargetName: string;
+    ExitTarget: Windows.UI.Xaml.DependencyObject;
+    ExitTargetName: string;
+  }
+  var IDrillInThemeAnimation: abstract new (...args: any[]) => IDrillInThemeAnimation;
+
+  interface IDrillInThemeAnimationStatics {
+    readonly EntranceTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly EntranceTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ExitTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ExitTargetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IDrillInThemeAnimationStatics: abstract new (...args: any[]) => IDrillInThemeAnimationStatics;
+
+  interface IDrillOutThemeAnimation {
+    EntranceTarget: Windows.UI.Xaml.DependencyObject;
+    EntranceTargetName: string;
+    ExitTarget: Windows.UI.Xaml.DependencyObject;
+    ExitTargetName: string;
+  }
+  var IDrillOutThemeAnimation: abstract new (...args: any[]) => IDrillOutThemeAnimation;
+
+  interface IDrillOutThemeAnimationStatics {
+    readonly EntranceTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly EntranceTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ExitTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ExitTargetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IDrillOutThemeAnimationStatics: abstract new (...args: any[]) => IDrillOutThemeAnimationStatics;
+
+  interface IDropTargetItemThemeAnimation {
+    TargetName: string;
+  }
+  var IDropTargetItemThemeAnimation: abstract new (...args: any[]) => IDropTargetItemThemeAnimation;
+
+  interface IDropTargetItemThemeAnimationStatics {
+    readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IDropTargetItemThemeAnimationStatics: abstract new (...args: any[]) => IDropTargetItemThemeAnimationStatics;
+
+  interface IEasingColorKeyFrame {
+    EasingFunction: Windows.UI.Xaml.Media.Animation.EasingFunctionBase;
+  }
+  var IEasingColorKeyFrame: abstract new (...args: any[]) => IEasingColorKeyFrame;
+
+  interface IEasingColorKeyFrameStatics {
+    readonly EasingFunctionProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IEasingColorKeyFrameStatics: abstract new (...args: any[]) => IEasingColorKeyFrameStatics;
+
+  interface IEasingDoubleKeyFrame {
+    EasingFunction: Windows.UI.Xaml.Media.Animation.EasingFunctionBase;
+  }
+  var IEasingDoubleKeyFrame: abstract new (...args: any[]) => IEasingDoubleKeyFrame;
+
+  interface IEasingDoubleKeyFrameStatics {
+    readonly EasingFunctionProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IEasingDoubleKeyFrameStatics: abstract new (...args: any[]) => IEasingDoubleKeyFrameStatics;
+
+  interface IEasingFunctionBase {
+    Ease(normalizedTime: number): number;
+    EasingMode: number;
+  }
+  var IEasingFunctionBase: abstract new (...args: any[]) => IEasingFunctionBase;
+
+  interface IEasingFunctionBaseFactory {
+  }
+  var IEasingFunctionBaseFactory: abstract new (...args: any[]) => IEasingFunctionBaseFactory;
+
+  interface IEasingFunctionBaseStatics {
+    readonly EasingModeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IEasingFunctionBaseStatics: abstract new (...args: any[]) => IEasingFunctionBaseStatics;
+
+  interface IEasingPointKeyFrame {
+    EasingFunction: Windows.UI.Xaml.Media.Animation.EasingFunctionBase;
+  }
+  var IEasingPointKeyFrame: abstract new (...args: any[]) => IEasingPointKeyFrame;
+
+  interface IEasingPointKeyFrameStatics {
+    readonly EasingFunctionProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IEasingPointKeyFrameStatics: abstract new (...args: any[]) => IEasingPointKeyFrameStatics;
+
+  interface IEdgeUIThemeTransition {
+    Edge: number;
+  }
+  var IEdgeUIThemeTransition: abstract new (...args: any[]) => IEdgeUIThemeTransition;
+
+  interface IEdgeUIThemeTransitionStatics {
+    readonly EdgeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IEdgeUIThemeTransitionStatics: abstract new (...args: any[]) => IEdgeUIThemeTransitionStatics;
+
+  interface IElasticEase {
+    Oscillations: number;
+    Springiness: number;
+  }
+  var IElasticEase: abstract new (...args: any[]) => IElasticEase;
+
+  interface IElasticEaseStatics {
+    readonly OscillationsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SpringinessProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IElasticEaseStatics: abstract new (...args: any[]) => IElasticEaseStatics;
+
+  interface IEntranceNavigationTransitionInfo {
+  }
+  var IEntranceNavigationTransitionInfo: abstract new (...args: any[]) => IEntranceNavigationTransitionInfo;
+
+  interface IEntranceNavigationTransitionInfoStatics {
+    GetIsTargetElement(element: Windows.UI.Xaml.UIElement): boolean;
+    SetIsTargetElement(element: Windows.UI.Xaml.UIElement, value: boolean): void;
+    readonly IsTargetElementProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IEntranceNavigationTransitionInfoStatics: abstract new (...args: any[]) => IEntranceNavigationTransitionInfoStatics;
+
+  interface IEntranceThemeTransition {
+    FromHorizontalOffset: number;
+    FromVerticalOffset: number;
+    IsStaggeringEnabled: boolean;
+  }
+  var IEntranceThemeTransition: abstract new (...args: any[]) => IEntranceThemeTransition;
+
+  interface IEntranceThemeTransitionStatics {
+    readonly FromHorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FromVerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsStaggeringEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IEntranceThemeTransitionStatics: abstract new (...args: any[]) => IEntranceThemeTransitionStatics;
+
+  interface IExponentialEase {
+    Exponent: number;
+  }
+  var IExponentialEase: abstract new (...args: any[]) => IExponentialEase;
+
+  interface IExponentialEaseStatics {
+    readonly ExponentProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IExponentialEaseStatics: abstract new (...args: any[]) => IExponentialEaseStatics;
+
+  interface IFadeInThemeAnimation {
+    TargetName: string;
+  }
+  var IFadeInThemeAnimation: abstract new (...args: any[]) => IFadeInThemeAnimation;
+
+  interface IFadeInThemeAnimationStatics {
+    readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFadeInThemeAnimationStatics: abstract new (...args: any[]) => IFadeInThemeAnimationStatics;
+
+  interface IFadeOutThemeAnimation {
+    TargetName: string;
+  }
+  var IFadeOutThemeAnimation: abstract new (...args: any[]) => IFadeOutThemeAnimation;
+
+  interface IFadeOutThemeAnimationStatics {
+    readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IFadeOutThemeAnimationStatics: abstract new (...args: any[]) => IFadeOutThemeAnimationStatics;
+
+  interface IGravityConnectedAnimationConfiguration {
+  }
+  var IGravityConnectedAnimationConfiguration: abstract new (...args: any[]) => IGravityConnectedAnimationConfiguration;
+
+  interface IGravityConnectedAnimationConfiguration2 {
+    IsShadowEnabled: boolean;
+  }
+  var IGravityConnectedAnimationConfiguration2: abstract new (...args: any[]) => IGravityConnectedAnimationConfiguration2;
+
+  interface IGravityConnectedAnimationConfigurationFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.Animation.GravityConnectedAnimationConfiguration;
+  }
+  var IGravityConnectedAnimationConfigurationFactory: abstract new (...args: any[]) => IGravityConnectedAnimationConfigurationFactory;
+
+  interface IKeySpline {
+    ControlPoint1: Windows.Foundation.Point;
+    ControlPoint2: Windows.Foundation.Point;
+  }
+  var IKeySpline: abstract new (...args: any[]) => IKeySpline;
+
+  interface IKeyTimeHelper {
+  }
+  var IKeyTimeHelper: abstract new (...args: any[]) => IKeyTimeHelper;
+
+  interface IKeyTimeHelperStatics {
+    FromTimeSpan(timeSpan: Windows.Foundation.TimeSpan): Windows.UI.Xaml.Media.Animation.KeyTime;
+  }
+  var IKeyTimeHelperStatics: abstract new (...args: any[]) => IKeyTimeHelperStatics;
+
+  interface ILinearColorKeyFrame {
+  }
+  var ILinearColorKeyFrame: abstract new (...args: any[]) => ILinearColorKeyFrame;
+
+  interface ILinearDoubleKeyFrame {
+  }
+  var ILinearDoubleKeyFrame: abstract new (...args: any[]) => ILinearDoubleKeyFrame;
+
+  interface ILinearPointKeyFrame {
+  }
+  var ILinearPointKeyFrame: abstract new (...args: any[]) => ILinearPointKeyFrame;
+
+  interface INavigationThemeTransition {
+    DefaultNavigationTransitionInfo: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+  }
+  var INavigationThemeTransition: abstract new (...args: any[]) => INavigationThemeTransition;
+
+  interface INavigationThemeTransitionStatics {
+    readonly DefaultNavigationTransitionInfoProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var INavigationThemeTransitionStatics: abstract new (...args: any[]) => INavigationThemeTransitionStatics;
+
+  interface INavigationTransitionInfo {
+  }
+  var INavigationTransitionInfo: abstract new (...args: any[]) => INavigationTransitionInfo;
+
+  interface INavigationTransitionInfoFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+  }
+  var INavigationTransitionInfoFactory: abstract new (...args: any[]) => INavigationTransitionInfoFactory;
+
+  interface INavigationTransitionInfoOverrides {
+    GetNavigationStateCore(): string;
+    SetNavigationStateCore(navigationState: string): void;
+  }
+  var INavigationTransitionInfoOverrides: abstract new (...args: any[]) => INavigationTransitionInfoOverrides;
+
+  interface IObjectAnimationUsingKeyFrames {
+    EnableDependentAnimation: boolean;
+    readonly KeyFrames: Windows.UI.Xaml.Media.Animation.ObjectKeyFrameCollection;
+  }
+  var IObjectAnimationUsingKeyFrames: abstract new (...args: any[]) => IObjectAnimationUsingKeyFrames;
+
+  interface IObjectAnimationUsingKeyFramesStatics {
+    readonly EnableDependentAnimationProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IObjectAnimationUsingKeyFramesStatics: abstract new (...args: any[]) => IObjectAnimationUsingKeyFramesStatics;
+
+  interface IObjectKeyFrame {
+    KeyTime: Windows.UI.Xaml.Media.Animation.KeyTime;
+    Value: Object;
+  }
+  var IObjectKeyFrame: abstract new (...args: any[]) => IObjectKeyFrame;
+
+  interface IObjectKeyFrameFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.Animation.ObjectKeyFrame;
+  }
+  var IObjectKeyFrameFactory: abstract new (...args: any[]) => IObjectKeyFrameFactory;
+
+  interface IObjectKeyFrameStatics {
+    readonly KeyTimeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ValueProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IObjectKeyFrameStatics: abstract new (...args: any[]) => IObjectKeyFrameStatics;
+
+  interface IPaneThemeTransition {
+    Edge: number;
+  }
+  var IPaneThemeTransition: abstract new (...args: any[]) => IPaneThemeTransition;
+
+  interface IPaneThemeTransitionStatics {
+    readonly EdgeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPaneThemeTransitionStatics: abstract new (...args: any[]) => IPaneThemeTransitionStatics;
+
+  interface IPointAnimation {
+    By: Windows.Foundation.Point | null;
+    EasingFunction: Windows.UI.Xaml.Media.Animation.EasingFunctionBase;
+    EnableDependentAnimation: boolean;
+    From: Windows.Foundation.Point | null;
+    To: Windows.Foundation.Point | null;
+  }
+  var IPointAnimation: abstract new (...args: any[]) => IPointAnimation;
+
+  interface IPointAnimationStatics {
+    readonly ByProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly EasingFunctionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly EnableDependentAnimationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FromProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ToProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPointAnimationStatics: abstract new (...args: any[]) => IPointAnimationStatics;
+
+  interface IPointAnimationUsingKeyFrames {
+    EnableDependentAnimation: boolean;
+    readonly KeyFrames: Windows.UI.Xaml.Media.Animation.PointKeyFrameCollection;
+  }
+  var IPointAnimationUsingKeyFrames: abstract new (...args: any[]) => IPointAnimationUsingKeyFrames;
+
+  interface IPointAnimationUsingKeyFramesStatics {
+    readonly EnableDependentAnimationProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPointAnimationUsingKeyFramesStatics: abstract new (...args: any[]) => IPointAnimationUsingKeyFramesStatics;
+
+  interface IPointKeyFrame {
+    KeyTime: Windows.UI.Xaml.Media.Animation.KeyTime;
+    Value: Windows.Foundation.Point;
+  }
+  var IPointKeyFrame: abstract new (...args: any[]) => IPointKeyFrame;
+
+  interface IPointKeyFrameFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.Animation.PointKeyFrame;
+  }
+  var IPointKeyFrameFactory: abstract new (...args: any[]) => IPointKeyFrameFactory;
+
+  interface IPointKeyFrameStatics {
+    readonly KeyTimeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ValueProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPointKeyFrameStatics: abstract new (...args: any[]) => IPointKeyFrameStatics;
+
+  interface IPointerDownThemeAnimation {
+    TargetName: string;
+  }
+  var IPointerDownThemeAnimation: abstract new (...args: any[]) => IPointerDownThemeAnimation;
+
+  interface IPointerDownThemeAnimationStatics {
+    readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPointerDownThemeAnimationStatics: abstract new (...args: any[]) => IPointerDownThemeAnimationStatics;
+
+  interface IPointerUpThemeAnimation {
+    TargetName: string;
+  }
+  var IPointerUpThemeAnimation: abstract new (...args: any[]) => IPointerUpThemeAnimation;
+
+  interface IPointerUpThemeAnimationStatics {
+    readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPointerUpThemeAnimationStatics: abstract new (...args: any[]) => IPointerUpThemeAnimationStatics;
+
+  interface IPopInThemeAnimation {
+    FromHorizontalOffset: number;
+    FromVerticalOffset: number;
+    TargetName: string;
+  }
+  var IPopInThemeAnimation: abstract new (...args: any[]) => IPopInThemeAnimation;
+
+  interface IPopInThemeAnimationStatics {
+    readonly FromHorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FromVerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPopInThemeAnimationStatics: abstract new (...args: any[]) => IPopInThemeAnimationStatics;
+
+  interface IPopOutThemeAnimation {
+    TargetName: string;
+  }
+  var IPopOutThemeAnimation: abstract new (...args: any[]) => IPopOutThemeAnimation;
+
+  interface IPopOutThemeAnimationStatics {
+    readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPopOutThemeAnimationStatics: abstract new (...args: any[]) => IPopOutThemeAnimationStatics;
+
+  interface IPopupThemeTransition {
+    FromHorizontalOffset: number;
+    FromVerticalOffset: number;
+  }
+  var IPopupThemeTransition: abstract new (...args: any[]) => IPopupThemeTransition;
+
+  interface IPopupThemeTransitionStatics {
+    readonly FromHorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FromVerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPopupThemeTransitionStatics: abstract new (...args: any[]) => IPopupThemeTransitionStatics;
+
+  interface IPowerEase {
+    Power: number;
+  }
+  var IPowerEase: abstract new (...args: any[]) => IPowerEase;
+
+  interface IPowerEaseStatics {
+    readonly PowerProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPowerEaseStatics: abstract new (...args: any[]) => IPowerEaseStatics;
+
+  interface IQuadraticEase {
+  }
+  var IQuadraticEase: abstract new (...args: any[]) => IQuadraticEase;
+
+  interface IQuarticEase {
+  }
+  var IQuarticEase: abstract new (...args: any[]) => IQuarticEase;
+
+  interface IQuinticEase {
+  }
+  var IQuinticEase: abstract new (...args: any[]) => IQuinticEase;
+
+  interface IReorderThemeTransition {
+  }
+  var IReorderThemeTransition: abstract new (...args: any[]) => IReorderThemeTransition;
+
+  interface IRepeatBehaviorHelper {
+  }
+  var IRepeatBehaviorHelper: abstract new (...args: any[]) => IRepeatBehaviorHelper;
+
+  interface IRepeatBehaviorHelperStatics {
+    Equals(target: Windows.UI.Xaml.Media.Animation.RepeatBehavior, value: Windows.UI.Xaml.Media.Animation.RepeatBehavior): boolean;
+    FromCount(count: number): Windows.UI.Xaml.Media.Animation.RepeatBehavior;
+    FromDuration(duration: Windows.Foundation.TimeSpan): Windows.UI.Xaml.Media.Animation.RepeatBehavior;
+    GetHasCount(target: Windows.UI.Xaml.Media.Animation.RepeatBehavior): boolean;
+    GetHasDuration(target: Windows.UI.Xaml.Media.Animation.RepeatBehavior): boolean;
+    readonly Forever: Windows.UI.Xaml.Media.Animation.RepeatBehavior;
+  }
+  var IRepeatBehaviorHelperStatics: abstract new (...args: any[]) => IRepeatBehaviorHelperStatics;
+
+  interface IRepositionThemeAnimation {
+    FromHorizontalOffset: number;
+    FromVerticalOffset: number;
+    TargetName: string;
+  }
+  var IRepositionThemeAnimation: abstract new (...args: any[]) => IRepositionThemeAnimation;
+
+  interface IRepositionThemeAnimationStatics {
+    readonly FromHorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FromVerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRepositionThemeAnimationStatics: abstract new (...args: any[]) => IRepositionThemeAnimationStatics;
+
+  interface IRepositionThemeTransition {
+  }
+  var IRepositionThemeTransition: abstract new (...args: any[]) => IRepositionThemeTransition;
+
+  interface IRepositionThemeTransition2 {
+    IsStaggeringEnabled: boolean;
+  }
+  var IRepositionThemeTransition2: abstract new (...args: any[]) => IRepositionThemeTransition2;
+
+  interface IRepositionThemeTransitionStatics2 {
+    readonly IsStaggeringEnabledProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRepositionThemeTransitionStatics2: abstract new (...args: any[]) => IRepositionThemeTransitionStatics2;
+
+  interface ISineEase {
+  }
+  var ISineEase: abstract new (...args: any[]) => ISineEase;
+
+  interface ISlideNavigationTransitionInfo {
+  }
+  var ISlideNavigationTransitionInfo: abstract new (...args: any[]) => ISlideNavigationTransitionInfo;
+
+  interface ISlideNavigationTransitionInfo2 {
+    Effect: number;
+  }
+  var ISlideNavigationTransitionInfo2: abstract new (...args: any[]) => ISlideNavigationTransitionInfo2;
+
+  interface ISlideNavigationTransitionInfoStatics2 {
+    readonly EffectProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISlideNavigationTransitionInfoStatics2: abstract new (...args: any[]) => ISlideNavigationTransitionInfoStatics2;
+
+  interface ISplineColorKeyFrame {
+    KeySpline: Windows.UI.Xaml.Media.Animation.KeySpline;
+  }
+  var ISplineColorKeyFrame: abstract new (...args: any[]) => ISplineColorKeyFrame;
+
+  interface ISplineColorKeyFrameStatics {
+    readonly KeySplineProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISplineColorKeyFrameStatics: abstract new (...args: any[]) => ISplineColorKeyFrameStatics;
+
+  interface ISplineDoubleKeyFrame {
+    KeySpline: Windows.UI.Xaml.Media.Animation.KeySpline;
+  }
+  var ISplineDoubleKeyFrame: abstract new (...args: any[]) => ISplineDoubleKeyFrame;
+
+  interface ISplineDoubleKeyFrameStatics {
+    readonly KeySplineProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISplineDoubleKeyFrameStatics: abstract new (...args: any[]) => ISplineDoubleKeyFrameStatics;
+
+  interface ISplinePointKeyFrame {
+    KeySpline: Windows.UI.Xaml.Media.Animation.KeySpline;
+  }
+  var ISplinePointKeyFrame: abstract new (...args: any[]) => ISplinePointKeyFrame;
+
+  interface ISplinePointKeyFrameStatics {
+    readonly KeySplineProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISplinePointKeyFrameStatics: abstract new (...args: any[]) => ISplinePointKeyFrameStatics;
+
+  interface ISplitCloseThemeAnimation {
+    ClosedLength: number;
+    ClosedTarget: Windows.UI.Xaml.DependencyObject;
+    ClosedTargetName: string;
+    ContentTarget: Windows.UI.Xaml.DependencyObject;
+    ContentTargetName: string;
+    ContentTranslationDirection: number;
+    ContentTranslationOffset: number;
+    OffsetFromCenter: number;
+    OpenedLength: number;
+    OpenedTarget: Windows.UI.Xaml.DependencyObject;
+    OpenedTargetName: string;
+  }
+  var ISplitCloseThemeAnimation: abstract new (...args: any[]) => ISplitCloseThemeAnimation;
+
+  interface ISplitCloseThemeAnimationStatics {
+    readonly ClosedLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ClosedTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ClosedTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentTranslationDirectionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentTranslationOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OffsetFromCenterProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OpenedLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OpenedTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OpenedTargetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISplitCloseThemeAnimationStatics: abstract new (...args: any[]) => ISplitCloseThemeAnimationStatics;
+
+  interface ISplitOpenThemeAnimation {
+    ClosedLength: number;
+    ClosedTarget: Windows.UI.Xaml.DependencyObject;
+    ClosedTargetName: string;
+    ContentTarget: Windows.UI.Xaml.DependencyObject;
+    ContentTargetName: string;
+    ContentTranslationDirection: number;
+    ContentTranslationOffset: number;
+    OffsetFromCenter: number;
+    OpenedLength: number;
+    OpenedTarget: Windows.UI.Xaml.DependencyObject;
+    OpenedTargetName: string;
+  }
+  var ISplitOpenThemeAnimation: abstract new (...args: any[]) => ISplitOpenThemeAnimation;
+
+  interface ISplitOpenThemeAnimationStatics {
+    readonly ClosedLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ClosedTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ClosedTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentTargetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentTranslationDirectionProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ContentTranslationOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OffsetFromCenterProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OpenedLengthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OpenedTargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OpenedTargetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISplitOpenThemeAnimationStatics: abstract new (...args: any[]) => ISplitOpenThemeAnimationStatics;
+
+  interface IStoryboard {
+    Begin(): void;
+    GetCurrentState(): number;
+    GetCurrentTime(): Windows.Foundation.TimeSpan;
+    Pause(): void;
+    Resume(): void;
+    Seek(offset: Windows.Foundation.TimeSpan): void;
+    SeekAlignedToLastTick(offset: Windows.Foundation.TimeSpan): void;
+    SkipToFill(): void;
+    Stop(): void;
+    readonly Children: Windows.UI.Xaml.Media.Animation.TimelineCollection;
+  }
+  var IStoryboard: abstract new (...args: any[]) => IStoryboard;
+
+  interface IStoryboardStatics {
+    GetTargetName(element: Windows.UI.Xaml.Media.Animation.Timeline): string;
+    GetTargetProperty(element: Windows.UI.Xaml.Media.Animation.Timeline): string;
+    SetTarget(timeline: Windows.UI.Xaml.Media.Animation.Timeline, target: Windows.UI.Xaml.DependencyObject): void;
+    SetTargetName(element: Windows.UI.Xaml.Media.Animation.Timeline, name: string): void;
+    SetTargetProperty(element: Windows.UI.Xaml.Media.Animation.Timeline, path: string): void;
+    readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TargetPropertyProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IStoryboardStatics: abstract new (...args: any[]) => IStoryboardStatics;
+
+  interface ISuppressNavigationTransitionInfo {
+  }
+  var ISuppressNavigationTransitionInfo: abstract new (...args: any[]) => ISuppressNavigationTransitionInfo;
+
+  interface ISwipeBackThemeAnimation {
+    FromHorizontalOffset: number;
+    FromVerticalOffset: number;
+    TargetName: string;
+  }
+  var ISwipeBackThemeAnimation: abstract new (...args: any[]) => ISwipeBackThemeAnimation;
+
+  interface ISwipeBackThemeAnimationStatics {
+    readonly FromHorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FromVerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISwipeBackThemeAnimationStatics: abstract new (...args: any[]) => ISwipeBackThemeAnimationStatics;
+
+  interface ISwipeHintThemeAnimation {
+    TargetName: string;
+    ToHorizontalOffset: number;
+    ToVerticalOffset: number;
+  }
+  var ISwipeHintThemeAnimation: abstract new (...args: any[]) => ISwipeHintThemeAnimation;
+
+  interface ISwipeHintThemeAnimationStatics {
+    readonly TargetNameProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ToHorizontalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ToVerticalOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISwipeHintThemeAnimationStatics: abstract new (...args: any[]) => ISwipeHintThemeAnimationStatics;
+
+  interface ITimeline {
+    AutoReverse: boolean;
+    BeginTime: Windows.Foundation.TimeSpan | null;
+    Duration: Windows.UI.Xaml.Duration;
+    FillBehavior: number;
+    RepeatBehavior: Windows.UI.Xaml.Media.Animation.RepeatBehavior;
+    SpeedRatio: number;
+    Completed: Windows.Foundation.EventHandler<Object> | null;
+  }
+  var ITimeline: abstract new (...args: any[]) => ITimeline;
+
+  interface ITimelineFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.Animation.Timeline;
+  }
+  var ITimelineFactory: abstract new (...args: any[]) => ITimelineFactory;
+
+  interface ITimelineStatics {
+    AllowDependentAnimations: boolean;
+    readonly AutoReverseProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly BeginTimeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DurationProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly FillBehaviorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RepeatBehaviorProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly SpeedRatioProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ITimelineStatics: abstract new (...args: any[]) => ITimelineStatics;
+
+  interface ITransition {
+  }
+  var ITransition: abstract new (...args: any[]) => ITransition;
+
+  interface ITransitionFactory {
+  }
+  var ITransitionFactory: abstract new (...args: any[]) => ITransitionFactory;
+
+  interface KeyTime {
+    TimeSpan: Windows.Foundation.TimeSpan;
+  }
+  var KeyTime: {
+    new(timeSpan: Windows.Foundation.TimeSpan): KeyTime;
+    new(fields: { TimeSpan?: Windows.Foundation.TimeSpan }): KeyTime;
+  };
+
+  interface RepeatBehavior {
+    Count: number;
+    Duration: Windows.Foundation.TimeSpan;
+    Type: number;
+  }
+  var RepeatBehavior: {
+    new(count: number, duration: Windows.Foundation.TimeSpan, type: number): RepeatBehavior;
+    new(fields: { Count?: number; Duration?: Windows.Foundation.TimeSpan; Type?: number }): RepeatBehavior;
+  };
+
+}
+
+declare namespace Windows.UI.Xaml.Media.Imaging {
+  class BitmapImage extends Windows.UI.Xaml.Media.Imaging.BitmapSource implements Windows.UI.Xaml.Media.Imaging.IBitmapImage, Windows.UI.Xaml.Media.Imaging.IBitmapImage2, Windows.UI.Xaml.Media.Imaging.IBitmapImage3 {
+    constructor(uriSource: Windows.Foundation.Uri);
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Play(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetSource(streamSource: Windows.Storage.Streams.IRandomAccessStream): void;
+    SetSourceAsync(streamSource: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    Stop(): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    AutoPlay: boolean;
+    static readonly AutoPlayProperty: Windows.UI.Xaml.DependencyProperty;
+    CreateOptions: number;
+    static readonly CreateOptionsProperty: Windows.UI.Xaml.DependencyProperty;
+    DecodePixelHeight: number;
+    static readonly DecodePixelHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    DecodePixelType: number;
+    static readonly DecodePixelTypeProperty: Windows.UI.Xaml.DependencyProperty;
+    DecodePixelWidth: number;
+    static readonly DecodePixelWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsAnimatedBitmap: boolean;
+    static readonly IsAnimatedBitmapProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsPlaying: boolean;
+    static readonly IsPlayingProperty: Windows.UI.Xaml.DependencyProperty;
+    UriSource: Windows.Foundation.Uri;
+    static readonly UriSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    DownloadProgress: Windows.UI.Xaml.Media.Imaging.DownloadProgressEventHandler | null;
+    ImageFailed: Windows.UI.Xaml.ExceptionRoutedEventHandler | null;
+    ImageOpened: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+
+  class BitmapSource extends Windows.UI.Xaml.Media.ImageSource implements Windows.UI.Xaml.Media.Imaging.IBitmapSource {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetSource(streamSource: Windows.Storage.Streams.IRandomAccessStream): void;
+    SetSourceAsync(streamSource: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly PixelHeight: number;
+    static readonly PixelHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PixelWidth: number;
+    static readonly PixelWidthProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class DownloadProgressEventArgs implements Windows.UI.Xaml.Media.Imaging.IDownloadProgressEventArgs {
+    Progress: number;
+  }
+
+  class RenderTargetBitmap extends Windows.UI.Xaml.Media.ImageSource implements Windows.UI.Xaml.Media.Imaging.IRenderTargetBitmap {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetPixelsAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    RenderAsync(element: Windows.UI.Xaml.UIElement): Windows.Foundation.IAsyncAction;
+    RenderAsync(element: Windows.UI.Xaml.UIElement, scaledWidth: number, scaledHeight: number): Windows.Foundation.IAsyncAction;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly PixelHeight: number;
+    static readonly PixelHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PixelWidth: number;
+    static readonly PixelWidthProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class SoftwareBitmapSource extends Windows.UI.Xaml.Media.ImageSource implements Windows.Foundation.IClosable, Windows.UI.Xaml.Media.Imaging.ISoftwareBitmapSource {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    Close(): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetBitmapAsync(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap): Windows.Foundation.IAsyncAction;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class SurfaceImageSource extends Windows.UI.Xaml.Media.ImageSource implements Windows.UI.Xaml.Media.Imaging.ISurfaceImageSource {
+    constructor(pixelWidth: number, pixelHeight: number);
+    constructor(pixelWidth: number, pixelHeight: number, isOpaque: boolean);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class SvgImageSource extends Windows.UI.Xaml.Media.ImageSource implements Windows.UI.Xaml.Media.Imaging.ISvgImageSource {
+    constructor();
+    constructor(uriSource: Windows.Foundation.Uri);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetSourceAsync(streamSource: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<number>;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    RasterizePixelHeight: number;
+    static readonly RasterizePixelHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    RasterizePixelWidth: number;
+    static readonly RasterizePixelWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    UriSource: Windows.Foundation.Uri;
+    static readonly UriSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    OpenFailed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Media.Imaging.SvgImageSource, Windows.UI.Xaml.Media.Imaging.SvgImageSourceFailedEventArgs> | null;
+    Opened: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Media.Imaging.SvgImageSource, Windows.UI.Xaml.Media.Imaging.SvgImageSourceOpenedEventArgs> | null;
+  }
+
+  class SvgImageSourceFailedEventArgs implements Windows.UI.Xaml.Media.Imaging.ISvgImageSourceFailedEventArgs {
+    readonly Status: number;
+  }
+
+  class SvgImageSourceOpenedEventArgs implements Windows.UI.Xaml.Media.Imaging.ISvgImageSourceOpenedEventArgs {
+  }
+
+  class VirtualSurfaceImageSource extends Windows.UI.Xaml.Media.Imaging.SurfaceImageSource implements Windows.UI.Xaml.Media.Imaging.IVirtualSurfaceImageSource {
+    constructor(pixelWidth: number, pixelHeight: number);
+    constructor(pixelWidth: number, pixelHeight: number, isOpaque: boolean);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  class WriteableBitmap extends Windows.UI.Xaml.Media.Imaging.BitmapSource implements Windows.UI.Xaml.Media.Imaging.IWriteableBitmap {
+    constructor(pixelWidth: number, pixelHeight: number);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    Invalidate(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetSource(streamSource: Windows.Storage.Streams.IRandomAccessStream): void;
+    SetSourceAsync(streamSource: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly PixelBuffer: Windows.Storage.Streams.IBuffer;
+  }
+
+  class XamlRenderingBackgroundTask implements Windows.UI.Xaml.Media.Imaging.IXamlRenderingBackgroundTask, Windows.UI.Xaml.Media.Imaging.IXamlRenderingBackgroundTaskOverrides {
+    OnRun(taskInstance: Windows.ApplicationModel.Background.IBackgroundTaskInstance): void;
+  }
+
+  enum BitmapCreateOptions {
+    None = 0,
+    IgnoreImageCache = 8,
+  }
+
+  enum DecodePixelType {
+    Physical = 0,
+    Logical = 1,
+  }
+
+  enum SvgImageSourceLoadStatus {
+    Success = 0,
+    NetworkError = 1,
+    InvalidFormat = 2,
+    Other = 3,
+  }
+
+  interface DownloadProgressEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Media.Imaging.DownloadProgressEventArgs): void;
+  }
+  var DownloadProgressEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Media.Imaging.DownloadProgressEventArgs) => void): DownloadProgressEventHandler;
+  };
+
+  interface IBitmapImage {
+    CreateOptions: number;
+    DecodePixelHeight: number;
+    DecodePixelWidth: number;
+    UriSource: Windows.Foundation.Uri;
+    DownloadProgress: Windows.UI.Xaml.Media.Imaging.DownloadProgressEventHandler | null;
+    ImageFailed: Windows.UI.Xaml.ExceptionRoutedEventHandler | null;
+    ImageOpened: Windows.UI.Xaml.RoutedEventHandler | null;
+  }
+  var IBitmapImage: abstract new (...args: any[]) => IBitmapImage;
+
+  interface IBitmapImage2 {
+    DecodePixelType: number;
+  }
+  var IBitmapImage2: abstract new (...args: any[]) => IBitmapImage2;
+
+  interface IBitmapImage3 {
+    Play(): void;
+    Stop(): void;
+    AutoPlay: boolean;
+    readonly IsAnimatedBitmap: boolean;
+    readonly IsPlaying: boolean;
+  }
+  var IBitmapImage3: abstract new (...args: any[]) => IBitmapImage3;
+
+  interface IBitmapImageFactory {
+    CreateInstanceWithUriSource(uriSource: Windows.Foundation.Uri): Windows.UI.Xaml.Media.Imaging.BitmapImage;
+  }
+  var IBitmapImageFactory: abstract new (...args: any[]) => IBitmapImageFactory;
+
+  interface IBitmapImageStatics {
+    readonly CreateOptionsProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DecodePixelHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly DecodePixelWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly UriSourceProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IBitmapImageStatics: abstract new (...args: any[]) => IBitmapImageStatics;
+
+  interface IBitmapImageStatics2 {
+    readonly DecodePixelTypeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IBitmapImageStatics2: abstract new (...args: any[]) => IBitmapImageStatics2;
+
+  interface IBitmapImageStatics3 {
+    readonly AutoPlayProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsAnimatedBitmapProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly IsPlayingProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IBitmapImageStatics3: abstract new (...args: any[]) => IBitmapImageStatics3;
+
+  interface IBitmapSource {
+    SetSource(streamSource: Windows.Storage.Streams.IRandomAccessStream): void;
+    SetSourceAsync(streamSource: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    readonly PixelHeight: number;
+    readonly PixelWidth: number;
+  }
+  var IBitmapSource: abstract new (...args: any[]) => IBitmapSource;
+
+  interface IBitmapSourceFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.Imaging.BitmapSource;
+  }
+  var IBitmapSourceFactory: abstract new (...args: any[]) => IBitmapSourceFactory;
+
+  interface IBitmapSourceStatics {
+    readonly PixelHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PixelWidthProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IBitmapSourceStatics: abstract new (...args: any[]) => IBitmapSourceStatics;
+
+  interface IDownloadProgressEventArgs {
+    Progress: number;
+  }
+  var IDownloadProgressEventArgs: abstract new (...args: any[]) => IDownloadProgressEventArgs;
+
+  interface IRenderTargetBitmap {
+    GetPixelsAsync(): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer>;
+    RenderAsync(element: Windows.UI.Xaml.UIElement): Windows.Foundation.IAsyncAction;
+    RenderAsync(element: Windows.UI.Xaml.UIElement, scaledWidth: number, scaledHeight: number): Windows.Foundation.IAsyncAction;
+    readonly PixelHeight: number;
+    readonly PixelWidth: number;
+  }
+  var IRenderTargetBitmap: abstract new (...args: any[]) => IRenderTargetBitmap;
+
+  interface IRenderTargetBitmapStatics {
+    readonly PixelHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PixelWidthProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRenderTargetBitmapStatics: abstract new (...args: any[]) => IRenderTargetBitmapStatics;
+
+  interface ISoftwareBitmapSource {
+    SetBitmapAsync(softwareBitmap: Windows.Graphics.Imaging.SoftwareBitmap): Windows.Foundation.IAsyncAction;
+  }
+  var ISoftwareBitmapSource: abstract new (...args: any[]) => ISoftwareBitmapSource;
+
+  interface ISurfaceImageSource {
+  }
+  var ISurfaceImageSource: abstract new (...args: any[]) => ISurfaceImageSource;
+
+  interface ISurfaceImageSourceFactory {
+    CreateInstanceWithDimensions(pixelWidth: number, pixelHeight: number, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.Imaging.SurfaceImageSource;
+    CreateInstanceWithDimensionsAndOpacity(pixelWidth: number, pixelHeight: number, isOpaque: boolean, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.Imaging.SurfaceImageSource;
+  }
+  var ISurfaceImageSourceFactory: abstract new (...args: any[]) => ISurfaceImageSourceFactory;
+
+  interface ISvgImageSource {
+    SetSourceAsync(streamSource: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncOperation<number>;
+    RasterizePixelHeight: number;
+    RasterizePixelWidth: number;
+    UriSource: Windows.Foundation.Uri;
+    OpenFailed: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Media.Imaging.SvgImageSource, Windows.UI.Xaml.Media.Imaging.SvgImageSourceFailedEventArgs> | null;
+    Opened: Windows.Foundation.TypedEventHandler<Windows.UI.Xaml.Media.Imaging.SvgImageSource, Windows.UI.Xaml.Media.Imaging.SvgImageSourceOpenedEventArgs> | null;
+  }
+  var ISvgImageSource: abstract new (...args: any[]) => ISvgImageSource;
+
+  interface ISvgImageSourceFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.Imaging.SvgImageSource;
+    CreateInstanceWithUriSource(uriSource: Windows.Foundation.Uri, baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.Imaging.SvgImageSource;
+  }
+  var ISvgImageSourceFactory: abstract new (...args: any[]) => ISvgImageSourceFactory;
+
+  interface ISvgImageSourceFailedEventArgs {
+    readonly Status: number;
+  }
+  var ISvgImageSourceFailedEventArgs: abstract new (...args: any[]) => ISvgImageSourceFailedEventArgs;
+
+  interface ISvgImageSourceOpenedEventArgs {
+  }
+  var ISvgImageSourceOpenedEventArgs: abstract new (...args: any[]) => ISvgImageSourceOpenedEventArgs;
+
+  interface ISvgImageSourceStatics {
+    readonly RasterizePixelHeightProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RasterizePixelWidthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly UriSourceProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ISvgImageSourceStatics: abstract new (...args: any[]) => ISvgImageSourceStatics;
+
+  interface IVirtualSurfaceImageSource {
+  }
+  var IVirtualSurfaceImageSource: abstract new (...args: any[]) => IVirtualSurfaceImageSource;
+
+  interface IVirtualSurfaceImageSourceFactory {
+    CreateInstanceWithDimensions(pixelWidth: number, pixelHeight: number): Windows.UI.Xaml.Media.Imaging.VirtualSurfaceImageSource;
+    CreateInstanceWithDimensionsAndOpacity(pixelWidth: number, pixelHeight: number, isOpaque: boolean): Windows.UI.Xaml.Media.Imaging.VirtualSurfaceImageSource;
+  }
+  var IVirtualSurfaceImageSourceFactory: abstract new (...args: any[]) => IVirtualSurfaceImageSourceFactory;
+
+  interface IWriteableBitmap {
+    Invalidate(): void;
+    readonly PixelBuffer: Windows.Storage.Streams.IBuffer;
+  }
+  var IWriteableBitmap: abstract new (...args: any[]) => IWriteableBitmap;
+
+  interface IWriteableBitmapFactory {
+    CreateInstanceWithDimensions(pixelWidth: number, pixelHeight: number): Windows.UI.Xaml.Media.Imaging.WriteableBitmap;
+  }
+  var IWriteableBitmapFactory: abstract new (...args: any[]) => IWriteableBitmapFactory;
+
+  interface IXamlRenderingBackgroundTask {
+  }
+  var IXamlRenderingBackgroundTask: abstract new (...args: any[]) => IXamlRenderingBackgroundTask;
+
+  interface IXamlRenderingBackgroundTaskFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.Imaging.XamlRenderingBackgroundTask;
+  }
+  var IXamlRenderingBackgroundTaskFactory: abstract new (...args: any[]) => IXamlRenderingBackgroundTaskFactory;
+
+  interface IXamlRenderingBackgroundTaskOverrides {
+    OnRun(taskInstance: Windows.ApplicationModel.Background.IBackgroundTaskInstance): void;
+  }
+  var IXamlRenderingBackgroundTaskOverrides: abstract new (...args: any[]) => IXamlRenderingBackgroundTaskOverrides;
+
+}
+
+declare namespace Windows.UI.Xaml.Media.Media3D {
+  class CompositeTransform3D extends Windows.UI.Xaml.Media.Media3D.Transform3D implements Windows.UI.Xaml.Media.Media3D.ICompositeTransform3D {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    CenterX: number;
+    static readonly CenterXProperty: Windows.UI.Xaml.DependencyProperty;
+    CenterY: number;
+    static readonly CenterYProperty: Windows.UI.Xaml.DependencyProperty;
+    CenterZ: number;
+    static readonly CenterZProperty: Windows.UI.Xaml.DependencyProperty;
+    RotationX: number;
+    static readonly RotationXProperty: Windows.UI.Xaml.DependencyProperty;
+    RotationY: number;
+    static readonly RotationYProperty: Windows.UI.Xaml.DependencyProperty;
+    RotationZ: number;
+    static readonly RotationZProperty: Windows.UI.Xaml.DependencyProperty;
+    ScaleX: number;
+    static readonly ScaleXProperty: Windows.UI.Xaml.DependencyProperty;
+    ScaleY: number;
+    static readonly ScaleYProperty: Windows.UI.Xaml.DependencyProperty;
+    ScaleZ: number;
+    static readonly ScaleZProperty: Windows.UI.Xaml.DependencyProperty;
+    TranslateX: number;
+    static readonly TranslateXProperty: Windows.UI.Xaml.DependencyProperty;
+    TranslateY: number;
+    static readonly TranslateYProperty: Windows.UI.Xaml.DependencyProperty;
+    TranslateZ: number;
+    static readonly TranslateZProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Matrix3DHelper implements Windows.UI.Xaml.Media.Media3D.IMatrix3DHelper {
+    static FromElements(m11: number, m12: number, m13: number, m14: number, m21: number, m22: number, m23: number, m24: number, m31: number, m32: number, m33: number, m34: number, offsetX: number, offsetY: number, offsetZ: number, m44: number): Windows.UI.Xaml.Media.Media3D.Matrix3D;
+    static GetHasInverse(target: Windows.UI.Xaml.Media.Media3D.Matrix3D): boolean;
+    static GetIsIdentity(target: Windows.UI.Xaml.Media.Media3D.Matrix3D): boolean;
+    static Invert(target: Windows.UI.Xaml.Media.Media3D.Matrix3D): Windows.UI.Xaml.Media.Media3D.Matrix3D;
+    static Multiply(matrix1: Windows.UI.Xaml.Media.Media3D.Matrix3D, matrix2: Windows.UI.Xaml.Media.Media3D.Matrix3D): Windows.UI.Xaml.Media.Media3D.Matrix3D;
+    static readonly Identity: Windows.UI.Xaml.Media.Media3D.Matrix3D;
+  }
+
+  class PerspectiveTransform3D extends Windows.UI.Xaml.Media.Media3D.Transform3D implements Windows.UI.Xaml.Media.Media3D.IPerspectiveTransform3D {
+    constructor();
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    Depth: number;
+    static readonly DepthProperty: Windows.UI.Xaml.DependencyProperty;
+    OffsetX: number;
+    static readonly OffsetXProperty: Windows.UI.Xaml.DependencyProperty;
+    OffsetY: number;
+    static readonly OffsetYProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Transform3D extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Media.Media3D.ITransform3D {
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+  }
+
+  interface ICompositeTransform3D {
+    CenterX: number;
+    CenterY: number;
+    CenterZ: number;
+    RotationX: number;
+    RotationY: number;
+    RotationZ: number;
+    ScaleX: number;
+    ScaleY: number;
+    ScaleZ: number;
+    TranslateX: number;
+    TranslateY: number;
+    TranslateZ: number;
+  }
+  var ICompositeTransform3D: abstract new (...args: any[]) => ICompositeTransform3D;
+
+  interface ICompositeTransform3DStatics {
+    readonly CenterXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CenterYProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly CenterZProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RotationXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RotationYProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RotationZProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ScaleXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ScaleYProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly ScaleZProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TranslateXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TranslateYProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly TranslateZProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ICompositeTransform3DStatics: abstract new (...args: any[]) => ICompositeTransform3DStatics;
+
+  interface IMatrix3DHelper {
+  }
+  var IMatrix3DHelper: abstract new (...args: any[]) => IMatrix3DHelper;
+
+  interface IMatrix3DHelperStatics {
+    FromElements(m11: number, m12: number, m13: number, m14: number, m21: number, m22: number, m23: number, m24: number, m31: number, m32: number, m33: number, m34: number, offsetX: number, offsetY: number, offsetZ: number, m44: number): Windows.UI.Xaml.Media.Media3D.Matrix3D;
+    GetHasInverse(target: Windows.UI.Xaml.Media.Media3D.Matrix3D): boolean;
+    GetIsIdentity(target: Windows.UI.Xaml.Media.Media3D.Matrix3D): boolean;
+    Invert(target: Windows.UI.Xaml.Media.Media3D.Matrix3D): Windows.UI.Xaml.Media.Media3D.Matrix3D;
+    Multiply(matrix1: Windows.UI.Xaml.Media.Media3D.Matrix3D, matrix2: Windows.UI.Xaml.Media.Media3D.Matrix3D): Windows.UI.Xaml.Media.Media3D.Matrix3D;
+    readonly Identity: Windows.UI.Xaml.Media.Media3D.Matrix3D;
+  }
+  var IMatrix3DHelperStatics: abstract new (...args: any[]) => IMatrix3DHelperStatics;
+
+  interface IPerspectiveTransform3D {
+    Depth: number;
+    OffsetX: number;
+    OffsetY: number;
+  }
+  var IPerspectiveTransform3D: abstract new (...args: any[]) => IPerspectiveTransform3D;
+
+  interface IPerspectiveTransform3DStatics {
+    readonly DepthProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OffsetXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly OffsetYProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPerspectiveTransform3DStatics: abstract new (...args: any[]) => IPerspectiveTransform3DStatics;
+
+  interface ITransform3D {
+  }
+  var ITransform3D: abstract new (...args: any[]) => ITransform3D;
+
+  interface ITransform3DFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Media.Media3D.Transform3D;
+  }
+  var ITransform3DFactory: abstract new (...args: any[]) => ITransform3DFactory;
+
+  interface Matrix3D {
+    M11: number;
+    M12: number;
+    M13: number;
+    M14: number;
+    M21: number;
+    M22: number;
+    M23: number;
+    M24: number;
+    M31: number;
+    M32: number;
+    M33: number;
+    M34: number;
+    OffsetX: number;
+    OffsetY: number;
+    OffsetZ: number;
+    M44: number;
+  }
+  var Matrix3D: {
+    new(m11: number, m12: number, m13: number, m14: number, m21: number, m22: number, m23: number, m24: number, m31: number, m32: number, m33: number, m34: number, offsetX: number, offsetY: number, offsetZ: number, m44: number): Matrix3D;
+    new(fields: { M11?: number; M12?: number; M13?: number; M14?: number; M21?: number; M22?: number; M23?: number; M24?: number; M31?: number; M32?: number; M33?: number; M34?: number; OffsetX?: number; OffsetY?: number; OffsetZ?: number; M44?: number }): Matrix3D;
+  };
+
+}
+
+declare namespace Windows.UI.Xaml.Navigation {
+  class FrameNavigationOptions implements Windows.UI.Xaml.Navigation.IFrameNavigationOptions {
+    constructor();
+    IsNavigationStackEnabled: boolean;
+    TransitionInfoOverride: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+  }
+
+  class NavigatingCancelEventArgs implements Windows.UI.Xaml.Navigation.INavigatingCancelEventArgs, Windows.UI.Xaml.Navigation.INavigatingCancelEventArgs2 {
+    Cancel: boolean;
+    readonly NavigationMode: number;
+    readonly NavigationTransitionInfo: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+    readonly Parameter: Object;
+    readonly SourcePageType: Windows.UI.Xaml.Interop.TypeName;
+  }
+
+  class NavigationEventArgs implements Windows.UI.Xaml.Navigation.INavigationEventArgs, Windows.UI.Xaml.Navigation.INavigationEventArgs2 {
+    readonly Content: Object;
+    readonly NavigationMode: number;
+    readonly NavigationTransitionInfo: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+    readonly Parameter: Object;
+    readonly SourcePageType: Windows.UI.Xaml.Interop.TypeName;
+    Uri: Windows.Foundation.Uri;
+  }
+
+  class NavigationFailedEventArgs implements Windows.UI.Xaml.Navigation.INavigationFailedEventArgs {
+    readonly Exception: Windows.Foundation.HResult;
+    Handled: boolean;
+    readonly SourcePageType: Windows.UI.Xaml.Interop.TypeName;
+  }
+
+  class PageStackEntry extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Navigation.IPageStackEntry {
+    constructor(sourcePageType: Windows.UI.Xaml.Interop.TypeName, parameter: Object, navigationTransitionInfo: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo);
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly NavigationTransitionInfo: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+    readonly Parameter: Object;
+    readonly SourcePageType: Windows.UI.Xaml.Interop.TypeName;
+    static readonly SourcePageTypeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  enum NavigationCacheMode {
+    Disabled = 0,
+    Required = 1,
+    Enabled = 2,
+  }
+
+  enum NavigationMode {
+    New = 0,
+    Back = 1,
+    Forward = 2,
+    Refresh = 3,
+  }
+
+  interface IFrameNavigationOptions {
+    IsNavigationStackEnabled: boolean;
+    TransitionInfoOverride: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+  }
+  var IFrameNavigationOptions: abstract new (...args: any[]) => IFrameNavigationOptions;
+
+  interface IFrameNavigationOptionsFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Navigation.FrameNavigationOptions;
+  }
+  var IFrameNavigationOptionsFactory: abstract new (...args: any[]) => IFrameNavigationOptionsFactory;
+
+  interface INavigatingCancelEventArgs {
+    Cancel: boolean;
+    readonly NavigationMode: number;
+    readonly SourcePageType: Windows.UI.Xaml.Interop.TypeName;
+  }
+  var INavigatingCancelEventArgs: abstract new (...args: any[]) => INavigatingCancelEventArgs;
+
+  interface INavigatingCancelEventArgs2 {
+    readonly NavigationTransitionInfo: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+    readonly Parameter: Object;
+  }
+  var INavigatingCancelEventArgs2: abstract new (...args: any[]) => INavigatingCancelEventArgs2;
+
+  interface INavigationEventArgs {
+    readonly Content: Object;
+    readonly NavigationMode: number;
+    readonly Parameter: Object;
+    readonly SourcePageType: Windows.UI.Xaml.Interop.TypeName;
+    Uri: Windows.Foundation.Uri;
+  }
+  var INavigationEventArgs: abstract new (...args: any[]) => INavigationEventArgs;
+
+  interface INavigationEventArgs2 {
+    readonly NavigationTransitionInfo: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+  }
+  var INavigationEventArgs2: abstract new (...args: any[]) => INavigationEventArgs2;
+
+  interface INavigationFailedEventArgs {
+    readonly Exception: Windows.Foundation.HResult;
+    Handled: boolean;
+    readonly SourcePageType: Windows.UI.Xaml.Interop.TypeName;
+  }
+  var INavigationFailedEventArgs: abstract new (...args: any[]) => INavigationFailedEventArgs;
+
+  interface IPageStackEntry {
+    readonly NavigationTransitionInfo: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo;
+    readonly Parameter: Object;
+    readonly SourcePageType: Windows.UI.Xaml.Interop.TypeName;
+  }
+  var IPageStackEntry: abstract new (...args: any[]) => IPageStackEntry;
+
+  interface IPageStackEntryFactory {
+    CreateInstance(sourcePageType: Windows.UI.Xaml.Interop.TypeName, parameter: Object, navigationTransitionInfo: Windows.UI.Xaml.Media.Animation.NavigationTransitionInfo): Windows.UI.Xaml.Navigation.PageStackEntry;
+  }
+  var IPageStackEntryFactory: abstract new (...args: any[]) => IPageStackEntryFactory;
+
+  interface IPageStackEntryStatics {
+    readonly SourcePageTypeProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPageStackEntryStatics: abstract new (...args: any[]) => IPageStackEntryStatics;
+
+  interface LoadCompletedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Navigation.NavigationEventArgs): void;
+  }
+  var LoadCompletedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Navigation.NavigationEventArgs) => void): LoadCompletedEventHandler;
+  };
+
+  interface NavigatedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Navigation.NavigationEventArgs): void;
+  }
+  var NavigatedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Navigation.NavigationEventArgs) => void): NavigatedEventHandler;
+  };
+
+  interface NavigatingCancelEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs): void;
+  }
+  var NavigatingCancelEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs) => void): NavigatingCancelEventHandler;
+  };
+
+  interface NavigationFailedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Navigation.NavigationFailedEventArgs): void;
+  }
+  var NavigationFailedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Navigation.NavigationFailedEventArgs) => void): NavigationFailedEventHandler;
+  };
+
+  interface NavigationStoppedEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Navigation.NavigationEventArgs): void;
+  }
+  var NavigationStoppedEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Navigation.NavigationEventArgs) => void): NavigationStoppedEventHandler;
+  };
+
+}
+
+declare namespace Windows.UI.Xaml.Printing {
+  class AddPagesEventArgs implements Windows.UI.Xaml.Printing.IAddPagesEventArgs {
+    constructor();
+    readonly PrintTaskOptions: Windows.Graphics.Printing.PrintTaskOptions;
+  }
+
+  class GetPreviewPageEventArgs implements Windows.UI.Xaml.Printing.IGetPreviewPageEventArgs {
+    constructor();
+    readonly PageNumber: number;
+  }
+
+  class PaginateEventArgs implements Windows.UI.Xaml.Printing.IPaginateEventArgs {
+    constructor();
+    readonly CurrentPreviewPageNumber: number;
+    readonly PrintTaskOptions: Windows.Graphics.Printing.PrintTaskOptions;
+  }
+
+  class PrintDocument extends Windows.UI.Xaml.DependencyObject implements Windows.UI.Xaml.Printing.IPrintDocument {
+    constructor();
+    AddPage(pageVisual: Windows.UI.Xaml.UIElement): void;
+    AddPagesComplete(): void;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    InvalidatePreview(): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    SetPreviewPage(pageNumber: number, pageVisual: Windows.UI.Xaml.UIElement): void;
+    SetPreviewPageCount(count: number, type: number): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    readonly DocumentSource: Windows.Graphics.Printing.IPrintDocumentSource;
+    static readonly DocumentSourceProperty: Windows.UI.Xaml.DependencyProperty;
+    AddPages: Windows.UI.Xaml.Printing.AddPagesEventHandler | null;
+    GetPreviewPage: Windows.UI.Xaml.Printing.GetPreviewPageEventHandler | null;
+    Paginate: Windows.UI.Xaml.Printing.PaginateEventHandler | null;
+  }
+
+  enum PreviewPageCountType {
+    Final = 0,
+    Intermediate = 1,
+  }
+
+  interface AddPagesEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Printing.AddPagesEventArgs): void;
+  }
+  var AddPagesEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Printing.AddPagesEventArgs) => void): AddPagesEventHandler;
+  };
+
+  interface GetPreviewPageEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Printing.GetPreviewPageEventArgs): void;
+  }
+  var GetPreviewPageEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Printing.GetPreviewPageEventArgs) => void): GetPreviewPageEventHandler;
+  };
+
+  interface IAddPagesEventArgs {
+    readonly PrintTaskOptions: Windows.Graphics.Printing.PrintTaskOptions;
+  }
+  var IAddPagesEventArgs: abstract new (...args: any[]) => IAddPagesEventArgs;
+
+  interface IGetPreviewPageEventArgs {
+    readonly PageNumber: number;
+  }
+  var IGetPreviewPageEventArgs: abstract new (...args: any[]) => IGetPreviewPageEventArgs;
+
+  interface IPaginateEventArgs {
+    readonly CurrentPreviewPageNumber: number;
+    readonly PrintTaskOptions: Windows.Graphics.Printing.PrintTaskOptions;
+  }
+  var IPaginateEventArgs: abstract new (...args: any[]) => IPaginateEventArgs;
+
+  interface IPrintDocument {
+    AddPage(pageVisual: Windows.UI.Xaml.UIElement): void;
+    AddPagesComplete(): void;
+    InvalidatePreview(): void;
+    SetPreviewPage(pageNumber: number, pageVisual: Windows.UI.Xaml.UIElement): void;
+    SetPreviewPageCount(count: number, type: number): void;
+    readonly DocumentSource: Windows.Graphics.Printing.IPrintDocumentSource;
+    AddPages: Windows.UI.Xaml.Printing.AddPagesEventHandler | null;
+    GetPreviewPage: Windows.UI.Xaml.Printing.GetPreviewPageEventHandler | null;
+    Paginate: Windows.UI.Xaml.Printing.PaginateEventHandler | null;
+  }
+  var IPrintDocument: abstract new (...args: any[]) => IPrintDocument;
+
+  interface IPrintDocumentFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Printing.PrintDocument;
+  }
+  var IPrintDocumentFactory: abstract new (...args: any[]) => IPrintDocumentFactory;
+
+  interface IPrintDocumentStatics {
+    readonly DocumentSourceProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPrintDocumentStatics: abstract new (...args: any[]) => IPrintDocumentStatics;
+
+  interface PaginateEventHandler {
+    (sender: Object, e: Windows.UI.Xaml.Printing.PaginateEventArgs): void;
+  }
+  var PaginateEventHandler: {
+    new(callback: (sender: Object, e: Windows.UI.Xaml.Printing.PaginateEventArgs) => void): PaginateEventHandler;
+  };
+
+}
+
+declare namespace Windows.UI.Xaml.Resources {
+  class CustomXamlResourceLoader implements Windows.UI.Xaml.Resources.ICustomXamlResourceLoader, Windows.UI.Xaml.Resources.ICustomXamlResourceLoaderOverrides {
+    constructor();
+    GetResource(resourceId: string, objectType: string, propertyName: string, propertyType: string): Object;
+    static Current: Windows.UI.Xaml.Resources.CustomXamlResourceLoader;
+  }
+
+  interface ICustomXamlResourceLoader {
+  }
+  var ICustomXamlResourceLoader: abstract new (...args: any[]) => ICustomXamlResourceLoader;
+
+  interface ICustomXamlResourceLoaderFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Resources.CustomXamlResourceLoader;
+  }
+  var ICustomXamlResourceLoaderFactory: abstract new (...args: any[]) => ICustomXamlResourceLoaderFactory;
+
+  interface ICustomXamlResourceLoaderOverrides {
+    GetResource(resourceId: string, objectType: string, propertyName: string, propertyType: string): Object;
+  }
+  var ICustomXamlResourceLoaderOverrides: abstract new (...args: any[]) => ICustomXamlResourceLoaderOverrides;
+
+  interface ICustomXamlResourceLoaderStatics {
+    Current: Windows.UI.Xaml.Resources.CustomXamlResourceLoader;
+  }
+  var ICustomXamlResourceLoaderStatics: abstract new (...args: any[]) => ICustomXamlResourceLoaderStatics;
+
+}
+
+declare namespace Windows.UI.Xaml.Shapes {
+  class Ellipse extends Windows.UI.Xaml.Shapes.Shape implements Windows.UI.Xaml.Shapes.IEllipse {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAlphaMask(): Windows.UI.Composition.CompositionBrush;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+  }
+
+  class Line extends Windows.UI.Xaml.Shapes.Shape implements Windows.UI.Xaml.Shapes.ILine {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAlphaMask(): Windows.UI.Composition.CompositionBrush;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    X1: number;
+    static readonly X1Property: Windows.UI.Xaml.DependencyProperty;
+    X2: number;
+    static readonly X2Property: Windows.UI.Xaml.DependencyProperty;
+    Y1: number;
+    static readonly Y1Property: Windows.UI.Xaml.DependencyProperty;
+    Y2: number;
+    static readonly Y2Property: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Path extends Windows.UI.Xaml.Shapes.Shape implements Windows.UI.Xaml.Shapes.IPath {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAlphaMask(): Windows.UI.Composition.CompositionBrush;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Data: Windows.UI.Xaml.Media.Geometry;
+    static readonly DataProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Polygon extends Windows.UI.Xaml.Shapes.Shape implements Windows.UI.Xaml.Shapes.IPolygon {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAlphaMask(): Windows.UI.Composition.CompositionBrush;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    FillRule: number;
+    static readonly FillRuleProperty: Windows.UI.Xaml.DependencyProperty;
+    Points: Windows.UI.Xaml.Media.PointCollection;
+    static readonly PointsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Polyline extends Windows.UI.Xaml.Shapes.Shape implements Windows.UI.Xaml.Shapes.IPolyline {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAlphaMask(): Windows.UI.Composition.CompositionBrush;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    FillRule: number;
+    static readonly FillRuleProperty: Windows.UI.Xaml.DependencyProperty;
+    Points: Windows.UI.Xaml.Media.PointCollection;
+    static readonly PointsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Rectangle extends Windows.UI.Xaml.Shapes.Shape implements Windows.UI.Xaml.Shapes.IRectangle {
+    constructor();
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAlphaMask(): Windows.UI.Composition.CompositionBrush;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    RadiusX: number;
+    static readonly RadiusXProperty: Windows.UI.Xaml.DependencyProperty;
+    RadiusY: number;
+    static readonly RadiusYProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  class Shape extends Windows.UI.Xaml.FrameworkElement implements Windows.UI.Xaml.Shapes.IShape, Windows.UI.Xaml.Shapes.IShape2 {
+    AddHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object, handledEventsToo: boolean): void;
+    Arrange(finalRect: Windows.Foundation.Rect): void;
+    ArrangeOverride(finalSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    CancelDirectManipulations(): boolean;
+    CapturePointer(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    ClearValue(dp: Windows.UI.Xaml.DependencyProperty): void;
+    static DeferTree(element: Windows.UI.Xaml.DependencyObject): void;
+    FindName(name: string): Object;
+    FindSubElementsForTouchTargeting(point: Windows.Foundation.Point, boundingRect: Windows.Foundation.Rect): Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[]> | Windows.Foundation.Collections.IIterable<Windows.Foundation.Point> | Windows.Foundation.Point[][];
+    GetAlphaMask(): Windows.UI.Composition.CompositionBrush;
+    GetAnimationBaseValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GetBindingExpression(dp: Windows.UI.Xaml.DependencyProperty): Windows.UI.Xaml.Data.BindingExpression;
+    GetChildrenInTabFocusOrder(): Windows.Foundation.Collections.IIterable<Windows.UI.Xaml.DependencyObject> | Windows.UI.Xaml.DependencyObject[];
+    GetValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    GoToElementStateCore(stateName: string, useTransitions: boolean): boolean;
+    InvalidateArrange(): void;
+    InvalidateMeasure(): void;
+    InvalidateViewport(): void;
+    Measure(availableSize: Windows.Foundation.Size): void;
+    MeasureOverride(availableSize: Windows.Foundation.Size): Windows.Foundation.Size;
+    OnApplyTemplate(): void;
+    OnBringIntoViewRequested(e: Windows.UI.Xaml.BringIntoViewRequestedEventArgs): void;
+    OnCreateAutomationPeer(): Windows.UI.Xaml.Automation.Peers.AutomationPeer;
+    OnDisconnectVisualChildren(): void;
+    OnKeyboardAcceleratorInvoked(args: Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs): void;
+    OnProcessKeyboardAccelerators(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    PopulatePropertyInfo(propertyName: string, propertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    PopulatePropertyInfoOverride(propertyName: string, animationPropertyInfo: Windows.UI.Composition.AnimationPropertyInfo): void;
+    ReadLocalValue(dp: Windows.UI.Xaml.DependencyProperty): Object;
+    static RegisterAsScrollPort(element: Windows.UI.Xaml.UIElement): void;
+    RegisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, callback: Windows.UI.Xaml.DependencyPropertyChangedCallback): number | bigint;
+    ReleasePointerCapture(value: Windows.UI.Xaml.Input.Pointer): void;
+    ReleasePointerCaptures(): void;
+    RemoveHandler(routedEvent: Windows.UI.Xaml.RoutedEvent, handler: Object): void;
+    SetBinding(dp: Windows.UI.Xaml.DependencyProperty, binding: Windows.UI.Xaml.Data.BindingBase): void;
+    SetValue(dp: Windows.UI.Xaml.DependencyProperty, value: Object): void;
+    StartAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    StartBringIntoView(): void;
+    StartBringIntoView(options: Windows.UI.Xaml.BringIntoViewOptions): void;
+    StartDragAsync(pointerPoint: Windows.UI.Input.PointerPoint): Windows.Foundation.IAsyncOperation<number>;
+    StopAnimation(animation: Windows.UI.Composition.ICompositionAnimationBase): void;
+    TransformToVisual(visual: Windows.UI.Xaml.UIElement): Windows.UI.Xaml.Media.GeneralTransform;
+    TryInvokeKeyboardAccelerator(args: Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs): void;
+    static TryStartDirectManipulation(value: Windows.UI.Xaml.Input.Pointer): boolean;
+    UnregisterPropertyChangedCallback(dp: Windows.UI.Xaml.DependencyProperty, token: number | bigint): void;
+    UpdateLayout(): void;
+    Fill: Windows.UI.Xaml.Media.Brush;
+    static readonly FillProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly GeometryTransform: Windows.UI.Xaml.Media.Transform;
+    Stretch: number;
+    static readonly StretchProperty: Windows.UI.Xaml.DependencyProperty;
+    Stroke: Windows.UI.Xaml.Media.Brush;
+    StrokeDashArray: Windows.UI.Xaml.Media.DoubleCollection;
+    static readonly StrokeDashArrayProperty: Windows.UI.Xaml.DependencyProperty;
+    StrokeDashCap: number;
+    static readonly StrokeDashCapProperty: Windows.UI.Xaml.DependencyProperty;
+    StrokeDashOffset: number;
+    static readonly StrokeDashOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    StrokeEndLineCap: number;
+    static readonly StrokeEndLineCapProperty: Windows.UI.Xaml.DependencyProperty;
+    StrokeLineJoin: number;
+    static readonly StrokeLineJoinProperty: Windows.UI.Xaml.DependencyProperty;
+    StrokeMiterLimit: number;
+    static readonly StrokeMiterLimitProperty: Windows.UI.Xaml.DependencyProperty;
+    static readonly StrokeProperty: Windows.UI.Xaml.DependencyProperty;
+    StrokeStartLineCap: number;
+    static readonly StrokeStartLineCapProperty: Windows.UI.Xaml.DependencyProperty;
+    StrokeThickness: number;
+    static readonly StrokeThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+
+  interface IEllipse {
+  }
+  var IEllipse: abstract new (...args: any[]) => IEllipse;
+
+  interface ILine {
+    X1: number;
+    X2: number;
+    Y1: number;
+    Y2: number;
+  }
+  var ILine: abstract new (...args: any[]) => ILine;
+
+  interface ILineStatics {
+    readonly X1Property: Windows.UI.Xaml.DependencyProperty;
+    readonly X2Property: Windows.UI.Xaml.DependencyProperty;
+    readonly Y1Property: Windows.UI.Xaml.DependencyProperty;
+    readonly Y2Property: Windows.UI.Xaml.DependencyProperty;
+  }
+  var ILineStatics: abstract new (...args: any[]) => ILineStatics;
+
+  interface IPath {
+    Data: Windows.UI.Xaml.Media.Geometry;
+  }
+  var IPath: abstract new (...args: any[]) => IPath;
+
+  interface IPathFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Shapes.Path;
+  }
+  var IPathFactory: abstract new (...args: any[]) => IPathFactory;
+
+  interface IPathStatics {
+    readonly DataProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPathStatics: abstract new (...args: any[]) => IPathStatics;
+
+  interface IPolygon {
+    FillRule: number;
+    Points: Windows.UI.Xaml.Media.PointCollection;
+  }
+  var IPolygon: abstract new (...args: any[]) => IPolygon;
+
+  interface IPolygonStatics {
+    readonly FillRuleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PointsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPolygonStatics: abstract new (...args: any[]) => IPolygonStatics;
+
+  interface IPolyline {
+    FillRule: number;
+    Points: Windows.UI.Xaml.Media.PointCollection;
+  }
+  var IPolyline: abstract new (...args: any[]) => IPolyline;
+
+  interface IPolylineStatics {
+    readonly FillRuleProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly PointsProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IPolylineStatics: abstract new (...args: any[]) => IPolylineStatics;
+
+  interface IRectangle {
+    RadiusX: number;
+    RadiusY: number;
+  }
+  var IRectangle: abstract new (...args: any[]) => IRectangle;
+
+  interface IRectangleStatics {
+    readonly RadiusXProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly RadiusYProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IRectangleStatics: abstract new (...args: any[]) => IRectangleStatics;
+
+  interface IShape {
+    Fill: Windows.UI.Xaml.Media.Brush;
+    readonly GeometryTransform: Windows.UI.Xaml.Media.Transform;
+    Stretch: number;
+    Stroke: Windows.UI.Xaml.Media.Brush;
+    StrokeDashArray: Windows.UI.Xaml.Media.DoubleCollection;
+    StrokeDashCap: number;
+    StrokeDashOffset: number;
+    StrokeEndLineCap: number;
+    StrokeLineJoin: number;
+    StrokeMiterLimit: number;
+    StrokeStartLineCap: number;
+    StrokeThickness: number;
+  }
+  var IShape: abstract new (...args: any[]) => IShape;
+
+  interface IShape2 {
+    GetAlphaMask(): Windows.UI.Composition.CompositionBrush;
+  }
+  var IShape2: abstract new (...args: any[]) => IShape2;
+
+  interface IShapeFactory {
+    CreateInstance(baseInterface: Object, innerInterface: Object): Windows.UI.Xaml.Shapes.Shape;
+  }
+  var IShapeFactory: abstract new (...args: any[]) => IShapeFactory;
+
+  interface IShapeStatics {
+    readonly FillProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StretchProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StrokeDashArrayProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StrokeDashCapProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StrokeDashOffsetProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StrokeEndLineCapProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StrokeLineJoinProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StrokeMiterLimitProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StrokeProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StrokeStartLineCapProperty: Windows.UI.Xaml.DependencyProperty;
+    readonly StrokeThicknessProperty: Windows.UI.Xaml.DependencyProperty;
+  }
+  var IShapeStatics: abstract new (...args: any[]) => IShapeStatics;
+
+}
+
+declare namespace Windows.Web {
+  class WebError {
+    static GetStatus(hresult: number): number;
+  }
+
+  enum WebErrorStatus {
+    Unknown = 0,
+    CertificateCommonNameIsIncorrect = 1,
+    CertificateExpired = 2,
+    CertificateContainsErrors = 3,
+    CertificateRevoked = 4,
+    CertificateIsInvalid = 5,
+    ServerUnreachable = 6,
+    Timeout = 7,
+    ErrorHttpInvalidServerResponse = 8,
+    ConnectionAborted = 9,
+    ConnectionReset = 10,
+    Disconnected = 11,
+    HttpToHttpsOnRedirection = 12,
+    HttpsToHttpOnRedirection = 13,
+    CannotConnect = 14,
+    HostNameNotResolved = 15,
+    OperationCanceled = 16,
+    RedirectFailed = 17,
+    UnexpectedStatusCode = 18,
+    UnexpectedRedirection = 19,
+    UnexpectedClientError = 20,
+    UnexpectedServerError = 21,
+    InsufficientRangeSupport = 22,
+    MissingContentLengthSupport = 23,
+    MultipleChoices = 300,
+    MovedPermanently = 301,
+    Found = 302,
+    SeeOther = 303,
+    NotModified = 304,
+    UseProxy = 305,
+    TemporaryRedirect = 307,
+    BadRequest = 400,
+    Unauthorized = 401,
+    PaymentRequired = 402,
+    Forbidden = 403,
+    NotFound = 404,
+    MethodNotAllowed = 405,
+    NotAcceptable = 406,
+    ProxyAuthenticationRequired = 407,
+    RequestTimeout = 408,
+    Conflict = 409,
+    Gone = 410,
+    LengthRequired = 411,
+    PreconditionFailed = 412,
+    RequestEntityTooLarge = 413,
+    RequestUriTooLong = 414,
+    UnsupportedMediaType = 415,
+    RequestedRangeNotSatisfiable = 416,
+    ExpectationFailed = 417,
+    InternalServerError = 500,
+    NotImplemented = 501,
+    BadGateway = 502,
+    ServiceUnavailable = 503,
+    GatewayTimeout = 504,
+    HttpVersionNotSupported = 505,
+  }
+
+  interface IUriToStreamResolver {
+    UriToStreamAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IInputStream>;
+  }
+  var IUriToStreamResolver: abstract new (...args: any[]) => IUriToStreamResolver;
+
+  interface IWebErrorStatics {
+    GetStatus(hresult: number): number;
+  }
+  var IWebErrorStatics: abstract new (...args: any[]) => IWebErrorStatics;
+
+}
+
+declare namespace Windows.Web.AtomPub {
+  class AtomPubClient implements Windows.Web.AtomPub.IAtomPubClient, Windows.Web.Syndication.ISyndicationClient {
+    constructor(serverCredential: Windows.Security.Credentials.PasswordCredential);
+    constructor();
+    CancelAsyncOperations(): void;
+    CreateMediaResourceAsync(uri: Windows.Foundation.Uri, mediaType: string, description: string, mediaStream: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Syndication.SyndicationItem, Windows.Web.Syndication.TransferProgress>;
+    CreateResourceAsync(uri: Windows.Foundation.Uri, description: string, item: Windows.Web.Syndication.SyndicationItem): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Syndication.SyndicationItem, Windows.Web.Syndication.TransferProgress>;
+    DeleteResourceAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncActionWithProgress<Windows.Web.Syndication.TransferProgress>;
+    DeleteResourceItemAsync(item: Windows.Web.Syndication.SyndicationItem): Windows.Foundation.IAsyncActionWithProgress<Windows.Web.Syndication.TransferProgress>;
+    RetrieveFeedAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Syndication.SyndicationFeed, Windows.Web.Syndication.RetrievalProgress>;
+    RetrieveMediaResourceAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IInputStream, Windows.Web.Syndication.RetrievalProgress>;
+    RetrieveResourceAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Syndication.SyndicationItem, Windows.Web.Syndication.RetrievalProgress>;
+    RetrieveServiceDocumentAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.AtomPub.ServiceDocument, Windows.Web.Syndication.RetrievalProgress>;
+    SetRequestHeader(name: string, value: string): void;
+    UpdateMediaResourceAsync(uri: Windows.Foundation.Uri, mediaType: string, mediaStream: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncActionWithProgress<Windows.Web.Syndication.TransferProgress>;
+    UpdateResourceAsync(uri: Windows.Foundation.Uri, item: Windows.Web.Syndication.SyndicationItem): Windows.Foundation.IAsyncActionWithProgress<Windows.Web.Syndication.TransferProgress>;
+    UpdateResourceItemAsync(item: Windows.Web.Syndication.SyndicationItem): Windows.Foundation.IAsyncActionWithProgress<Windows.Web.Syndication.TransferProgress>;
+    BypassCacheOnRetrieve: boolean;
+    MaxResponseBufferSize: number;
+    ProxyCredential: Windows.Security.Credentials.PasswordCredential;
+    ServerCredential: Windows.Security.Credentials.PasswordCredential;
+    Timeout: number;
+  }
+
+  class ResourceCollection implements Windows.Web.AtomPub.IResourceCollection, Windows.Web.Syndication.ISyndicationNode {
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    readonly Accepts: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly AttributeExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationAttribute> | Windows.Web.Syndication.SyndicationAttribute[];
+    BaseUri: Windows.Foundation.Uri;
+    readonly Categories: Windows.Foundation.Collections.IVectorView<Windows.Web.Syndication.SyndicationCategory> | Windows.Web.Syndication.SyndicationCategory[];
+    readonly ElementExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.ISyndicationNode> | Windows.Web.Syndication.ISyndicationNode[];
+    Language: string;
+    NodeName: string;
+    NodeNamespace: string;
+    NodeValue: string;
+    readonly Title: Windows.Web.Syndication.ISyndicationText;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class ServiceDocument implements Windows.Web.AtomPub.IServiceDocument, Windows.Web.Syndication.ISyndicationNode {
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    readonly AttributeExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationAttribute> | Windows.Web.Syndication.SyndicationAttribute[];
+    BaseUri: Windows.Foundation.Uri;
+    readonly ElementExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.ISyndicationNode> | Windows.Web.Syndication.ISyndicationNode[];
+    Language: string;
+    NodeName: string;
+    NodeNamespace: string;
+    NodeValue: string;
+    readonly Workspaces: Windows.Foundation.Collections.IVectorView<Windows.Web.AtomPub.Workspace> | Windows.Web.AtomPub.Workspace[];
+  }
+
+  class Workspace implements Windows.Web.AtomPub.IWorkspace, Windows.Web.Syndication.ISyndicationNode {
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    readonly AttributeExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationAttribute> | Windows.Web.Syndication.SyndicationAttribute[];
+    BaseUri: Windows.Foundation.Uri;
+    readonly Collections: Windows.Foundation.Collections.IVectorView<Windows.Web.AtomPub.ResourceCollection> | Windows.Web.AtomPub.ResourceCollection[];
+    readonly ElementExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.ISyndicationNode> | Windows.Web.Syndication.ISyndicationNode[];
+    Language: string;
+    NodeName: string;
+    NodeNamespace: string;
+    NodeValue: string;
+    readonly Title: Windows.Web.Syndication.ISyndicationText;
+  }
+
+  interface IAtomPubClient extends Windows.Web.Syndication.ISyndicationClient {
+    CancelAsyncOperations(): void;
+    CreateMediaResourceAsync(uri: Windows.Foundation.Uri, mediaType: string, description: string, mediaStream: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Syndication.SyndicationItem, Windows.Web.Syndication.TransferProgress>;
+    CreateResourceAsync(uri: Windows.Foundation.Uri, description: string, item: Windows.Web.Syndication.SyndicationItem): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Syndication.SyndicationItem, Windows.Web.Syndication.TransferProgress>;
+    DeleteResourceAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncActionWithProgress<Windows.Web.Syndication.TransferProgress>;
+    DeleteResourceItemAsync(item: Windows.Web.Syndication.SyndicationItem): Windows.Foundation.IAsyncActionWithProgress<Windows.Web.Syndication.TransferProgress>;
+    RetrieveFeedAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Syndication.SyndicationFeed, Windows.Web.Syndication.RetrievalProgress>;
+    RetrieveMediaResourceAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IInputStream, Windows.Web.Syndication.RetrievalProgress>;
+    RetrieveResourceAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Syndication.SyndicationItem, Windows.Web.Syndication.RetrievalProgress>;
+    RetrieveServiceDocumentAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.AtomPub.ServiceDocument, Windows.Web.Syndication.RetrievalProgress>;
+    SetRequestHeader(name: string, value: string): void;
+    UpdateMediaResourceAsync(uri: Windows.Foundation.Uri, mediaType: string, mediaStream: Windows.Storage.Streams.IInputStream): Windows.Foundation.IAsyncActionWithProgress<Windows.Web.Syndication.TransferProgress>;
+    UpdateResourceAsync(uri: Windows.Foundation.Uri, item: Windows.Web.Syndication.SyndicationItem): Windows.Foundation.IAsyncActionWithProgress<Windows.Web.Syndication.TransferProgress>;
+    UpdateResourceItemAsync(item: Windows.Web.Syndication.SyndicationItem): Windows.Foundation.IAsyncActionWithProgress<Windows.Web.Syndication.TransferProgress>;
+  }
+  var IAtomPubClient: abstract new (...args: any[]) => IAtomPubClient;
+
+  interface IAtomPubClientFactory {
+    CreateAtomPubClientWithCredentials(serverCredential: Windows.Security.Credentials.PasswordCredential): Windows.Web.AtomPub.AtomPubClient;
+  }
+  var IAtomPubClientFactory: abstract new (...args: any[]) => IAtomPubClientFactory;
+
+  interface IResourceCollection extends Windows.Web.Syndication.ISyndicationNode {
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    readonly Accepts: Windows.Foundation.Collections.IVectorView<string> | string[];
+    readonly Categories: Windows.Foundation.Collections.IVectorView<Windows.Web.Syndication.SyndicationCategory> | Windows.Web.Syndication.SyndicationCategory[];
+    readonly Title: Windows.Web.Syndication.ISyndicationText;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IResourceCollection: abstract new (...args: any[]) => IResourceCollection;
+
+  interface IServiceDocument extends Windows.Web.Syndication.ISyndicationNode {
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    readonly Workspaces: Windows.Foundation.Collections.IVectorView<Windows.Web.AtomPub.Workspace> | Windows.Web.AtomPub.Workspace[];
+  }
+  var IServiceDocument: abstract new (...args: any[]) => IServiceDocument;
+
+  interface IWorkspace extends Windows.Web.Syndication.ISyndicationNode {
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    readonly Collections: Windows.Foundation.Collections.IVectorView<Windows.Web.AtomPub.ResourceCollection> | Windows.Web.AtomPub.ResourceCollection[];
+    readonly Title: Windows.Web.Syndication.ISyndicationText;
+  }
+  var IWorkspace: abstract new (...args: any[]) => IWorkspace;
+
+}
+
+declare namespace Windows.Web.Http {
+  class HttpBufferContent implements Windows.Foundation.IClosable, Windows.Foundation.IStringable, Windows.Web.Http.IHttpContent {
+    constructor(content: Windows.Storage.Streams.IBuffer);
+    constructor(content: Windows.Storage.Streams.IBuffer, offset: number, count: number);
+    BufferAllAsync(): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+    Close(): void;
+    ReadAsBufferAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number | bigint>;
+    ReadAsInputStreamAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IInputStream, number | bigint>;
+    ReadAsStringAsync(): Windows.Foundation.IAsyncOperationWithProgress<string, number | bigint>;
+    ToString(): string;
+    TryComputeLength(length: number | bigint): boolean;
+    WriteToStreamAsync(outputStream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+    readonly Headers: Windows.Web.Http.Headers.HttpContentHeaderCollection;
+  }
+
+  class HttpClient implements Windows.Foundation.IClosable, Windows.Foundation.IStringable, Windows.Web.Http.IHttpClient, Windows.Web.Http.IHttpClient2, Windows.Web.Http.IHttpClient3 {
+    constructor(filter: Windows.Web.Http.Filters.IHttpFilter);
+    constructor();
+    Close(): void;
+    DeleteAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpResponseMessage, Windows.Web.Http.HttpProgress>;
+    GetAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpResponseMessage, Windows.Web.Http.HttpProgress>;
+    GetAsync(uri: Windows.Foundation.Uri, completionOption: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpResponseMessage, Windows.Web.Http.HttpProgress>;
+    GetBufferAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, Windows.Web.Http.HttpProgress>;
+    GetInputStreamAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IInputStream, Windows.Web.Http.HttpProgress>;
+    GetStringAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<string, Windows.Web.Http.HttpProgress>;
+    PostAsync(uri: Windows.Foundation.Uri, content: Windows.Web.Http.IHttpContent): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpResponseMessage, Windows.Web.Http.HttpProgress>;
+    PutAsync(uri: Windows.Foundation.Uri, content: Windows.Web.Http.IHttpContent): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpResponseMessage, Windows.Web.Http.HttpProgress>;
+    SendRequestAsync(request: Windows.Web.Http.HttpRequestMessage): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpResponseMessage, Windows.Web.Http.HttpProgress>;
+    SendRequestAsync(request: Windows.Web.Http.HttpRequestMessage, completionOption: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpResponseMessage, Windows.Web.Http.HttpProgress>;
+    ToString(): string;
+    TryDeleteAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpRequestResult, Windows.Web.Http.HttpProgress>;
+    TryGetAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpRequestResult, Windows.Web.Http.HttpProgress>;
+    TryGetAsync(uri: Windows.Foundation.Uri, completionOption: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpRequestResult, Windows.Web.Http.HttpProgress>;
+    TryGetBufferAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpGetBufferResult, Windows.Web.Http.HttpProgress>;
+    TryGetInputStreamAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpGetInputStreamResult, Windows.Web.Http.HttpProgress>;
+    TryGetStringAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpGetStringResult, Windows.Web.Http.HttpProgress>;
+    TryPostAsync(uri: Windows.Foundation.Uri, content: Windows.Web.Http.IHttpContent): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpRequestResult, Windows.Web.Http.HttpProgress>;
+    TryPutAsync(uri: Windows.Foundation.Uri, content: Windows.Web.Http.IHttpContent): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpRequestResult, Windows.Web.Http.HttpProgress>;
+    TrySendRequestAsync(request: Windows.Web.Http.HttpRequestMessage): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpRequestResult, Windows.Web.Http.HttpProgress>;
+    TrySendRequestAsync(request: Windows.Web.Http.HttpRequestMessage, completionOption: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpRequestResult, Windows.Web.Http.HttpProgress>;
+    DefaultPrivacyAnnotation: string;
+    readonly DefaultRequestHeaders: Windows.Web.Http.Headers.HttpRequestHeaderCollection;
+  }
+
+  class HttpCookie implements Windows.Foundation.IStringable, Windows.Web.Http.IHttpCookie {
+    constructor(name: string, domain: string, path: string);
+    ToString(): string;
+    readonly Domain: string;
+    Expires: Windows.Foundation.DateTime | null;
+    HttpOnly: boolean;
+    readonly Name: string;
+    readonly Path: string;
+    Secure: boolean;
+    Value: string;
+  }
+
+  class HttpCookieCollection {
+    First(): Windows.Foundation.Collections.IIterator<Windows.Web.Http.HttpCookie>;
+    GetAt(index: number): Windows.Web.Http.HttpCookie;
+    GetMany(startIndex: number, items: Windows.Web.Http.HttpCookie[]): number;
+    IndexOf(value: Windows.Web.Http.HttpCookie, index: number): boolean;
+    readonly Size: number;
+  }
+
+  class HttpCookieManager implements Windows.Web.Http.IHttpCookieManager {
+    DeleteCookie(cookie: Windows.Web.Http.HttpCookie): void;
+    GetCookies(uri: Windows.Foundation.Uri): Windows.Web.Http.HttpCookieCollection;
+    SetCookie(cookie: Windows.Web.Http.HttpCookie): boolean;
+    SetCookie(cookie: Windows.Web.Http.HttpCookie, thirdParty: boolean): boolean;
+  }
+
+  class HttpFormUrlEncodedContent implements Windows.Foundation.IClosable, Windows.Foundation.IStringable, Windows.Web.Http.IHttpContent {
+    constructor(content: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, string>> | Windows.Foundation.Collections.IKeyValuePair<string, string>[]);
+    BufferAllAsync(): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+    Close(): void;
+    ReadAsBufferAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number | bigint>;
+    ReadAsInputStreamAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IInputStream, number | bigint>;
+    ReadAsStringAsync(): Windows.Foundation.IAsyncOperationWithProgress<string, number | bigint>;
+    ToString(): string;
+    TryComputeLength(length: number | bigint): boolean;
+    WriteToStreamAsync(outputStream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+    readonly Headers: Windows.Web.Http.Headers.HttpContentHeaderCollection;
+  }
+
+  class HttpGetBufferResult implements Windows.Foundation.IClosable, Windows.Foundation.IStringable, Windows.Web.Http.IHttpGetBufferResult {
+    Close(): void;
+    ToString(): string;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly RequestMessage: Windows.Web.Http.HttpRequestMessage;
+    readonly ResponseMessage: Windows.Web.Http.HttpResponseMessage;
+    readonly Succeeded: boolean;
+    readonly Value: Windows.Storage.Streams.IBuffer;
+  }
+
+  class HttpGetInputStreamResult implements Windows.Foundation.IClosable, Windows.Foundation.IStringable, Windows.Web.Http.IHttpGetInputStreamResult {
+    Close(): void;
+    ToString(): string;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly RequestMessage: Windows.Web.Http.HttpRequestMessage;
+    readonly ResponseMessage: Windows.Web.Http.HttpResponseMessage;
+    readonly Succeeded: boolean;
+    readonly Value: Windows.Storage.Streams.IInputStream;
+  }
+
+  class HttpGetStringResult implements Windows.Foundation.IClosable, Windows.Foundation.IStringable, Windows.Web.Http.IHttpGetStringResult {
+    Close(): void;
+    ToString(): string;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly RequestMessage: Windows.Web.Http.HttpRequestMessage;
+    readonly ResponseMessage: Windows.Web.Http.HttpResponseMessage;
+    readonly Succeeded: boolean;
+    readonly Value: string;
+  }
+
+  class HttpMethod implements Windows.Foundation.IStringable, Windows.Web.Http.IHttpMethod {
+    constructor(method: string);
+    ToString(): string;
+    static readonly Delete: Windows.Web.Http.HttpMethod;
+    static readonly Get: Windows.Web.Http.HttpMethod;
+    static readonly Head: Windows.Web.Http.HttpMethod;
+    readonly Method: string;
+    static readonly Options: Windows.Web.Http.HttpMethod;
+    static readonly Patch: Windows.Web.Http.HttpMethod;
+    static readonly Post: Windows.Web.Http.HttpMethod;
+    static readonly Put: Windows.Web.Http.HttpMethod;
+  }
+
+  class HttpMultipartContent implements Windows.Foundation.IClosable, Windows.Foundation.IStringable, Windows.Web.Http.IHttpContent, Windows.Web.Http.IHttpMultipartContent {
+    constructor(subtype: string);
+    constructor(subtype: string, boundary: string);
+    constructor();
+    Add(content: Windows.Web.Http.IHttpContent): void;
+    BufferAllAsync(): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+    Close(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Web.Http.IHttpContent>;
+    ReadAsBufferAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number | bigint>;
+    ReadAsInputStreamAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IInputStream, number | bigint>;
+    ReadAsStringAsync(): Windows.Foundation.IAsyncOperationWithProgress<string, number | bigint>;
+    ToString(): string;
+    TryComputeLength(length: number | bigint): boolean;
+    WriteToStreamAsync(outputStream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+    readonly Headers: Windows.Web.Http.Headers.HttpContentHeaderCollection;
+  }
+
+  class HttpMultipartFormDataContent implements Windows.Foundation.IClosable, Windows.Foundation.IStringable, Windows.Web.Http.IHttpContent, Windows.Web.Http.IHttpMultipartFormDataContent {
+    constructor(boundary: string);
+    constructor();
+    Add(content: Windows.Web.Http.IHttpContent): void;
+    Add(content: Windows.Web.Http.IHttpContent, name: string): void;
+    Add(content: Windows.Web.Http.IHttpContent, name: string, fileName: string): void;
+    BufferAllAsync(): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+    Close(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Web.Http.IHttpContent>;
+    ReadAsBufferAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number | bigint>;
+    ReadAsInputStreamAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IInputStream, number | bigint>;
+    ReadAsStringAsync(): Windows.Foundation.IAsyncOperationWithProgress<string, number | bigint>;
+    ToString(): string;
+    TryComputeLength(length: number | bigint): boolean;
+    WriteToStreamAsync(outputStream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+    readonly Headers: Windows.Web.Http.Headers.HttpContentHeaderCollection;
+  }
+
+  class HttpRequestMessage implements Windows.Foundation.IClosable, Windows.Foundation.IStringable, Windows.Web.Http.IHttpRequestMessage, Windows.Web.Http.IHttpRequestMessage2 {
+    constructor(method: Windows.Web.Http.HttpMethod, uri: Windows.Foundation.Uri);
+    constructor();
+    Close(): void;
+    ToString(): string;
+    Content: Windows.Web.Http.IHttpContent;
+    readonly Headers: Windows.Web.Http.Headers.HttpRequestHeaderCollection;
+    Method: Windows.Web.Http.HttpMethod;
+    PrivacyAnnotation: string;
+    readonly Properties: Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>;
+    RequestUri: Windows.Foundation.Uri;
+    readonly TransportInformation: Windows.Web.Http.HttpTransportInformation;
+  }
+
+  class HttpRequestResult implements Windows.Foundation.IClosable, Windows.Foundation.IStringable, Windows.Web.Http.IHttpRequestResult {
+    Close(): void;
+    ToString(): string;
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly RequestMessage: Windows.Web.Http.HttpRequestMessage;
+    readonly ResponseMessage: Windows.Web.Http.HttpResponseMessage;
+    readonly Succeeded: boolean;
+  }
+
+  class HttpResponseMessage implements Windows.Foundation.IClosable, Windows.Foundation.IStringable, Windows.Web.Http.IHttpResponseMessage {
+    constructor(statusCode: number);
+    constructor();
+    Close(): void;
+    EnsureSuccessStatusCode(): Windows.Web.Http.HttpResponseMessage;
+    ToString(): string;
+    Content: Windows.Web.Http.IHttpContent;
+    readonly Headers: Windows.Web.Http.Headers.HttpResponseHeaderCollection;
+    readonly IsSuccessStatusCode: boolean;
+    ReasonPhrase: string;
+    RequestMessage: Windows.Web.Http.HttpRequestMessage;
+    Source: number;
+    StatusCode: number;
+    Version: number;
+  }
+
+  class HttpStreamContent implements Windows.Foundation.IClosable, Windows.Foundation.IStringable, Windows.Web.Http.IHttpContent {
+    constructor(content: Windows.Storage.Streams.IInputStream);
+    BufferAllAsync(): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+    Close(): void;
+    ReadAsBufferAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number | bigint>;
+    ReadAsInputStreamAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IInputStream, number | bigint>;
+    ReadAsStringAsync(): Windows.Foundation.IAsyncOperationWithProgress<string, number | bigint>;
+    ToString(): string;
+    TryComputeLength(length: number | bigint): boolean;
+    WriteToStreamAsync(outputStream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+    readonly Headers: Windows.Web.Http.Headers.HttpContentHeaderCollection;
+  }
+
+  class HttpStringContent implements Windows.Foundation.IClosable, Windows.Foundation.IStringable, Windows.Web.Http.IHttpContent {
+    constructor(content: string);
+    constructor(content: string, encoding: number);
+    constructor(content: string, encoding: number, mediaType: string);
+    BufferAllAsync(): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+    Close(): void;
+    ReadAsBufferAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number | bigint>;
+    ReadAsInputStreamAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IInputStream, number | bigint>;
+    ReadAsStringAsync(): Windows.Foundation.IAsyncOperationWithProgress<string, number | bigint>;
+    ToString(): string;
+    TryComputeLength(length: number | bigint): boolean;
+    WriteToStreamAsync(outputStream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+    readonly Headers: Windows.Web.Http.Headers.HttpContentHeaderCollection;
+  }
+
+  class HttpTransportInformation implements Windows.Foundation.IStringable, Windows.Web.Http.IHttpTransportInformation {
+    ToString(): string;
+    readonly ServerCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    readonly ServerCertificateErrorSeverity: number;
+    readonly ServerCertificateErrors: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly ServerIntermediateCertificates: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+  }
+
+  enum HttpCompletionOption {
+    ResponseContentRead = 0,
+    ResponseHeadersRead = 1,
+  }
+
+  enum HttpProgressStage {
+    None = 0,
+    DetectingProxy = 10,
+    ResolvingName = 20,
+    ConnectingToServer = 30,
+    NegotiatingSsl = 40,
+    SendingHeaders = 50,
+    SendingContent = 60,
+    WaitingForResponse = 70,
+    ReceivingHeaders = 80,
+    ReceivingContent = 90,
+  }
+
+  enum HttpResponseMessageSource {
+    None = 0,
+    Cache = 1,
+    Network = 2,
+  }
+
+  enum HttpStatusCode {
+    None = 0,
+    Continue = 100,
+    SwitchingProtocols = 101,
+    Processing = 102,
+    Ok = 200,
+    Created = 201,
+    Accepted = 202,
+    NonAuthoritativeInformation = 203,
+    NoContent = 204,
+    ResetContent = 205,
+    PartialContent = 206,
+    MultiStatus = 207,
+    AlreadyReported = 208,
+    IMUsed = 226,
+    MultipleChoices = 300,
+    MovedPermanently = 301,
+    Found = 302,
+    SeeOther = 303,
+    NotModified = 304,
+    UseProxy = 305,
+    TemporaryRedirect = 307,
+    PermanentRedirect = 308,
+    BadRequest = 400,
+    Unauthorized = 401,
+    PaymentRequired = 402,
+    Forbidden = 403,
+    NotFound = 404,
+    MethodNotAllowed = 405,
+    NotAcceptable = 406,
+    ProxyAuthenticationRequired = 407,
+    RequestTimeout = 408,
+    Conflict = 409,
+    Gone = 410,
+    LengthRequired = 411,
+    PreconditionFailed = 412,
+    RequestEntityTooLarge = 413,
+    RequestUriTooLong = 414,
+    UnsupportedMediaType = 415,
+    RequestedRangeNotSatisfiable = 416,
+    ExpectationFailed = 417,
+    UnprocessableEntity = 422,
+    Locked = 423,
+    FailedDependency = 424,
+    UpgradeRequired = 426,
+    PreconditionRequired = 428,
+    TooManyRequests = 429,
+    RequestHeaderFieldsTooLarge = 431,
+    InternalServerError = 500,
+    NotImplemented = 501,
+    BadGateway = 502,
+    ServiceUnavailable = 503,
+    GatewayTimeout = 504,
+    HttpVersionNotSupported = 505,
+    VariantAlsoNegotiates = 506,
+    InsufficientStorage = 507,
+    LoopDetected = 508,
+    NotExtended = 510,
+    NetworkAuthenticationRequired = 511,
+  }
+
+  enum HttpVersion {
+    None = 0,
+    Http10 = 1,
+    Http11 = 2,
+    Http20 = 3,
+  }
+
+  interface HttpProgress {
+    Stage: number;
+    BytesSent: number | bigint;
+    TotalBytesToSend: number | bigint | null;
+    BytesReceived: number | bigint;
+    TotalBytesToReceive: number | bigint | null;
+    Retries: number;
+  }
+  var HttpProgress: {
+    new(stage: number, bytesSent: number | bigint, totalBytesToSend: number | bigint | null, bytesReceived: number | bigint, totalBytesToReceive: number | bigint | null, retries: number): HttpProgress;
+    new(fields: { Stage?: number; BytesSent?: number | bigint; TotalBytesToSend?: number | bigint | null; BytesReceived?: number | bigint; TotalBytesToReceive?: number | bigint | null; Retries?: number }): HttpProgress;
+  };
+
+  interface IHttpBufferContentFactory {
+    CreateFromBuffer(content: Windows.Storage.Streams.IBuffer): Windows.Web.Http.HttpBufferContent;
+    CreateFromBufferWithOffset(content: Windows.Storage.Streams.IBuffer, offset: number, count: number): Windows.Web.Http.HttpBufferContent;
+  }
+  var IHttpBufferContentFactory: abstract new (...args: any[]) => IHttpBufferContentFactory;
+
+  interface IHttpClient {
+    DeleteAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpResponseMessage, Windows.Web.Http.HttpProgress>;
+    GetAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpResponseMessage, Windows.Web.Http.HttpProgress>;
+    GetAsync(uri: Windows.Foundation.Uri, completionOption: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpResponseMessage, Windows.Web.Http.HttpProgress>;
+    GetBufferAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, Windows.Web.Http.HttpProgress>;
+    GetInputStreamAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IInputStream, Windows.Web.Http.HttpProgress>;
+    GetStringAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<string, Windows.Web.Http.HttpProgress>;
+    PostAsync(uri: Windows.Foundation.Uri, content: Windows.Web.Http.IHttpContent): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpResponseMessage, Windows.Web.Http.HttpProgress>;
+    PutAsync(uri: Windows.Foundation.Uri, content: Windows.Web.Http.IHttpContent): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpResponseMessage, Windows.Web.Http.HttpProgress>;
+    SendRequestAsync(request: Windows.Web.Http.HttpRequestMessage): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpResponseMessage, Windows.Web.Http.HttpProgress>;
+    SendRequestAsync(request: Windows.Web.Http.HttpRequestMessage, completionOption: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpResponseMessage, Windows.Web.Http.HttpProgress>;
+    readonly DefaultRequestHeaders: Windows.Web.Http.Headers.HttpRequestHeaderCollection;
+  }
+  var IHttpClient: abstract new (...args: any[]) => IHttpClient;
+
+  interface IHttpClient2 {
+    TryDeleteAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpRequestResult, Windows.Web.Http.HttpProgress>;
+    TryGetAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpRequestResult, Windows.Web.Http.HttpProgress>;
+    TryGetAsync(uri: Windows.Foundation.Uri, completionOption: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpRequestResult, Windows.Web.Http.HttpProgress>;
+    TryGetBufferAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpGetBufferResult, Windows.Web.Http.HttpProgress>;
+    TryGetInputStreamAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpGetInputStreamResult, Windows.Web.Http.HttpProgress>;
+    TryGetStringAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpGetStringResult, Windows.Web.Http.HttpProgress>;
+    TryPostAsync(uri: Windows.Foundation.Uri, content: Windows.Web.Http.IHttpContent): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpRequestResult, Windows.Web.Http.HttpProgress>;
+    TryPutAsync(uri: Windows.Foundation.Uri, content: Windows.Web.Http.IHttpContent): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpRequestResult, Windows.Web.Http.HttpProgress>;
+    TrySendRequestAsync(request: Windows.Web.Http.HttpRequestMessage): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpRequestResult, Windows.Web.Http.HttpProgress>;
+    TrySendRequestAsync(request: Windows.Web.Http.HttpRequestMessage, completionOption: number): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpRequestResult, Windows.Web.Http.HttpProgress>;
+  }
+  var IHttpClient2: abstract new (...args: any[]) => IHttpClient2;
+
+  interface IHttpClient3 {
+    DefaultPrivacyAnnotation: string;
+  }
+  var IHttpClient3: abstract new (...args: any[]) => IHttpClient3;
+
+  interface IHttpClientFactory {
+    Create(filter: Windows.Web.Http.Filters.IHttpFilter): Windows.Web.Http.HttpClient;
+  }
+  var IHttpClientFactory: abstract new (...args: any[]) => IHttpClientFactory;
+
+  interface IHttpContent extends Windows.Foundation.IClosable {
+    BufferAllAsync(): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+    Close(): void;
+    ReadAsBufferAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IBuffer, number | bigint>;
+    ReadAsInputStreamAsync(): Windows.Foundation.IAsyncOperationWithProgress<Windows.Storage.Streams.IInputStream, number | bigint>;
+    ReadAsStringAsync(): Windows.Foundation.IAsyncOperationWithProgress<string, number | bigint>;
+    TryComputeLength(length: number | bigint): boolean;
+    WriteToStreamAsync(outputStream: Windows.Storage.Streams.IOutputStream): Windows.Foundation.IAsyncOperationWithProgress<number | bigint, number | bigint>;
+    readonly Headers: Windows.Web.Http.Headers.HttpContentHeaderCollection;
+  }
+  var IHttpContent: abstract new (...args: any[]) => IHttpContent;
+
+  interface IHttpCookie {
+    readonly Domain: string;
+    Expires: Windows.Foundation.DateTime | null;
+    HttpOnly: boolean;
+    readonly Name: string;
+    readonly Path: string;
+    Secure: boolean;
+    Value: string;
+  }
+  var IHttpCookie: abstract new (...args: any[]) => IHttpCookie;
+
+  interface IHttpCookieFactory {
+    Create(name: string, domain: string, path: string): Windows.Web.Http.HttpCookie;
+  }
+  var IHttpCookieFactory: abstract new (...args: any[]) => IHttpCookieFactory;
+
+  interface IHttpCookieManager {
+    DeleteCookie(cookie: Windows.Web.Http.HttpCookie): void;
+    GetCookies(uri: Windows.Foundation.Uri): Windows.Web.Http.HttpCookieCollection;
+    SetCookie(cookie: Windows.Web.Http.HttpCookie): boolean;
+    SetCookie(cookie: Windows.Web.Http.HttpCookie, thirdParty: boolean): boolean;
+  }
+  var IHttpCookieManager: abstract new (...args: any[]) => IHttpCookieManager;
+
+  interface IHttpFormUrlEncodedContentFactory {
+    Create(content: Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<string, string>> | Windows.Foundation.Collections.IKeyValuePair<string, string>[]): Windows.Web.Http.HttpFormUrlEncodedContent;
+  }
+  var IHttpFormUrlEncodedContentFactory: abstract new (...args: any[]) => IHttpFormUrlEncodedContentFactory;
+
+  interface IHttpGetBufferResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly RequestMessage: Windows.Web.Http.HttpRequestMessage;
+    readonly ResponseMessage: Windows.Web.Http.HttpResponseMessage;
+    readonly Succeeded: boolean;
+    readonly Value: Windows.Storage.Streams.IBuffer;
+  }
+  var IHttpGetBufferResult: abstract new (...args: any[]) => IHttpGetBufferResult;
+
+  interface IHttpGetInputStreamResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly RequestMessage: Windows.Web.Http.HttpRequestMessage;
+    readonly ResponseMessage: Windows.Web.Http.HttpResponseMessage;
+    readonly Succeeded: boolean;
+    readonly Value: Windows.Storage.Streams.IInputStream;
+  }
+  var IHttpGetInputStreamResult: abstract new (...args: any[]) => IHttpGetInputStreamResult;
+
+  interface IHttpGetStringResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly RequestMessage: Windows.Web.Http.HttpRequestMessage;
+    readonly ResponseMessage: Windows.Web.Http.HttpResponseMessage;
+    readonly Succeeded: boolean;
+    readonly Value: string;
+  }
+  var IHttpGetStringResult: abstract new (...args: any[]) => IHttpGetStringResult;
+
+  interface IHttpMethod {
+    readonly Method: string;
+  }
+  var IHttpMethod: abstract new (...args: any[]) => IHttpMethod;
+
+  interface IHttpMethodFactory {
+    Create(method: string): Windows.Web.Http.HttpMethod;
+  }
+  var IHttpMethodFactory: abstract new (...args: any[]) => IHttpMethodFactory;
+
+  interface IHttpMethodStatics {
+    readonly Delete: Windows.Web.Http.HttpMethod;
+    readonly Get: Windows.Web.Http.HttpMethod;
+    readonly Head: Windows.Web.Http.HttpMethod;
+    readonly Options: Windows.Web.Http.HttpMethod;
+    readonly Patch: Windows.Web.Http.HttpMethod;
+    readonly Post: Windows.Web.Http.HttpMethod;
+    readonly Put: Windows.Web.Http.HttpMethod;
+  }
+  var IHttpMethodStatics: abstract new (...args: any[]) => IHttpMethodStatics;
+
+  interface IHttpMultipartContent {
+    Add(content: Windows.Web.Http.IHttpContent): void;
+  }
+  var IHttpMultipartContent: abstract new (...args: any[]) => IHttpMultipartContent;
+
+  interface IHttpMultipartContentFactory {
+    CreateWithSubtype(subtype: string): Windows.Web.Http.HttpMultipartContent;
+    CreateWithSubtypeAndBoundary(subtype: string, boundary: string): Windows.Web.Http.HttpMultipartContent;
+  }
+  var IHttpMultipartContentFactory: abstract new (...args: any[]) => IHttpMultipartContentFactory;
+
+  interface IHttpMultipartFormDataContent {
+    Add(content: Windows.Web.Http.IHttpContent): void;
+    Add(content: Windows.Web.Http.IHttpContent, name: string): void;
+    Add(content: Windows.Web.Http.IHttpContent, name: string, fileName: string): void;
+  }
+  var IHttpMultipartFormDataContent: abstract new (...args: any[]) => IHttpMultipartFormDataContent;
+
+  interface IHttpMultipartFormDataContentFactory {
+    CreateWithBoundary(boundary: string): Windows.Web.Http.HttpMultipartFormDataContent;
+  }
+  var IHttpMultipartFormDataContentFactory: abstract new (...args: any[]) => IHttpMultipartFormDataContentFactory;
+
+  interface IHttpRequestMessage {
+    Content: Windows.Web.Http.IHttpContent;
+    readonly Headers: Windows.Web.Http.Headers.HttpRequestHeaderCollection;
+    Method: Windows.Web.Http.HttpMethod;
+    readonly Properties: Windows.Foundation.Collections.IMap<string, Object> | Record<string, Object>;
+    RequestUri: Windows.Foundation.Uri;
+    readonly TransportInformation: Windows.Web.Http.HttpTransportInformation;
+  }
+  var IHttpRequestMessage: abstract new (...args: any[]) => IHttpRequestMessage;
+
+  interface IHttpRequestMessage2 {
+    PrivacyAnnotation: string;
+  }
+  var IHttpRequestMessage2: abstract new (...args: any[]) => IHttpRequestMessage2;
+
+  interface IHttpRequestMessageFactory {
+    Create(method: Windows.Web.Http.HttpMethod, uri: Windows.Foundation.Uri): Windows.Web.Http.HttpRequestMessage;
+  }
+  var IHttpRequestMessageFactory: abstract new (...args: any[]) => IHttpRequestMessageFactory;
+
+  interface IHttpRequestResult {
+    readonly ExtendedError: Windows.Foundation.HResult;
+    readonly RequestMessage: Windows.Web.Http.HttpRequestMessage;
+    readonly ResponseMessage: Windows.Web.Http.HttpResponseMessage;
+    readonly Succeeded: boolean;
+  }
+  var IHttpRequestResult: abstract new (...args: any[]) => IHttpRequestResult;
+
+  interface IHttpResponseMessage {
+    EnsureSuccessStatusCode(): Windows.Web.Http.HttpResponseMessage;
+    Content: Windows.Web.Http.IHttpContent;
+    readonly Headers: Windows.Web.Http.Headers.HttpResponseHeaderCollection;
+    readonly IsSuccessStatusCode: boolean;
+    ReasonPhrase: string;
+    RequestMessage: Windows.Web.Http.HttpRequestMessage;
+    Source: number;
+    StatusCode: number;
+    Version: number;
+  }
+  var IHttpResponseMessage: abstract new (...args: any[]) => IHttpResponseMessage;
+
+  interface IHttpResponseMessageFactory {
+    Create(statusCode: number): Windows.Web.Http.HttpResponseMessage;
+  }
+  var IHttpResponseMessageFactory: abstract new (...args: any[]) => IHttpResponseMessageFactory;
+
+  interface IHttpStreamContentFactory {
+    CreateFromInputStream(content: Windows.Storage.Streams.IInputStream): Windows.Web.Http.HttpStreamContent;
+  }
+  var IHttpStreamContentFactory: abstract new (...args: any[]) => IHttpStreamContentFactory;
+
+  interface IHttpStringContentFactory {
+    CreateFromString(content: string): Windows.Web.Http.HttpStringContent;
+    CreateFromStringWithEncoding(content: string, encoding: number): Windows.Web.Http.HttpStringContent;
+    CreateFromStringWithEncodingAndMediaType(content: string, encoding: number, mediaType: string): Windows.Web.Http.HttpStringContent;
+  }
+  var IHttpStringContentFactory: abstract new (...args: any[]) => IHttpStringContentFactory;
+
+  interface IHttpTransportInformation {
+    readonly ServerCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    readonly ServerCertificateErrorSeverity: number;
+    readonly ServerCertificateErrors: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly ServerIntermediateCertificates: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+  }
+  var IHttpTransportInformation: abstract new (...args: any[]) => IHttpTransportInformation;
+
+}
+
+declare namespace Windows.Web.Http.Diagnostics {
+  class HttpDiagnosticProvider implements Windows.Web.Http.Diagnostics.IHttpDiagnosticProvider {
+    static CreateFromProcessDiagnosticInfo(processDiagnosticInfo: Windows.System.Diagnostics.ProcessDiagnosticInfo): Windows.Web.Http.Diagnostics.HttpDiagnosticProvider;
+    Start(): void;
+    Stop(): void;
+    RequestResponseCompleted: Windows.Foundation.TypedEventHandler<Windows.Web.Http.Diagnostics.HttpDiagnosticProvider, Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestResponseCompletedEventArgs> | null;
+    RequestSent: Windows.Foundation.TypedEventHandler<Windows.Web.Http.Diagnostics.HttpDiagnosticProvider, Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestSentEventArgs> | null;
+    ResponseReceived: Windows.Foundation.TypedEventHandler<Windows.Web.Http.Diagnostics.HttpDiagnosticProvider, Windows.Web.Http.Diagnostics.HttpDiagnosticProviderResponseReceivedEventArgs> | null;
+  }
+
+  class HttpDiagnosticProviderRequestResponseCompletedEventArgs implements Windows.Web.Http.Diagnostics.IHttpDiagnosticProviderRequestResponseCompletedEventArgs {
+    readonly ActivityId: Guid;
+    readonly Initiator: number;
+    readonly ProcessId: number;
+    readonly RequestedUri: Windows.Foundation.Uri;
+    readonly SourceLocations: Windows.Foundation.Collections.IVectorView<Windows.Web.Http.Diagnostics.HttpDiagnosticSourceLocation> | Windows.Web.Http.Diagnostics.HttpDiagnosticSourceLocation[];
+    readonly ThreadId: number;
+    readonly Timestamps: Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestResponseTimestamps;
+  }
+
+  class HttpDiagnosticProviderRequestResponseTimestamps implements Windows.Web.Http.Diagnostics.IHttpDiagnosticProviderRequestResponseTimestamps {
+    readonly CacheCheckedTimestamp: Windows.Foundation.DateTime | null;
+    readonly ConnectionCompletedTimestamp: Windows.Foundation.DateTime | null;
+    readonly ConnectionInitiatedTimestamp: Windows.Foundation.DateTime | null;
+    readonly NameResolvedTimestamp: Windows.Foundation.DateTime | null;
+    readonly RequestCompletedTimestamp: Windows.Foundation.DateTime | null;
+    readonly RequestSentTimestamp: Windows.Foundation.DateTime | null;
+    readonly ResponseCompletedTimestamp: Windows.Foundation.DateTime | null;
+    readonly ResponseReceivedTimestamp: Windows.Foundation.DateTime | null;
+    readonly SslNegotiatedTimestamp: Windows.Foundation.DateTime | null;
+  }
+
+  class HttpDiagnosticProviderRequestSentEventArgs implements Windows.Web.Http.Diagnostics.IHttpDiagnosticProviderRequestSentEventArgs {
+    readonly ActivityId: Guid;
+    readonly Initiator: number;
+    readonly Message: Windows.Web.Http.HttpRequestMessage;
+    readonly ProcessId: number;
+    readonly SourceLocations: Windows.Foundation.Collections.IVectorView<Windows.Web.Http.Diagnostics.HttpDiagnosticSourceLocation> | Windows.Web.Http.Diagnostics.HttpDiagnosticSourceLocation[];
+    readonly ThreadId: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class HttpDiagnosticProviderResponseReceivedEventArgs implements Windows.Web.Http.Diagnostics.IHttpDiagnosticProviderResponseReceivedEventArgs {
+    readonly ActivityId: Guid;
+    readonly Message: Windows.Web.Http.HttpResponseMessage;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+
+  class HttpDiagnosticSourceLocation implements Windows.Web.Http.Diagnostics.IHttpDiagnosticSourceLocation {
+    readonly ColumnNumber: number | bigint;
+    readonly LineNumber: number | bigint;
+    readonly SourceUri: Windows.Foundation.Uri;
+  }
+
+  enum HttpDiagnosticRequestInitiator {
+    ParsedElement = 0,
+    Script = 1,
+    Image = 2,
+    Link = 3,
+    Style = 4,
+    XmlHttpRequest = 5,
+    Media = 6,
+    HtmlDownload = 7,
+    Prefetch = 8,
+    Other = 9,
+    CrossOriginPreFlight = 10,
+    Fetch = 11,
+    Beacon = 12,
+  }
+
+  interface HttpDiagnosticsContract {
+  }
+  var HttpDiagnosticsContract: {
+    new(fields: {  }): HttpDiagnosticsContract;
+  };
+
+  interface IHttpDiagnosticProvider {
+    Start(): void;
+    Stop(): void;
+    RequestResponseCompleted: Windows.Foundation.TypedEventHandler<Windows.Web.Http.Diagnostics.HttpDiagnosticProvider, Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestResponseCompletedEventArgs> | null;
+    RequestSent: Windows.Foundation.TypedEventHandler<Windows.Web.Http.Diagnostics.HttpDiagnosticProvider, Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestSentEventArgs> | null;
+    ResponseReceived: Windows.Foundation.TypedEventHandler<Windows.Web.Http.Diagnostics.HttpDiagnosticProvider, Windows.Web.Http.Diagnostics.HttpDiagnosticProviderResponseReceivedEventArgs> | null;
+  }
+  var IHttpDiagnosticProvider: abstract new (...args: any[]) => IHttpDiagnosticProvider;
+
+  interface IHttpDiagnosticProviderRequestResponseCompletedEventArgs {
+    readonly ActivityId: Guid;
+    readonly Initiator: number;
+    readonly ProcessId: number;
+    readonly RequestedUri: Windows.Foundation.Uri;
+    readonly SourceLocations: Windows.Foundation.Collections.IVectorView<Windows.Web.Http.Diagnostics.HttpDiagnosticSourceLocation> | Windows.Web.Http.Diagnostics.HttpDiagnosticSourceLocation[];
+    readonly ThreadId: number;
+    readonly Timestamps: Windows.Web.Http.Diagnostics.HttpDiagnosticProviderRequestResponseTimestamps;
+  }
+  var IHttpDiagnosticProviderRequestResponseCompletedEventArgs: abstract new (...args: any[]) => IHttpDiagnosticProviderRequestResponseCompletedEventArgs;
+
+  interface IHttpDiagnosticProviderRequestResponseTimestamps {
+    readonly CacheCheckedTimestamp: Windows.Foundation.DateTime | null;
+    readonly ConnectionCompletedTimestamp: Windows.Foundation.DateTime | null;
+    readonly ConnectionInitiatedTimestamp: Windows.Foundation.DateTime | null;
+    readonly NameResolvedTimestamp: Windows.Foundation.DateTime | null;
+    readonly RequestCompletedTimestamp: Windows.Foundation.DateTime | null;
+    readonly RequestSentTimestamp: Windows.Foundation.DateTime | null;
+    readonly ResponseCompletedTimestamp: Windows.Foundation.DateTime | null;
+    readonly ResponseReceivedTimestamp: Windows.Foundation.DateTime | null;
+    readonly SslNegotiatedTimestamp: Windows.Foundation.DateTime | null;
+  }
+  var IHttpDiagnosticProviderRequestResponseTimestamps: abstract new (...args: any[]) => IHttpDiagnosticProviderRequestResponseTimestamps;
+
+  interface IHttpDiagnosticProviderRequestSentEventArgs {
+    readonly ActivityId: Guid;
+    readonly Initiator: number;
+    readonly Message: Windows.Web.Http.HttpRequestMessage;
+    readonly ProcessId: number;
+    readonly SourceLocations: Windows.Foundation.Collections.IVectorView<Windows.Web.Http.Diagnostics.HttpDiagnosticSourceLocation> | Windows.Web.Http.Diagnostics.HttpDiagnosticSourceLocation[];
+    readonly ThreadId: number;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IHttpDiagnosticProviderRequestSentEventArgs: abstract new (...args: any[]) => IHttpDiagnosticProviderRequestSentEventArgs;
+
+  interface IHttpDiagnosticProviderResponseReceivedEventArgs {
+    readonly ActivityId: Guid;
+    readonly Message: Windows.Web.Http.HttpResponseMessage;
+    readonly Timestamp: Windows.Foundation.DateTime;
+  }
+  var IHttpDiagnosticProviderResponseReceivedEventArgs: abstract new (...args: any[]) => IHttpDiagnosticProviderResponseReceivedEventArgs;
+
+  interface IHttpDiagnosticProviderStatics {
+    CreateFromProcessDiagnosticInfo(processDiagnosticInfo: Windows.System.Diagnostics.ProcessDiagnosticInfo): Windows.Web.Http.Diagnostics.HttpDiagnosticProvider;
+  }
+  var IHttpDiagnosticProviderStatics: abstract new (...args: any[]) => IHttpDiagnosticProviderStatics;
+
+  interface IHttpDiagnosticSourceLocation {
+    readonly ColumnNumber: number | bigint;
+    readonly LineNumber: number | bigint;
+    readonly SourceUri: Windows.Foundation.Uri;
+  }
+  var IHttpDiagnosticSourceLocation: abstract new (...args: any[]) => IHttpDiagnosticSourceLocation;
+
+}
+
+declare namespace Windows.Web.Http.Filters {
+  class HttpBaseProtocolFilter implements Windows.Foundation.IClosable, Windows.Web.Http.Filters.IHttpBaseProtocolFilter, Windows.Web.Http.Filters.IHttpBaseProtocolFilter2, Windows.Web.Http.Filters.IHttpBaseProtocolFilter3, Windows.Web.Http.Filters.IHttpBaseProtocolFilter4, Windows.Web.Http.Filters.IHttpBaseProtocolFilter5, Windows.Web.Http.Filters.IHttpFilter {
+    constructor();
+    ClearAuthenticationCache(): void;
+    Close(): void;
+    static CreateForUser(user: Windows.System.User): Windows.Web.Http.Filters.HttpBaseProtocolFilter;
+    SendRequestAsync(request: Windows.Web.Http.HttpRequestMessage): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpResponseMessage, Windows.Web.Http.HttpProgress>;
+    AllowAutoRedirect: boolean;
+    AllowUI: boolean;
+    AutomaticDecompression: boolean;
+    readonly CacheControl: Windows.Web.Http.Filters.HttpCacheControl;
+    ClientCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    readonly CookieManager: Windows.Web.Http.HttpCookieManager;
+    CookieUsageBehavior: number;
+    readonly IgnorableServerCertificateErrors: Windows.Foundation.Collections.IVector<number> | number[];
+    MaxConnectionsPerServer: number;
+    MaxVersion: number;
+    ProxyCredential: Windows.Security.Credentials.PasswordCredential;
+    ServerCredential: Windows.Security.Credentials.PasswordCredential;
+    UseProxy: boolean;
+    readonly User: Windows.System.User;
+    ServerCustomValidationRequested: Windows.Foundation.TypedEventHandler<Windows.Web.Http.Filters.HttpBaseProtocolFilter, Windows.Web.Http.Filters.HttpServerCustomValidationRequestedEventArgs> | null;
+  }
+
+  class HttpCacheControl implements Windows.Web.Http.Filters.IHttpCacheControl {
+    ReadBehavior: number;
+    WriteBehavior: number;
+  }
+
+  class HttpServerCustomValidationRequestedEventArgs implements Windows.Web.Http.Filters.IHttpServerCustomValidationRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Reject(): void;
+    readonly RequestMessage: Windows.Web.Http.HttpRequestMessage;
+    readonly ServerCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    readonly ServerCertificateErrorSeverity: number;
+    readonly ServerCertificateErrors: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly ServerIntermediateCertificates: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+  }
+
+  enum HttpCacheReadBehavior {
+    Default = 0,
+    MostRecent = 1,
+    OnlyFromCache = 2,
+    NoCache = 3,
+  }
+
+  enum HttpCacheWriteBehavior {
+    Default = 0,
+    NoCache = 1,
+  }
+
+  enum HttpCookieUsageBehavior {
+    Default = 0,
+    NoCookies = 1,
+  }
+
+  interface IHttpBaseProtocolFilter {
+    AllowAutoRedirect: boolean;
+    AllowUI: boolean;
+    AutomaticDecompression: boolean;
+    readonly CacheControl: Windows.Web.Http.Filters.HttpCacheControl;
+    ClientCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    readonly CookieManager: Windows.Web.Http.HttpCookieManager;
+    readonly IgnorableServerCertificateErrors: Windows.Foundation.Collections.IVector<number> | number[];
+    MaxConnectionsPerServer: number;
+    ProxyCredential: Windows.Security.Credentials.PasswordCredential;
+    ServerCredential: Windows.Security.Credentials.PasswordCredential;
+    UseProxy: boolean;
+  }
+  var IHttpBaseProtocolFilter: abstract new (...args: any[]) => IHttpBaseProtocolFilter;
+
+  interface IHttpBaseProtocolFilter2 {
+    MaxVersion: number;
+  }
+  var IHttpBaseProtocolFilter2: abstract new (...args: any[]) => IHttpBaseProtocolFilter2;
+
+  interface IHttpBaseProtocolFilter3 {
+    CookieUsageBehavior: number;
+  }
+  var IHttpBaseProtocolFilter3: abstract new (...args: any[]) => IHttpBaseProtocolFilter3;
+
+  interface IHttpBaseProtocolFilter4 {
+    ClearAuthenticationCache(): void;
+    ServerCustomValidationRequested: Windows.Foundation.TypedEventHandler<Windows.Web.Http.Filters.HttpBaseProtocolFilter, Windows.Web.Http.Filters.HttpServerCustomValidationRequestedEventArgs> | null;
+  }
+  var IHttpBaseProtocolFilter4: abstract new (...args: any[]) => IHttpBaseProtocolFilter4;
+
+  interface IHttpBaseProtocolFilter5 {
+    readonly User: Windows.System.User;
+  }
+  var IHttpBaseProtocolFilter5: abstract new (...args: any[]) => IHttpBaseProtocolFilter5;
+
+  interface IHttpBaseProtocolFilterStatics {
+    CreateForUser(user: Windows.System.User): Windows.Web.Http.Filters.HttpBaseProtocolFilter;
+  }
+  var IHttpBaseProtocolFilterStatics: abstract new (...args: any[]) => IHttpBaseProtocolFilterStatics;
+
+  interface IHttpCacheControl {
+    ReadBehavior: number;
+    WriteBehavior: number;
+  }
+  var IHttpCacheControl: abstract new (...args: any[]) => IHttpCacheControl;
+
+  interface IHttpFilter extends Windows.Foundation.IClosable {
+    Close(): void;
+    SendRequestAsync(request: Windows.Web.Http.HttpRequestMessage): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Http.HttpResponseMessage, Windows.Web.Http.HttpProgress>;
+  }
+  var IHttpFilter: abstract new (...args: any[]) => IHttpFilter;
+
+  interface IHttpServerCustomValidationRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Reject(): void;
+    readonly RequestMessage: Windows.Web.Http.HttpRequestMessage;
+    readonly ServerCertificate: Windows.Security.Cryptography.Certificates.Certificate;
+    readonly ServerCertificateErrorSeverity: number;
+    readonly ServerCertificateErrors: Windows.Foundation.Collections.IVectorView<number> | number[];
+    readonly ServerIntermediateCertificates: Windows.Foundation.Collections.IVectorView<Windows.Security.Cryptography.Certificates.Certificate> | Windows.Security.Cryptography.Certificates.Certificate[];
+  }
+  var IHttpServerCustomValidationRequestedEventArgs: abstract new (...args: any[]) => IHttpServerCustomValidationRequestedEventArgs;
+
+}
+
+declare namespace Windows.Web.Http.Headers {
+  class HttpCacheDirectiveHeaderValueCollection implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpCacheDirectiveHeaderValueCollection {
+    Append(value: Windows.Web.Http.Headers.HttpNameValueHeaderValue): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Web.Http.Headers.HttpNameValueHeaderValue>;
+    GetAt(index: number): Windows.Web.Http.Headers.HttpNameValueHeaderValue;
+    GetMany(startIndex: number, items: Windows.Web.Http.Headers.HttpNameValueHeaderValue[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.Web.Http.Headers.HttpNameValueHeaderValue> | Windows.Web.Http.Headers.HttpNameValueHeaderValue[];
+    IndexOf(value: Windows.Web.Http.Headers.HttpNameValueHeaderValue, index: number): boolean;
+    InsertAt(index: number, value: Windows.Web.Http.Headers.HttpNameValueHeaderValue): void;
+    ParseAdd(input: string): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.Web.Http.Headers.HttpNameValueHeaderValue[]): void;
+    SetAt(index: number, value: Windows.Web.Http.Headers.HttpNameValueHeaderValue): void;
+    ToString(): string;
+    TryParseAdd(input: string): boolean;
+    MaxAge: Windows.Foundation.TimeSpan | null;
+    MaxStale: Windows.Foundation.TimeSpan | null;
+    MinFresh: Windows.Foundation.TimeSpan | null;
+    SharedMaxAge: Windows.Foundation.TimeSpan | null;
+    readonly Size: number;
+  }
+
+  class HttpChallengeHeaderValue implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpChallengeHeaderValue {
+    constructor(scheme: string);
+    constructor(scheme: string, token: string);
+    static Parse(input: string): Windows.Web.Http.Headers.HttpChallengeHeaderValue;
+    ToString(): string;
+    static TryParse(input: string, challengeHeaderValue: Windows.Web.Http.Headers.HttpChallengeHeaderValue): boolean;
+    readonly Parameters: Windows.Foundation.Collections.IVector<Windows.Web.Http.Headers.HttpNameValueHeaderValue> | Windows.Web.Http.Headers.HttpNameValueHeaderValue[];
+    readonly Scheme: string;
+    readonly Token: string;
+  }
+
+  class HttpChallengeHeaderValueCollection implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpChallengeHeaderValueCollection {
+    Append(value: Windows.Web.Http.Headers.HttpChallengeHeaderValue): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Web.Http.Headers.HttpChallengeHeaderValue>;
+    GetAt(index: number): Windows.Web.Http.Headers.HttpChallengeHeaderValue;
+    GetMany(startIndex: number, items: Windows.Web.Http.Headers.HttpChallengeHeaderValue[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.Web.Http.Headers.HttpChallengeHeaderValue> | Windows.Web.Http.Headers.HttpChallengeHeaderValue[];
+    IndexOf(value: Windows.Web.Http.Headers.HttpChallengeHeaderValue, index: number): boolean;
+    InsertAt(index: number, value: Windows.Web.Http.Headers.HttpChallengeHeaderValue): void;
+    ParseAdd(input: string): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.Web.Http.Headers.HttpChallengeHeaderValue[]): void;
+    SetAt(index: number, value: Windows.Web.Http.Headers.HttpChallengeHeaderValue): void;
+    ToString(): string;
+    TryParseAdd(input: string): boolean;
+    readonly Size: number;
+  }
+
+  class HttpConnectionOptionHeaderValue implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpConnectionOptionHeaderValue {
+    constructor(token: string);
+    static Parse(input: string): Windows.Web.Http.Headers.HttpConnectionOptionHeaderValue;
+    ToString(): string;
+    static TryParse(input: string, connectionOptionHeaderValue: Windows.Web.Http.Headers.HttpConnectionOptionHeaderValue): boolean;
+    readonly Token: string;
+  }
+
+  class HttpConnectionOptionHeaderValueCollection implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpConnectionOptionHeaderValueCollection {
+    Append(value: Windows.Web.Http.Headers.HttpConnectionOptionHeaderValue): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Web.Http.Headers.HttpConnectionOptionHeaderValue>;
+    GetAt(index: number): Windows.Web.Http.Headers.HttpConnectionOptionHeaderValue;
+    GetMany(startIndex: number, items: Windows.Web.Http.Headers.HttpConnectionOptionHeaderValue[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.Web.Http.Headers.HttpConnectionOptionHeaderValue> | Windows.Web.Http.Headers.HttpConnectionOptionHeaderValue[];
+    IndexOf(value: Windows.Web.Http.Headers.HttpConnectionOptionHeaderValue, index: number): boolean;
+    InsertAt(index: number, value: Windows.Web.Http.Headers.HttpConnectionOptionHeaderValue): void;
+    ParseAdd(input: string): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.Web.Http.Headers.HttpConnectionOptionHeaderValue[]): void;
+    SetAt(index: number, value: Windows.Web.Http.Headers.HttpConnectionOptionHeaderValue): void;
+    ToString(): string;
+    TryParseAdd(input: string): boolean;
+    readonly Size: number;
+  }
+
+  class HttpContentCodingHeaderValue implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpContentCodingHeaderValue {
+    constructor(contentCoding: string);
+    static Parse(input: string): Windows.Web.Http.Headers.HttpContentCodingHeaderValue;
+    ToString(): string;
+    static TryParse(input: string, contentCodingHeaderValue: Windows.Web.Http.Headers.HttpContentCodingHeaderValue): boolean;
+    readonly ContentCoding: string;
+  }
+
+  class HttpContentCodingHeaderValueCollection implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpContentCodingHeaderValueCollection {
+    Append(value: Windows.Web.Http.Headers.HttpContentCodingHeaderValue): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Web.Http.Headers.HttpContentCodingHeaderValue>;
+    GetAt(index: number): Windows.Web.Http.Headers.HttpContentCodingHeaderValue;
+    GetMany(startIndex: number, items: Windows.Web.Http.Headers.HttpContentCodingHeaderValue[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.Web.Http.Headers.HttpContentCodingHeaderValue> | Windows.Web.Http.Headers.HttpContentCodingHeaderValue[];
+    IndexOf(value: Windows.Web.Http.Headers.HttpContentCodingHeaderValue, index: number): boolean;
+    InsertAt(index: number, value: Windows.Web.Http.Headers.HttpContentCodingHeaderValue): void;
+    ParseAdd(input: string): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.Web.Http.Headers.HttpContentCodingHeaderValue[]): void;
+    SetAt(index: number, value: Windows.Web.Http.Headers.HttpContentCodingHeaderValue): void;
+    ToString(): string;
+    TryParseAdd(input: string): boolean;
+    readonly Size: number;
+  }
+
+  class HttpContentCodingWithQualityHeaderValue implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpContentCodingWithQualityHeaderValue {
+    constructor(contentCoding: string);
+    constructor(contentCoding: string, quality: number);
+    static Parse(input: string): Windows.Web.Http.Headers.HttpContentCodingWithQualityHeaderValue;
+    ToString(): string;
+    static TryParse(input: string, contentCodingWithQualityHeaderValue: Windows.Web.Http.Headers.HttpContentCodingWithQualityHeaderValue): boolean;
+    readonly ContentCoding: string;
+    readonly Quality: number | null;
+  }
+
+  class HttpContentCodingWithQualityHeaderValueCollection implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpContentCodingWithQualityHeaderValueCollection {
+    Append(value: Windows.Web.Http.Headers.HttpContentCodingWithQualityHeaderValue): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Web.Http.Headers.HttpContentCodingWithQualityHeaderValue>;
+    GetAt(index: number): Windows.Web.Http.Headers.HttpContentCodingWithQualityHeaderValue;
+    GetMany(startIndex: number, items: Windows.Web.Http.Headers.HttpContentCodingWithQualityHeaderValue[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.Web.Http.Headers.HttpContentCodingWithQualityHeaderValue> | Windows.Web.Http.Headers.HttpContentCodingWithQualityHeaderValue[];
+    IndexOf(value: Windows.Web.Http.Headers.HttpContentCodingWithQualityHeaderValue, index: number): boolean;
+    InsertAt(index: number, value: Windows.Web.Http.Headers.HttpContentCodingWithQualityHeaderValue): void;
+    ParseAdd(input: string): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.Web.Http.Headers.HttpContentCodingWithQualityHeaderValue[]): void;
+    SetAt(index: number, value: Windows.Web.Http.Headers.HttpContentCodingWithQualityHeaderValue): void;
+    ToString(): string;
+    TryParseAdd(input: string): boolean;
+    readonly Size: number;
+  }
+
+  class HttpContentDispositionHeaderValue implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpContentDispositionHeaderValue {
+    constructor(dispositionType: string);
+    static Parse(input: string): Windows.Web.Http.Headers.HttpContentDispositionHeaderValue;
+    ToString(): string;
+    static TryParse(input: string, contentDispositionHeaderValue: Windows.Web.Http.Headers.HttpContentDispositionHeaderValue): boolean;
+    DispositionType: string;
+    FileName: string;
+    FileNameStar: string;
+    Name: string;
+    readonly Parameters: Windows.Foundation.Collections.IVector<Windows.Web.Http.Headers.HttpNameValueHeaderValue> | Windows.Web.Http.Headers.HttpNameValueHeaderValue[];
+    Size: number | bigint | null;
+  }
+
+  class HttpContentHeaderCollection implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpContentHeaderCollection {
+    constructor();
+    Append(name: string, value: string): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, string>>;
+    GetView(): Windows.Foundation.Collections.IMapView<string, string>;
+    HasKey(key: string): boolean;
+    Insert(key: string, value: string): boolean;
+    Lookup(key: string): string;
+    Remove(key: string): void;
+    ToString(): string;
+    TryAppendWithoutValidation(name: string, value: string): boolean;
+    ContentDisposition: Windows.Web.Http.Headers.HttpContentDispositionHeaderValue;
+    readonly ContentEncoding: Windows.Web.Http.Headers.HttpContentCodingHeaderValueCollection;
+    readonly ContentLanguage: Windows.Web.Http.Headers.HttpLanguageHeaderValueCollection;
+    ContentLength: number | bigint | null;
+    ContentLocation: Windows.Foundation.Uri;
+    ContentMD5: Windows.Storage.Streams.IBuffer;
+    ContentRange: Windows.Web.Http.Headers.HttpContentRangeHeaderValue;
+    ContentType: Windows.Web.Http.Headers.HttpMediaTypeHeaderValue;
+    Expires: Windows.Foundation.DateTime | null;
+    LastModified: Windows.Foundation.DateTime | null;
+    readonly Size: number;
+  }
+
+  class HttpContentRangeHeaderValue implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpContentRangeHeaderValue {
+    constructor(length: number | bigint);
+    constructor(from: number | bigint, to: number | bigint);
+    constructor(from: number | bigint, to: number | bigint, length: number | bigint);
+    static Parse(input: string): Windows.Web.Http.Headers.HttpContentRangeHeaderValue;
+    ToString(): string;
+    static TryParse(input: string, contentRangeHeaderValue: Windows.Web.Http.Headers.HttpContentRangeHeaderValue): boolean;
+    readonly FirstBytePosition: number | bigint | null;
+    readonly LastBytePosition: number | bigint | null;
+    readonly Length: number | bigint | null;
+    Unit: string;
+  }
+
+  class HttpCookiePairHeaderValue implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpCookiePairHeaderValue {
+    constructor(name: string);
+    constructor(name: string, value: string);
+    static Parse(input: string): Windows.Web.Http.Headers.HttpCookiePairHeaderValue;
+    ToString(): string;
+    static TryParse(input: string, cookiePairHeaderValue: Windows.Web.Http.Headers.HttpCookiePairHeaderValue): boolean;
+    readonly Name: string;
+    Value: string;
+  }
+
+  class HttpCookiePairHeaderValueCollection implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpCookiePairHeaderValueCollection {
+    Append(value: Windows.Web.Http.Headers.HttpCookiePairHeaderValue): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Web.Http.Headers.HttpCookiePairHeaderValue>;
+    GetAt(index: number): Windows.Web.Http.Headers.HttpCookiePairHeaderValue;
+    GetMany(startIndex: number, items: Windows.Web.Http.Headers.HttpCookiePairHeaderValue[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.Web.Http.Headers.HttpCookiePairHeaderValue> | Windows.Web.Http.Headers.HttpCookiePairHeaderValue[];
+    IndexOf(value: Windows.Web.Http.Headers.HttpCookiePairHeaderValue, index: number): boolean;
+    InsertAt(index: number, value: Windows.Web.Http.Headers.HttpCookiePairHeaderValue): void;
+    ParseAdd(input: string): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.Web.Http.Headers.HttpCookiePairHeaderValue[]): void;
+    SetAt(index: number, value: Windows.Web.Http.Headers.HttpCookiePairHeaderValue): void;
+    ToString(): string;
+    TryParseAdd(input: string): boolean;
+    readonly Size: number;
+  }
+
+  class HttpCredentialsHeaderValue implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpCredentialsHeaderValue {
+    constructor(scheme: string);
+    constructor(scheme: string, token: string);
+    static Parse(input: string): Windows.Web.Http.Headers.HttpCredentialsHeaderValue;
+    ToString(): string;
+    static TryParse(input: string, credentialsHeaderValue: Windows.Web.Http.Headers.HttpCredentialsHeaderValue): boolean;
+    readonly Parameters: Windows.Foundation.Collections.IVector<Windows.Web.Http.Headers.HttpNameValueHeaderValue> | Windows.Web.Http.Headers.HttpNameValueHeaderValue[];
+    readonly Scheme: string;
+    readonly Token: string;
+  }
+
+  class HttpDateOrDeltaHeaderValue implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpDateOrDeltaHeaderValue {
+    static Parse(input: string): Windows.Web.Http.Headers.HttpDateOrDeltaHeaderValue;
+    ToString(): string;
+    static TryParse(input: string, dateOrDeltaHeaderValue: Windows.Web.Http.Headers.HttpDateOrDeltaHeaderValue): boolean;
+    readonly Date: Windows.Foundation.DateTime | null;
+    readonly Delta: Windows.Foundation.TimeSpan | null;
+  }
+
+  class HttpExpectationHeaderValue implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpExpectationHeaderValue {
+    constructor(name: string);
+    constructor(name: string, value: string);
+    static Parse(input: string): Windows.Web.Http.Headers.HttpExpectationHeaderValue;
+    ToString(): string;
+    static TryParse(input: string, expectationHeaderValue: Windows.Web.Http.Headers.HttpExpectationHeaderValue): boolean;
+    readonly Name: string;
+    readonly Parameters: Windows.Foundation.Collections.IVector<Windows.Web.Http.Headers.HttpNameValueHeaderValue> | Windows.Web.Http.Headers.HttpNameValueHeaderValue[];
+    Value: string;
+  }
+
+  class HttpExpectationHeaderValueCollection implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpExpectationHeaderValueCollection {
+    Append(value: Windows.Web.Http.Headers.HttpExpectationHeaderValue): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Web.Http.Headers.HttpExpectationHeaderValue>;
+    GetAt(index: number): Windows.Web.Http.Headers.HttpExpectationHeaderValue;
+    GetMany(startIndex: number, items: Windows.Web.Http.Headers.HttpExpectationHeaderValue[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.Web.Http.Headers.HttpExpectationHeaderValue> | Windows.Web.Http.Headers.HttpExpectationHeaderValue[];
+    IndexOf(value: Windows.Web.Http.Headers.HttpExpectationHeaderValue, index: number): boolean;
+    InsertAt(index: number, value: Windows.Web.Http.Headers.HttpExpectationHeaderValue): void;
+    ParseAdd(input: string): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.Web.Http.Headers.HttpExpectationHeaderValue[]): void;
+    SetAt(index: number, value: Windows.Web.Http.Headers.HttpExpectationHeaderValue): void;
+    ToString(): string;
+    TryParseAdd(input: string): boolean;
+    readonly Size: number;
+  }
+
+  class HttpLanguageHeaderValueCollection implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpLanguageHeaderValueCollection {
+    Append(value: Windows.Globalization.Language): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Globalization.Language>;
+    GetAt(index: number): Windows.Globalization.Language;
+    GetMany(startIndex: number, items: Windows.Globalization.Language[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.Globalization.Language> | Windows.Globalization.Language[];
+    IndexOf(value: Windows.Globalization.Language, index: number): boolean;
+    InsertAt(index: number, value: Windows.Globalization.Language): void;
+    ParseAdd(input: string): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.Globalization.Language[]): void;
+    SetAt(index: number, value: Windows.Globalization.Language): void;
+    ToString(): string;
+    TryParseAdd(input: string): boolean;
+    readonly Size: number;
+  }
+
+  class HttpLanguageRangeWithQualityHeaderValue implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpLanguageRangeWithQualityHeaderValue {
+    constructor(languageRange: string);
+    constructor(languageRange: string, quality: number);
+    static Parse(input: string): Windows.Web.Http.Headers.HttpLanguageRangeWithQualityHeaderValue;
+    ToString(): string;
+    static TryParse(input: string, languageRangeWithQualityHeaderValue: Windows.Web.Http.Headers.HttpLanguageRangeWithQualityHeaderValue): boolean;
+    readonly LanguageRange: string;
+    readonly Quality: number | null;
+  }
+
+  class HttpLanguageRangeWithQualityHeaderValueCollection implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpLanguageRangeWithQualityHeaderValueCollection {
+    Append(value: Windows.Web.Http.Headers.HttpLanguageRangeWithQualityHeaderValue): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Web.Http.Headers.HttpLanguageRangeWithQualityHeaderValue>;
+    GetAt(index: number): Windows.Web.Http.Headers.HttpLanguageRangeWithQualityHeaderValue;
+    GetMany(startIndex: number, items: Windows.Web.Http.Headers.HttpLanguageRangeWithQualityHeaderValue[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.Web.Http.Headers.HttpLanguageRangeWithQualityHeaderValue> | Windows.Web.Http.Headers.HttpLanguageRangeWithQualityHeaderValue[];
+    IndexOf(value: Windows.Web.Http.Headers.HttpLanguageRangeWithQualityHeaderValue, index: number): boolean;
+    InsertAt(index: number, value: Windows.Web.Http.Headers.HttpLanguageRangeWithQualityHeaderValue): void;
+    ParseAdd(input: string): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.Web.Http.Headers.HttpLanguageRangeWithQualityHeaderValue[]): void;
+    SetAt(index: number, value: Windows.Web.Http.Headers.HttpLanguageRangeWithQualityHeaderValue): void;
+    ToString(): string;
+    TryParseAdd(input: string): boolean;
+    readonly Size: number;
+  }
+
+  class HttpMediaTypeHeaderValue implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpMediaTypeHeaderValue {
+    constructor(mediaType: string);
+    static Parse(input: string): Windows.Web.Http.Headers.HttpMediaTypeHeaderValue;
+    ToString(): string;
+    static TryParse(input: string, mediaTypeHeaderValue: Windows.Web.Http.Headers.HttpMediaTypeHeaderValue): boolean;
+    CharSet: string;
+    MediaType: string;
+    readonly Parameters: Windows.Foundation.Collections.IVector<Windows.Web.Http.Headers.HttpNameValueHeaderValue> | Windows.Web.Http.Headers.HttpNameValueHeaderValue[];
+  }
+
+  class HttpMediaTypeWithQualityHeaderValue implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpMediaTypeWithQualityHeaderValue {
+    constructor(mediaType: string);
+    constructor(mediaType: string, quality: number);
+    static Parse(input: string): Windows.Web.Http.Headers.HttpMediaTypeWithQualityHeaderValue;
+    ToString(): string;
+    static TryParse(input: string, mediaTypeWithQualityHeaderValue: Windows.Web.Http.Headers.HttpMediaTypeWithQualityHeaderValue): boolean;
+    CharSet: string;
+    MediaType: string;
+    readonly Parameters: Windows.Foundation.Collections.IVector<Windows.Web.Http.Headers.HttpNameValueHeaderValue> | Windows.Web.Http.Headers.HttpNameValueHeaderValue[];
+    Quality: number | null;
+  }
+
+  class HttpMediaTypeWithQualityHeaderValueCollection implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpMediaTypeWithQualityHeaderValueCollection {
+    Append(value: Windows.Web.Http.Headers.HttpMediaTypeWithQualityHeaderValue): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Web.Http.Headers.HttpMediaTypeWithQualityHeaderValue>;
+    GetAt(index: number): Windows.Web.Http.Headers.HttpMediaTypeWithQualityHeaderValue;
+    GetMany(startIndex: number, items: Windows.Web.Http.Headers.HttpMediaTypeWithQualityHeaderValue[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.Web.Http.Headers.HttpMediaTypeWithQualityHeaderValue> | Windows.Web.Http.Headers.HttpMediaTypeWithQualityHeaderValue[];
+    IndexOf(value: Windows.Web.Http.Headers.HttpMediaTypeWithQualityHeaderValue, index: number): boolean;
+    InsertAt(index: number, value: Windows.Web.Http.Headers.HttpMediaTypeWithQualityHeaderValue): void;
+    ParseAdd(input: string): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.Web.Http.Headers.HttpMediaTypeWithQualityHeaderValue[]): void;
+    SetAt(index: number, value: Windows.Web.Http.Headers.HttpMediaTypeWithQualityHeaderValue): void;
+    ToString(): string;
+    TryParseAdd(input: string): boolean;
+    readonly Size: number;
+  }
+
+  class HttpMethodHeaderValueCollection implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpMethodHeaderValueCollection {
+    Append(value: Windows.Web.Http.HttpMethod): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Web.Http.HttpMethod>;
+    GetAt(index: number): Windows.Web.Http.HttpMethod;
+    GetMany(startIndex: number, items: Windows.Web.Http.HttpMethod[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.Web.Http.HttpMethod> | Windows.Web.Http.HttpMethod[];
+    IndexOf(value: Windows.Web.Http.HttpMethod, index: number): boolean;
+    InsertAt(index: number, value: Windows.Web.Http.HttpMethod): void;
+    ParseAdd(input: string): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.Web.Http.HttpMethod[]): void;
+    SetAt(index: number, value: Windows.Web.Http.HttpMethod): void;
+    ToString(): string;
+    TryParseAdd(input: string): boolean;
+    readonly Size: number;
+  }
+
+  class HttpNameValueHeaderValue implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpNameValueHeaderValue {
+    constructor(name: string);
+    constructor(name: string, value: string);
+    static Parse(input: string): Windows.Web.Http.Headers.HttpNameValueHeaderValue;
+    ToString(): string;
+    static TryParse(input: string, nameValueHeaderValue: Windows.Web.Http.Headers.HttpNameValueHeaderValue): boolean;
+    readonly Name: string;
+    Value: string;
+  }
+
+  class HttpProductHeaderValue implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpProductHeaderValue {
+    constructor(productName: string);
+    constructor(productName: string, productVersion: string);
+    static Parse(input: string): Windows.Web.Http.Headers.HttpProductHeaderValue;
+    ToString(): string;
+    static TryParse(input: string, productHeaderValue: Windows.Web.Http.Headers.HttpProductHeaderValue): boolean;
+    readonly Name: string;
+    readonly Version: string;
+  }
+
+  class HttpProductInfoHeaderValue implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpProductInfoHeaderValue {
+    constructor(productComment: string);
+    constructor(productName: string, productVersion: string);
+    static Parse(input: string): Windows.Web.Http.Headers.HttpProductInfoHeaderValue;
+    ToString(): string;
+    static TryParse(input: string, productInfoHeaderValue: Windows.Web.Http.Headers.HttpProductInfoHeaderValue): boolean;
+    readonly Comment: string;
+    readonly Product: Windows.Web.Http.Headers.HttpProductHeaderValue;
+  }
+
+  class HttpProductInfoHeaderValueCollection implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpProductInfoHeaderValueCollection {
+    Append(value: Windows.Web.Http.Headers.HttpProductInfoHeaderValue): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Web.Http.Headers.HttpProductInfoHeaderValue>;
+    GetAt(index: number): Windows.Web.Http.Headers.HttpProductInfoHeaderValue;
+    GetMany(startIndex: number, items: Windows.Web.Http.Headers.HttpProductInfoHeaderValue[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.Web.Http.Headers.HttpProductInfoHeaderValue> | Windows.Web.Http.Headers.HttpProductInfoHeaderValue[];
+    IndexOf(value: Windows.Web.Http.Headers.HttpProductInfoHeaderValue, index: number): boolean;
+    InsertAt(index: number, value: Windows.Web.Http.Headers.HttpProductInfoHeaderValue): void;
+    ParseAdd(input: string): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.Web.Http.Headers.HttpProductInfoHeaderValue[]): void;
+    SetAt(index: number, value: Windows.Web.Http.Headers.HttpProductInfoHeaderValue): void;
+    ToString(): string;
+    TryParseAdd(input: string): boolean;
+    readonly Size: number;
+  }
+
+  class HttpRequestHeaderCollection implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpRequestHeaderCollection {
+    Append(name: string, value: string): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, string>>;
+    GetView(): Windows.Foundation.Collections.IMapView<string, string>;
+    HasKey(key: string): boolean;
+    Insert(key: string, value: string): boolean;
+    Lookup(key: string): string;
+    Remove(key: string): void;
+    ToString(): string;
+    TryAppendWithoutValidation(name: string, value: string): boolean;
+    readonly Accept: Windows.Web.Http.Headers.HttpMediaTypeWithQualityHeaderValueCollection;
+    readonly AcceptEncoding: Windows.Web.Http.Headers.HttpContentCodingWithQualityHeaderValueCollection;
+    readonly AcceptLanguage: Windows.Web.Http.Headers.HttpLanguageRangeWithQualityHeaderValueCollection;
+    Authorization: Windows.Web.Http.Headers.HttpCredentialsHeaderValue;
+    readonly CacheControl: Windows.Web.Http.Headers.HttpCacheDirectiveHeaderValueCollection;
+    readonly Connection: Windows.Web.Http.Headers.HttpConnectionOptionHeaderValueCollection;
+    readonly Cookie: Windows.Web.Http.Headers.HttpCookiePairHeaderValueCollection;
+    Date: Windows.Foundation.DateTime | null;
+    readonly Expect: Windows.Web.Http.Headers.HttpExpectationHeaderValueCollection;
+    From: string;
+    Host: Windows.Networking.HostName;
+    IfModifiedSince: Windows.Foundation.DateTime | null;
+    IfUnmodifiedSince: Windows.Foundation.DateTime | null;
+    MaxForwards: number | null;
+    ProxyAuthorization: Windows.Web.Http.Headers.HttpCredentialsHeaderValue;
+    Referer: Windows.Foundation.Uri;
+    readonly Size: number;
+    readonly TransferEncoding: Windows.Web.Http.Headers.HttpTransferCodingHeaderValueCollection;
+    readonly UserAgent: Windows.Web.Http.Headers.HttpProductInfoHeaderValueCollection;
+  }
+
+  class HttpResponseHeaderCollection implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpResponseHeaderCollection {
+    Append(name: string, value: string): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Foundation.Collections.IKeyValuePair<string, string>>;
+    GetView(): Windows.Foundation.Collections.IMapView<string, string>;
+    HasKey(key: string): boolean;
+    Insert(key: string, value: string): boolean;
+    Lookup(key: string): string;
+    Remove(key: string): void;
+    ToString(): string;
+    TryAppendWithoutValidation(name: string, value: string): boolean;
+    Age: Windows.Foundation.TimeSpan | null;
+    readonly Allow: Windows.Web.Http.Headers.HttpMethodHeaderValueCollection;
+    readonly CacheControl: Windows.Web.Http.Headers.HttpCacheDirectiveHeaderValueCollection;
+    readonly Connection: Windows.Web.Http.Headers.HttpConnectionOptionHeaderValueCollection;
+    Date: Windows.Foundation.DateTime | null;
+    Location: Windows.Foundation.Uri;
+    readonly ProxyAuthenticate: Windows.Web.Http.Headers.HttpChallengeHeaderValueCollection;
+    RetryAfter: Windows.Web.Http.Headers.HttpDateOrDeltaHeaderValue;
+    readonly Size: number;
+    readonly TransferEncoding: Windows.Web.Http.Headers.HttpTransferCodingHeaderValueCollection;
+    readonly WwwAuthenticate: Windows.Web.Http.Headers.HttpChallengeHeaderValueCollection;
+  }
+
+  class HttpTransferCodingHeaderValue implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpTransferCodingHeaderValue {
+    constructor(input: string);
+    static Parse(input: string): Windows.Web.Http.Headers.HttpTransferCodingHeaderValue;
+    ToString(): string;
+    static TryParse(input: string, transferCodingHeaderValue: Windows.Web.Http.Headers.HttpTransferCodingHeaderValue): boolean;
+    readonly Parameters: Windows.Foundation.Collections.IVector<Windows.Web.Http.Headers.HttpNameValueHeaderValue> | Windows.Web.Http.Headers.HttpNameValueHeaderValue[];
+    readonly Value: string;
+  }
+
+  class HttpTransferCodingHeaderValueCollection implements Windows.Foundation.IStringable, Windows.Web.Http.Headers.IHttpTransferCodingHeaderValueCollection {
+    Append(value: Windows.Web.Http.Headers.HttpTransferCodingHeaderValue): void;
+    Clear(): void;
+    First(): Windows.Foundation.Collections.IIterator<Windows.Web.Http.Headers.HttpTransferCodingHeaderValue>;
+    GetAt(index: number): Windows.Web.Http.Headers.HttpTransferCodingHeaderValue;
+    GetMany(startIndex: number, items: Windows.Web.Http.Headers.HttpTransferCodingHeaderValue[]): number;
+    GetView(): Windows.Foundation.Collections.IVectorView<Windows.Web.Http.Headers.HttpTransferCodingHeaderValue> | Windows.Web.Http.Headers.HttpTransferCodingHeaderValue[];
+    IndexOf(value: Windows.Web.Http.Headers.HttpTransferCodingHeaderValue, index: number): boolean;
+    InsertAt(index: number, value: Windows.Web.Http.Headers.HttpTransferCodingHeaderValue): void;
+    ParseAdd(input: string): void;
+    RemoveAt(index: number): void;
+    RemoveAtEnd(): void;
+    ReplaceAll(items: Windows.Web.Http.Headers.HttpTransferCodingHeaderValue[]): void;
+    SetAt(index: number, value: Windows.Web.Http.Headers.HttpTransferCodingHeaderValue): void;
+    ToString(): string;
+    TryParseAdd(input: string): boolean;
+    readonly Size: number;
+  }
+
+  interface IHttpCacheDirectiveHeaderValueCollection {
+    ParseAdd(input: string): void;
+    TryParseAdd(input: string): boolean;
+    MaxAge: Windows.Foundation.TimeSpan | null;
+    MaxStale: Windows.Foundation.TimeSpan | null;
+    MinFresh: Windows.Foundation.TimeSpan | null;
+    SharedMaxAge: Windows.Foundation.TimeSpan | null;
+  }
+  var IHttpCacheDirectiveHeaderValueCollection: abstract new (...args: any[]) => IHttpCacheDirectiveHeaderValueCollection;
+
+  interface IHttpChallengeHeaderValue {
+    readonly Parameters: Windows.Foundation.Collections.IVector<Windows.Web.Http.Headers.HttpNameValueHeaderValue> | Windows.Web.Http.Headers.HttpNameValueHeaderValue[];
+    readonly Scheme: string;
+    readonly Token: string;
+  }
+  var IHttpChallengeHeaderValue: abstract new (...args: any[]) => IHttpChallengeHeaderValue;
+
+  interface IHttpChallengeHeaderValueCollection {
+    ParseAdd(input: string): void;
+    TryParseAdd(input: string): boolean;
+  }
+  var IHttpChallengeHeaderValueCollection: abstract new (...args: any[]) => IHttpChallengeHeaderValueCollection;
+
+  interface IHttpChallengeHeaderValueFactory {
+    CreateFromScheme(scheme: string): Windows.Web.Http.Headers.HttpChallengeHeaderValue;
+    CreateFromSchemeWithToken(scheme: string, token: string): Windows.Web.Http.Headers.HttpChallengeHeaderValue;
+  }
+  var IHttpChallengeHeaderValueFactory: abstract new (...args: any[]) => IHttpChallengeHeaderValueFactory;
+
+  interface IHttpChallengeHeaderValueStatics {
+    Parse(input: string): Windows.Web.Http.Headers.HttpChallengeHeaderValue;
+    TryParse(input: string, challengeHeaderValue: Windows.Web.Http.Headers.HttpChallengeHeaderValue): boolean;
+  }
+  var IHttpChallengeHeaderValueStatics: abstract new (...args: any[]) => IHttpChallengeHeaderValueStatics;
+
+  interface IHttpConnectionOptionHeaderValue {
+    readonly Token: string;
+  }
+  var IHttpConnectionOptionHeaderValue: abstract new (...args: any[]) => IHttpConnectionOptionHeaderValue;
+
+  interface IHttpConnectionOptionHeaderValueCollection {
+    ParseAdd(input: string): void;
+    TryParseAdd(input: string): boolean;
+  }
+  var IHttpConnectionOptionHeaderValueCollection: abstract new (...args: any[]) => IHttpConnectionOptionHeaderValueCollection;
+
+  interface IHttpConnectionOptionHeaderValueFactory {
+    Create(token: string): Windows.Web.Http.Headers.HttpConnectionOptionHeaderValue;
+  }
+  var IHttpConnectionOptionHeaderValueFactory: abstract new (...args: any[]) => IHttpConnectionOptionHeaderValueFactory;
+
+  interface IHttpConnectionOptionHeaderValueStatics {
+    Parse(input: string): Windows.Web.Http.Headers.HttpConnectionOptionHeaderValue;
+    TryParse(input: string, connectionOptionHeaderValue: Windows.Web.Http.Headers.HttpConnectionOptionHeaderValue): boolean;
+  }
+  var IHttpConnectionOptionHeaderValueStatics: abstract new (...args: any[]) => IHttpConnectionOptionHeaderValueStatics;
+
+  interface IHttpContentCodingHeaderValue {
+    readonly ContentCoding: string;
+  }
+  var IHttpContentCodingHeaderValue: abstract new (...args: any[]) => IHttpContentCodingHeaderValue;
+
+  interface IHttpContentCodingHeaderValueCollection {
+    ParseAdd(input: string): void;
+    TryParseAdd(input: string): boolean;
+  }
+  var IHttpContentCodingHeaderValueCollection: abstract new (...args: any[]) => IHttpContentCodingHeaderValueCollection;
+
+  interface IHttpContentCodingHeaderValueFactory {
+    Create(contentCoding: string): Windows.Web.Http.Headers.HttpContentCodingHeaderValue;
+  }
+  var IHttpContentCodingHeaderValueFactory: abstract new (...args: any[]) => IHttpContentCodingHeaderValueFactory;
+
+  interface IHttpContentCodingHeaderValueStatics {
+    Parse(input: string): Windows.Web.Http.Headers.HttpContentCodingHeaderValue;
+    TryParse(input: string, contentCodingHeaderValue: Windows.Web.Http.Headers.HttpContentCodingHeaderValue): boolean;
+  }
+  var IHttpContentCodingHeaderValueStatics: abstract new (...args: any[]) => IHttpContentCodingHeaderValueStatics;
+
+  interface IHttpContentCodingWithQualityHeaderValue {
+    readonly ContentCoding: string;
+    readonly Quality: number | null;
+  }
+  var IHttpContentCodingWithQualityHeaderValue: abstract new (...args: any[]) => IHttpContentCodingWithQualityHeaderValue;
+
+  interface IHttpContentCodingWithQualityHeaderValueCollection {
+    ParseAdd(input: string): void;
+    TryParseAdd(input: string): boolean;
+  }
+  var IHttpContentCodingWithQualityHeaderValueCollection: abstract new (...args: any[]) => IHttpContentCodingWithQualityHeaderValueCollection;
+
+  interface IHttpContentCodingWithQualityHeaderValueFactory {
+    CreateFromValue(contentCoding: string): Windows.Web.Http.Headers.HttpContentCodingWithQualityHeaderValue;
+    CreateFromValueWithQuality(contentCoding: string, quality: number): Windows.Web.Http.Headers.HttpContentCodingWithQualityHeaderValue;
+  }
+  var IHttpContentCodingWithQualityHeaderValueFactory: abstract new (...args: any[]) => IHttpContentCodingWithQualityHeaderValueFactory;
+
+  interface IHttpContentCodingWithQualityHeaderValueStatics {
+    Parse(input: string): Windows.Web.Http.Headers.HttpContentCodingWithQualityHeaderValue;
+    TryParse(input: string, contentCodingWithQualityHeaderValue: Windows.Web.Http.Headers.HttpContentCodingWithQualityHeaderValue): boolean;
+  }
+  var IHttpContentCodingWithQualityHeaderValueStatics: abstract new (...args: any[]) => IHttpContentCodingWithQualityHeaderValueStatics;
+
+  interface IHttpContentDispositionHeaderValue {
+    DispositionType: string;
+    FileName: string;
+    FileNameStar: string;
+    Name: string;
+    readonly Parameters: Windows.Foundation.Collections.IVector<Windows.Web.Http.Headers.HttpNameValueHeaderValue> | Windows.Web.Http.Headers.HttpNameValueHeaderValue[];
+    Size: number | bigint | null;
+  }
+  var IHttpContentDispositionHeaderValue: abstract new (...args: any[]) => IHttpContentDispositionHeaderValue;
+
+  interface IHttpContentDispositionHeaderValueFactory {
+    Create(dispositionType: string): Windows.Web.Http.Headers.HttpContentDispositionHeaderValue;
+  }
+  var IHttpContentDispositionHeaderValueFactory: abstract new (...args: any[]) => IHttpContentDispositionHeaderValueFactory;
+
+  interface IHttpContentDispositionHeaderValueStatics {
+    Parse(input: string): Windows.Web.Http.Headers.HttpContentDispositionHeaderValue;
+    TryParse(input: string, contentDispositionHeaderValue: Windows.Web.Http.Headers.HttpContentDispositionHeaderValue): boolean;
+  }
+  var IHttpContentDispositionHeaderValueStatics: abstract new (...args: any[]) => IHttpContentDispositionHeaderValueStatics;
+
+  interface IHttpContentHeaderCollection {
+    Append(name: string, value: string): void;
+    TryAppendWithoutValidation(name: string, value: string): boolean;
+    ContentDisposition: Windows.Web.Http.Headers.HttpContentDispositionHeaderValue;
+    readonly ContentEncoding: Windows.Web.Http.Headers.HttpContentCodingHeaderValueCollection;
+    readonly ContentLanguage: Windows.Web.Http.Headers.HttpLanguageHeaderValueCollection;
+    ContentLength: number | bigint | null;
+    ContentLocation: Windows.Foundation.Uri;
+    ContentMD5: Windows.Storage.Streams.IBuffer;
+    ContentRange: Windows.Web.Http.Headers.HttpContentRangeHeaderValue;
+    ContentType: Windows.Web.Http.Headers.HttpMediaTypeHeaderValue;
+    Expires: Windows.Foundation.DateTime | null;
+    LastModified: Windows.Foundation.DateTime | null;
+  }
+  var IHttpContentHeaderCollection: abstract new (...args: any[]) => IHttpContentHeaderCollection;
+
+  interface IHttpContentRangeHeaderValue {
+    readonly FirstBytePosition: number | bigint | null;
+    readonly LastBytePosition: number | bigint | null;
+    readonly Length: number | bigint | null;
+    Unit: string;
+  }
+  var IHttpContentRangeHeaderValue: abstract new (...args: any[]) => IHttpContentRangeHeaderValue;
+
+  interface IHttpContentRangeHeaderValueFactory {
+    CreateFromLength(length: number | bigint): Windows.Web.Http.Headers.HttpContentRangeHeaderValue;
+    CreateFromRange(from: number | bigint, to: number | bigint): Windows.Web.Http.Headers.HttpContentRangeHeaderValue;
+    CreateFromRangeWithLength(from: number | bigint, to: number | bigint, length: number | bigint): Windows.Web.Http.Headers.HttpContentRangeHeaderValue;
+  }
+  var IHttpContentRangeHeaderValueFactory: abstract new (...args: any[]) => IHttpContentRangeHeaderValueFactory;
+
+  interface IHttpContentRangeHeaderValueStatics {
+    Parse(input: string): Windows.Web.Http.Headers.HttpContentRangeHeaderValue;
+    TryParse(input: string, contentRangeHeaderValue: Windows.Web.Http.Headers.HttpContentRangeHeaderValue): boolean;
+  }
+  var IHttpContentRangeHeaderValueStatics: abstract new (...args: any[]) => IHttpContentRangeHeaderValueStatics;
+
+  interface IHttpCookiePairHeaderValue {
+    readonly Name: string;
+    Value: string;
+  }
+  var IHttpCookiePairHeaderValue: abstract new (...args: any[]) => IHttpCookiePairHeaderValue;
+
+  interface IHttpCookiePairHeaderValueCollection {
+    ParseAdd(input: string): void;
+    TryParseAdd(input: string): boolean;
+  }
+  var IHttpCookiePairHeaderValueCollection: abstract new (...args: any[]) => IHttpCookiePairHeaderValueCollection;
+
+  interface IHttpCookiePairHeaderValueFactory {
+    CreateFromName(name: string): Windows.Web.Http.Headers.HttpCookiePairHeaderValue;
+    CreateFromNameWithValue(name: string, value: string): Windows.Web.Http.Headers.HttpCookiePairHeaderValue;
+  }
+  var IHttpCookiePairHeaderValueFactory: abstract new (...args: any[]) => IHttpCookiePairHeaderValueFactory;
+
+  interface IHttpCookiePairHeaderValueStatics {
+    Parse(input: string): Windows.Web.Http.Headers.HttpCookiePairHeaderValue;
+    TryParse(input: string, cookiePairHeaderValue: Windows.Web.Http.Headers.HttpCookiePairHeaderValue): boolean;
+  }
+  var IHttpCookiePairHeaderValueStatics: abstract new (...args: any[]) => IHttpCookiePairHeaderValueStatics;
+
+  interface IHttpCredentialsHeaderValue {
+    readonly Parameters: Windows.Foundation.Collections.IVector<Windows.Web.Http.Headers.HttpNameValueHeaderValue> | Windows.Web.Http.Headers.HttpNameValueHeaderValue[];
+    readonly Scheme: string;
+    readonly Token: string;
+  }
+  var IHttpCredentialsHeaderValue: abstract new (...args: any[]) => IHttpCredentialsHeaderValue;
+
+  interface IHttpCredentialsHeaderValueFactory {
+    CreateFromScheme(scheme: string): Windows.Web.Http.Headers.HttpCredentialsHeaderValue;
+    CreateFromSchemeWithToken(scheme: string, token: string): Windows.Web.Http.Headers.HttpCredentialsHeaderValue;
+  }
+  var IHttpCredentialsHeaderValueFactory: abstract new (...args: any[]) => IHttpCredentialsHeaderValueFactory;
+
+  interface IHttpCredentialsHeaderValueStatics {
+    Parse(input: string): Windows.Web.Http.Headers.HttpCredentialsHeaderValue;
+    TryParse(input: string, credentialsHeaderValue: Windows.Web.Http.Headers.HttpCredentialsHeaderValue): boolean;
+  }
+  var IHttpCredentialsHeaderValueStatics: abstract new (...args: any[]) => IHttpCredentialsHeaderValueStatics;
+
+  interface IHttpDateOrDeltaHeaderValue {
+    readonly Date: Windows.Foundation.DateTime | null;
+    readonly Delta: Windows.Foundation.TimeSpan | null;
+  }
+  var IHttpDateOrDeltaHeaderValue: abstract new (...args: any[]) => IHttpDateOrDeltaHeaderValue;
+
+  interface IHttpDateOrDeltaHeaderValueStatics {
+    Parse(input: string): Windows.Web.Http.Headers.HttpDateOrDeltaHeaderValue;
+    TryParse(input: string, dateOrDeltaHeaderValue: Windows.Web.Http.Headers.HttpDateOrDeltaHeaderValue): boolean;
+  }
+  var IHttpDateOrDeltaHeaderValueStatics: abstract new (...args: any[]) => IHttpDateOrDeltaHeaderValueStatics;
+
+  interface IHttpExpectationHeaderValue {
+    readonly Name: string;
+    readonly Parameters: Windows.Foundation.Collections.IVector<Windows.Web.Http.Headers.HttpNameValueHeaderValue> | Windows.Web.Http.Headers.HttpNameValueHeaderValue[];
+    Value: string;
+  }
+  var IHttpExpectationHeaderValue: abstract new (...args: any[]) => IHttpExpectationHeaderValue;
+
+  interface IHttpExpectationHeaderValueCollection {
+    ParseAdd(input: string): void;
+    TryParseAdd(input: string): boolean;
+  }
+  var IHttpExpectationHeaderValueCollection: abstract new (...args: any[]) => IHttpExpectationHeaderValueCollection;
+
+  interface IHttpExpectationHeaderValueFactory {
+    CreateFromName(name: string): Windows.Web.Http.Headers.HttpExpectationHeaderValue;
+    CreateFromNameWithValue(name: string, value: string): Windows.Web.Http.Headers.HttpExpectationHeaderValue;
+  }
+  var IHttpExpectationHeaderValueFactory: abstract new (...args: any[]) => IHttpExpectationHeaderValueFactory;
+
+  interface IHttpExpectationHeaderValueStatics {
+    Parse(input: string): Windows.Web.Http.Headers.HttpExpectationHeaderValue;
+    TryParse(input: string, expectationHeaderValue: Windows.Web.Http.Headers.HttpExpectationHeaderValue): boolean;
+  }
+  var IHttpExpectationHeaderValueStatics: abstract new (...args: any[]) => IHttpExpectationHeaderValueStatics;
+
+  interface IHttpLanguageHeaderValueCollection {
+    ParseAdd(input: string): void;
+    TryParseAdd(input: string): boolean;
+  }
+  var IHttpLanguageHeaderValueCollection: abstract new (...args: any[]) => IHttpLanguageHeaderValueCollection;
+
+  interface IHttpLanguageRangeWithQualityHeaderValue {
+    readonly LanguageRange: string;
+    readonly Quality: number | null;
+  }
+  var IHttpLanguageRangeWithQualityHeaderValue: abstract new (...args: any[]) => IHttpLanguageRangeWithQualityHeaderValue;
+
+  interface IHttpLanguageRangeWithQualityHeaderValueCollection {
+    ParseAdd(input: string): void;
+    TryParseAdd(input: string): boolean;
+  }
+  var IHttpLanguageRangeWithQualityHeaderValueCollection: abstract new (...args: any[]) => IHttpLanguageRangeWithQualityHeaderValueCollection;
+
+  interface IHttpLanguageRangeWithQualityHeaderValueFactory {
+    CreateFromLanguageRange(languageRange: string): Windows.Web.Http.Headers.HttpLanguageRangeWithQualityHeaderValue;
+    CreateFromLanguageRangeWithQuality(languageRange: string, quality: number): Windows.Web.Http.Headers.HttpLanguageRangeWithQualityHeaderValue;
+  }
+  var IHttpLanguageRangeWithQualityHeaderValueFactory: abstract new (...args: any[]) => IHttpLanguageRangeWithQualityHeaderValueFactory;
+
+  interface IHttpLanguageRangeWithQualityHeaderValueStatics {
+    Parse(input: string): Windows.Web.Http.Headers.HttpLanguageRangeWithQualityHeaderValue;
+    TryParse(input: string, languageRangeWithQualityHeaderValue: Windows.Web.Http.Headers.HttpLanguageRangeWithQualityHeaderValue): boolean;
+  }
+  var IHttpLanguageRangeWithQualityHeaderValueStatics: abstract new (...args: any[]) => IHttpLanguageRangeWithQualityHeaderValueStatics;
+
+  interface IHttpMediaTypeHeaderValue {
+    CharSet: string;
+    MediaType: string;
+    readonly Parameters: Windows.Foundation.Collections.IVector<Windows.Web.Http.Headers.HttpNameValueHeaderValue> | Windows.Web.Http.Headers.HttpNameValueHeaderValue[];
+  }
+  var IHttpMediaTypeHeaderValue: abstract new (...args: any[]) => IHttpMediaTypeHeaderValue;
+
+  interface IHttpMediaTypeHeaderValueFactory {
+    Create(mediaType: string): Windows.Web.Http.Headers.HttpMediaTypeHeaderValue;
+  }
+  var IHttpMediaTypeHeaderValueFactory: abstract new (...args: any[]) => IHttpMediaTypeHeaderValueFactory;
+
+  interface IHttpMediaTypeHeaderValueStatics {
+    Parse(input: string): Windows.Web.Http.Headers.HttpMediaTypeHeaderValue;
+    TryParse(input: string, mediaTypeHeaderValue: Windows.Web.Http.Headers.HttpMediaTypeHeaderValue): boolean;
+  }
+  var IHttpMediaTypeHeaderValueStatics: abstract new (...args: any[]) => IHttpMediaTypeHeaderValueStatics;
+
+  interface IHttpMediaTypeWithQualityHeaderValue {
+    CharSet: string;
+    MediaType: string;
+    readonly Parameters: Windows.Foundation.Collections.IVector<Windows.Web.Http.Headers.HttpNameValueHeaderValue> | Windows.Web.Http.Headers.HttpNameValueHeaderValue[];
+    Quality: number | null;
+  }
+  var IHttpMediaTypeWithQualityHeaderValue: abstract new (...args: any[]) => IHttpMediaTypeWithQualityHeaderValue;
+
+  interface IHttpMediaTypeWithQualityHeaderValueCollection {
+    ParseAdd(input: string): void;
+    TryParseAdd(input: string): boolean;
+  }
+  var IHttpMediaTypeWithQualityHeaderValueCollection: abstract new (...args: any[]) => IHttpMediaTypeWithQualityHeaderValueCollection;
+
+  interface IHttpMediaTypeWithQualityHeaderValueFactory {
+    CreateFromMediaType(mediaType: string): Windows.Web.Http.Headers.HttpMediaTypeWithQualityHeaderValue;
+    CreateFromMediaTypeWithQuality(mediaType: string, quality: number): Windows.Web.Http.Headers.HttpMediaTypeWithQualityHeaderValue;
+  }
+  var IHttpMediaTypeWithQualityHeaderValueFactory: abstract new (...args: any[]) => IHttpMediaTypeWithQualityHeaderValueFactory;
+
+  interface IHttpMediaTypeWithQualityHeaderValueStatics {
+    Parse(input: string): Windows.Web.Http.Headers.HttpMediaTypeWithQualityHeaderValue;
+    TryParse(input: string, mediaTypeWithQualityHeaderValue: Windows.Web.Http.Headers.HttpMediaTypeWithQualityHeaderValue): boolean;
+  }
+  var IHttpMediaTypeWithQualityHeaderValueStatics: abstract new (...args: any[]) => IHttpMediaTypeWithQualityHeaderValueStatics;
+
+  interface IHttpMethodHeaderValueCollection {
+    ParseAdd(input: string): void;
+    TryParseAdd(input: string): boolean;
+  }
+  var IHttpMethodHeaderValueCollection: abstract new (...args: any[]) => IHttpMethodHeaderValueCollection;
+
+  interface IHttpNameValueHeaderValue {
+    readonly Name: string;
+    Value: string;
+  }
+  var IHttpNameValueHeaderValue: abstract new (...args: any[]) => IHttpNameValueHeaderValue;
+
+  interface IHttpNameValueHeaderValueFactory {
+    CreateFromName(name: string): Windows.Web.Http.Headers.HttpNameValueHeaderValue;
+    CreateFromNameWithValue(name: string, value: string): Windows.Web.Http.Headers.HttpNameValueHeaderValue;
+  }
+  var IHttpNameValueHeaderValueFactory: abstract new (...args: any[]) => IHttpNameValueHeaderValueFactory;
+
+  interface IHttpNameValueHeaderValueStatics {
+    Parse(input: string): Windows.Web.Http.Headers.HttpNameValueHeaderValue;
+    TryParse(input: string, nameValueHeaderValue: Windows.Web.Http.Headers.HttpNameValueHeaderValue): boolean;
+  }
+  var IHttpNameValueHeaderValueStatics: abstract new (...args: any[]) => IHttpNameValueHeaderValueStatics;
+
+  interface IHttpProductHeaderValue {
+    readonly Name: string;
+    readonly Version: string;
+  }
+  var IHttpProductHeaderValue: abstract new (...args: any[]) => IHttpProductHeaderValue;
+
+  interface IHttpProductHeaderValueFactory {
+    CreateFromName(productName: string): Windows.Web.Http.Headers.HttpProductHeaderValue;
+    CreateFromNameWithVersion(productName: string, productVersion: string): Windows.Web.Http.Headers.HttpProductHeaderValue;
+  }
+  var IHttpProductHeaderValueFactory: abstract new (...args: any[]) => IHttpProductHeaderValueFactory;
+
+  interface IHttpProductHeaderValueStatics {
+    Parse(input: string): Windows.Web.Http.Headers.HttpProductHeaderValue;
+    TryParse(input: string, productHeaderValue: Windows.Web.Http.Headers.HttpProductHeaderValue): boolean;
+  }
+  var IHttpProductHeaderValueStatics: abstract new (...args: any[]) => IHttpProductHeaderValueStatics;
+
+  interface IHttpProductInfoHeaderValue {
+    readonly Comment: string;
+    readonly Product: Windows.Web.Http.Headers.HttpProductHeaderValue;
+  }
+  var IHttpProductInfoHeaderValue: abstract new (...args: any[]) => IHttpProductInfoHeaderValue;
+
+  interface IHttpProductInfoHeaderValueCollection {
+    ParseAdd(input: string): void;
+    TryParseAdd(input: string): boolean;
+  }
+  var IHttpProductInfoHeaderValueCollection: abstract new (...args: any[]) => IHttpProductInfoHeaderValueCollection;
+
+  interface IHttpProductInfoHeaderValueFactory {
+    CreateFromComment(productComment: string): Windows.Web.Http.Headers.HttpProductInfoHeaderValue;
+    CreateFromNameWithVersion(productName: string, productVersion: string): Windows.Web.Http.Headers.HttpProductInfoHeaderValue;
+  }
+  var IHttpProductInfoHeaderValueFactory: abstract new (...args: any[]) => IHttpProductInfoHeaderValueFactory;
+
+  interface IHttpProductInfoHeaderValueStatics {
+    Parse(input: string): Windows.Web.Http.Headers.HttpProductInfoHeaderValue;
+    TryParse(input: string, productInfoHeaderValue: Windows.Web.Http.Headers.HttpProductInfoHeaderValue): boolean;
+  }
+  var IHttpProductInfoHeaderValueStatics: abstract new (...args: any[]) => IHttpProductInfoHeaderValueStatics;
+
+  interface IHttpRequestHeaderCollection {
+    Append(name: string, value: string): void;
+    TryAppendWithoutValidation(name: string, value: string): boolean;
+    readonly Accept: Windows.Web.Http.Headers.HttpMediaTypeWithQualityHeaderValueCollection;
+    readonly AcceptEncoding: Windows.Web.Http.Headers.HttpContentCodingWithQualityHeaderValueCollection;
+    readonly AcceptLanguage: Windows.Web.Http.Headers.HttpLanguageRangeWithQualityHeaderValueCollection;
+    Authorization: Windows.Web.Http.Headers.HttpCredentialsHeaderValue;
+    readonly CacheControl: Windows.Web.Http.Headers.HttpCacheDirectiveHeaderValueCollection;
+    readonly Connection: Windows.Web.Http.Headers.HttpConnectionOptionHeaderValueCollection;
+    readonly Cookie: Windows.Web.Http.Headers.HttpCookiePairHeaderValueCollection;
+    Date: Windows.Foundation.DateTime | null;
+    readonly Expect: Windows.Web.Http.Headers.HttpExpectationHeaderValueCollection;
+    From: string;
+    Host: Windows.Networking.HostName;
+    IfModifiedSince: Windows.Foundation.DateTime | null;
+    IfUnmodifiedSince: Windows.Foundation.DateTime | null;
+    MaxForwards: number | null;
+    ProxyAuthorization: Windows.Web.Http.Headers.HttpCredentialsHeaderValue;
+    Referer: Windows.Foundation.Uri;
+    readonly TransferEncoding: Windows.Web.Http.Headers.HttpTransferCodingHeaderValueCollection;
+    readonly UserAgent: Windows.Web.Http.Headers.HttpProductInfoHeaderValueCollection;
+  }
+  var IHttpRequestHeaderCollection: abstract new (...args: any[]) => IHttpRequestHeaderCollection;
+
+  interface IHttpResponseHeaderCollection {
+    Append(name: string, value: string): void;
+    TryAppendWithoutValidation(name: string, value: string): boolean;
+    Age: Windows.Foundation.TimeSpan | null;
+    readonly Allow: Windows.Web.Http.Headers.HttpMethodHeaderValueCollection;
+    readonly CacheControl: Windows.Web.Http.Headers.HttpCacheDirectiveHeaderValueCollection;
+    readonly Connection: Windows.Web.Http.Headers.HttpConnectionOptionHeaderValueCollection;
+    Date: Windows.Foundation.DateTime | null;
+    Location: Windows.Foundation.Uri;
+    readonly ProxyAuthenticate: Windows.Web.Http.Headers.HttpChallengeHeaderValueCollection;
+    RetryAfter: Windows.Web.Http.Headers.HttpDateOrDeltaHeaderValue;
+    readonly TransferEncoding: Windows.Web.Http.Headers.HttpTransferCodingHeaderValueCollection;
+    readonly WwwAuthenticate: Windows.Web.Http.Headers.HttpChallengeHeaderValueCollection;
+  }
+  var IHttpResponseHeaderCollection: abstract new (...args: any[]) => IHttpResponseHeaderCollection;
+
+  interface IHttpTransferCodingHeaderValue {
+    readonly Parameters: Windows.Foundation.Collections.IVector<Windows.Web.Http.Headers.HttpNameValueHeaderValue> | Windows.Web.Http.Headers.HttpNameValueHeaderValue[];
+    readonly Value: string;
+  }
+  var IHttpTransferCodingHeaderValue: abstract new (...args: any[]) => IHttpTransferCodingHeaderValue;
+
+  interface IHttpTransferCodingHeaderValueCollection {
+    ParseAdd(input: string): void;
+    TryParseAdd(input: string): boolean;
+  }
+  var IHttpTransferCodingHeaderValueCollection: abstract new (...args: any[]) => IHttpTransferCodingHeaderValueCollection;
+
+  interface IHttpTransferCodingHeaderValueFactory {
+    Create(input: string): Windows.Web.Http.Headers.HttpTransferCodingHeaderValue;
+  }
+  var IHttpTransferCodingHeaderValueFactory: abstract new (...args: any[]) => IHttpTransferCodingHeaderValueFactory;
+
+  interface IHttpTransferCodingHeaderValueStatics {
+    Parse(input: string): Windows.Web.Http.Headers.HttpTransferCodingHeaderValue;
+    TryParse(input: string, transferCodingHeaderValue: Windows.Web.Http.Headers.HttpTransferCodingHeaderValue): boolean;
+  }
+  var IHttpTransferCodingHeaderValueStatics: abstract new (...args: any[]) => IHttpTransferCodingHeaderValueStatics;
+
+}
+
+declare namespace Windows.Web.Syndication {
+  class SyndicationAttribute implements Windows.Web.Syndication.ISyndicationAttribute {
+    constructor(attributeName: string, attributeNamespace: string, attributeValue: string);
+    constructor();
+    Name: string;
+    Namespace: string;
+    Value: string;
+  }
+
+  class SyndicationCategory implements Windows.Web.Syndication.ISyndicationCategory, Windows.Web.Syndication.ISyndicationNode {
+    constructor(term: string);
+    constructor(term: string, scheme: string, label: string);
+    constructor();
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    readonly AttributeExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationAttribute> | Windows.Web.Syndication.SyndicationAttribute[];
+    BaseUri: Windows.Foundation.Uri;
+    readonly ElementExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.ISyndicationNode> | Windows.Web.Syndication.ISyndicationNode[];
+    Label: string;
+    Language: string;
+    NodeName: string;
+    NodeNamespace: string;
+    NodeValue: string;
+    Scheme: string;
+    Term: string;
+  }
+
+  class SyndicationClient implements Windows.Web.Syndication.ISyndicationClient {
+    constructor(serverCredential: Windows.Security.Credentials.PasswordCredential);
+    constructor();
+    RetrieveFeedAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Syndication.SyndicationFeed, Windows.Web.Syndication.RetrievalProgress>;
+    SetRequestHeader(name: string, value: string): void;
+    BypassCacheOnRetrieve: boolean;
+    MaxResponseBufferSize: number;
+    ProxyCredential: Windows.Security.Credentials.PasswordCredential;
+    ServerCredential: Windows.Security.Credentials.PasswordCredential;
+    Timeout: number;
+  }
+
+  class SyndicationContent implements Windows.Web.Syndication.ISyndicationContent, Windows.Web.Syndication.ISyndicationNode, Windows.Web.Syndication.ISyndicationText {
+    constructor(text: string, type: number);
+    constructor(sourceUri: Windows.Foundation.Uri);
+    constructor();
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    readonly AttributeExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationAttribute> | Windows.Web.Syndication.SyndicationAttribute[];
+    BaseUri: Windows.Foundation.Uri;
+    readonly ElementExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.ISyndicationNode> | Windows.Web.Syndication.ISyndicationNode[];
+    Language: string;
+    NodeName: string;
+    NodeNamespace: string;
+    NodeValue: string;
+    SourceUri: Windows.Foundation.Uri;
+    Text: string;
+    Type: string;
+    Xml: Windows.Data.Xml.Dom.XmlDocument;
+  }
+
+  class SyndicationError {
+    static GetStatus(hresult: number): number;
+  }
+
+  class SyndicationFeed implements Windows.Web.Syndication.ISyndicationFeed, Windows.Web.Syndication.ISyndicationNode {
+    constructor(title: string, subtitle: string, uri: Windows.Foundation.Uri);
+    constructor();
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    Load(feed: string): void;
+    LoadFromXml(feedDocument: Windows.Data.Xml.Dom.XmlDocument): void;
+    readonly AttributeExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationAttribute> | Windows.Web.Syndication.SyndicationAttribute[];
+    readonly Authors: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationPerson> | Windows.Web.Syndication.SyndicationPerson[];
+    BaseUri: Windows.Foundation.Uri;
+    readonly Categories: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationCategory> | Windows.Web.Syndication.SyndicationCategory[];
+    readonly Contributors: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationPerson> | Windows.Web.Syndication.SyndicationPerson[];
+    readonly ElementExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.ISyndicationNode> | Windows.Web.Syndication.ISyndicationNode[];
+    readonly FirstUri: Windows.Foundation.Uri;
+    Generator: Windows.Web.Syndication.SyndicationGenerator;
+    IconUri: Windows.Foundation.Uri;
+    Id: string;
+    ImageUri: Windows.Foundation.Uri;
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationItem> | Windows.Web.Syndication.SyndicationItem[];
+    Language: string;
+    LastUpdatedTime: Windows.Foundation.DateTime;
+    readonly LastUri: Windows.Foundation.Uri;
+    readonly Links: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationLink> | Windows.Web.Syndication.SyndicationLink[];
+    readonly NextUri: Windows.Foundation.Uri;
+    NodeName: string;
+    NodeNamespace: string;
+    NodeValue: string;
+    readonly PreviousUri: Windows.Foundation.Uri;
+    Rights: Windows.Web.Syndication.ISyndicationText;
+    readonly SourceFormat: number;
+    Subtitle: Windows.Web.Syndication.ISyndicationText;
+    Title: Windows.Web.Syndication.ISyndicationText;
+  }
+
+  class SyndicationGenerator implements Windows.Web.Syndication.ISyndicationGenerator, Windows.Web.Syndication.ISyndicationNode {
+    constructor(text: string);
+    constructor();
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    readonly AttributeExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationAttribute> | Windows.Web.Syndication.SyndicationAttribute[];
+    BaseUri: Windows.Foundation.Uri;
+    readonly ElementExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.ISyndicationNode> | Windows.Web.Syndication.ISyndicationNode[];
+    Language: string;
+    NodeName: string;
+    NodeNamespace: string;
+    NodeValue: string;
+    Text: string;
+    Uri: Windows.Foundation.Uri;
+    Version: string;
+  }
+
+  class SyndicationItem implements Windows.Web.Syndication.ISyndicationItem, Windows.Web.Syndication.ISyndicationNode {
+    constructor(title: string, content: Windows.Web.Syndication.SyndicationContent, uri: Windows.Foundation.Uri);
+    constructor();
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    Load(item: string): void;
+    LoadFromXml(itemDocument: Windows.Data.Xml.Dom.XmlDocument): void;
+    readonly AttributeExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationAttribute> | Windows.Web.Syndication.SyndicationAttribute[];
+    readonly Authors: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationPerson> | Windows.Web.Syndication.SyndicationPerson[];
+    BaseUri: Windows.Foundation.Uri;
+    readonly Categories: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationCategory> | Windows.Web.Syndication.SyndicationCategory[];
+    CommentsUri: Windows.Foundation.Uri;
+    Content: Windows.Web.Syndication.SyndicationContent;
+    readonly Contributors: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationPerson> | Windows.Web.Syndication.SyndicationPerson[];
+    readonly ETag: string;
+    readonly EditMediaUri: Windows.Foundation.Uri;
+    readonly EditUri: Windows.Foundation.Uri;
+    readonly ElementExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.ISyndicationNode> | Windows.Web.Syndication.ISyndicationNode[];
+    Id: string;
+    readonly ItemUri: Windows.Foundation.Uri;
+    Language: string;
+    LastUpdatedTime: Windows.Foundation.DateTime;
+    readonly Links: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationLink> | Windows.Web.Syndication.SyndicationLink[];
+    NodeName: string;
+    NodeNamespace: string;
+    NodeValue: string;
+    PublishedDate: Windows.Foundation.DateTime;
+    Rights: Windows.Web.Syndication.ISyndicationText;
+    Source: Windows.Web.Syndication.SyndicationFeed;
+    Summary: Windows.Web.Syndication.ISyndicationText;
+    Title: Windows.Web.Syndication.ISyndicationText;
+  }
+
+  class SyndicationLink implements Windows.Web.Syndication.ISyndicationLink, Windows.Web.Syndication.ISyndicationNode {
+    constructor(uri: Windows.Foundation.Uri);
+    constructor(uri: Windows.Foundation.Uri, relationship: string, title: string, mediaType: string, length: number);
+    constructor();
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    readonly AttributeExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationAttribute> | Windows.Web.Syndication.SyndicationAttribute[];
+    BaseUri: Windows.Foundation.Uri;
+    readonly ElementExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.ISyndicationNode> | Windows.Web.Syndication.ISyndicationNode[];
+    Language: string;
+    Length: number;
+    MediaType: string;
+    NodeName: string;
+    NodeNamespace: string;
+    NodeValue: string;
+    Relationship: string;
+    ResourceLanguage: string;
+    Title: string;
+    Uri: Windows.Foundation.Uri;
+  }
+
+  class SyndicationNode implements Windows.Web.Syndication.ISyndicationNode {
+    constructor(nodeName: string, nodeNamespace: string, nodeValue: string);
+    constructor();
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    readonly AttributeExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationAttribute> | Windows.Web.Syndication.SyndicationAttribute[];
+    BaseUri: Windows.Foundation.Uri;
+    readonly ElementExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.ISyndicationNode> | Windows.Web.Syndication.ISyndicationNode[];
+    Language: string;
+    NodeName: string;
+    NodeNamespace: string;
+    NodeValue: string;
+  }
+
+  class SyndicationPerson implements Windows.Web.Syndication.ISyndicationNode, Windows.Web.Syndication.ISyndicationPerson {
+    constructor(name: string);
+    constructor(name: string, email: string, uri: Windows.Foundation.Uri);
+    constructor();
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    readonly AttributeExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationAttribute> | Windows.Web.Syndication.SyndicationAttribute[];
+    BaseUri: Windows.Foundation.Uri;
+    readonly ElementExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.ISyndicationNode> | Windows.Web.Syndication.ISyndicationNode[];
+    Email: string;
+    Language: string;
+    Name: string;
+    NodeName: string;
+    NodeNamespace: string;
+    NodeValue: string;
+    Uri: Windows.Foundation.Uri;
+  }
+
+  class SyndicationText implements Windows.Web.Syndication.ISyndicationNode, Windows.Web.Syndication.ISyndicationText {
+    constructor(text: string);
+    constructor(text: string, type: number);
+    constructor();
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    readonly AttributeExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationAttribute> | Windows.Web.Syndication.SyndicationAttribute[];
+    BaseUri: Windows.Foundation.Uri;
+    readonly ElementExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.ISyndicationNode> | Windows.Web.Syndication.ISyndicationNode[];
+    Language: string;
+    NodeName: string;
+    NodeNamespace: string;
+    NodeValue: string;
+    Text: string;
+    Type: string;
+    Xml: Windows.Data.Xml.Dom.XmlDocument;
+  }
+
+  enum SyndicationErrorStatus {
+    Unknown = 0,
+    MissingRequiredElement = 1,
+    MissingRequiredAttribute = 2,
+    InvalidXml = 3,
+    UnexpectedContent = 4,
+    UnsupportedFormat = 5,
+  }
+
+  enum SyndicationFormat {
+    Atom10 = 0,
+    Rss20 = 1,
+    Rss10 = 2,
+    Rss092 = 3,
+    Rss091 = 4,
+    Atom03 = 5,
+  }
+
+  enum SyndicationTextType {
+    Text = 0,
+    Html = 1,
+    Xhtml = 2,
+  }
+
+  interface ISyndicationAttribute {
+    Name: string;
+    Namespace: string;
+    Value: string;
+  }
+  var ISyndicationAttribute: abstract new (...args: any[]) => ISyndicationAttribute;
+
+  interface ISyndicationAttributeFactory {
+    CreateSyndicationAttribute(attributeName: string, attributeNamespace: string, attributeValue: string): Windows.Web.Syndication.SyndicationAttribute;
+  }
+  var ISyndicationAttributeFactory: abstract new (...args: any[]) => ISyndicationAttributeFactory;
+
+  interface ISyndicationCategory extends Windows.Web.Syndication.ISyndicationNode {
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    Label: string;
+    Scheme: string;
+    Term: string;
+  }
+  var ISyndicationCategory: abstract new (...args: any[]) => ISyndicationCategory;
+
+  interface ISyndicationCategoryFactory {
+    CreateSyndicationCategory(term: string): Windows.Web.Syndication.SyndicationCategory;
+    CreateSyndicationCategoryEx(term: string, scheme: string, label: string): Windows.Web.Syndication.SyndicationCategory;
+  }
+  var ISyndicationCategoryFactory: abstract new (...args: any[]) => ISyndicationCategoryFactory;
+
+  interface ISyndicationClient {
+    RetrieveFeedAsync(uri: Windows.Foundation.Uri): Windows.Foundation.IAsyncOperationWithProgress<Windows.Web.Syndication.SyndicationFeed, Windows.Web.Syndication.RetrievalProgress>;
+    SetRequestHeader(name: string, value: string): void;
+    BypassCacheOnRetrieve: boolean;
+    MaxResponseBufferSize: number;
+    ProxyCredential: Windows.Security.Credentials.PasswordCredential;
+    ServerCredential: Windows.Security.Credentials.PasswordCredential;
+    Timeout: number;
+  }
+  var ISyndicationClient: abstract new (...args: any[]) => ISyndicationClient;
+
+  interface ISyndicationClientFactory {
+    CreateSyndicationClient(serverCredential: Windows.Security.Credentials.PasswordCredential): Windows.Web.Syndication.SyndicationClient;
+  }
+  var ISyndicationClientFactory: abstract new (...args: any[]) => ISyndicationClientFactory;
+
+  interface ISyndicationContent extends Windows.Web.Syndication.ISyndicationNode, Windows.Web.Syndication.ISyndicationText {
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    SourceUri: Windows.Foundation.Uri;
+  }
+  var ISyndicationContent: abstract new (...args: any[]) => ISyndicationContent;
+
+  interface ISyndicationContentFactory {
+    CreateSyndicationContent(text: string, type: number): Windows.Web.Syndication.SyndicationContent;
+    CreateSyndicationContentWithSourceUri(sourceUri: Windows.Foundation.Uri): Windows.Web.Syndication.SyndicationContent;
+  }
+  var ISyndicationContentFactory: abstract new (...args: any[]) => ISyndicationContentFactory;
+
+  interface ISyndicationErrorStatics {
+    GetStatus(hresult: number): number;
+  }
+  var ISyndicationErrorStatics: abstract new (...args: any[]) => ISyndicationErrorStatics;
+
+  interface ISyndicationFeed extends Windows.Web.Syndication.ISyndicationNode {
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    Load(feed: string): void;
+    LoadFromXml(feedDocument: Windows.Data.Xml.Dom.XmlDocument): void;
+    readonly Authors: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationPerson> | Windows.Web.Syndication.SyndicationPerson[];
+    readonly Categories: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationCategory> | Windows.Web.Syndication.SyndicationCategory[];
+    readonly Contributors: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationPerson> | Windows.Web.Syndication.SyndicationPerson[];
+    readonly FirstUri: Windows.Foundation.Uri;
+    Generator: Windows.Web.Syndication.SyndicationGenerator;
+    IconUri: Windows.Foundation.Uri;
+    Id: string;
+    ImageUri: Windows.Foundation.Uri;
+    readonly Items: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationItem> | Windows.Web.Syndication.SyndicationItem[];
+    LastUpdatedTime: Windows.Foundation.DateTime;
+    readonly LastUri: Windows.Foundation.Uri;
+    readonly Links: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationLink> | Windows.Web.Syndication.SyndicationLink[];
+    readonly NextUri: Windows.Foundation.Uri;
+    readonly PreviousUri: Windows.Foundation.Uri;
+    Rights: Windows.Web.Syndication.ISyndicationText;
+    readonly SourceFormat: number;
+    Subtitle: Windows.Web.Syndication.ISyndicationText;
+    Title: Windows.Web.Syndication.ISyndicationText;
+  }
+  var ISyndicationFeed: abstract new (...args: any[]) => ISyndicationFeed;
+
+  interface ISyndicationFeedFactory {
+    CreateSyndicationFeed(title: string, subtitle: string, uri: Windows.Foundation.Uri): Windows.Web.Syndication.SyndicationFeed;
+  }
+  var ISyndicationFeedFactory: abstract new (...args: any[]) => ISyndicationFeedFactory;
+
+  interface ISyndicationGenerator {
+    Text: string;
+    Uri: Windows.Foundation.Uri;
+    Version: string;
+  }
+  var ISyndicationGenerator: abstract new (...args: any[]) => ISyndicationGenerator;
+
+  interface ISyndicationGeneratorFactory {
+    CreateSyndicationGenerator(text: string): Windows.Web.Syndication.SyndicationGenerator;
+  }
+  var ISyndicationGeneratorFactory: abstract new (...args: any[]) => ISyndicationGeneratorFactory;
+
+  interface ISyndicationItem extends Windows.Web.Syndication.ISyndicationNode {
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    Load(item: string): void;
+    LoadFromXml(itemDocument: Windows.Data.Xml.Dom.XmlDocument): void;
+    readonly Authors: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationPerson> | Windows.Web.Syndication.SyndicationPerson[];
+    readonly Categories: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationCategory> | Windows.Web.Syndication.SyndicationCategory[];
+    CommentsUri: Windows.Foundation.Uri;
+    Content: Windows.Web.Syndication.SyndicationContent;
+    readonly Contributors: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationPerson> | Windows.Web.Syndication.SyndicationPerson[];
+    readonly ETag: string;
+    readonly EditMediaUri: Windows.Foundation.Uri;
+    readonly EditUri: Windows.Foundation.Uri;
+    Id: string;
+    readonly ItemUri: Windows.Foundation.Uri;
+    LastUpdatedTime: Windows.Foundation.DateTime;
+    readonly Links: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationLink> | Windows.Web.Syndication.SyndicationLink[];
+    PublishedDate: Windows.Foundation.DateTime;
+    Rights: Windows.Web.Syndication.ISyndicationText;
+    Source: Windows.Web.Syndication.SyndicationFeed;
+    Summary: Windows.Web.Syndication.ISyndicationText;
+    Title: Windows.Web.Syndication.ISyndicationText;
+  }
+  var ISyndicationItem: abstract new (...args: any[]) => ISyndicationItem;
+
+  interface ISyndicationItemFactory {
+    CreateSyndicationItem(title: string, content: Windows.Web.Syndication.SyndicationContent, uri: Windows.Foundation.Uri): Windows.Web.Syndication.SyndicationItem;
+  }
+  var ISyndicationItemFactory: abstract new (...args: any[]) => ISyndicationItemFactory;
+
+  interface ISyndicationLink extends Windows.Web.Syndication.ISyndicationNode {
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    Length: number;
+    MediaType: string;
+    Relationship: string;
+    ResourceLanguage: string;
+    Title: string;
+    Uri: Windows.Foundation.Uri;
+  }
+  var ISyndicationLink: abstract new (...args: any[]) => ISyndicationLink;
+
+  interface ISyndicationLinkFactory {
+    CreateSyndicationLink(uri: Windows.Foundation.Uri): Windows.Web.Syndication.SyndicationLink;
+    CreateSyndicationLinkEx(uri: Windows.Foundation.Uri, relationship: string, title: string, mediaType: string, length: number): Windows.Web.Syndication.SyndicationLink;
+  }
+  var ISyndicationLinkFactory: abstract new (...args: any[]) => ISyndicationLinkFactory;
+
+  interface ISyndicationNode {
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    readonly AttributeExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.SyndicationAttribute> | Windows.Web.Syndication.SyndicationAttribute[];
+    BaseUri: Windows.Foundation.Uri;
+    readonly ElementExtensions: Windows.Foundation.Collections.IVector<Windows.Web.Syndication.ISyndicationNode> | Windows.Web.Syndication.ISyndicationNode[];
+    Language: string;
+    NodeName: string;
+    NodeNamespace: string;
+    NodeValue: string;
+  }
+  var ISyndicationNode: abstract new (...args: any[]) => ISyndicationNode;
+
+  interface ISyndicationNodeFactory {
+    CreateSyndicationNode(nodeName: string, nodeNamespace: string, nodeValue: string): Windows.Web.Syndication.SyndicationNode;
+  }
+  var ISyndicationNodeFactory: abstract new (...args: any[]) => ISyndicationNodeFactory;
+
+  interface ISyndicationPerson extends Windows.Web.Syndication.ISyndicationNode {
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    Email: string;
+    Name: string;
+    Uri: Windows.Foundation.Uri;
+  }
+  var ISyndicationPerson: abstract new (...args: any[]) => ISyndicationPerson;
+
+  interface ISyndicationPersonFactory {
+    CreateSyndicationPerson(name: string): Windows.Web.Syndication.SyndicationPerson;
+    CreateSyndicationPersonEx(name: string, email: string, uri: Windows.Foundation.Uri): Windows.Web.Syndication.SyndicationPerson;
+  }
+  var ISyndicationPersonFactory: abstract new (...args: any[]) => ISyndicationPersonFactory;
+
+  interface ISyndicationText extends Windows.Web.Syndication.ISyndicationNode {
+    GetXmlDocument(format: number): Windows.Data.Xml.Dom.XmlDocument;
+    Text: string;
+    Type: string;
+    Xml: Windows.Data.Xml.Dom.XmlDocument;
+  }
+  var ISyndicationText: abstract new (...args: any[]) => ISyndicationText;
+
+  interface ISyndicationTextFactory {
+    CreateSyndicationText(text: string): Windows.Web.Syndication.SyndicationText;
+    CreateSyndicationTextEx(text: string, type: number): Windows.Web.Syndication.SyndicationText;
+  }
+  var ISyndicationTextFactory: abstract new (...args: any[]) => ISyndicationTextFactory;
+
+  interface RetrievalProgress {
+    BytesRetrieved: number;
+    TotalBytesToRetrieve: number;
+  }
+  var RetrievalProgress: {
+    new(bytesRetrieved: number, totalBytesToRetrieve: number): RetrievalProgress;
+    new(fields: { BytesRetrieved?: number; TotalBytesToRetrieve?: number }): RetrievalProgress;
+  };
+
+  interface TransferProgress {
+    BytesSent: number;
+    TotalBytesToSend: number;
+    BytesRetrieved: number;
+    TotalBytesToRetrieve: number;
+  }
+  var TransferProgress: {
+    new(bytesSent: number, totalBytesToSend: number, bytesRetrieved: number, totalBytesToRetrieve: number): TransferProgress;
+    new(fields: { BytesSent?: number; TotalBytesToSend?: number; BytesRetrieved?: number; TotalBytesToRetrieve?: number }): TransferProgress;
+  };
+
+}
+
+declare namespace Windows.Web.UI {
+  class WebViewControlContentLoadingEventArgs implements Windows.Web.UI.IWebViewControlContentLoadingEventArgs {
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class WebViewControlDOMContentLoadedEventArgs implements Windows.Web.UI.IWebViewControlDOMContentLoadedEventArgs {
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class WebViewControlDeferredPermissionRequest implements Windows.Web.UI.IWebViewControlDeferredPermissionRequest {
+    Allow(): void;
+    Deny(): void;
+    readonly Id: number;
+    readonly PermissionType: number;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class WebViewControlLongRunningScriptDetectedEventArgs implements Windows.Web.UI.IWebViewControlLongRunningScriptDetectedEventArgs {
+    readonly ExecutionTime: Windows.Foundation.TimeSpan;
+    StopPageScriptExecution: boolean;
+  }
+
+  class WebViewControlNavigationCompletedEventArgs implements Windows.Web.UI.IWebViewControlNavigationCompletedEventArgs {
+    readonly IsSuccess: boolean;
+    readonly Uri: Windows.Foundation.Uri;
+    readonly WebErrorStatus: number;
+  }
+
+  class WebViewControlNavigationStartingEventArgs implements Windows.Web.UI.IWebViewControlNavigationStartingEventArgs {
+    Cancel: boolean;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class WebViewControlNewWindowRequestedEventArgs implements Windows.Web.UI.IWebViewControlNewWindowRequestedEventArgs, Windows.Web.UI.IWebViewControlNewWindowRequestedEventArgs2 {
+    GetDeferral(): Windows.Foundation.Deferral;
+    Handled: boolean;
+    NewWindow: Windows.Web.UI.IWebViewControl;
+    readonly Referrer: Windows.Foundation.Uri;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class WebViewControlPermissionRequest implements Windows.Web.UI.IWebViewControlPermissionRequest {
+    Allow(): void;
+    Defer(): void;
+    Deny(): void;
+    readonly Id: number;
+    readonly PermissionType: number;
+    readonly State: number;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class WebViewControlPermissionRequestedEventArgs implements Windows.Web.UI.IWebViewControlPermissionRequestedEventArgs {
+    readonly PermissionRequest: Windows.Web.UI.WebViewControlPermissionRequest;
+  }
+
+  class WebViewControlScriptNotifyEventArgs implements Windows.Web.UI.IWebViewControlScriptNotifyEventArgs {
+    readonly Uri: Windows.Foundation.Uri;
+    readonly Value: string;
+  }
+
+  class WebViewControlSettings implements Windows.Web.UI.IWebViewControlSettings {
+    IsIndexedDBEnabled: boolean;
+    IsJavaScriptEnabled: boolean;
+    IsScriptNotifyAllowed: boolean;
+  }
+
+  class WebViewControlUnsupportedUriSchemeIdentifiedEventArgs implements Windows.Web.UI.IWebViewControlUnsupportedUriSchemeIdentifiedEventArgs {
+    Handled: boolean;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class WebViewControlUnviewableContentIdentifiedEventArgs implements Windows.Web.UI.IWebViewControlUnviewableContentIdentifiedEventArgs {
+    readonly MediaType: string;
+    readonly Referrer: Windows.Foundation.Uri;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+
+  class WebViewControlWebResourceRequestedEventArgs implements Windows.Web.UI.IWebViewControlWebResourceRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Web.Http.HttpRequestMessage;
+    Response: Windows.Web.Http.HttpResponseMessage;
+  }
+
+  enum WebViewControlPermissionState {
+    Unknown = 0,
+    Defer = 1,
+    Allow = 2,
+    Deny = 3,
+  }
+
+  enum WebViewControlPermissionType {
+    Geolocation = 0,
+    UnlimitedIndexedDBQuota = 1,
+    Media = 2,
+    PointerLock = 3,
+    WebNotifications = 4,
+    Screen = 5,
+    ImmersiveView = 6,
+  }
+
+  interface IWebViewControl {
+    BuildLocalStreamUri(contentIdentifier: string, relativePath: string): Windows.Foundation.Uri;
+    CapturePreviewToStreamAsync(stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    CaptureSelectedContentToDataPackageAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.DataTransfer.DataPackage>;
+    GetDeferredPermissionRequestById(id: number, result: Windows.Web.UI.WebViewControlDeferredPermissionRequest): void;
+    GoBack(): void;
+    GoForward(): void;
+    InvokeScriptAsync(scriptName: string, arguments_: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<string>;
+    Navigate(source: Windows.Foundation.Uri): void;
+    NavigateToLocalStreamUri(source: Windows.Foundation.Uri, streamResolver: Windows.Web.IUriToStreamResolver): void;
+    NavigateToString(text: string): void;
+    NavigateWithHttpRequestMessage(requestMessage: Windows.Web.Http.HttpRequestMessage): void;
+    Refresh(): void;
+    Stop(): void;
+    readonly CanGoBack: boolean;
+    readonly CanGoForward: boolean;
+    readonly ContainsFullScreenElement: boolean;
+    DefaultBackgroundColor: Windows.UI.Color;
+    readonly DeferredPermissionRequests: Windows.Foundation.Collections.IVectorView<Windows.Web.UI.WebViewControlDeferredPermissionRequest> | Windows.Web.UI.WebViewControlDeferredPermissionRequest[];
+    readonly DocumentTitle: string;
+    readonly Settings: Windows.Web.UI.WebViewControlSettings;
+    Source: Windows.Foundation.Uri;
+    ContainsFullScreenElementChanged: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Object> | null;
+    ContentLoading: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlContentLoadingEventArgs> | null;
+    DOMContentLoaded: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs> | null;
+    FrameContentLoading: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlContentLoadingEventArgs> | null;
+    FrameDOMContentLoaded: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs> | null;
+    FrameNavigationCompleted: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlNavigationCompletedEventArgs> | null;
+    FrameNavigationStarting: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlNavigationStartingEventArgs> | null;
+    LongRunningScriptDetected: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs> | null;
+    NavigationCompleted: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlNavigationCompletedEventArgs> | null;
+    NavigationStarting: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlNavigationStartingEventArgs> | null;
+    NewWindowRequested: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs> | null;
+    PermissionRequested: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlPermissionRequestedEventArgs> | null;
+    ScriptNotify: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlScriptNotifyEventArgs> | null;
+    UnsafeContentWarningDisplaying: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Object> | null;
+    UnsupportedUriSchemeIdentified: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs> | null;
+    UnviewableContentIdentified: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs> | null;
+    WebResourceRequested: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs> | null;
+  }
+  var IWebViewControl: abstract new (...args: any[]) => IWebViewControl;
+
+  interface IWebViewControl2 {
+    AddInitializeScript(script: string): void;
+  }
+  var IWebViewControl2: abstract new (...args: any[]) => IWebViewControl2;
+
+  interface IWebViewControlContentLoadingEventArgs {
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IWebViewControlContentLoadingEventArgs: abstract new (...args: any[]) => IWebViewControlContentLoadingEventArgs;
+
+  interface IWebViewControlDOMContentLoadedEventArgs {
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IWebViewControlDOMContentLoadedEventArgs: abstract new (...args: any[]) => IWebViewControlDOMContentLoadedEventArgs;
+
+  interface IWebViewControlDeferredPermissionRequest {
+    Allow(): void;
+    Deny(): void;
+    readonly Id: number;
+    readonly PermissionType: number;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IWebViewControlDeferredPermissionRequest: abstract new (...args: any[]) => IWebViewControlDeferredPermissionRequest;
+
+  interface IWebViewControlLongRunningScriptDetectedEventArgs {
+    readonly ExecutionTime: Windows.Foundation.TimeSpan;
+    StopPageScriptExecution: boolean;
+  }
+  var IWebViewControlLongRunningScriptDetectedEventArgs: abstract new (...args: any[]) => IWebViewControlLongRunningScriptDetectedEventArgs;
+
+  interface IWebViewControlNavigationCompletedEventArgs {
+    readonly IsSuccess: boolean;
+    readonly Uri: Windows.Foundation.Uri;
+    readonly WebErrorStatus: number;
+  }
+  var IWebViewControlNavigationCompletedEventArgs: abstract new (...args: any[]) => IWebViewControlNavigationCompletedEventArgs;
+
+  interface IWebViewControlNavigationStartingEventArgs {
+    Cancel: boolean;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IWebViewControlNavigationStartingEventArgs: abstract new (...args: any[]) => IWebViewControlNavigationStartingEventArgs;
+
+  interface IWebViewControlNewWindowRequestedEventArgs {
+    Handled: boolean;
+    readonly Referrer: Windows.Foundation.Uri;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IWebViewControlNewWindowRequestedEventArgs: abstract new (...args: any[]) => IWebViewControlNewWindowRequestedEventArgs;
+
+  interface IWebViewControlNewWindowRequestedEventArgs2 {
+    GetDeferral(): Windows.Foundation.Deferral;
+    NewWindow: Windows.Web.UI.IWebViewControl;
+  }
+  var IWebViewControlNewWindowRequestedEventArgs2: abstract new (...args: any[]) => IWebViewControlNewWindowRequestedEventArgs2;
+
+  interface IWebViewControlPermissionRequest {
+    Allow(): void;
+    Defer(): void;
+    Deny(): void;
+    readonly Id: number;
+    readonly PermissionType: number;
+    readonly State: number;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IWebViewControlPermissionRequest: abstract new (...args: any[]) => IWebViewControlPermissionRequest;
+
+  interface IWebViewControlPermissionRequestedEventArgs {
+    readonly PermissionRequest: Windows.Web.UI.WebViewControlPermissionRequest;
+  }
+  var IWebViewControlPermissionRequestedEventArgs: abstract new (...args: any[]) => IWebViewControlPermissionRequestedEventArgs;
+
+  interface IWebViewControlScriptNotifyEventArgs {
+    readonly Uri: Windows.Foundation.Uri;
+    readonly Value: string;
+  }
+  var IWebViewControlScriptNotifyEventArgs: abstract new (...args: any[]) => IWebViewControlScriptNotifyEventArgs;
+
+  interface IWebViewControlSettings {
+    IsIndexedDBEnabled: boolean;
+    IsJavaScriptEnabled: boolean;
+    IsScriptNotifyAllowed: boolean;
+  }
+  var IWebViewControlSettings: abstract new (...args: any[]) => IWebViewControlSettings;
+
+  interface IWebViewControlUnsupportedUriSchemeIdentifiedEventArgs {
+    Handled: boolean;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IWebViewControlUnsupportedUriSchemeIdentifiedEventArgs: abstract new (...args: any[]) => IWebViewControlUnsupportedUriSchemeIdentifiedEventArgs;
+
+  interface IWebViewControlUnviewableContentIdentifiedEventArgs {
+    readonly MediaType: string;
+    readonly Referrer: Windows.Foundation.Uri;
+    readonly Uri: Windows.Foundation.Uri;
+  }
+  var IWebViewControlUnviewableContentIdentifiedEventArgs: abstract new (...args: any[]) => IWebViewControlUnviewableContentIdentifiedEventArgs;
+
+  interface IWebViewControlWebResourceRequestedEventArgs {
+    GetDeferral(): Windows.Foundation.Deferral;
+    readonly Request: Windows.Web.Http.HttpRequestMessage;
+    Response: Windows.Web.Http.HttpResponseMessage;
+  }
+  var IWebViewControlWebResourceRequestedEventArgs: abstract new (...args: any[]) => IWebViewControlWebResourceRequestedEventArgs;
+
+}
+
+declare namespace Windows.Web.UI.Interop {
+  class WebViewControl implements Windows.Web.UI.IWebViewControl, Windows.Web.UI.IWebViewControl2, Windows.Web.UI.Interop.IWebViewControlSite, Windows.Web.UI.Interop.IWebViewControlSite2 {
+    AddInitializeScript(script: string): void;
+    BuildLocalStreamUri(contentIdentifier: string, relativePath: string): Windows.Foundation.Uri;
+    CapturePreviewToStreamAsync(stream: Windows.Storage.Streams.IRandomAccessStream): Windows.Foundation.IAsyncAction;
+    CaptureSelectedContentToDataPackageAsync(): Windows.Foundation.IAsyncOperation<Windows.ApplicationModel.DataTransfer.DataPackage>;
+    Close(): void;
+    GetDeferredPermissionRequestById(id: number, result: Windows.Web.UI.WebViewControlDeferredPermissionRequest): void;
+    GoBack(): void;
+    GoForward(): void;
+    InvokeScriptAsync(scriptName: string, arguments_: Windows.Foundation.Collections.IIterable<string> | string[]): Windows.Foundation.IAsyncOperation<string>;
+    MoveFocus(reason: number): void;
+    Navigate(source: Windows.Foundation.Uri): void;
+    NavigateToLocalStreamUri(source: Windows.Foundation.Uri, streamResolver: Windows.Web.IUriToStreamResolver): void;
+    NavigateToString(text: string): void;
+    NavigateWithHttpRequestMessage(requestMessage: Windows.Web.Http.HttpRequestMessage): void;
+    Refresh(): void;
+    Stop(): void;
+    Bounds: Windows.Foundation.Rect;
+    readonly CanGoBack: boolean;
+    readonly CanGoForward: boolean;
+    readonly ContainsFullScreenElement: boolean;
+    DefaultBackgroundColor: Windows.UI.Color;
+    readonly DeferredPermissionRequests: Windows.Foundation.Collections.IVectorView<Windows.Web.UI.WebViewControlDeferredPermissionRequest> | Windows.Web.UI.WebViewControlDeferredPermissionRequest[];
+    readonly DocumentTitle: string;
+    IsVisible: boolean;
+    readonly Process: Windows.Web.UI.Interop.WebViewControlProcess;
+    Scale: number;
+    readonly Settings: Windows.Web.UI.WebViewControlSettings;
+    Source: Windows.Foundation.Uri;
+    ContainsFullScreenElementChanged: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Object> | null;
+    ContentLoading: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlContentLoadingEventArgs> | null;
+    DOMContentLoaded: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs> | null;
+    FrameContentLoading: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlContentLoadingEventArgs> | null;
+    FrameDOMContentLoaded: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlDOMContentLoadedEventArgs> | null;
+    FrameNavigationCompleted: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlNavigationCompletedEventArgs> | null;
+    FrameNavigationStarting: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlNavigationStartingEventArgs> | null;
+    LongRunningScriptDetected: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlLongRunningScriptDetectedEventArgs> | null;
+    NavigationCompleted: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlNavigationCompletedEventArgs> | null;
+    NavigationStarting: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlNavigationStartingEventArgs> | null;
+    NewWindowRequested: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlNewWindowRequestedEventArgs> | null;
+    PermissionRequested: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlPermissionRequestedEventArgs> | null;
+    ScriptNotify: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlScriptNotifyEventArgs> | null;
+    UnsafeContentWarningDisplaying: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Object> | null;
+    UnsupportedUriSchemeIdentified: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlUnsupportedUriSchemeIdentifiedEventArgs> | null;
+    UnviewableContentIdentified: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlUnviewableContentIdentifiedEventArgs> | null;
+    WebResourceRequested: Windows.Foundation.TypedEventHandler<Windows.Web.UI.IWebViewControl, Windows.Web.UI.WebViewControlWebResourceRequestedEventArgs> | null;
+    AcceleratorKeyPressed: Windows.Foundation.TypedEventHandler<Windows.Web.UI.Interop.WebViewControl, Windows.Web.UI.Interop.WebViewControlAcceleratorKeyPressedEventArgs> | null;
+    MoveFocusRequested: Windows.Foundation.TypedEventHandler<Windows.Web.UI.Interop.WebViewControl, Windows.Web.UI.Interop.WebViewControlMoveFocusRequestedEventArgs> | null;
+    GotFocus: Windows.Foundation.TypedEventHandler<Windows.Web.UI.Interop.WebViewControl, Object> | null;
+    LostFocus: Windows.Foundation.TypedEventHandler<Windows.Web.UI.Interop.WebViewControl, Object> | null;
+  }
+
+  class WebViewControlAcceleratorKeyPressedEventArgs implements Windows.Web.UI.Interop.IWebViewControlAcceleratorKeyPressedEventArgs {
+    readonly EventType: number;
+    Handled: boolean;
+    readonly KeyStatus: Windows.UI.Core.CorePhysicalKeyStatus;
+    readonly RoutingStage: number;
+    readonly VirtualKey: number;
+  }
+
+  class WebViewControlMoveFocusRequestedEventArgs implements Windows.Web.UI.Interop.IWebViewControlMoveFocusRequestedEventArgs {
+    readonly Reason: number;
+  }
+
+  class WebViewControlProcess implements Windows.Web.UI.Interop.IWebViewControlProcess {
+    constructor(processOptions: Windows.Web.UI.Interop.WebViewControlProcessOptions);
+    constructor();
+    CreateWebViewControlAsync(hostWindowHandle: number | bigint, bounds: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<Windows.Web.UI.Interop.WebViewControl>;
+    GetWebViewControls(): Windows.Foundation.Collections.IVectorView<Windows.Web.UI.Interop.WebViewControl> | Windows.Web.UI.Interop.WebViewControl[];
+    Terminate(): void;
+    readonly EnterpriseId: string;
+    readonly IsPrivateNetworkClientServerCapabilityEnabled: boolean;
+    readonly ProcessId: number;
+    ProcessExited: Windows.Foundation.TypedEventHandler<Windows.Web.UI.Interop.WebViewControlProcess, Object> | null;
+  }
+
+  class WebViewControlProcessOptions implements Windows.Web.UI.Interop.IWebViewControlProcessOptions {
+    constructor();
+    EnterpriseId: string;
+    PrivateNetworkClientServerCapability: number;
+  }
+
+  enum WebViewControlAcceleratorKeyRoutingStage {
+    Tunneling = 0,
+    Bubbling = 1,
+  }
+
+  enum WebViewControlMoveFocusReason {
+    Programmatic = 0,
+    Next = 1,
+    Previous = 2,
+  }
+
+  enum WebViewControlProcessCapabilityState {
+    Default = 0,
+    Disabled = 1,
+    Enabled = 2,
+  }
+
+  interface IWebViewControlAcceleratorKeyPressedEventArgs {
+    readonly EventType: number;
+    Handled: boolean;
+    readonly KeyStatus: Windows.UI.Core.CorePhysicalKeyStatus;
+    readonly RoutingStage: number;
+    readonly VirtualKey: number;
+  }
+  var IWebViewControlAcceleratorKeyPressedEventArgs: abstract new (...args: any[]) => IWebViewControlAcceleratorKeyPressedEventArgs;
+
+  interface IWebViewControlMoveFocusRequestedEventArgs {
+    readonly Reason: number;
+  }
+  var IWebViewControlMoveFocusRequestedEventArgs: abstract new (...args: any[]) => IWebViewControlMoveFocusRequestedEventArgs;
+
+  interface IWebViewControlProcess {
+    CreateWebViewControlAsync(hostWindowHandle: number | bigint, bounds: Windows.Foundation.Rect): Windows.Foundation.IAsyncOperation<Windows.Web.UI.Interop.WebViewControl>;
+    GetWebViewControls(): Windows.Foundation.Collections.IVectorView<Windows.Web.UI.Interop.WebViewControl> | Windows.Web.UI.Interop.WebViewControl[];
+    Terminate(): void;
+    readonly EnterpriseId: string;
+    readonly IsPrivateNetworkClientServerCapabilityEnabled: boolean;
+    readonly ProcessId: number;
+    ProcessExited: Windows.Foundation.TypedEventHandler<Windows.Web.UI.Interop.WebViewControlProcess, Object> | null;
+  }
+  var IWebViewControlProcess: abstract new (...args: any[]) => IWebViewControlProcess;
+
+  interface IWebViewControlProcessFactory {
+    CreateWithOptions(processOptions: Windows.Web.UI.Interop.WebViewControlProcessOptions): Windows.Web.UI.Interop.WebViewControlProcess;
+  }
+  var IWebViewControlProcessFactory: abstract new (...args: any[]) => IWebViewControlProcessFactory;
+
+  interface IWebViewControlProcessOptions {
+    EnterpriseId: string;
+    PrivateNetworkClientServerCapability: number;
+  }
+  var IWebViewControlProcessOptions: abstract new (...args: any[]) => IWebViewControlProcessOptions;
+
+  interface IWebViewControlSite {
+    Close(): void;
+    MoveFocus(reason: number): void;
+    Bounds: Windows.Foundation.Rect;
+    IsVisible: boolean;
+    readonly Process: Windows.Web.UI.Interop.WebViewControlProcess;
+    Scale: number;
+    AcceleratorKeyPressed: Windows.Foundation.TypedEventHandler<Windows.Web.UI.Interop.WebViewControl, Windows.Web.UI.Interop.WebViewControlAcceleratorKeyPressedEventArgs> | null;
+    MoveFocusRequested: Windows.Foundation.TypedEventHandler<Windows.Web.UI.Interop.WebViewControl, Windows.Web.UI.Interop.WebViewControlMoveFocusRequestedEventArgs> | null;
+  }
+  var IWebViewControlSite: abstract new (...args: any[]) => IWebViewControlSite;
+
+  interface IWebViewControlSite2 {
+    GotFocus: Windows.Foundation.TypedEventHandler<Windows.Web.UI.Interop.WebViewControl, Object> | null;
+    LostFocus: Windows.Foundation.TypedEventHandler<Windows.Web.UI.Interop.WebViewControl, Object> | null;
+  }
+  var IWebViewControlSite2: abstract new (...args: any[]) => IWebViewControlSite2;
+
+}
+
diff --git a/packages/types-minimal/src/lib/windows/winrt-helpers.d.ts b/packages/types-minimal/src/lib/windows/winrt-helpers.d.ts
new file mode 100644
index 0000000000..c85adbc174
--- /dev/null
+++ b/packages/types-minimal/src/lib/windows/winrt-helpers.d.ts
@@ -0,0 +1,139 @@
+/* Auto-generated runtime helper typings for NSWinRT / interop */
+
+export {};
+
+declare global {
+  // TypeScript @Interfaces decorator — attach WinRT interface/delegate list to a class.
+  // Usage: @Interfaces([Windows.UI.Xaml.Controls.Primitives.IButtonBase])
+  function Interfaces(interfaces: any[]): ClassDecorator;
+
+  // TypeScript @CSharpProxy decorator — set an explicit managed type name.
+  // Usage: @CSharpProxy('MyApp.Namespace.MyButton')
+  // When present, creates a real C# subclass via the managed bridge.
+  function CSharpProxy(name: string): ClassDecorator;
+
+  type ExtendOverrides<T> = T & { interfaces?: any[]; init?(...args: any[]): void };
+
+  interface Function {
+    /** Subclass this WinRT class with JS overrides. Returns a typed constructor. */
+    extend<TOverrides extends Record<string, any> = {}>(
+      overrides: ExtendOverrides<TOverrides>
+    ): new (...args: any[]) => Omit<TOverrides, 'interfaces' | 'init'>;
+    extend<TOverrides extends Record<string, any> = {}>(
+      name: string,
+      overrides?: ExtendOverrides<TOverrides>
+    ): new (...args: any[]) => Omit<TOverrides, 'interfaces' | 'init'>;
+
+    /** Subclass via the managed (.NET) bridge. Returns a typed constructor. */
+    extendManaged<TOverrides extends Record<string, any> = {}>(
+      overrides: ExtendOverrides<TOverrides>
+    ): new (...args: any[]) => Omit<TOverrides, 'interfaces' | 'init'>;
+    extendManaged<TOverrides extends Record<string, any> = {}>(
+      name: string,
+      overrides?: ExtendOverrides<TOverrides>
+    ): new (...args: any[]) => Omit<TOverrides, 'interfaces' | 'init'>;
+  }
+
+  interface NSWinRTPointer {
+    handle: any | null;
+    isNull(): boolean;
+    unwrap(): any | null;
+    toString(): string;
+  }
+
+  interface NSWinRTInterop {
+    Pointer: { new(handle?: any | null): NSWinRTPointer };
+    pointer(value: any): NSWinRTPointer;
+    isPointer(value: any): boolean;
+    handleOf(value: any): any;
+
+    asBufferSource(value: ArrayBuffer | ArrayBufferView | null): ArrayBuffer | ArrayBufferView | null;
+    asUint8View(value: ArrayBuffer | ArrayBufferView | null): Uint8Array;
+    asDataView(value: ArrayBuffer | ArrayBufferView | null): DataView;
+    toWinRTDateTimeTicks(input: Date | number): bigint;
+    fromWinRTDateTimeTicks(value: any): Date;
+    pointerKey(value: any): string | null;
+    pointerFromBuffer(value: ArrayBuffer | ArrayBufferView | null): any | null;
+    trackBufferSource(value: ArrayBuffer | ArrayBufferView | null): any | null;
+    resolveTrackedBuffer(pointerLike: any): ArrayBuffer | ArrayBufferView | undefined;
+    byteLengthOf(value: ArrayBuffer | ArrayBufferView | null): number;
+    byteOffsetOf(value: ArrayBuffer | ArrayBufferView | null): number;
+    readU8(value: ArrayBuffer | ArrayBufferView, offset: number): number;
+    writeU8(value: ArrayBuffer | ArrayBufferView, offset: number, input: number): ArrayBuffer | ArrayBufferView;
+    readI32(value: ArrayBuffer | ArrayBufferView, offset: number, littleEndian?: boolean): number;
+    writeI32(value: ArrayBuffer | ArrayBufferView, offset: number, input: number, littleEndian?: boolean): ArrayBuffer | ArrayBufferView;
+    readF32(value: ArrayBuffer | ArrayBufferView, offset: number, littleEndian?: boolean): number;
+    writeF32(value: ArrayBuffer | ArrayBufferView, offset: number, input: number, littleEndian?: boolean): ArrayBuffer | ArrayBufferView;
+    readF64(value: ArrayBuffer | ArrayBufferView, offset: number, littleEndian?: boolean): number;
+    writeF64(value: ArrayBuffer | ArrayBufferView, offset: number, input: number, littleEndian?: boolean): ArrayBuffer | ArrayBufferView;
+
+    // Reference/value helpers
+    reference(typeName: string, value: any): any | null;
+    float(n: number): any;
+    double(n: number): any;
+    int(n: number): any;
+    uint(n: number): any;
+    long(n: number): any;
+    ulong(n: number): any;
+    short(n: number): any;
+    ushort(n: number): any;
+    byte(n: number): any;
+    char(c: string): any;
+    bool(v: boolean): any;
+    timeSpan(ms: number): any;
+    dateTime(msOrDate: number | Date): any;
+    guid(str: string): any;
+  }
+
+  interface NSWinRTEventEmitter {
+    add(listener: Function): { dispose(): void };
+    emit(...args: any[]): void;
+    count(): number;
+  }
+
+  interface NSWinRTDotNet {
+    taskToPromise?(obj: any): Promise<any>;
+    asDelegate?(typeNameOrFn: Function | string, fn?: Function): any;
+  }
+
+  interface NSWinRTWin32 {
+    call(dll: string, fn_name: string, returnType: string, ...args: any[]): any;
+    bind(dll: string, returnType?: string): Record<string, (...args: any[]) => any>;
+    define(dll: string, signatures: Record<string, string[]>, defaultReturnType?: string): Record<string, (...args: any[]) => any>;
+    import(dll: string, returnType?: string): void;
+  }
+
+  interface NSWinRTProxy {
+    getExtensions(): any[];
+    emit(meta: any, outDir?: string): { dir: string; csprojPath: string; csPath: string };
+    compile(meta: any, outDir?: string, configuration?: string): any;
+    register(meta: any, outDir?: string, configuration?: string): any;
+    createManagedSubclass(assembly?: string, typeName?: string, overrides?: any): any;
+    invokeById(proxyId: number, methodName: string, argsArray?: any[]): any;
+    listRegisteredManifests(): any[];
+  }
+
+  interface NSWinRTGlobal {
+    toPromise(op: any, options?: { timeoutMs?: number }): Promise<any>;
+    wait(op: any, options?: { timeoutMs?: number }): any;
+    getStatus(op: any): number;
+    getResults(op: any): any;
+    onCompleted(op: any, callback: (op: any, status: number) => void, options?: any): any;
+    setDefaultTimeoutMs(timeoutMs: number): void;
+
+    asDelegate(typeNameOrFn: string | Function | { invoke: Function }, fn?: Function): any;
+    createEventEmitter(): NSWinRTEventEmitter;
+
+    interop: NSWinRTInterop;
+
+    import(path: string): any;
+    dynamicImport(path: string): Promise<any>;
+    proxy: NSWinRTProxy;
+    win32: NSWinRTWin32;
+    dotnet: NSWinRTDotNet;
+    runOnUIThread?(fn: Function): any;
+  }
+
+  var NSWinRT: NSWinRTGlobal;
+  var interop: NSWinRTInterop;
+}
diff --git a/packages/ui-mobile-base/.gitignore b/packages/ui-mobile-base/.gitignore
index f29a91f50b..2c36beb9f7 100644
--- a/packages/ui-mobile-base/.gitignore
+++ b/packages/ui-mobile-base/.gitignore
@@ -52,4 +52,7 @@ android/widgets/bin
 android/widgets/.settings
 android/.project
 android/widgets/.project
-android/.settings
\ No newline at end of file
+android/.settings
+
+windows/widgets/bin
+windows/widgets/obj
\ No newline at end of file
diff --git a/packages/ui-mobile-base/build.sh b/packages/ui-mobile-base/build.sh
index e7f449d025..25da023452 100755
--- a/packages/ui-mobile-base/build.sh
+++ b/packages/ui-mobile-base/build.sh
@@ -14,6 +14,15 @@ export SKIP_PACK=true
 ./build.android.sh
 ./build.ios.sh
 
+# Windows widgets — requires PowerShell and the Windows SDK (Windows host only).
+# Skipped automatically on macOS/Linux CI; run build.windows.ps1 directly on Windows.
+if command -v powershell.exe >/dev/null 2>&1; then
+  echo "Build Windows widgets"
+  powershell.exe -ExecutionPolicy Bypass -File ./build.windows.ps1 "$1"
+else
+  echo "Skipping Windows build (powershell.exe not available)"
+fi
+
 echo "Copy NPM artifacts"
 cp .npmignore README.md package.json dist/package
 cp ../../LICENSE dist/package
diff --git a/packages/ui-mobile-base/build.windows.ps1 b/packages/ui-mobile-base/build.windows.ps1
new file mode 100644
index 0000000000..1b545708d3
--- /dev/null
+++ b/packages/ui-mobile-base/build.windows.ps1
@@ -0,0 +1,162 @@
+#Requires -Version 5.1
+<#
+.SYNOPSIS
+    Builds the C++/WinRT NativeScript.Widgets component for Windows (x64 + ARM64)
+    and ships the per-architecture artifacts from @nativescript/core.
+
+.DESCRIPTION
+    The widgets are a hand-authored C++/WinRT WinUI3 component (no DotNetBridge).
+    The CLI builds the host with `dotnet build`, which cannot build a C++ .vcxproj,
+    so the component is PREBUILT here with full MSBuild and its outputs are copied
+    into the @nativescript/core platform payload:
+
+        packages/core/platforms/windows/x64/NativeScript.Widgets.{dll,winmd}
+        packages/core/platforms/windows/arm64/NativeScript.Widgets.{dll,winmd}
+
+    At app build time the CLI stages these per-arch files and core's plugin.props /
+    plugin.targets copy the matching-arch dll+winmd to the package root, where the
+    runtime's RoGetMetaDataFile resolves the winmd and RoGetActivationFactory finds
+    the in-proc server (registered in the app's Package.appxmanifest).
+
+    Native DLLs are per-architecture (no "universal" fat binary on Windows), so we
+    build x64 and ARM64 separately.
+
+.PARAMETER SkipArm64
+    Build x64 only (faster local iteration).
+
+.PARAMETER SkipTypings
+    Skip regenerating types-minimal/.../NativeScript.Widgets.d.ts from the winmd.
+
+.PARAMETER Configuration
+    MSBuild configuration (default Release).
+#>
+param(
+    [switch]$SkipArm64,
+    [switch]$SkipTypings,
+    [ValidateSet("Release", "Debug")]
+    [string]$Configuration = "Release"
+)
+
+$ErrorActionPreference = "Stop"
+Set-StrictMode -Version Latest
+
+$ScriptDir   = $PSScriptRoot
+$WidgetsProj = Join-Path $ScriptDir "windows\widgets-cpp\NativeScript.Widgets.vcxproj"
+$WidgetsDir  = Split-Path $WidgetsProj
+$CoreWindows = (Resolve-Path (Join-Path $ScriptDir "..\core\platforms\windows")).Path
+
+if (-not (Test-Path $WidgetsProj)) {
+    Write-Error "Widgets project not found: $WidgetsProj"
+    exit 1
+}
+
+# --- Locate MSBuild ---------------------------------------------------------
+# Prefer the Community (or full VS) MSBuild: the Build Tools SKU lacks the PRI
+# packaging task (Microsoft.Build.Packaging.Pri.Tasks.dll) that a WinUI3 C++
+# component needs, so a Build-Tools-only MSBuild fails to package the .pri.
+function Find-MSBuild {
+    $vswhere = "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe"
+    if (Test-Path $vswhere) {
+        # -requires the VC tools + restrict to a full VS product (not BuildTools)
+        $found = & $vswhere -all -products "Microsoft.VisualStudio.Product.Community","Microsoft.VisualStudio.Product.Professional","Microsoft.VisualStudio.Product.Enterprise" `
+            -requires Microsoft.Component.MSBuild `
+            -find "MSBuild\**\Bin\MSBuild.exe" 2>$null | Select-Object -First 1
+        if ($found) { return $found }
+        # Fallback: any MSBuild vswhere can find
+        $found = & $vswhere -all -products "*" -find "MSBuild\**\Bin\MSBuild.exe" 2>$null | Select-Object -First 1
+        if ($found) { return $found }
+    }
+    $cmd = Get-Command "MSBuild.exe" -ErrorAction SilentlyContinue
+    if ($cmd) { return $cmd.Source }
+    return $null
+}
+
+$MSBuild = Find-MSBuild
+if (-not $MSBuild) {
+    Write-Error "MSBuild.exe not found. Install Visual Studio (Community or higher) with the C++/WinRT + Windows App SDK workloads."
+    exit 1
+}
+Write-Host "MSBuild     : $MSBuild"
+Write-Host "Widgets proj: $WidgetsProj"
+Write-Host "Core output : $CoreWindows"
+
+# --- Build targets ----------------------------------------------------------
+# MSBuild Platform name -> shipped per-arch folder name under platforms/windows.
+$Targets = @(
+    @{ Platform = "x64";   Arch = "x64"   }
+)
+if (-not $SkipArm64) {
+    $Targets += @{ Platform = "ARM64"; Arch = "arm64" }
+}
+
+foreach ($t in $Targets) {
+    $platform = $t.Platform
+    $arch     = $t.Arch
+
+    Write-Host "`n=== Building NativeScript.Widgets ($Configuration|$platform) ===" -ForegroundColor Cyan
+    & $MSBuild $WidgetsProj /t:Restore /p:Configuration=$Configuration /p:Platform=$platform /nologo /v:minimal
+    if ($LASTEXITCODE -ne 0) { Write-Error "MSBuild Restore failed ($platform)"; exit 1 }
+    & $MSBuild $WidgetsProj /t:Rebuild /p:Configuration=$Configuration /p:Platform=$platform /nologo /v:minimal
+    if ($LASTEXITCODE -ne 0) { Write-Error "MSBuild Rebuild failed ($platform)"; exit 1 }
+
+    $outDir = Join-Path $WidgetsDir "$platform\$Configuration"
+    $destDir = Join-Path $CoreWindows $arch
+    New-Item -ItemType Directory -Force $destDir | Out-Null
+
+    # Ship ONLY the component dll + its metadata winmd. NuGet runtime deps
+    # (WebView2.Core, WindowsAppRuntime.Bootstrap, etc.) come from the framework
+    # package dependency and must NOT be shipped here.
+    foreach ($file in @("NativeScript.Widgets.dll", "NativeScript.Widgets.winmd")) {
+        $src = Join-Path $outDir $file
+        if (-not (Test-Path $src)) {
+            Write-Error "Expected build output not found: $src"
+            exit 1
+        }
+        Copy-Item -Force $src (Join-Path $destDir $file)
+        Write-Host "  + $arch\$file"
+    }
+}
+
+# --- Remove the legacy flat C# artifact if it lingers -----------------------
+$legacyDll = Join-Path $CoreWindows "NativeScript.Widgets.dll"
+if (Test-Path $legacyDll) {
+    Remove-Item -Force $legacyDll
+    Write-Host "  - removed legacy (flat) NativeScript.Widgets.dll"
+}
+
+# --- Typings ----------------------------------------------------------------
+# Generate the TypeScript typings from the C++ winmd (the sole metadata source
+# now that the C# project is retired).
+if (-not $SkipTypings) {
+    Write-Host "`n=== Generating TypeScript typings from winmd ===" -ForegroundColor Cyan
+    $winmd = Join-Path $CoreWindows "x64\NativeScript.Widgets.winmd"
+    $typingsOut = (Resolve-Path (Join-Path $ScriptDir "..\types-minimal\src\lib\windows")).Path
+    $typingsOut = Join-Path $typingsOut "NativeScript.Widgets.d.ts"
+
+    # typings-generator sub-tool from the windows-runtime repo. Try common
+    # locations; override with $env:TYPINGS_GEN_PROJ if your layout differs.
+    $candidates = @(
+        $env:TYPINGS_GEN_PROJ,
+        (Join-Path $ScriptDir "..\..\..\windows-runtime\typings-generator\dotnet-src\dotnet-typings-gen.csproj"),
+        (Join-Path $ScriptDir "..\..\..\..\windows-runtime\typings-generator\dotnet-src\dotnet-typings-gen.csproj")
+    ) | Where-Object { $_ }
+
+    $typingsGen = $null
+    foreach ($c in $candidates) {
+        if (Test-Path $c) { $typingsGen = (Resolve-Path $c).Path; break }
+    }
+
+    if ($typingsGen) {
+        & dotnet run --project $typingsGen -- --input $winmd --root "NativeScript" --out $typingsOut
+        if ($LASTEXITCODE -ne 0) { Write-Warning "typings-gen exited $LASTEXITCODE - continuing" }
+        else { Write-Host "  + NativeScript.Widgets.d.ts" }
+    } else {
+        Write-Warning "typings-generator not found (set `$env:TYPINGS_GEN_PROJ) - skipping typings"
+    }
+}
+
+Write-Host "`nDone." -ForegroundColor Green
+Get-ChildItem -Recurse $CoreWindows -Filter "*.dll" -ErrorAction SilentlyContinue |
+    ForEach-Object { "  " + $_.FullName.Substring($CoreWindows.Length + 1) }
+Get-ChildItem -Recurse $CoreWindows -Filter "*.winmd" -ErrorAction SilentlyContinue |
+    ForEach-Object { "  " + $_.FullName.Substring($CoreWindows.Length + 1) }
diff --git a/packages/ui-mobile-base/package.json b/packages/ui-mobile-base/package.json
index dbd855355b..a7f6689d55 100644
--- a/packages/ui-mobile-base/package.json
+++ b/packages/ui-mobile-base/package.json
@@ -18,7 +18,8 @@
 	"nativescript": {
 		"platforms": {
 			"ios": "6.0.0",
-			"android": "6.0.0"
+			"android": "6.0.0",
+			"windows": "9.1.0"
 		}
 	}
 }
diff --git a/packages/ui-mobile-base/windows/widgets-cpp/FlexboxLayout.cpp b/packages/ui-mobile-base/windows/widgets-cpp/FlexboxLayout.cpp
new file mode 100644
index 0000000000..da902a5cbe
--- /dev/null
+++ b/packages/ui-mobile-base/windows/widgets-cpp/FlexboxLayout.cpp
@@ -0,0 +1,404 @@
+#include "pch.h"
+#include "FlexboxLayout.h"
+#include "FlexboxLayout.g.cpp"
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+
+using namespace winrt;
+using namespace winrt::Windows::Foundation;
+using namespace winrt::Microsoft::UI::Xaml;
+
+namespace
+{
+    // Integer constants (kept in sync with the TS maps in flexbox-layout/index.windows.ts).
+    constexpr int32_t DIR_ROW = 0, DIR_ROW_REV = 1 /*, DIR_COL = 2 */, DIR_COL_REV = 3;
+    constexpr int32_t WRAP_NO = 0, /* WRAP_YES = 1, */ WRAP_REV = 2;
+    constexpr int32_t JUSTIFY_END = 1, JUSTIFY_CENTER = 2, JUSTIFY_SPACE_BETWEEN = 3, JUSTIFY_SPACE_AROUND = 4, JUSTIFY_SPACE_EVENLY = 5;
+    constexpr int32_t ALIGN_AUTO = -1, /* ALIGN_START = 0, */ ALIGN_END = 1, ALIGN_CENTER = 2, /* ALIGN_BASELINE = 3, */ ALIGN_STRETCH = 4;
+    constexpr int32_t CONTENT_END = 1, CONTENT_CENTER = 2, CONTENT_SPACE_BETWEEN = 3, CONTENT_SPACE_AROUND = 4, CONTENT_STRETCH = 5, CONTENT_SPACE_EVENLY = 6;
+
+    constexpr float fInf = std::numeric_limits<float>::infinity();
+    constexpr double dInf = std::numeric_limits<double>::infinity();
+    constexpr double dNaN = std::numeric_limits<double>::quiet_NaN();
+
+    inline double MainOf(Size const& s, bool isRow) { return isRow ? s.Width : s.Height; }
+    inline double CrossOf(Size const& s, bool isRow) { return isRow ? s.Height : s.Width; }
+
+    inline Size AsSize(double main, double cross, bool isRow)
+    {
+        return isRow ? Size{ static_cast<float>(main), static_cast<float>(cross) }
+                     : Size{ static_cast<float>(cross), static_cast<float>(main) };
+    }
+
+    inline Rect AsRect(double mainPos, double crossPos, double main, double cross, bool isRow)
+    {
+        return isRow
+            ? Rect{ static_cast<float>(mainPos), static_cast<float>(crossPos), static_cast<float>(main), static_cast<float>(cross) }
+            : Rect{ static_cast<float>(crossPos), static_cast<float>(mainPos), static_cast<float>(cross), static_cast<float>(main) };
+    }
+}
+
+namespace winrt::NativeScript::Widgets::implementation
+{
+    // ── Attached DependencyProperties ────────────────────────────────────────
+    DependencyProperty FlexboxLayout::OrderProperty()
+    {
+        static DependencyProperty const prop = DependencyProperty::RegisterAttached(
+            L"Order", winrt::xaml_typename<int32_t>(), winrt::xaml_typename<winrt::NativeScript::Widgets::FlexboxLayout>(),
+            PropertyMetadata{ winrt::box_value<int32_t>(1), PropertyChangedCallback{ &FlexboxLayout::OnChildPropertyChanged } });
+        return prop;
+    }
+    DependencyProperty FlexboxLayout::FlexGrowProperty()
+    {
+        static DependencyProperty const prop = DependencyProperty::RegisterAttached(
+            L"FlexGrow", winrt::xaml_typename<double>(), winrt::xaml_typename<winrt::NativeScript::Widgets::FlexboxLayout>(),
+            PropertyMetadata{ winrt::box_value(0.0), PropertyChangedCallback{ &FlexboxLayout::OnChildPropertyChanged } });
+        return prop;
+    }
+    DependencyProperty FlexboxLayout::FlexShrinkProperty()
+    {
+        static DependencyProperty const prop = DependencyProperty::RegisterAttached(
+            L"FlexShrink", winrt::xaml_typename<double>(), winrt::xaml_typename<winrt::NativeScript::Widgets::FlexboxLayout>(),
+            PropertyMetadata{ winrt::box_value(1.0), PropertyChangedCallback{ &FlexboxLayout::OnChildPropertyChanged } });
+        return prop;
+    }
+    DependencyProperty FlexboxLayout::AlignSelfProperty()
+    {
+        static DependencyProperty const prop = DependencyProperty::RegisterAttached(
+            L"AlignSelf", winrt::xaml_typename<int32_t>(), winrt::xaml_typename<winrt::NativeScript::Widgets::FlexboxLayout>(),
+            PropertyMetadata{ winrt::box_value<int32_t>(-1), PropertyChangedCallback{ &FlexboxLayout::OnChildPropertyChanged } });
+        return prop;
+    }
+    DependencyProperty FlexboxLayout::FlexBasisPercentProperty()
+    {
+        static DependencyProperty const prop = DependencyProperty::RegisterAttached(
+            L"FlexBasisPercent", winrt::xaml_typename<double>(), winrt::xaml_typename<winrt::NativeScript::Widgets::FlexboxLayout>(),
+            PropertyMetadata{ winrt::box_value(-1.0), PropertyChangedCallback{ &FlexboxLayout::OnChildPropertyChanged } });
+        return prop;
+    }
+    DependencyProperty FlexboxLayout::WrapBeforeProperty()
+    {
+        static DependencyProperty const prop = DependencyProperty::RegisterAttached(
+            L"WrapBefore", winrt::xaml_typename<bool>(), winrt::xaml_typename<winrt::NativeScript::Widgets::FlexboxLayout>(),
+            PropertyMetadata{ winrt::box_value(false), PropertyChangedCallback{ &FlexboxLayout::OnChildPropertyChanged } });
+        return prop;
+    }
+
+    int32_t FlexboxLayout::GetOrder(UIElement const& e) { return winrt::unbox_value_or<int32_t>(e.GetValue(OrderProperty()), 1); }
+    void FlexboxLayout::SetOrder(UIElement const& e, int32_t v) { e.SetValue(OrderProperty(), winrt::box_value<int32_t>(v)); }
+    double FlexboxLayout::GetFlexGrow(UIElement const& e) { return winrt::unbox_value_or<double>(e.GetValue(FlexGrowProperty()), 0.0); }
+    void FlexboxLayout::SetFlexGrow(UIElement const& e, double v) { e.SetValue(FlexGrowProperty(), winrt::box_value(v)); }
+    double FlexboxLayout::GetFlexShrink(UIElement const& e) { return winrt::unbox_value_or<double>(e.GetValue(FlexShrinkProperty()), 1.0); }
+    void FlexboxLayout::SetFlexShrink(UIElement const& e, double v) { e.SetValue(FlexShrinkProperty(), winrt::box_value(v)); }
+    int32_t FlexboxLayout::GetAlignSelf(UIElement const& e) { return winrt::unbox_value_or<int32_t>(e.GetValue(AlignSelfProperty()), -1); }
+    void FlexboxLayout::SetAlignSelf(UIElement const& e, int32_t v) { e.SetValue(AlignSelfProperty(), winrt::box_value<int32_t>(v)); }
+    double FlexboxLayout::GetFlexBasisPercent(UIElement const& e) { return winrt::unbox_value_or<double>(e.GetValue(FlexBasisPercentProperty()), -1.0); }
+    void FlexboxLayout::SetFlexBasisPercent(UIElement const& e, double v) { e.SetValue(FlexBasisPercentProperty(), winrt::box_value(v)); }
+    bool FlexboxLayout::GetWrapBefore(UIElement const& e) { return winrt::unbox_value_or<bool>(e.GetValue(WrapBeforeProperty()), false); }
+    void FlexboxLayout::SetWrapBefore(UIElement const& e, bool v) { e.SetValue(WrapBeforeProperty(), winrt::box_value(v)); }
+
+    void FlexboxLayout::OnChildPropertyChanged(DependencyObject const& d, DependencyPropertyChangedEventArgs const&)
+    {
+        if (auto fe = d.try_as<FrameworkElement>())
+        {
+            if (auto parent = fe.Parent().try_as<winrt::NativeScript::Widgets::FlexboxLayout>())
+            {
+                parent.InvalidateMeasure();
+            }
+        }
+    }
+
+    // ── MeasureOverride ──────────────────────────────────────────────────────
+    Size FlexboxLayout::MeasureOverride(Size const& avail)
+    {
+        m_lines.clear();
+        auto children = Children();
+        if (children.Size() == 0)
+        {
+            return Size{ 0, 0 };
+        }
+
+        const bool isRow = IsRow();
+        const bool doWrap = (m_flexWrap != WRAP_NO);
+        const double mainAv = MainOf(avail, isRow);
+        const double crossAv = CrossOf(avail, isRow);
+        const bool mainInf = std::isinf(mainAv);
+        const bool crossInf = std::isinf(crossAv);
+
+        // CollectItems — gather visible children with their flex props, then stable-sort by Order.
+        // Order is cached in FlexItem to avoid O(N log N) WinRT DependencyProperty reads in the comparator.
+        std::vector<FlexItem> items;
+        items.reserve(children.Size());
+        int32_t idx = 0;
+        for (auto const& child : children)
+        {
+            if (child.Visibility() == Visibility::Collapsed)
+            {
+                continue;
+            }
+            FlexItem fi;
+            fi.Element = child;
+            fi.OriginalIndex = idx++;
+            fi.Order = GetOrder(child);
+            fi.FlexGrow = GetFlexGrow(child);
+            fi.FlexShrink = GetFlexShrink(child);
+            fi.FlexBasisPercent = GetFlexBasisPercent(child);
+            fi.AlignSelf = GetAlignSelf(child);
+            fi.WrapBefore = GetWrapBefore(child);
+            items.push_back(std::move(fi));
+        }
+        // Stable sort: primary = Order (cached — no WinRT per comparison), secondary = insertion order.
+        std::stable_sort(items.begin(), items.end(), [](FlexItem const& a, FlexItem const& b) {
+            if (a.Order != b.Order) return a.Order < b.Order;
+            return a.OriginalIndex < b.OriginalIndex;
+        });
+
+        // MeasureInitial — each item at its flex-basis (or natural) main size.
+        for (auto& item : items)
+        {
+            const double basisMain = (!mainInf && item.FlexBasisPercent >= 0)
+                ? mainAv * item.FlexBasisPercent / 100.0
+                : dNaN;
+
+            const Size constraint = AsSize(
+                std::isnan(basisMain) ? static_cast<double>(fInf) : basisMain,
+                crossInf ? static_cast<double>(fInf) : crossAv,
+                isRow);
+
+            item.Element.Measure(constraint);
+            const Size d = item.Element.DesiredSize();
+            item.MainSize = std::isnan(basisMain) ? MainOf(d, isRow) : basisMain;
+            item.CrossSize = CrossOf(d, isRow);
+        }
+
+        // BuildLines — wrap into flex lines.
+        // mainGap = CSS column-gap (row direction) or row-gap (column direction): gap between items.
+        // crossGap = CSS row-gap (row direction) or column-gap (column direction): gap between lines.
+        const double mainGap = isRow ? m_columnGap : m_rowGap;
+        const double crossGap = isRow ? m_rowGap : m_columnGap;
+
+        std::vector<FlexLine> lines;
+        {
+            FlexLine cur;
+            for (auto& item : items)
+            {
+                const bool forceBreak = doWrap && item.WrapBefore && !cur.Items.empty();
+                // Include the inter-item gap in the overflow check.
+                const double addedMain = cur.Items.empty() ? item.MainSize : mainGap + item.MainSize;
+                const bool overflow = doWrap && !mainInf && !cur.Items.empty()
+                    && (cur.MainSize + addedMain > mainAv + 0.001);
+
+                if (forceBreak || overflow)
+                {
+                    lines.push_back(std::move(cur));
+                    cur = FlexLine{};
+                }
+                cur.MainSize += cur.Items.empty() ? item.MainSize : mainGap + item.MainSize;
+                if (item.CrossSize > cur.CrossSize) cur.CrossSize = item.CrossSize;
+                cur.Items.push_back(std::move(item));
+            }
+            if (!cur.Items.empty()) lines.push_back(std::move(cur));
+        }
+
+        // ResolveFlexFactors — grow/shrink each line to the available main extent.
+        if (!mainInf)
+        {
+            for (auto& line : lines)
+            {
+                const double free = mainAv - line.MainSize;
+                if (free > 0.001)
+                {
+                    double totalGrow = 0;
+                    for (auto const& it : line.Items) totalGrow += it.FlexGrow;
+                    if (totalGrow > 0)
+                    {
+                        const double perUnit = free / totalGrow;
+                        double maxCross = 0;
+                        for (auto& it : line.Items)
+                        {
+                            if (it.FlexGrow > 0)
+                            {
+                                it.MainSize += it.FlexGrow * perUnit;
+                                const Size s = AsSize(it.MainSize, crossInf ? static_cast<double>(fInf) : crossAv, isRow);
+                                it.Element.Measure(s);
+                                it.CrossSize = CrossOf(it.Element.DesiredSize(), isRow);
+                            }
+                            if (it.CrossSize > maxCross) maxCross = it.CrossSize;
+                        }
+                        line.CrossSize = maxCross;
+                        line.MainSize += free;
+                    }
+                }
+                else if (free < -0.001)
+                {
+                    double totalShrink = 0;
+                    for (auto const& it : line.Items) totalShrink += it.FlexShrink * it.MainSize;
+                    if (totalShrink > 0)
+                    {
+                        double maxCross = 0;
+                        for (auto& it : line.Items)
+                        {
+                            if (it.FlexShrink > 0)
+                            {
+                                const double ratio = (it.FlexShrink * it.MainSize) / totalShrink;
+                                it.MainSize = (std::max)(0.0, it.MainSize + free * ratio);
+                                const Size s = AsSize(it.MainSize, crossInf ? static_cast<double>(fInf) : crossAv, isRow);
+                                it.Element.Measure(s);
+                                it.CrossSize = CrossOf(it.Element.DesiredSize(), isRow);
+                            }
+                            if (it.CrossSize > maxCross) maxCross = it.CrossSize;
+                        }
+                        line.CrossSize = maxCross;
+                    }
+                }
+            }
+        }
+
+        m_lines = std::move(lines);
+
+        double totalCross = 0;
+        for (auto const& l : m_lines) totalCross += l.CrossSize;
+        if (m_lines.size() > 1) totalCross += (m_lines.size() - 1) * crossGap;
+
+        double totalMain;
+        if (mainInf)
+        {
+            totalMain = 0;
+            for (auto const& l : m_lines) if (l.MainSize > totalMain) totalMain = l.MainSize;
+        }
+        else
+        {
+            totalMain = mainAv;
+        }
+
+        return AsSize(totalMain, totalCross, isRow);
+    }
+
+    // ── ArrangeOverride ──────────────────────────────────────────────────────
+    Size FlexboxLayout::ArrangeOverride(Size const& final)
+    {
+        if (m_lines.empty())
+        {
+            return final;
+        }
+
+        const bool isRow = IsRow();
+        const bool revMain = (m_flexDirection == DIR_ROW_REV || m_flexDirection == DIR_COL_REV);
+        const bool revWrap = (m_flexWrap == WRAP_REV);
+        const double mainFn = MainOf(final, isRow);
+        const double crossFn = CrossOf(final, isRow);
+
+        // Gaps: main-axis between items, cross-axis between lines.
+        const double mainGap  = isRow ? m_columnGap : m_rowGap;
+        const double crossGap = isRow ? m_rowGap    : m_columnGap;
+
+        const int lineCount = static_cast<int>(m_lines.size());
+        double totalCross = 0;
+        for (auto const& l : m_lines) totalCross += l.CrossSize;
+        if (lineCount > 1) totalCross += (lineCount - 1) * crossGap;
+        const double freeCross = crossFn - totalCross;
+        const double stretchExtra = (m_alignContent == CONTENT_STRETCH && freeCross > 0 && lineCount > 0)
+            ? freeCross / lineCount
+            : 0.0;
+
+        // ComputeLineOffsets — cross-axis position/size of each visual line slot.
+        std::vector<double> lineStart(lineCount, 0.0);
+        std::vector<double> lineSize(lineCount, 0.0);
+        {
+            // acGap = extra space per slot from align-content (on top of fixed crossGap).
+            double pos = 0, acGap = 0;
+            switch (m_alignContent)
+            {
+            case CONTENT_END:           pos = freeCross; break;
+            case CONTENT_CENTER:        pos = freeCross / 2.0; break;
+            case CONTENT_SPACE_BETWEEN: acGap = lineCount > 1 ? freeCross / (lineCount - 1) : 0.0; break;
+            case CONTENT_SPACE_AROUND:  acGap = lineCount > 0 ? freeCross / lineCount : 0.0; pos = acGap / 2.0; break;
+            case CONTENT_SPACE_EVENLY:  acGap = lineCount > 0 ? freeCross / (lineCount + 1) : 0.0; pos = acGap; break;
+            default: break;
+            }
+            for (int vi = 0; vi < lineCount; vi++)
+            {
+                const int li = revWrap ? (lineCount - 1 - vi) : vi;
+                const double sz = m_lines[li].CrossSize + stretchExtra;
+                lineStart[vi] = pos;
+                lineSize[vi] = sz;
+                pos += sz + crossGap + acGap;
+            }
+        }
+
+        for (int vi = 0; vi < lineCount; vi++)
+        {
+            const int li = revWrap ? (lineCount - 1 - vi) : vi;
+            FlexLine& line = m_lines[li];
+            const double crossStart = lineStart[vi];
+            const double lineCross = lineSize[vi];
+
+            // ComputeMainPositions — main-axis position of each visual item slot.
+            // Reuse scratch buffer to avoid per-line heap allocation.
+            const int n = static_cast<int>(line.Items.size());
+            m_scratchMainPos.resize(n);
+            {
+                // line.MainSize already includes (n-1)*mainGap from MeasureOverride.
+                // free is what remains for justify-content to distribute.
+                const double free = mainFn - line.MainSize;
+                // jcGap = extra space per inter-item slot from justify-content (adds to fixed mainGap).
+                double cur = 0, jcGap = 0;
+                switch (m_justifyContent)
+                {
+                case JUSTIFY_END:           cur = free; break;
+                case JUSTIFY_CENTER:        cur = free / 2.0; break;
+                case JUSTIFY_SPACE_BETWEEN: jcGap = n > 1 ? free / (n - 1) : 0.0; break;
+                case JUSTIFY_SPACE_AROUND:  jcGap = n > 0 ? free / n : 0.0; cur = jcGap / 2.0; break;
+                case JUSTIFY_SPACE_EVENLY:  jcGap = n > 0 ? free / (n + 1) : 0.0; cur = jcGap; break;
+                default: break;
+                }
+                for (int vj = 0; vj < n; vj++)
+                {
+                    const int lj = revMain ? (n - 1 - vj) : vj;
+                    m_scratchMainPos[vj] = cur;
+                    cur += line.Items[lj].MainSize + mainGap + jcGap;
+                }
+            }
+
+            for (int vj = 0; vj < n; vj++)
+            {
+                const int lj = revMain ? (n - 1 - vj) : vj;
+                FlexItem& item = line.Items[lj];
+
+                const int align = (item.AlignSelf == ALIGN_AUTO) ? m_alignItems : item.AlignSelf;
+                double crossPos, itemCross;
+
+                switch (align)
+                {
+                case ALIGN_END:
+                    itemCross = item.CrossSize;
+                    crossPos = crossStart + lineCross - itemCross;
+                    break;
+                case ALIGN_CENTER:
+                    itemCross = item.CrossSize;
+                    crossPos = crossStart + (lineCross - itemCross) / 2.0;
+                    break;
+                case ALIGN_STRETCH:
+                    itemCross = lineCross;
+                    crossPos = crossStart;
+                    // Re-measure at the stretched cross size only if it changed to avoid redundant WinRT calls.
+                    if (std::abs(item.CrossSize - lineCross) > 0.5)
+                    {
+                        item.Element.Measure(AsSize(item.MainSize, lineCross, isRow));
+                    }
+                    break;
+                default: // ALIGN_START, ALIGN_BASELINE
+                    itemCross = item.CrossSize;
+                    crossPos = crossStart;
+                    break;
+                }
+
+                item.Element.Arrange(AsRect(m_scratchMainPos[vj], crossPos, item.MainSize, itemCross, isRow));
+            }
+        }
+
+        return final;
+    }
+}
diff --git a/packages/ui-mobile-base/windows/widgets-cpp/FlexboxLayout.h b/packages/ui-mobile-base/windows/widgets-cpp/FlexboxLayout.h
new file mode 100644
index 0000000000..bd4ba941b2
--- /dev/null
+++ b/packages/ui-mobile-base/windows/widgets-cpp/FlexboxLayout.h
@@ -0,0 +1,108 @@
+#pragma once
+#include "FlexboxLayout.g.h"
+#include <vector>
+
+namespace winrt::NativeScript::Widgets::implementation
+{
+    struct FlexboxLayout : FlexboxLayoutT<FlexboxLayout>
+    {
+        FlexboxLayout() = default;
+
+        // ── Container properties (changing any re-measures) ──────────────────
+        int32_t FlexDirection() const noexcept { return m_flexDirection; }
+        void FlexDirection(int32_t v) { if (m_flexDirection != v) { m_flexDirection = v; InvalidateMeasure(); } }
+
+        int32_t FlexWrap() const noexcept { return m_flexWrap; }
+        void FlexWrap(int32_t v) { if (m_flexWrap != v) { m_flexWrap = v; InvalidateMeasure(); } }
+
+        int32_t JustifyContent() const noexcept { return m_justifyContent; }
+        void JustifyContent(int32_t v) { if (m_justifyContent != v) { m_justifyContent = v; InvalidateMeasure(); } }
+
+        int32_t AlignItems() const noexcept { return m_alignItems; }
+        void AlignItems(int32_t v) { if (m_alignItems != v) { m_alignItems = v; InvalidateMeasure(); } }
+
+        int32_t AlignContent() const noexcept { return m_alignContent; }
+        void AlignContent(int32_t v) { if (m_alignContent != v) { m_alignContent = v; InvalidateMeasure(); } }
+
+        double ColumnGap() const noexcept { return m_columnGap; }
+        void ColumnGap(double v) { if (m_columnGap != v) { m_columnGap = v; InvalidateMeasure(); } }
+
+        double RowGap() const noexcept { return m_rowGap; }
+        void RowGap(double v) { if (m_rowGap != v) { m_rowGap = v; InvalidateMeasure(); } }
+
+        // ── Layout ───────────────────────────────────────────────────────────
+        winrt::Windows::Foundation::Size MeasureOverride(winrt::Windows::Foundation::Size const& availableSize);
+        winrt::Windows::Foundation::Size ArrangeOverride(winrt::Windows::Foundation::Size const& finalSize);
+
+        // ── Attached properties (per child) — static accessors used by JS ────
+        static int32_t GetOrder(winrt::Microsoft::UI::Xaml::UIElement const& e);
+        static void SetOrder(winrt::Microsoft::UI::Xaml::UIElement const& e, int32_t v);
+        static double GetFlexGrow(winrt::Microsoft::UI::Xaml::UIElement const& e);
+        static void SetFlexGrow(winrt::Microsoft::UI::Xaml::UIElement const& e, double v);
+        static double GetFlexShrink(winrt::Microsoft::UI::Xaml::UIElement const& e);
+        static void SetFlexShrink(winrt::Microsoft::UI::Xaml::UIElement const& e, double v);
+        static int32_t GetAlignSelf(winrt::Microsoft::UI::Xaml::UIElement const& e);
+        static void SetAlignSelf(winrt::Microsoft::UI::Xaml::UIElement const& e, int32_t v);
+        static double GetFlexBasisPercent(winrt::Microsoft::UI::Xaml::UIElement const& e);
+        static void SetFlexBasisPercent(winrt::Microsoft::UI::Xaml::UIElement const& e, double v);
+        static bool GetWrapBefore(winrt::Microsoft::UI::Xaml::UIElement const& e);
+        static void SetWrapBefore(winrt::Microsoft::UI::Xaml::UIElement const& e, bool v);
+
+    private:
+        // Lazily-registered attached DependencyProperties (one-time, thread-safe via function-local
+        // statics). Not projected — internal storage + change notification only.
+        static winrt::Microsoft::UI::Xaml::DependencyProperty OrderProperty();
+        static winrt::Microsoft::UI::Xaml::DependencyProperty FlexGrowProperty();
+        static winrt::Microsoft::UI::Xaml::DependencyProperty FlexShrinkProperty();
+        static winrt::Microsoft::UI::Xaml::DependencyProperty AlignSelfProperty();
+        static winrt::Microsoft::UI::Xaml::DependencyProperty FlexBasisPercentProperty();
+        static winrt::Microsoft::UI::Xaml::DependencyProperty WrapBeforeProperty();
+
+        // When a child's flex attached property changes, re-measure the owning FlexboxLayout.
+        static void OnChildPropertyChanged(winrt::Microsoft::UI::Xaml::DependencyObject const& d,
+                                           winrt::Microsoft::UI::Xaml::DependencyPropertyChangedEventArgs const& e);
+
+        int32_t m_flexDirection{ 0 };  // row
+        int32_t m_flexWrap{ 0 };       // nowrap
+        int32_t m_justifyContent{ 0 }; // flex-start
+        int32_t m_alignItems{ 4 };     // stretch
+        int32_t m_alignContent{ 5 };   // stretch
+        double  m_columnGap{ 0.0 };    // gap between items along the main axis (CSS column-gap)
+        double  m_rowGap{ 0.0 };       // gap between flex lines along the cross axis (CSS row-gap)
+
+        bool IsRow() const noexcept { return m_flexDirection == 0 || m_flexDirection == 1; }
+
+        struct FlexItem
+        {
+            winrt::Microsoft::UI::Xaml::UIElement Element{ nullptr };
+            int32_t OriginalIndex{ 0 };
+            int32_t Order{ 1 };            // cached from DependencyProperty — avoids per-comparison WinRT reads
+            double FlexGrow{ 0.0 };
+            double FlexShrink{ 1.0 };
+            double FlexBasisPercent{ -1.0 };
+            int32_t AlignSelf{ -1 };
+            bool WrapBefore{ false };
+            double MainSize{ 0.0 };
+            double CrossSize{ 0.0 };
+        };
+
+        struct FlexLine
+        {
+            std::vector<FlexItem> Items;
+            double MainSize{ 0.0 };
+            double CrossSize{ 0.0 };
+        };
+
+        // Cached between Measure and Arrange (XAML layout is single-threaded).
+        std::vector<FlexLine> m_lines;
+        // Reused scratch buffer for ArrangeOverride main-axis positions (avoids per-line heap allocation).
+        std::vector<double> m_scratchMainPos;
+    };
+}
+
+namespace winrt::NativeScript::Widgets::factory_implementation
+{
+    struct FlexboxLayout : FlexboxLayoutT<FlexboxLayout, implementation::FlexboxLayout>
+    {
+    };
+}
diff --git a/packages/ui-mobile-base/windows/widgets-cpp/FlexboxLayout.idl b/packages/ui-mobile-base/windows/widgets-cpp/FlexboxLayout.idl
new file mode 100644
index 0000000000..9fddc3f995
--- /dev/null
+++ b/packages/ui-mobile-base/windows/widgets-cpp/FlexboxLayout.idl
@@ -0,0 +1,41 @@
+namespace NativeScript.Widgets
+{
+    // CSS Flexible Box Layout (flexbox) as a WinUI3 (Microsoft.UI.Xaml) Panel. Direct C++ measure/
+    // arrange — the JS layout class is a thin wrapper. Replaces the legacy C# FlexboxLayout, which
+    // derived from the UWP Windows.UI.Xaml.Controls.Panel and so was incompatible with the WinUI3
+    // visual tree. Integer enums are kept in sync with the TS maps in flexbox-layout/index.windows.ts:
+    //   FlexDirection  0=row 1=row-reverse 2=column 3=column-reverse
+    //   FlexWrap       0=nowrap 1=wrap 2=wrap-reverse
+    //   JustifyContent 0=flex-start 1=flex-end 2=center 3=space-between 4=space-around 5=space-evenly
+    //   AlignItems     0=flex-start 1=flex-end 2=center 3=baseline 4=stretch
+    //   AlignContent   0=flex-start 1=flex-end 2=center 3=space-between 4=space-around 5=stretch 6=space-evenly
+    //   AlignSelf      -1=auto + the AlignItems values
+    // ColumnGap/RowGap are CSS gap values in DIPs (column-gap = between items, row-gap = between lines).
+    [default_interface]
+    runtimeclass FlexboxLayout : Microsoft.UI.Xaml.Controls.Panel
+    {
+        FlexboxLayout();
+
+        Int32 FlexDirection;
+        Int32 FlexWrap;
+        Int32 JustifyContent;
+        Int32 AlignItems;
+        Int32 AlignContent;
+        Double ColumnGap;
+        Double RowGap;
+
+        // Per-child attached properties (set by JS via these static accessors).
+        static Int32 GetOrder(Microsoft.UI.Xaml.UIElement element);
+        static void SetOrder(Microsoft.UI.Xaml.UIElement element, Int32 value);
+        static Double GetFlexGrow(Microsoft.UI.Xaml.UIElement element);
+        static void SetFlexGrow(Microsoft.UI.Xaml.UIElement element, Double value);
+        static Double GetFlexShrink(Microsoft.UI.Xaml.UIElement element);
+        static void SetFlexShrink(Microsoft.UI.Xaml.UIElement element, Double value);
+        static Int32 GetAlignSelf(Microsoft.UI.Xaml.UIElement element);
+        static void SetAlignSelf(Microsoft.UI.Xaml.UIElement element, Int32 value);
+        static Double GetFlexBasisPercent(Microsoft.UI.Xaml.UIElement element);
+        static void SetFlexBasisPercent(Microsoft.UI.Xaml.UIElement element, Double value);
+        static Boolean GetWrapBefore(Microsoft.UI.Xaml.UIElement element);
+        static void SetWrapBefore(Microsoft.UI.Xaml.UIElement element, Boolean value);
+    }
+}
diff --git a/packages/ui-mobile-base/windows/widgets-cpp/ImageHelper.cpp b/packages/ui-mobile-base/windows/widgets-cpp/ImageHelper.cpp
new file mode 100644
index 0000000000..94f6b445ef
--- /dev/null
+++ b/packages/ui-mobile-base/windows/widgets-cpp/ImageHelper.cpp
@@ -0,0 +1,117 @@
+#include "pch.h"
+#include "ImageResult.h"
+#include "ImageHelper.h"
+#include "ImageResult.g.cpp"
+#include "ImageHelper.g.cpp"
+
+#include <algorithm>
+#include <cmath>
+
+using namespace winrt;
+using namespace winrt::Windows::Foundation;
+using namespace winrt::Windows::Storage;
+using namespace winrt::Windows::Storage::Streams;
+using namespace winrt::Windows::Graphics::Imaging;
+using BitmapImage = winrt::Microsoft::UI::Xaml::Media::Imaging::BitmapImage;
+
+// THREADING: these coroutines deliberately do NOT resume_background(). The NativeScript Windows
+// runtime hosts V8 on the UI thread and only marshals WinRT async `Completed` callbacks back into
+// JS when they fire on that (UI) apartment. WinRT async operations started on the UI apartment
+// marshal their completion back to it automatically, so awaiting them inline keeps every resume on
+// the UI thread — which is also where the UI-affine BitmapImage must be created. Hopping to a
+// background thread (resume_background) would make the final completion fire on a pool thread where
+// the runtime's thread-local isolate pointer is null, so the JS promise would silently never settle.
+// The awaited ops are themselves async (non-blocking), so the UI thread is not stalled.
+
+namespace
+{
+    // Copy an IBuffer into a fresh in-memory stream, rewound to the start.
+    IAsyncOperation<InMemoryRandomAccessStream> WriteToStreamAsync(IBuffer buffer)
+    {
+        InMemoryRandomAccessStream stream;
+        co_await stream.WriteAsync(buffer);
+        stream.Seek(0);
+        co_return stream;
+    }
+
+    IAsyncOperation<BitmapImage> BitmapFromStreamAsync(IRandomAccessStream stream)
+    {
+        try { stream.Seek(0); }
+        catch (...) {}
+        BitmapImage bmp;
+        co_await bmp.SetSourceAsync(stream);
+        co_return bmp;
+    }
+}
+
+namespace winrt::NativeScript::Widgets::implementation
+{
+    IAsyncOperation<winrt::NativeScript::Widgets::ImageResult> ImageHelper::LoadFromBufferAsync(IBuffer buffer)
+    {
+        auto stream = co_await WriteToStreamAsync(buffer);
+        auto bmp = co_await BitmapFromStreamAsync(stream);
+        co_return winrt::make<ImageResult>(bmp, buffer, bmp.PixelWidth(), bmp.PixelHeight());
+    }
+
+    IAsyncOperation<winrt::NativeScript::Widgets::ImageResult> ImageHelper::LoadFromUrlAsync(hstring url)
+    {
+        winrt::Windows::Web::Http::HttpClient client;
+        auto buffer = co_await client.GetBufferAsync(Uri{ url });
+        auto stream = co_await WriteToStreamAsync(buffer);
+        auto bmp = co_await BitmapFromStreamAsync(stream);
+        co_return winrt::make<ImageResult>(bmp, buffer, bmp.PixelWidth(), bmp.PixelHeight());
+    }
+
+    IAsyncOperation<winrt::NativeScript::Widgets::ImageResult> ImageHelper::LoadFromFileAsync(hstring path)
+    {
+        auto buffer = co_await PathIO::ReadBufferAsync(path);
+        auto stream = co_await WriteToStreamAsync(buffer);
+        auto bmp = co_await BitmapFromStreamAsync(stream);
+        co_return winrt::make<ImageResult>(bmp, buffer, bmp.PixelWidth(), bmp.PixelHeight());
+    }
+
+    IAsyncOperation<winrt::NativeScript::Widgets::ImageResult> ImageHelper::ResizeAsync(IBuffer buffer, int32_t maxSize)
+    {
+        auto inStream = co_await WriteToStreamAsync(buffer);
+        auto decoder = co_await BitmapDecoder::CreateAsync(inStream);
+
+        const uint32_t srcW = decoder.PixelWidth();
+        const uint32_t srcH = decoder.PixelHeight();
+        const double scale = static_cast<double>(maxSize) / (std::max)(srcW, srcH);
+        const uint32_t dstW = static_cast<uint32_t>(std::lround(srcW * scale));
+        const uint32_t dstH = static_cast<uint32_t>(std::lround(srcH * scale));
+
+        InMemoryRandomAccessStream outStream;
+        auto encoder = co_await BitmapEncoder::CreateForTranscodingAsync(outStream, decoder);
+        encoder.BitmapTransform().ScaledWidth(dstW);
+        encoder.BitmapTransform().ScaledHeight(dstH);
+        co_await encoder.FlushAsync();
+
+        outStream.Seek(0);
+        auto bmp = co_await BitmapFromStreamAsync(outStream);
+
+        outStream.Seek(0);
+        DataReader reader{ outStream };
+        co_await reader.LoadAsync(static_cast<uint32_t>(outStream.Size()));
+        auto outBuffer = reader.DetachBuffer();
+
+        co_return winrt::make<ImageResult>(bmp, outBuffer, static_cast<int32_t>(dstW), static_cast<int32_t>(dstH));
+    }
+
+    IAsyncOperation<bool> ImageHelper::SaveToFileAsync(IBuffer buffer, hstring path)
+    {
+        co_await PathIO::WriteBufferAsync(path, buffer);
+        co_return true;
+    }
+
+    IAsyncOperation<IBuffer> ImageHelper::ReadFileAsync(hstring path)
+    {
+        // Single native call — return the operation directly.
+        return PathIO::ReadBufferAsync(path);
+    }
+
+    hstring ImageHelper::BufferToBase64(IBuffer buffer)
+    {
+        return winrt::Windows::Security::Cryptography::CryptographicBuffer::EncodeToBase64String(buffer);
+    }
+}
diff --git a/packages/ui-mobile-base/windows/widgets-cpp/ImageHelper.h b/packages/ui-mobile-base/windows/widgets-cpp/ImageHelper.h
new file mode 100644
index 0000000000..6ae642ecc6
--- /dev/null
+++ b/packages/ui-mobile-base/windows/widgets-cpp/ImageHelper.h
@@ -0,0 +1,34 @@
+#pragma once
+#include "ImageHelper.g.h"
+
+namespace winrt::NativeScript::Widgets::implementation
+{
+    // Static-class implementation: the generated projected statics + the factory both call these
+    // static methods. (For a `static runtimeclass`, cppwinrt only emits a base in
+    // factory_implementation, so this implementation type is a plain struct of static methods.)
+    struct ImageHelper
+    {
+        ImageHelper() = default;
+
+        static winrt::Windows::Foundation::IAsyncOperation<winrt::NativeScript::Widgets::ImageResult>
+            LoadFromBufferAsync(winrt::Windows::Storage::Streams::IBuffer buffer);
+        static winrt::Windows::Foundation::IAsyncOperation<winrt::NativeScript::Widgets::ImageResult>
+            LoadFromUrlAsync(winrt::hstring url);
+        static winrt::Windows::Foundation::IAsyncOperation<winrt::NativeScript::Widgets::ImageResult>
+            LoadFromFileAsync(winrt::hstring path);
+        static winrt::Windows::Foundation::IAsyncOperation<winrt::NativeScript::Widgets::ImageResult>
+            ResizeAsync(winrt::Windows::Storage::Streams::IBuffer buffer, int32_t maxSize);
+        static winrt::Windows::Foundation::IAsyncOperation<bool>
+            SaveToFileAsync(winrt::Windows::Storage::Streams::IBuffer buffer, winrt::hstring path);
+        static winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IBuffer>
+            ReadFileAsync(winrt::hstring path);
+        static winrt::hstring BufferToBase64(winrt::Windows::Storage::Streams::IBuffer buffer);
+    };
+}
+
+namespace winrt::NativeScript::Widgets::factory_implementation
+{
+    struct ImageHelper : ImageHelperT<ImageHelper, implementation::ImageHelper>
+    {
+    };
+}
diff --git a/packages/ui-mobile-base/windows/widgets-cpp/ImageHelper.idl b/packages/ui-mobile-base/windows/widgets-cpp/ImageHelper.idl
new file mode 100644
index 0000000000..39354c1426
--- /dev/null
+++ b/packages/ui-mobile-base/windows/widgets-cpp/ImageHelper.idl
@@ -0,0 +1,26 @@
+namespace NativeScript.Widgets
+{
+    // Result of an image load/resize: a WinUI3 BitmapImage (UI-thread object) plus the raw encoded
+    // bytes and pixel dimensions. Created internally by ImageHelper (no public constructor).
+    runtimeclass ImageResult
+    {
+        Microsoft.UI.Xaml.Media.Imaging.BitmapImage Bitmap{ get; };
+        Windows.Storage.Streams.IBuffer RawBuffer{ get; };
+        Int32 Width{ get; };
+        Int32 Height{ get; };
+    }
+
+    // Static image utilities. Bitmaps are created on the UI thread (BitmapImage has thread affinity);
+    // decode/encode/IO run on a background thread. Replaces the C# ImageHelper, which returned the
+    // UWP Windows.UI.Xaml BitmapImage (incompatible with the WinUI3 Image control).
+    static runtimeclass ImageHelper
+    {
+        static Windows.Foundation.IAsyncOperation<ImageResult> LoadFromBufferAsync(Windows.Storage.Streams.IBuffer buffer);
+        static Windows.Foundation.IAsyncOperation<ImageResult> LoadFromUrlAsync(String url);
+        static Windows.Foundation.IAsyncOperation<ImageResult> LoadFromFileAsync(String path);
+        static Windows.Foundation.IAsyncOperation<ImageResult> ResizeAsync(Windows.Storage.Streams.IBuffer buffer, Int32 maxSize);
+        static Windows.Foundation.IAsyncOperation<Boolean> SaveToFileAsync(Windows.Storage.Streams.IBuffer buffer, String path);
+        static Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IBuffer> ReadFileAsync(String path);
+        static String BufferToBase64(Windows.Storage.Streams.IBuffer buffer);
+    }
+}
diff --git a/packages/ui-mobile-base/windows/widgets-cpp/ImageResult.h b/packages/ui-mobile-base/windows/widgets-cpp/ImageResult.h
new file mode 100644
index 0000000000..e62bd34ead
--- /dev/null
+++ b/packages/ui-mobile-base/windows/widgets-cpp/ImageResult.h
@@ -0,0 +1,25 @@
+#pragma once
+#include "ImageResult.g.h"
+
+namespace winrt::NativeScript::Widgets::implementation
+{
+    struct ImageResult : ImageResultT<ImageResult>
+    {
+        ImageResult() = default;
+        ImageResult(winrt::Microsoft::UI::Xaml::Media::Imaging::BitmapImage const& bitmap,
+                    winrt::Windows::Storage::Streams::IBuffer const& rawBuffer,
+                    int32_t width, int32_t height)
+            : m_bitmap(bitmap), m_rawBuffer(rawBuffer), m_width(width), m_height(height) {}
+
+        winrt::Microsoft::UI::Xaml::Media::Imaging::BitmapImage Bitmap() const { return m_bitmap; }
+        winrt::Windows::Storage::Streams::IBuffer RawBuffer() const { return m_rawBuffer; }
+        int32_t Width() const { return m_width; }
+        int32_t Height() const { return m_height; }
+
+    private:
+        winrt::Microsoft::UI::Xaml::Media::Imaging::BitmapImage m_bitmap{ nullptr };
+        winrt::Windows::Storage::Streams::IBuffer m_rawBuffer{ nullptr };
+        int32_t m_width{ 0 };
+        int32_t m_height{ 0 };
+    };
+}
diff --git a/packages/ui-mobile-base/windows/widgets-cpp/NativeScript.Widgets.vcxproj b/packages/ui-mobile-base/windows/widgets-cpp/NativeScript.Widgets.vcxproj
new file mode 100644
index 0000000000..bda170e80b
--- /dev/null
+++ b/packages/ui-mobile-base/windows/widgets-cpp/NativeScript.Widgets.vcxproj
@@ -0,0 +1,116 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <CppWinRTOptimized>true</CppWinRTOptimized>
+    <CppWinRTRootNamespaceAutoMerge>true</CppWinRTRootNamespaceAutoMerge>
+    <CppWinRTGenerateWindowsMetadata>true</CppWinRTGenerateWindowsMetadata>
+    <MinimalCoreWin>true</MinimalCoreWin>
+    <ProjectGuid>{B6D1F2A0-0E2C-4C7E-9D2B-7A1E5C9D0001}</ProjectGuid>
+    <ProjectName>NativeScript.Widgets</ProjectName>
+    <RootNamespace>NativeScript.Widgets</RootNamespace>
+    <TargetName>NativeScript.Widgets</TargetName>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <WindowsTargetPlatformVersion>10.0.26100.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformMinVersion>10.0.17763.0</WindowsTargetPlatformMinVersion>
+    <RestoreProjectStyle>PackageReference</RestoreProjectStyle>
+    <AppContainerApplication>false</AppContainerApplication>
+    <Desktop>true</Desktop>
+  </PropertyGroup>
+
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <PlatformToolset>v145</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+    <UseWinUI>true</UseWinUI>
+    <UseLegacyMallocAlign>false</UseLegacyMallocAlign>
+    <UseDebugLibraries Condition="'$(Configuration)'=='Debug'">true</UseDebugLibraries>
+    <UseDebugLibraries Condition="'$(Configuration)'!='Debug'">false</UseDebugLibraries>
+    <WholeProgramOptimization Condition="'$(Configuration)'=='Release'">true</WholeProgramOptimization>
+  </PropertyGroup>
+
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <LanguageStandard>stdcpp20</LanguageStandard>
+      <WarningLevel>Level4</WarningLevel>
+      <!-- C++20 has standard coroutines (std::coroutine_handle), so the deprecated /await is gone. -->
+      <AdditionalOptions>%(AdditionalOptions) /bigobj</AdditionalOptions>
+      <!-- Static CRT so the in-proc server has NO external VCRUNTIME140.dll dependency (the package
+           carries no VC++ redist / VCLibs framework dep). WinRT components talk over the COM ABI,
+           not CRT objects, so static linking is safe here. -->
+      <RuntimeLibrary Condition="'$(Configuration)'=='Debug'">MultiThreadedDebug</RuntimeLibrary>
+      <RuntimeLibrary Condition="'$(Configuration)'!='Debug'">MultiThreaded</RuntimeLibrary>
+      <!-- Put the project root on the include path so the cppwinrt-generated files under
+           "Generated Files\" (module.g.cpp, *.g.h) can resolve our project-root pch.h. -->
+      <AdditionalIncludeDirectories>$(MSBuildProjectDirectory);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+    </Link>
+  </ItemDefinitionGroup>
+
+  <ItemGroup>
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="StackLayout.h" />
+    <ClInclude Include="FlexboxLayout.h" />
+    <ClInclude Include="ImageResult.h" />
+    <ClInclude Include="ImageHelper.h" />
+    <ClInclude Include="ShadowImageResult.h" />
+    <ClInclude Include="ShadowHelper.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="pch.cpp">
+      <PrecompiledHeader>Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="StackLayout.cpp" />
+    <ClCompile Include="FlexboxLayout.cpp" />
+    <ClCompile Include="ImageHelper.cpp" />
+    <ClCompile Include="ShadowHelper.cpp" />
+    <ClCompile Include="exports.cpp" />
+    <!-- cppwinrt generates module.g.cpp (DllGetActivationFactory / DllCanUnloadNow exports) under
+         "Generated Files\", but our hand-authored project doesn't auto-include it, so the DLL
+         exported no activation factory → RoGetActivationFactory failed with REGDB_E_CLASSNOTREG.
+         Compile it explicitly. NotUsing: it's generated and doesn't use our PCH. -->
+    <ClCompile Include="$(IntDir)Generated Files\module.g.cpp">
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Midl Include="StackLayout.idl" />
+    <Midl Include="FlexboxLayout.idl" />
+    <Midl Include="ImageHelper.idl" />
+    <Midl Include="ShadowHelper.idl" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Windows.CppWinRT" Version="2.0.240111.5" />
+    <PackageReference Include="Microsoft.WindowsAppSDK" Version="1.6.250205002" />
+    <PackageReference Include="Microsoft.Windows.SDK.BuildTools" Version="10.0.26100.1742" />
+  </ItemGroup>
+
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+</Project>
diff --git a/packages/ui-mobile-base/windows/widgets-cpp/ShadowHelper.cpp b/packages/ui-mobile-base/windows/widgets-cpp/ShadowHelper.cpp
new file mode 100644
index 0000000000..c2de69ad62
--- /dev/null
+++ b/packages/ui-mobile-base/windows/widgets-cpp/ShadowHelper.cpp
@@ -0,0 +1,208 @@
+#include "pch.h"
+#include "ShadowImageResult.h"
+#include "ShadowHelper.h"
+#include "ShadowImageResult.g.cpp"
+#include "ShadowHelper.g.cpp"
+
+#include <algorithm>
+#include <cmath>
+#include <vector>
+#include <cstdint>
+
+using namespace winrt;
+using namespace winrt::Windows::Graphics::Imaging;
+using namespace winrt::Microsoft::UI::Xaml::Controls;
+using namespace winrt::Microsoft::UI::Xaml::Media;
+using namespace winrt::Microsoft::UI::Xaml::Media::Imaging;
+
+// THREADING: synchronous by design. JS calls these on the UI/V8 thread, so the SoftwareBitmap /
+// SoftwareBitmapSource / Image are created inline on that thread. The blur is a small element-sized
+// buffer and the result is cached by the caller, so the on-thread cost is negligible. (The C#
+// version offloaded the blur with Parallel.For; here it's a plain serial loop — same output.)
+
+namespace
+{
+    inline int iround(double v) { return static_cast<int>(std::lround(v)); }
+    inline int iclamp(int v, int lo, int hi) { return v < lo ? lo : (v > hi ? hi : v); }
+
+    // True when (px,py) lies inside the rounded rect [x0,y0]-[x1,y1] with corner radius r.
+    bool inside_rounded_rect(float px, float py, float x0, float y0, float x1, float y1, float r)
+    {
+        if (px < x0 || px > x1 || py < y0 || py > y1) return false;
+        if (r <= 0) return true;
+        float cx = px < x0 + r ? x0 + r : (px > x1 - r ? x1 - r : px);
+        float cy = py < y0 + r ? y0 + r : (py > y1 - r ? y1 - r : py);
+        float dx = px - cx, dy = py - cy;
+        return dx * dx + dy * dy <= r * r;
+    }
+
+    void blur_h(const std::vector<float>& src, std::vector<float>& dst, int w, int h, int radius)
+    {
+        const float norm = 1.0f / (radius * 2 + 1);
+        for (int y = 0; y < h; y++)
+        {
+            const int row = y * w;
+            float acc = 0;
+            for (int i = -radius; i <= radius; i++) acc += src[row + iclamp(i, 0, w - 1)];
+            for (int x = 0; x < w; x++)
+            {
+                dst[row + x] = acc * norm;
+                acc += src[row + iclamp(x + radius + 1, 0, w - 1)] - src[row + iclamp(x - radius, 0, w - 1)];
+            }
+        }
+    }
+
+    void blur_v(const std::vector<float>& src, std::vector<float>& dst, int w, int h, int radius)
+    {
+        const float norm = 1.0f / (radius * 2 + 1);
+        for (int x = 0; x < w; x++)
+        {
+            float acc = 0;
+            for (int i = -radius; i <= radius; i++) acc += src[iclamp(i, 0, h - 1) * w + x];
+            for (int y = 0; y < h; y++)
+            {
+                dst[y * w + x] = acc * norm;
+                acc += src[iclamp(y + radius + 1, 0, h - 1) * w + x] - src[iclamp(y - radius, 0, h - 1) * w + x];
+            }
+        }
+    }
+
+    // Separable box blur, `passes` times (≈ Gaussian).
+    void box_blur(std::vector<float>& buf, int w, int h, int radius, int passes)
+    {
+        if (radius < 1) return;
+        std::vector<float> tmp(buf.size());
+        for (int p = 0; p < passes; p++)
+        {
+            blur_h(buf, tmp, w, h, radius);
+            blur_v(tmp, buf, w, h, radius);
+        }
+    }
+
+    // Wrap a premultiplied-BGRA8 buffer in a SoftwareBitmap → SoftwareBitmapSource → Image.
+    Image make_image(const std::vector<uint8_t>& bgra, int w, int h)
+    {
+        auto buffer = winrt::Windows::Security::Cryptography::CryptographicBuffer::CreateFromByteArray(
+            winrt::array_view<uint8_t const>(bgra.data(), bgra.data() + bgra.size()));
+        auto sb = SoftwareBitmap::CreateCopyFromBuffer(buffer, BitmapPixelFormat::Bgra8, w, h, BitmapAlphaMode::Premultiplied);
+
+        SoftwareBitmapSource source;
+        Image img;
+        img.Source(source);
+        img.Width(static_cast<double>(w));
+        img.Height(static_cast<double>(h));
+        img.Stretch(Stretch::Fill);
+        img.IsHitTestVisible(false);
+        source.SetBitmapAsync(sb); // fire-and-forget; Image repaints when the bitmap is ready
+        return img;
+    }
+}
+
+namespace winrt::NativeScript::Widgets::implementation
+{
+    winrt::NativeScript::Widgets::ShadowImageResult ShadowHelper::CreateShadow(
+        double width, double height, double blurRadius, double spread, double cornerRadius,
+        double offsetX, double offsetY, uint32_t argb)
+    {
+        const int sw = (std::max)(1, iround(width + spread * 2));
+        const int sh = (std::max)(1, iround(height + spread * 2));
+
+        const int boxRadius = (std::max)(1, iround(blurRadius * 0.5));
+        const int passes = 3;
+        const int overhang = boxRadius * passes + 1;
+
+        const int ox = iround(offsetX);
+        const int oy = iround(offsetY);
+        const int bw = sw + (overhang + std::abs(ox)) * 2;
+        const int bh = sh + (overhang + std::abs(oy)) * 2;
+
+        const float radius = static_cast<float>((std::max)(0.0, cornerRadius + spread));
+
+        const uint8_t a = static_cast<uint8_t>((argb >> 24) & 0xFF);
+        const uint8_t r = static_cast<uint8_t>((argb >> 16) & 0xFF);
+        const uint8_t g = static_cast<uint8_t>((argb >> 8) & 0xFF);
+        const uint8_t b = static_cast<uint8_t>(argb & 0xFF);
+
+        const int n = bw * bh;
+        std::vector<float> cov(n, 0.0f);
+        const float x0 = (bw - sw) / 2.0f + ox, y0 = (bh - sh) / 2.0f + oy, x1 = x0 + sw, y1 = y0 + sh;
+        const float rr = (std::min)(radius, (std::min)(sw / 2.0f, sh / 2.0f));
+
+        for (int y = 0; y < bh; y++)
+        {
+            const int row = y * bw;
+            for (int x = 0; x < bw; x++)
+                cov[row + x] = inside_rounded_rect(x + 0.5f, y + 0.5f, x0, y0, x1, y1, rr) ? 1.0f : 0.0f;
+        }
+
+        box_blur(cov, bw, bh, boxRadius, passes);
+
+        std::vector<uint8_t> bgra(static_cast<size_t>(n) * 4);
+        const float ca = a / 255.0f;
+        for (int i = 0; i < n; i++)
+        {
+            float alpha = cov[i] * ca;
+            alpha = alpha < 0.0f ? 0.0f : (alpha > 1.0f ? 1.0f : alpha);
+            const int o = i * 4;
+            bgra[o + 0] = static_cast<uint8_t>(b * alpha);
+            bgra[o + 1] = static_cast<uint8_t>(g * alpha);
+            bgra[o + 2] = static_cast<uint8_t>(r * alpha);
+            bgra[o + 3] = static_cast<uint8_t>(alpha * 255.0f);
+        }
+
+        auto img = make_image(bgra, bw, bh);
+        return winrt::make<ShadowImageResult>(img, static_cast<double>(bw), static_cast<double>(bh), static_cast<double>(overhang));
+    }
+
+    winrt::NativeScript::Widgets::ShadowImageResult ShadowHelper::CreateBorder(
+        double width, double height,
+        double topW, double rightW, double bottomW, double leftW,
+        uint32_t topArgb, uint32_t rightArgb, uint32_t bottomArgb, uint32_t leftArgb,
+        double cornerRadius)
+    {
+        const int w = (std::max)(1, iround(width));
+        const int h = (std::max)(1, iround(height));
+        const float tW = static_cast<float>((std::max)(0.0, topW));
+        const float rW = static_cast<float>((std::max)(0.0, rightW));
+        const float bW = static_cast<float>((std::max)(0.0, bottomW));
+        const float lW = static_cast<float>((std::max)(0.0, leftW));
+        const float r = static_cast<float>((std::max)(0.0, cornerRadius));
+        const float innerR = (std::max)(0.0f, r - (std::max)((std::max)(tW, bW), (std::max)(lW, rW)));
+
+        const int n = w * h;
+        std::vector<uint8_t> bgra(static_cast<size_t>(n) * 4, 0);
+
+        for (int y = 0; y < h; y++)
+        {
+            for (int x = 0; x < w; x++)
+            {
+                const float px = x + 0.5f, py = y + 0.5f;
+                const bool insideOuter = inside_rounded_rect(px, py, 0, 0, static_cast<float>(w), static_cast<float>(h), r);
+                const bool insideInner = inside_rounded_rect(px, py, lW, tW, w - rW, h - bW, innerR);
+                if (!insideOuter || insideInner) continue; // transparent (centre + outside)
+
+                // Nearest edge → 45° mitred corners (matches CSS for uniform widths).
+                const float dT = py, dB = h - py, dL = px, dR = w - px;
+                uint32_t c;
+                if (dT <= dB && dT <= dL && dT <= dR) c = topArgb;
+                else if (dB <= dL && dB <= dR) c = bottomArgb;
+                else if (dL <= dR) c = leftArgb;
+                else c = rightArgb;
+
+                const uint8_t a = static_cast<uint8_t>((c >> 24) & 0xFF);
+                const uint8_t rr = static_cast<uint8_t>((c >> 16) & 0xFF);
+                const uint8_t gg = static_cast<uint8_t>((c >> 8) & 0xFF);
+                const uint8_t bb = static_cast<uint8_t>(c & 0xFF);
+                const float af = a / 255.0f;
+                const int o = (y * w + x) * 4;
+                bgra[o + 0] = static_cast<uint8_t>(bb * af);
+                bgra[o + 1] = static_cast<uint8_t>(gg * af);
+                bgra[o + 2] = static_cast<uint8_t>(rr * af);
+                bgra[o + 3] = a;
+            }
+        }
+
+        auto img = make_image(bgra, w, h);
+        return winrt::make<ShadowImageResult>(img, static_cast<double>(w), static_cast<double>(h), 0.0);
+    }
+}
diff --git a/packages/ui-mobile-base/windows/widgets-cpp/ShadowHelper.h b/packages/ui-mobile-base/windows/widgets-cpp/ShadowHelper.h
new file mode 100644
index 0000000000..0fad15af9e
--- /dev/null
+++ b/packages/ui-mobile-base/windows/widgets-cpp/ShadowHelper.h
@@ -0,0 +1,28 @@
+#pragma once
+#include "ShadowHelper.g.h"
+
+namespace winrt::NativeScript::Widgets::implementation
+{
+    // Static-class implementation (see ImageHelper.h for the `static runtimeclass` codegen pattern).
+    struct ShadowHelper
+    {
+        ShadowHelper() = default;
+
+        static winrt::NativeScript::Widgets::ShadowImageResult CreateShadow(
+            double width, double height, double blurRadius, double spread, double cornerRadius,
+            double offsetX, double offsetY, uint32_t argb);
+
+        static winrt::NativeScript::Widgets::ShadowImageResult CreateBorder(
+            double width, double height,
+            double topW, double rightW, double bottomW, double leftW,
+            uint32_t topArgb, uint32_t rightArgb, uint32_t bottomArgb, uint32_t leftArgb,
+            double cornerRadius);
+    };
+}
+
+namespace winrt::NativeScript::Widgets::factory_implementation
+{
+    struct ShadowHelper : ShadowHelperT<ShadowHelper, implementation::ShadowHelper>
+    {
+    };
+}
diff --git a/packages/ui-mobile-base/windows/widgets-cpp/ShadowHelper.idl b/packages/ui-mobile-base/windows/widgets-cpp/ShadowHelper.idl
new file mode 100644
index 0000000000..f0808876c8
--- /dev/null
+++ b/packages/ui-mobile-base/windows/widgets-cpp/ShadowHelper.idl
@@ -0,0 +1,26 @@
+namespace NativeScript.Widgets
+{
+    // Result of a shadow/border render: a ready-to-place WinUI3 Image plus positioning metrics.
+    // The Image is `Overhang` DIPs larger than the element on every side (blur bleed + spread).
+    runtimeclass ShadowImageResult
+    {
+        Microsoft.UI.Xaml.Controls.Image Image{ get; };
+        Double Width{ get; };
+        Double Height{ get; };
+        Double Overhang{ get; };
+    }
+
+    // Renders CSS box-shadow (Gaussian-blurred rounded silhouette) and per-side borders as native
+    // WinUI3 bitmaps (Image). Replaces the C# ShadowHelper, which produced a UWP Windows.UI.Xaml
+    // Image incompatible with the WinUI3 visual tree. Synchronous by design: JS invokes on the UI
+    // thread, so the SoftwareBitmap/SoftwareBitmapSource/Image are created inline; the blur is a
+    // small (element-sized) buffer and the result is cached by the caller. argb is 0xAARRGGBB.
+    static runtimeclass ShadowHelper
+    {
+        static ShadowImageResult CreateShadow(Double width, Double height, Double blurRadius, Double spread,
+            Double cornerRadius, Double offsetX, Double offsetY, UInt32 argb);
+        static ShadowImageResult CreateBorder(Double width, Double height,
+            Double topW, Double rightW, Double bottomW, Double leftW,
+            UInt32 topArgb, UInt32 rightArgb, UInt32 bottomArgb, UInt32 leftArgb, Double cornerRadius);
+    }
+}
diff --git a/packages/ui-mobile-base/windows/widgets-cpp/ShadowImageResult.h b/packages/ui-mobile-base/windows/widgets-cpp/ShadowImageResult.h
new file mode 100644
index 0000000000..038017db38
--- /dev/null
+++ b/packages/ui-mobile-base/windows/widgets-cpp/ShadowImageResult.h
@@ -0,0 +1,24 @@
+#pragma once
+#include "ShadowImageResult.g.h"
+
+namespace winrt::NativeScript::Widgets::implementation
+{
+    struct ShadowImageResult : ShadowImageResultT<ShadowImageResult>
+    {
+        ShadowImageResult() = default;
+        ShadowImageResult(winrt::Microsoft::UI::Xaml::Controls::Image const& image,
+                          double width, double height, double overhang)
+            : m_image(image), m_width(width), m_height(height), m_overhang(overhang) {}
+
+        winrt::Microsoft::UI::Xaml::Controls::Image Image() const { return m_image; }
+        double Width() const { return m_width; }
+        double Height() const { return m_height; }
+        double Overhang() const { return m_overhang; }
+
+    private:
+        winrt::Microsoft::UI::Xaml::Controls::Image m_image{ nullptr };
+        double m_width{ 0 };
+        double m_height{ 0 };
+        double m_overhang{ 0 };
+    };
+}
diff --git a/packages/ui-mobile-base/windows/widgets-cpp/StackLayout.cpp b/packages/ui-mobile-base/windows/widgets-cpp/StackLayout.cpp
new file mode 100644
index 0000000000..f478310b29
--- /dev/null
+++ b/packages/ui-mobile-base/windows/widgets-cpp/StackLayout.cpp
@@ -0,0 +1,101 @@
+#include "pch.h"
+#include "StackLayout.h"
+#include "StackLayout.g.cpp"
+
+#include <algorithm>
+#include <limits>
+#include <vector>
+
+using namespace winrt;
+using namespace winrt::Windows::Foundation;
+using namespace winrt::Microsoft::UI::Xaml;
+
+namespace winrt::NativeScript::Widgets::implementation
+{
+    // A child "fills" the main axis when its main-axis alignment is Stretch (e.g. a ScrollView with
+    // height:100% in a vertical stack — the Windows View maps 100% → Stretch). Such a child is sized
+    // to the space the stack actually has left, which is what gives a ScrollView a bounded, scrollable
+    // viewport — no JS clamp needed.
+    static bool IsMainStretch(UIElement const& child, bool vertical)
+    {
+        if (auto fe = child.try_as<FrameworkElement>())
+        {
+            return vertical ? (fe.VerticalAlignment() == VerticalAlignment::Stretch)
+                            : (fe.HorizontalAlignment() == HorizontalAlignment::Stretch);
+        }
+        return false;
+    }
+
+    Size StackLayout::MeasureOverride(Size const& availableSize)
+    {
+        const bool vertical = (m_orientation == 0);
+        const float inf = std::numeric_limits<float>::infinity();
+        const float mainAvail = vertical ? availableSize.Height : availableSize.Width;
+        const float crossAvail = vertical ? availableSize.Width : availableSize.Height;
+        const bool mainBounded = std::isfinite(mainAvail);
+
+        float usedMain = 0.0f;
+        float maxCross = 0.0f;
+        std::vector<UIElement> fillChildren;
+
+        // Pass 1: content children take their natural main size (measured with unbounded main).
+        // Main-axis fill children are deferred — they only make sense when the main axis is bounded.
+        for (auto const& child : Children())
+        {
+            if (child.Visibility() == Visibility::Collapsed)
+            {
+                continue;
+            }
+            if (mainBounded && IsMainStretch(child, vertical))
+            {
+                fillChildren.push_back(child);
+                continue;
+            }
+            const Size childAvail = vertical ? Size{ crossAvail, inf } : Size{ inf, crossAvail };
+            child.Measure(childAvail);
+            const Size d = child.DesiredSize();
+            usedMain += (vertical ? d.Height : d.Width);
+            maxCross = (std::max)(maxCross, vertical ? d.Width : d.Height);
+        }
+
+        // Pass 2: split the remaining bounded main extent among the fill children.
+        if (!fillChildren.empty())
+        {
+            const float remaining = (std::max)(0.0f, mainAvail - usedMain);
+            const float per = remaining / static_cast<float>(fillChildren.size());
+            for (auto const& child : fillChildren)
+            {
+                const Size childAvail = vertical ? Size{ crossAvail, per } : Size{ per, crossAvail };
+                child.Measure(childAvail);
+                const Size d = child.DesiredSize();
+                usedMain += (vertical ? d.Height : d.Width);
+                maxCross = (std::max)(maxCross, vertical ? d.Width : d.Height);
+            }
+        }
+
+        return vertical ? Size{ maxCross, usedMain } : Size{ usedMain, maxCross };
+    }
+
+    Size StackLayout::ArrangeOverride(Size const& finalSize)
+    {
+        const bool vertical = (m_orientation == 0);
+        const float cross = vertical ? finalSize.Width : finalSize.Height;
+
+        float offset = 0.0f;
+        for (auto const& child : Children())
+        {
+            if (child.Visibility() == Visibility::Collapsed)
+            {
+                continue;
+            }
+            const Size d = child.DesiredSize();
+            const float childMain = vertical ? d.Height : d.Width;
+            const Rect slot = vertical ? Rect{ 0.0f, offset, cross, childMain }
+                                       : Rect{ offset, 0.0f, childMain, cross };
+            child.Arrange(slot);
+            offset += childMain;
+        }
+
+        return finalSize;
+    }
+}
diff --git a/packages/ui-mobile-base/windows/widgets-cpp/StackLayout.h b/packages/ui-mobile-base/windows/widgets-cpp/StackLayout.h
new file mode 100644
index 0000000000..d3475bf910
--- /dev/null
+++ b/packages/ui-mobile-base/windows/widgets-cpp/StackLayout.h
@@ -0,0 +1,33 @@
+#pragma once
+#include "StackLayout.g.h"
+
+namespace winrt::NativeScript::Widgets::implementation
+{
+    struct StackLayout : StackLayoutT<StackLayout>
+    {
+        StackLayout() = default;
+
+        int32_t Orientation() const noexcept { return m_orientation; }
+        void Orientation(int32_t value)
+        {
+            if (m_orientation != value)
+            {
+                m_orientation = value;
+                InvalidateMeasure();
+            }
+        }
+
+        winrt::Windows::Foundation::Size MeasureOverride(winrt::Windows::Foundation::Size const& availableSize);
+        winrt::Windows::Foundation::Size ArrangeOverride(winrt::Windows::Foundation::Size const& finalSize);
+
+    private:
+        int32_t m_orientation{ 0 }; // 0 = Vertical, 1 = Horizontal
+    };
+}
+
+namespace winrt::NativeScript::Widgets::factory_implementation
+{
+    struct StackLayout : StackLayoutT<StackLayout, implementation::StackLayout>
+    {
+    };
+}
diff --git a/packages/ui-mobile-base/windows/widgets-cpp/StackLayout.idl b/packages/ui-mobile-base/windows/widgets-cpp/StackLayout.idl
new file mode 100644
index 0000000000..6c3b060db0
--- /dev/null
+++ b/packages/ui-mobile-base/windows/widgets-cpp/StackLayout.idl
@@ -0,0 +1,11 @@
+namespace NativeScript.Widgets
+{
+    // Custom stacking panel (NativeScript StackLayout). Does its own measure/arrange in compiled
+    // C++ — the JS layout class becomes a thin wrapper. Orientation: 0 = Vertical, 1 = Horizontal.
+    [default_interface]
+    runtimeclass StackLayout : Microsoft.UI.Xaml.Controls.Panel
+    {
+        StackLayout();
+        Int32 Orientation;
+    }
+}
diff --git a/packages/ui-mobile-base/windows/widgets-cpp/exports.cpp b/packages/ui-mobile-base/windows/widgets-cpp/exports.cpp
new file mode 100644
index 0000000000..9d698edf1e
--- /dev/null
+++ b/packages/ui-mobile-base/windows/widgets-cpp/exports.cpp
@@ -0,0 +1,23 @@
+#include "pch.h"
+#include <cstdint>
+
+// cppwinrt's generated module.g.cpp defines the module entry points as WINRT_GetActivationFactory /
+// WINRT_CanUnloadNow. The OS WinRT activator (RoGetActivationFactory) loads the in-proc server and
+// calls the classic export names DllGetActivationFactory / DllCanUnloadNow. The cppwinrt NuGet does
+// not emit these exports by itself (the VS template normally provides them), so a hand-authored
+// component must surface them. Forward to the generated implementation.
+//
+// These extern declarations must match module.g.cpp's definitions exactly so the linker resolves
+// them to the generated symbols.
+int32_t __stdcall WINRT_GetActivationFactory(void* classId, void** factory) noexcept;
+int32_t __stdcall WINRT_CanUnloadNow() noexcept;
+
+extern "C" __declspec(dllexport) int32_t __stdcall DllGetActivationFactory(void* classId, void** factory) noexcept
+{
+    return WINRT_GetActivationFactory(classId, factory);
+}
+
+extern "C" __declspec(dllexport) int32_t __stdcall DllCanUnloadNow() noexcept
+{
+    return WINRT_CanUnloadNow();
+}
diff --git a/packages/ui-mobile-base/windows/widgets-cpp/pch.cpp b/packages/ui-mobile-base/windows/widgets-cpp/pch.cpp
new file mode 100644
index 0000000000..1d9f38c57d
--- /dev/null
+++ b/packages/ui-mobile-base/windows/widgets-cpp/pch.cpp
@@ -0,0 +1 @@
+#include "pch.h"
diff --git a/packages/ui-mobile-base/windows/widgets-cpp/pch.h b/packages/ui-mobile-base/windows/widgets-cpp/pch.h
new file mode 100644
index 0000000000..e0d27c11e3
--- /dev/null
+++ b/packages/ui-mobile-base/windows/widgets-cpp/pch.h
@@ -0,0 +1,17 @@
+#pragma once
+#include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.Foundation.Collections.h>
+// xaml_typename<T>() (used to register attached DependencyProperties) returns the universal
+// Windows.UI.Xaml.Interop.TypeName — Microsoft.UI.Xaml.DependencyProperty.RegisterAttached takes it.
+#include <winrt/Windows.UI.Xaml.Interop.h>
+#include <winrt/Microsoft.UI.Xaml.h>
+#include <winrt/Microsoft.UI.Xaml.Controls.h>
+// ImageHelper: bitmap decode/encode/IO + UI-thread BitmapImage creation.
+#include <winrt/Microsoft.UI.Xaml.Media.h>
+#include <winrt/Microsoft.UI.Xaml.Media.Imaging.h>
+#include <winrt/Microsoft.UI.Dispatching.h>
+#include <winrt/Windows.Storage.h>
+#include <winrt/Windows.Storage.Streams.h>
+#include <winrt/Windows.Graphics.Imaging.h>
+#include <winrt/Windows.Web.Http.h>
+#include <winrt/Windows.Security.Cryptography.h>
diff --git a/packages/vite/configuration/base.ts b/packages/vite/configuration/base.ts
index aabca98f4e..0e3fe13684 100644
--- a/packages/vite/configuration/base.ts
+++ b/packages/vite/configuration/base.ts
@@ -99,7 +99,7 @@ if (themePkgDir && existsSync(themePkgDir)) {
  */
 applyExternalConfigs();
 
-type PlatformType = 'android' | 'ios' | 'visionos';
+type PlatformType = 'android' | 'ios' | 'visionos' | 'windows';
 
 export const baseConfig = ({ mode, flavor }: { mode: string; flavor?: string }): UserConfig => {
 	const targetMode = mode === 'development' ? 'development' : 'production';
@@ -117,6 +117,8 @@ export const baseConfig = ({ mode, flavor }: { mode: string; flavor?: string }):
 		platform = 'ios';
 	} else if (cliFlags.visionos) {
 		platform = 'visionos';
+	} else if (cliFlags.windows) {
+		platform = 'windows';
 	}
 	if (verbose) {
 		console.log('--------------');
@@ -148,6 +150,8 @@ export const baseConfig = ({ mode, flavor }: { mode: string; flavor?: string }):
 		} else if (platform === 'ios' || platform === 'visionos') {
 			// Treat visionOS like iOS for file resolution
 			exts.push('.ios.tsx', '.tsx', '.ios.jsx', '.jsx', '.ios.ts', '.ts', '.ios.js', '.js');
+		} else if (platform === 'windows') {
+			exts.push('.windows.tsx', '.tsx', '.windows.jsx', '.jsx', '.windows.ts', '.ts', '.windows.js', '.js');
 		} else {
 			// Fallback: no platform-specific preference
 			exts.push(...base);
@@ -369,7 +373,8 @@ export const baseConfig = ({ mode, flavor }: { mode: string; flavor?: string }):
 		// Development server configuration for HMR
 		server: isDevMode
 			? {
-					// Expose dev server to local network so simulator or device can connect
+					// Expose dev server to local network so simulator or device can connect.
+					// Windows runs on the same machine so localhost is sufficient.
 					host: process.env.NS_HMR_HOST || (platform === 'android' ? '0.0.0.0' : 'localhost'),
 					// Use a stable port so the device URL remains correct
 					port: 5173,
diff --git a/packages/vite/helpers/css-platform-plugin.ts b/packages/vite/helpers/css-platform-plugin.ts
index f57494efa2..8a87b217c6 100644
--- a/packages/vite/helpers/css-platform-plugin.ts
+++ b/packages/vite/helpers/css-platform-plugin.ts
@@ -18,7 +18,7 @@ export function createPlatformCssPlugin(platform: string): Plugin {
 			const baseId = id.split('?')[0];
 			if (!baseId.endsWith('.css') || !code.includes('@import')) return null;
 			const dir = path.dirname(baseId);
-			const platformExt = platform === 'android' ? '.android.css' : '.ios.css';
+			const platformExt = platform === 'android' ? '.android.css' : platform === 'windows' ? '.windows.css' : '.ios.css';
 			let changed = false;
 			// Support @import "foo.css"; @import 'foo.css'; @import url("foo.css"); preserving rest
 			const importRegex = /@import\s+(?:url\()?['"]([^'"()]+\.css)['"]\)?/g;
@@ -46,7 +46,7 @@ export function createPlatformCssPlugin(platform: string): Plugin {
 			const baseDir = path.dirname(importerPath);
 			const abs = path.isAbsolute(id) ? id : path.resolve(baseDir, id);
 			if (existsSync(abs)) return null;
-			const platformExt = platform === 'android' ? '.android.css' : '.ios.css';
+			const platformExt = platform === 'android' ? '.android.css' : platform === 'windows' ? '.windows.css' : '.ios.css';
 			const alt = abs.replace(/\.css$/, platformExt);
 			if (existsSync(alt)) {
 				return '\0ns-css-platform:' + alt;
diff --git a/packages/vite/helpers/global-defines.ts b/packages/vite/helpers/global-defines.ts
index fbc4531311..23eb9d2a33 100644
--- a/packages/vite/helpers/global-defines.ts
+++ b/packages/vite/helpers/global-defines.ts
@@ -10,6 +10,7 @@ export function getGlobalDefines(opts: { platform: string; targetMode: string; v
 		__IOS__: JSON.stringify(opts.platform === 'ios'),
 		__VISIONOS__: JSON.stringify(opts.platform === 'visionos'),
 		__APPLE__: JSON.stringify(opts.platform === 'ios' || opts.platform === 'visionos'),
+		__WINDOWS__: JSON.stringify(opts.platform === 'windows'),
 		__DEV__: JSON.stringify(opts.targetMode === 'development'),
 		__COMMONJS__: false,
 		__NS_WEBPACK__: false,
diff --git a/packages/vite/helpers/init.ts b/packages/vite/helpers/init.ts
index deae3fe2d0..ec893bfdfa 100644
--- a/packages/vite/helpers/init.ts
+++ b/packages/vite/helpers/init.ts
@@ -52,10 +52,13 @@ function ensureScripts(pkg: PackageJson) {
 	pkg.scripts = pkg.scripts ?? {};
 	pkg.scripts['dev:ios'] = "concurrently -k -n vite,ns 'npm run dev:server:ios' 'wait-on tcp:5173 && npm run ios'";
 	pkg.scripts['dev:android'] = "concurrently -k -n vite,ns 'npm run dev:server:android' 'wait-on tcp:5173 && npm run android'";
+	pkg.scripts['dev:windows'] = "concurrently -k -n vite,ns 'npm run dev:server:windows' 'wait-on tcp:5173 && npm run windows'";
 	pkg.scripts['dev:server:ios'] = 'VITE_DEBUG_LOGS=1 vite serve -- --env.ios --env.hmr';
 	pkg.scripts['dev:server:android'] = 'VITE_DEBUG_LOGS=1 vite serve -- --env.android --env.hmr';
+	pkg.scripts['dev:server:windows'] = 'VITE_DEBUG_LOGS=1 vite serve -- --env.windows --env.hmr';
 	pkg.scripts['ios'] = 'VITE_DEBUG_LOGS=1 ns debug ios';
 	pkg.scripts['android'] = 'VITE_DEBUG_LOGS=1 ns debug android';
+	pkg.scripts['windows'] = 'VITE_DEBUG_LOGS=1 ns debug windows';
 }
 
 function ensureGitignore() {
diff --git a/packages/vite/hmr/server/websocket.ts b/packages/vite/hmr/server/websocket.ts
index d5a5f0caf8..f42f7945f2 100644
--- a/packages/vite/hmr/server/websocket.ts
+++ b/packages/vite/hmr/server/websocket.ts
@@ -1172,6 +1172,7 @@ function processCodeForDevice(code: string, isVitePreBundled: boolean): string {
 		'const __UI_USE_XML_PARSER__ = globalThis.__UI_USE_XML_PARSER__ !== undefined ? globalThis.__UI_USE_XML_PARSER__ : true;',
 		'const __UI_USE_EXTERNAL_RENDERER__ = globalThis.__UI_USE_EXTERNAL_RENDERER__ !== undefined ? globalThis.__UI_USE_EXTERNAL_RENDERER__ : false;',
 		'const __TEST__ = globalThis.__TEST__ !== undefined ? globalThis.__TEST__ : false;',
+		'const __WINDOWS__ = globalThis.__WINDOWS__ !== undefined ? globalThis.__WINDOWS__ : false;',
 	];
 	result = allGlobals.join('\n') + '\n' + result;
 
diff --git a/packages/webpack5/src/configuration/base.ts b/packages/webpack5/src/configuration/base.ts
index 79fa1bb725..ff2cec60c4 100644
--- a/packages/webpack5/src/configuration/base.ts
+++ b/packages/webpack5/src/configuration/base.ts
@@ -58,11 +58,13 @@ export default function (config: Config, env: IWebpackEnv = _env): Config {
 	if (
 		hasDependency('@nativescript/ios') ||
 		hasDependency('@nativescript/visionos') ||
-		hasDependency('@nativescript/android')
+		hasDependency('@nativescript/android') ||
+		hasDependency('@nativescript/windows')
 	) {
 		const iosVersion = getDependencyVersion('@nativescript/ios');
 		const visionosVersion = getDependencyVersion('@nativescript/visionos');
 		const androidVersion = getDependencyVersion('@nativescript/android');
+		const windowsVersion = getDependencyVersion('@nativescript/windows');
 
 		if (platform === 'ios') {
 			const iosResolved =
@@ -100,6 +102,19 @@ export default function (config: Config, env: IWebpackEnv = _env): Config {
 			} else {
 				env.commonjs = true;
 			}
+		} else if (platform === 'windows') {
+			const windowsResolved =
+				getResolvedDependencyVersionForCheck(
+					'@nativescript/windows',
+					'9.0.0',
+				) ??
+				windowsVersion ??
+				undefined;
+			if (isVersionGteConsideringPrerelease(windowsResolved, '9.0.0')) {
+				useSourceMapFiles();
+			} else {
+				env.commonjs = true;
+			}
 		}
 	} else {
 		env.commonjs = true;
@@ -190,8 +205,7 @@ export default function (config: Config, env: IWebpackEnv = _env): Config {
 	// when using hidden-source-map, output source maps to the `platforms/{platformName}-sourceMaps` folder
 	if (env.sourceMap === 'hidden-source-map') {
 		const sourceMapAbsolutePath = getProjectFilePath(
-			`./${
-				env.buildPath ?? 'platforms'
+			`./${env.buildPath ?? 'platforms'
 			}/${platform}-sourceMaps/[file].map[query]`,
 		);
 		const sourceMapRelativePath = relative(outputPath, sourceMapAbsolutePath);
@@ -441,8 +455,8 @@ export default function (config: Config, env: IWebpackEnv = _env): Config {
 	const tsConfigPath = getProjectTSConfigPath();
 	const configFile = tsConfigPath
 		? {
-				configFile: tsConfigPath,
-			}
+			configFile: tsConfigPath,
+		}
 		: undefined;
 
 	// set up ts support
@@ -534,7 +548,7 @@ export default function (config: Config, env: IWebpackEnv = _env): Config {
 										return require.resolve(platformRequest, {
 											paths: [baseDir],
 										});
-									} catch {}
+									} catch { }
 
 									if (existsSync(extPath)) {
 										console.log(`resolving "${id}" to "${platformRequest}"`);
@@ -658,10 +672,12 @@ export default function (config: Config, env: IWebpackEnv = _env): Config {
 				__IOS__: platform === 'ios',
 				__VISIONOS__: platform === 'visionos',
 				__APPLE__: platform === 'ios' || platform === 'visionos',
+				__WINDOWS__: platform === 'windows',
 				/* for compat only */ 'global.isAndroid': platform === 'android',
 				/* for compat only */ 'global.isIOS':
 					platform === 'ios' || platform === 'visionos',
 				/* for compat only */ 'global.isVisionOS': platform === 'visionos',
+				/* for compat only */ 'global.isWindows': platform === 'windows',
 				process: 'global.process',
 			},
 		] as any,
@@ -706,8 +722,8 @@ function shouldIncludeInspectorModules(): boolean {
 	const coreVersion = getDependencyVersion('@nativescript/core');
 
 	if (coreVersion && satisfies(coreVersion, '>=8.7.0')) {
-		return platform === 'ios' || platform === 'android';
+		return platform === 'ios' || platform === 'android' || platform === 'windows';
 	}
 
-	return platform === 'ios';
+	return platform === 'ios' || platform === 'windows';
 }
diff --git a/packages/webpack5/src/helpers/name.ts b/packages/webpack5/src/helpers/name.ts
new file mode 100644
index 0000000000..a3dce60ca3
--- /dev/null
+++ b/packages/webpack5/src/helpers/name.ts
@@ -0,0 +1,6 @@
+export function sanitizeName(appName: string): string {
+	return appName
+		.split('')
+		.filter((c) => /[a-zA-Z0-9]/.test(c))
+		.join('');
+}
diff --git a/packages/webpack5/src/helpers/platform.ts b/packages/webpack5/src/helpers/platform.ts
index 6a28fdcc9e..872761b64e 100644
--- a/packages/webpack5/src/helpers/platform.ts
+++ b/packages/webpack5/src/helpers/platform.ts
@@ -8,6 +8,7 @@ import { env } from '../';
 import AndroidPlatform from '../platforms/android';
 import iOSPlatform from '../platforms/ios';
 import visionOSPlatform from '../platforms/visionos';
+import WindowsPlatform from '../platforms/windows';
 
 export interface INativeScriptPlatform {
 	getEntryPath?(): string;
@@ -23,6 +24,7 @@ const platforms: {
 	android: AndroidPlatform,
 	ios: iOSPlatform,
 	visionos: visionOSPlatform,
+	windows: WindowsPlatform,
 };
 
 /**
@@ -66,6 +68,10 @@ export function getPlatformName(): Platform {
 		return 'visionos';
 	}
 
+	if (env?.windows) {
+		return 'windows';
+	}
+
 	// support custom platforms
 	if (env?.platform) {
 		if (platforms[env.platform]) {
diff --git a/packages/webpack5/src/platforms/ios.ts b/packages/webpack5/src/platforms/ios.ts
index df8ffb5ed3..4f9a27b1ab 100644
--- a/packages/webpack5/src/platforms/ios.ts
+++ b/packages/webpack5/src/platforms/ios.ts
@@ -4,12 +4,7 @@ import { INativeScriptPlatform } from "../helpers/platform";
 import { getProjectRootPath } from "../helpers/project";
 import { env } from '../';
 import { getValue } from '../helpers/config';
-
-function sanitizeName(appName: string): string {
-	return appName.split("").filter((c) =>
-		/[a-zA-Z0-9]/.test(c)
-	).join("");
-}
+import { sanitizeName } from '../helpers/name';
 function getDistPath() {
 	// if nativescript.config projectName is defined, use that custom name
 	// otherwise, default to base project directory name for project name
diff --git a/packages/webpack5/src/platforms/visionos.ts b/packages/webpack5/src/platforms/visionos.ts
index fde5d5a970..5be339b97b 100644
--- a/packages/webpack5/src/platforms/visionos.ts
+++ b/packages/webpack5/src/platforms/visionos.ts
@@ -3,12 +3,7 @@ import { basename } from "path";
 import { INativeScriptPlatform } from "../helpers/platform";
 import { getProjectRootPath } from "../helpers/project";
 import { env } from '../';
-
-function sanitizeName(appName: string): string {
-	return appName.split("").filter((c) =>
-		/[a-zA-Z0-9]/.test(c)
-	).join("");
-}
+import { sanitizeName } from '../helpers/name';
 function getDistPath() {
 	const appName = sanitizeName(basename(getProjectRootPath()));
 	return `${env.buildPath ?? "platforms"}/visionos/${appName}/app`;
diff --git a/packages/webpack5/src/platforms/windows.ts b/packages/webpack5/src/platforms/windows.ts
new file mode 100644
index 0000000000..25cf179bc4
--- /dev/null
+++ b/packages/webpack5/src/platforms/windows.ts
@@ -0,0 +1,18 @@
+import { basename } from 'path';
+
+import { INativeScriptPlatform } from "../helpers/platform";
+import { getProjectRootPath } from "../helpers/project";
+import { env } from '../';
+import { sanitizeName } from '../helpers/name';
+
+function getDistPath() {
+    const appName = sanitizeName(basename(getProjectRootPath()));
+    const platform = process.env.USER_PROJECT_PLATFORMS_WINDOWS ? process.env.USER_PROJECT_PLATFORMS_WINDOWS : `${env.buildPath ?? "platforms"}/windows`;
+    return `${platform}/${appName}/app`;
+}
+
+const WindowsPlatform: INativeScriptPlatform = {
+    getDistPath,
+}
+
+export default WindowsPlatform;
diff --git a/tools/assets/App_Resources/Windows/Assets/LockScreenLogo.png b/tools/assets/App_Resources/Windows/Assets/LockScreenLogo.png
new file mode 100644
index 0000000000..271c6830c1
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/LockScreenLogo.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/LockScreenLogo.scale-125.png b/tools/assets/App_Resources/Windows/Assets/LockScreenLogo.scale-125.png
new file mode 100644
index 0000000000..bd0245cfc3
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/LockScreenLogo.scale-125.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/LockScreenLogo.scale-150.png b/tools/assets/App_Resources/Windows/Assets/LockScreenLogo.scale-150.png
new file mode 100644
index 0000000000..83dcc340fb
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/LockScreenLogo.scale-150.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/LockScreenLogo.scale-200.png b/tools/assets/App_Resources/Windows/Assets/LockScreenLogo.scale-200.png
new file mode 100644
index 0000000000..778e1e315d
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/LockScreenLogo.scale-200.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/LockScreenLogo.scale-400.png b/tools/assets/App_Resources/Windows/Assets/LockScreenLogo.scale-400.png
new file mode 100644
index 0000000000..0e458cb01f
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/LockScreenLogo.scale-400.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/SplashScreen.png b/tools/assets/App_Resources/Windows/Assets/SplashScreen.png
new file mode 100644
index 0000000000..b8f8137c01
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/SplashScreen.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/SplashScreen.scale-125.png b/tools/assets/App_Resources/Windows/Assets/SplashScreen.scale-125.png
new file mode 100644
index 0000000000..d62071df12
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/SplashScreen.scale-125.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/SplashScreen.scale-150.png b/tools/assets/App_Resources/Windows/Assets/SplashScreen.scale-150.png
new file mode 100644
index 0000000000..04e7780f7c
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/SplashScreen.scale-150.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/SplashScreen.scale-200.png b/tools/assets/App_Resources/Windows/Assets/SplashScreen.scale-200.png
new file mode 100644
index 0000000000..5417f6b164
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/SplashScreen.scale-200.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/SplashScreen.scale-400.png b/tools/assets/App_Resources/Windows/Assets/SplashScreen.scale-400.png
new file mode 100644
index 0000000000..86cef37bfe
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/SplashScreen.scale-400.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Square150x150Logo.png b/tools/assets/App_Resources/Windows/Assets/Square150x150Logo.png
new file mode 100644
index 0000000000..e9635725f1
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Square150x150Logo.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Square150x150Logo.scale-125.png b/tools/assets/App_Resources/Windows/Assets/Square150x150Logo.scale-125.png
new file mode 100644
index 0000000000..b3479b75c7
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Square150x150Logo.scale-125.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Square150x150Logo.scale-150.png b/tools/assets/App_Resources/Windows/Assets/Square150x150Logo.scale-150.png
new file mode 100644
index 0000000000..889cc6a05a
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Square150x150Logo.scale-150.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Square150x150Logo.scale-200.png b/tools/assets/App_Resources/Windows/Assets/Square150x150Logo.scale-200.png
new file mode 100644
index 0000000000..81d292276c
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Square150x150Logo.scale-200.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Square150x150Logo.scale-400.png b/tools/assets/App_Resources/Windows/Assets/Square150x150Logo.scale-400.png
new file mode 100644
index 0000000000..129e7ba892
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Square150x150Logo.scale-400.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.png b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.png
new file mode 100644
index 0000000000..ecf4599095
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.scale-125.png b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.scale-125.png
new file mode 100644
index 0000000000..0fb7a8095c
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.scale-125.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.scale-150.png b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.scale-150.png
new file mode 100644
index 0000000000..8a72f3fbb6
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.scale-150.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.scale-200.png b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.scale-200.png
new file mode 100644
index 0000000000..cc675d00e8
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.scale-200.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.scale-400.png b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.scale-400.png
new file mode 100644
index 0000000000..6674699391
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.scale-400.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.targetsize-24_altform-unplated.png b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.targetsize-24_altform-unplated.png
new file mode 100644
index 0000000000..988fa459bf
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.targetsize-24_altform-unplated.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.targetsize-24_altform-unplated.scale-125.png b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.targetsize-24_altform-unplated.scale-125.png
new file mode 100644
index 0000000000..5e52976284
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.targetsize-24_altform-unplated.scale-125.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.targetsize-24_altform-unplated.scale-150.png b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.targetsize-24_altform-unplated.scale-150.png
new file mode 100644
index 0000000000..d204eafbc8
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.targetsize-24_altform-unplated.scale-150.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.targetsize-24_altform-unplated.scale-200.png b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.targetsize-24_altform-unplated.scale-200.png
new file mode 100644
index 0000000000..da2be9389e
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.targetsize-24_altform-unplated.scale-200.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.targetsize-24_altform-unplated.scale-400.png b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.targetsize-24_altform-unplated.scale-400.png
new file mode 100644
index 0000000000..5d06348e3a
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Square44x44Logo.targetsize-24_altform-unplated.scale-400.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/StoreLogo.png b/tools/assets/App_Resources/Windows/Assets/StoreLogo.png
new file mode 100644
index 0000000000..251e0b8d9e
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/StoreLogo.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/StoreLogo.scale-125.png b/tools/assets/App_Resources/Windows/Assets/StoreLogo.scale-125.png
new file mode 100644
index 0000000000..2757fb5b3c
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/StoreLogo.scale-125.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/StoreLogo.scale-150.png b/tools/assets/App_Resources/Windows/Assets/StoreLogo.scale-150.png
new file mode 100644
index 0000000000..df0fb1fa1e
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/StoreLogo.scale-150.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/StoreLogo.scale-200.png b/tools/assets/App_Resources/Windows/Assets/StoreLogo.scale-200.png
new file mode 100644
index 0000000000..263aa0bfef
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/StoreLogo.scale-200.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/StoreLogo.scale-400.png b/tools/assets/App_Resources/Windows/Assets/StoreLogo.scale-400.png
new file mode 100644
index 0000000000..e8b877c25c
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/StoreLogo.scale-400.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Wide310x150Logo.png b/tools/assets/App_Resources/Windows/Assets/Wide310x150Logo.png
new file mode 100644
index 0000000000..b411e874a0
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Wide310x150Logo.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Wide310x150Logo.scale-125.png b/tools/assets/App_Resources/Windows/Assets/Wide310x150Logo.scale-125.png
new file mode 100644
index 0000000000..77be9a72ab
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Wide310x150Logo.scale-125.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Wide310x150Logo.scale-150.png b/tools/assets/App_Resources/Windows/Assets/Wide310x150Logo.scale-150.png
new file mode 100644
index 0000000000..194da01292
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Wide310x150Logo.scale-150.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Wide310x150Logo.scale-200.png b/tools/assets/App_Resources/Windows/Assets/Wide310x150Logo.scale-200.png
new file mode 100644
index 0000000000..901ddadf16
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Wide310x150Logo.scale-200.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/Wide310x150Logo.scale-400.png b/tools/assets/App_Resources/Windows/Assets/Wide310x150Logo.scale-400.png
new file mode 100644
index 0000000000..5b53b409a3
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/Wide310x150Logo.scale-400.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/icon.png b/tools/assets/App_Resources/Windows/Assets/icon.png
new file mode 100644
index 0000000000..251e0b8d9e
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/icon.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/icon.scale-125.png b/tools/assets/App_Resources/Windows/Assets/icon.scale-125.png
new file mode 100644
index 0000000000..2757fb5b3c
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/icon.scale-125.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/icon.scale-150.png b/tools/assets/App_Resources/Windows/Assets/icon.scale-150.png
new file mode 100644
index 0000000000..df0fb1fa1e
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/icon.scale-150.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/icon.scale-200.png b/tools/assets/App_Resources/Windows/Assets/icon.scale-200.png
new file mode 100644
index 0000000000..263aa0bfef
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/icon.scale-200.png differ
diff --git a/tools/assets/App_Resources/Windows/Assets/icon.scale-400.png b/tools/assets/App_Resources/Windows/Assets/icon.scale-400.png
new file mode 100644
index 0000000000..e8b877c25c
Binary files /dev/null and b/tools/assets/App_Resources/Windows/Assets/icon.scale-400.png differ
diff --git a/tools/assets/App_Resources/Windows/Package.appxmanifest b/tools/assets/App_Resources/Windows/Package.appxmanifest
new file mode 100644
index 0000000000..7209e24d53
--- /dev/null
+++ b/tools/assets/App_Resources/Windows/Package.appxmanifest
@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<Package
+  xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
+  xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
+  xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
+  xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest"
+  IgnorableNamespaces="uap rescap">
+
+  <mp:PhoneIdentity PhoneProductId="00000000-0000-0000-0000-000000000000" PhonePublisherId="00000000-0000-0000-0000-000000000000" />
+
+  <Identity Name="__APP_IDENTIFIER__" Publisher="CN=ui" Version="1.0.0.0" />
+
+  <Properties>
+    <DisplayName>__PROJECT_NAME__</DisplayName>
+    <PublisherDisplayName>__PROJECT_NAME__</PublisherDisplayName>
+    <Logo>Assets\StoreLogo.png</Logo>
+  </Properties>
+
+  <Dependencies>
+    <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.17763.0" MaxVersionTested="10.0.26100.0" />
+    <!-- WinUI3 / Windows App SDK 1.6 framework package (framework-dependent). Without this, the
+         registered app can't activate Microsoft.UI.Xaml.* and fails with REGDB_E_CLASSNOTREG. -->
+    <PackageDependency Name="Microsoft.WindowsAppRuntime.1.6" MinVersion="6000.0.0.0" Publisher="CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US" />
+  </Dependencies>
+
+  <Resources>
+    <Resource Language="en-US"/>
+  </Resources>
+
+  <Applications>
+    <!-- WinUI3 desktop: full-trust Win32 entry (runs Program.Main), not a UWP managed class entry. -->
+    <Application Id="App" Executable="$targetnametoken$.exe" EntryPoint="Windows.FullTrustApplication">
+      <uap:VisualElements DisplayName="__PROJECT_NAME__"
+        Square150x150Logo="Assets\Square150x150Logo.png"
+        Square44x44Logo="Assets\Square44x44Logo.png"
+        Description="A NativeScript Windows application"
+        BackgroundColor="transparent">
+        <uap:DefaultTile Wide310x150Logo="Assets\Wide310x150Logo.png"/>
+        <uap:SplashScreen Image="Assets\SplashScreen.png" />
+      </uap:VisualElements>
+    </Application>
+  </Applications>
+
+  <!-- PACKAGE-level activatable-class registration (NOT Application-level, which only allows
+       background-task categories). Registers the prebuilt C++/WinRT NativeScript.Widgets component
+       as an in-proc server so the runtime's RoGetActivationFactory can create its classes directly
+       (no DotNetBridge). The DLL + winmd are copied to the package root via App_Resources app.csproj. -->
+  <Extensions>
+    <Extension Category="windows.activatableClass.inProcessServer">
+      <InProcessServer>
+        <Path>NativeScript.Widgets.dll</Path>
+        <ActivatableClass ActivatableClassId="NativeScript.Widgets.StackLayout" ThreadingModel="both" />
+        <ActivatableClass ActivatableClassId="NativeScript.Widgets.FlexboxLayout" ThreadingModel="both" />
+        <ActivatableClass ActivatableClassId="NativeScript.Widgets.ImageHelper" ThreadingModel="both" />
+        <ActivatableClass ActivatableClassId="NativeScript.Widgets.ShadowHelper" ThreadingModel="both" />
+      </InProcessServer>
+    </Extension>
+  </Extensions>
+
+  <Capabilities>
+    <rescap:Capability Name="runFullTrust" />
+    <Capability Name="internetClient" />
+    <Capability Name="privateNetworkClientServer" />
+  </Capabilities>
+</Package>
diff --git a/tools/assets/App_Resources/Windows/app.csproj b/tools/assets/App_Resources/Windows/app.csproj
new file mode 100644
index 0000000000..8c119d5413
--- /dev/null
+++ b/tools/assets/App_Resources/Windows/app.csproj
@@ -0,0 +1,2 @@
+<Project>
+</Project>